Як найкраще захистити від 0 переданих параметрів std :: string?

Я щойно зрозумів щось тривожне. Кожного разу, коли я писав метод, який приймає параметр 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));
    }
}

Це загальне та / або прийнятне рішення?

EDIT: Деякі вказували, що я повинен приймати 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*значення зі значенням 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)призведе до помилки зв’язку.

Ваш метод у першому кодовому блоці ніколи не буде викликаний, якщо ви спробуєте викликати його з a (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), відповідь полягає у використанні версії функції const char * замість std :: string one. тобто

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

Звичайно, вам також знадобиться версія std :: string, якщо ви хочете дозволити їх використовувати.

Взагалі найкраще ізолювати виклики до зовнішніх API та аргументацію маршалу у дійсні значення.