Как лучше всего защитить от 0 передаваемых в std :: string параметров?

Я только что понял, что-то беспокоит. Каждый раз, когда я писал метод, который принимает a std::stringв качестве параметра, я открывал себя для неопределенного поведения.

Например, это ...

void myMethod(const std::string& s) { 
    /* Do something with s. */
}

... можно назвать так ...

char* s = 0;
myMethod(s);

... и я ничего не могу сделать, чтобы предотвратить это (о чем я знаю).

Итак, мой вопрос: как кто-то защищает себя от этого?

Единственный подход, который приходит на ум, - это всегда писать две версии любого метода, который принимает std::stringв качестве параметра, например:

void myMethod(const std::string& s) {
    /* Do something. */
}

void myMethod(char* s) {
    if (s == 0) {
        throw std::exception("Null passed.");
    } else {
        myMethod(string(s));
    }
}

Это общее и / или приемлемое решение?

РЕДАКТИРОВАТЬ: Некоторые указали, что я должен принять, const std::string& sа не std::string sв качестве параметра. Я согласен. Я изменил пост. Я не думаю, что это меняет ответ, хотя.

Я не думаю, что вы должны защищать себя. Это неопределенное поведение на стороне звонящего. Звонит не ты, а тот, кто не звонит std::string::string(nullptr). Компилятор позволяет его компилировать, но он также позволяет компилировать и другие неопределенные варианты поведения.

Точно так же можно получить «нулевую ссылку»:

int* p = nullptr;
f(*p);
void f(int& x) { x = 0; /* bang! */ }

Тот, кто разыменовывает нулевой указатель, создает UB и отвечает за него.

Более того, вы не можете защитить себя после того, как произошло неопределенное поведение, потому что оптимизатор имеет полное право предполагать, что неопределенное поведение никогда не происходило, поэтому проверки, c_str()равные нулю, могут быть оптимизированы.

Приведенный ниже код дает ошибку компиляции для явного прохода 0и ошибку времени выполнения для char*значения with 0.

Обратите внимание, что я не имею в виду, что обычно это следует делать, но, без сомнения, могут быть случаи, когда защита от ошибки вызывающего абонента оправдана.

struct Test
{
    template<class T> void myMethod(T s);
};

template<> inline void Test::myMethod(const std::string& s)
{
    std::cout << "Cool " << std::endl;
}

template<> inline void Test::myMethod(const char* s)
{
    if (s != 0)
        myMethod(std::string(s));
    else
    {
        throw "Bad bad bad";
    }
}

template<class T> inline void Test::myMethod(T  s)
{
    myMethod(std::string(s));
    const bool ok = !std::is_same<T,int>::value;
    static_assert(ok, "oops");
}

int main()
{
    Test t;
    std::string s ("a");
    t.myMethod("b");
    const char* c = "c";
    t.myMethod(c);
    const char* d = 0;
    t.myMethod(d); // run time exception
    t.myMethod(0); // Compile failure
}

Я также столкнулся с этой проблемой несколько лет назад, и я обнаружил, что это действительно очень страшная вещь. Это может произойти, если передать a nullptrили случайно передать int со значением 0. Это действительно абсурдно:

std::string s(1); // compile error
std::string s(0); // runtime error

Тем не менее, в конце концов это всего лишь пару раз. И каждый раз это вызывало немедленный сбой при тестировании моего кода. Так что никаких ночных сессий не потребуется, чтобы это исправить.

Я думаю, что перегрузка функции const char*- это хорошая идея.

void foo(std::string s)
{
    // work
}

void foo(const char* s) // use const char* rather than char* (binds to string literals)
{
    assert(s); // I would use assert or std::abort in case of nullptr . 
    foo(std::string(s));
}

Хотелось бы, чтобы было лучше решение. Тем не менее, нет.

Как насчет изменения подписи вашего метода на:

void myMethod(std::string& s) // maybe throw const in there too.

Таким образом, вызывающий объект должен создать строку перед тем, как ее вызвать, и небрежность, о которой вы беспокоитесь, вызовет проблемы, прежде чем он попадет в ваш метод, делая очевидным то, на что указали другие, что это ошибка вызывающего, а не ваша.

Как насчет того, чтобы обеспечить перегрузку принимает intпараметр?

public:
    void myMethod(const std::string& s)
    { 
        /* Do something with s. */
    }    

private:
    void myMethod(int);

Вам даже не нужно определять перегрузку. Попытка вызова myMethod(0)вызовет ошибку компоновщика.

Ваш метод в первом блоке кода никогда не будет вызван, если вы попытаетесь вызвать его с помощью (char *)0. C ++ просто попытается создать строку и выдаст исключение для вас. Вы пробовали это?

#include <cstdlib>
#include <iostream>

void myMethod(std::string s) {
    std::cout << "s=" << s << "\n";
}

int main(int argc,char **argv) {
    char *s = 0;
    myMethod(s);
    return(0);
}


$ g++ -g -o x x.cpp 
$ lldb x 
(lldb) run
Process 2137 launched: '/Users/simsong/x' (x86_64)
Process 2137 stopped
* thread #1: tid = 0x49b8, 0x00007fff99bf9812 libsystem_c.dylib`strlen + 18, queue = 'com.apple.main-thread, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
    frame #0: 0x00007fff99bf9812 libsystem_c.dylib`strlen + 18
libsystem_c.dylib`strlen + 18:
-> 0x7fff99bf9812:  pcmpeqb (%rdi), %xmm0
   0x7fff99bf9816:  pmovmskb %xmm0, %esi
   0x7fff99bf981a:  andq   $15, %rcx
   0x7fff99bf981e:  orq    $-1, %rax
(lldb) bt
* thread #1: tid = 0x49b8, 0x00007fff99bf9812 libsystem_c.dylib`strlen + 18, queue = 'com.apple.main-thread, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
    frame #0: 0x00007fff99bf9812 libsystem_c.dylib`strlen + 18
    frame #1: 0x000000010000077a x`main [inlined] std::__1::char_traits<char>::length(__s=0x0000000000000000) + 122 at string:644
    frame #2: 0x000000010000075d x`main [inlined] std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::basic_string(this=0x00007fff5fbff548, __s=0x0000000000000000) + 8 at string:1856
    frame #3: 0x0000000100000755 x`main [inlined] std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >::basic_string(this=0x00007fff5fbff548, __s=0x0000000000000000) at string:1857
    frame #4: 0x0000000100000755 x`main(argc=1, argv=0x00007fff5fbff5e0) + 85 at x.cpp:10
    frame #5: 0x00007fff92ea25fd libdyld.dylib`start + 1
(lldb) 

Видеть? Вам не о чем беспокоиться.

Теперь, если вы хотите поймать это более изящно, просто не стоит использовать char *, тогда проблема не возникнет.

Если вы беспокоитесь о том, что char * может быть нулевым указателем (например, при возврате из внешних API C), ответом будет использование версии функции const char * вместо std :: string. т.е.

void myMethod(const char* c) { 
    std::string s(c ? c : "");
    /* Do something with s. */
}

Конечно, вам также потребуется версия std :: string, если вы хотите разрешить их использование.

В общем, лучше всего изолировать вызовы внешних API и маршальные аргументы в допустимые значения.