如何最好地保护传递给std :: string参数的0？

我刚刚意识到一些令人不安的事情。每次我编写一个接受std::string参数为a 的方法时，我都会向不确定的行为敞开大门。

例如，这...

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

可以这样称呼

char* s = 0;
myMethod(s);

...而且我无能为力（我知道）无法阻止它。

所以我的问题是：某人如何捍卫自己呢？

想到的唯一方法是，始终编写接受a 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()可以优化检查是否为null的情况。

以下代码给出了显式传递的编译失败0和char*with的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或偶然传递一个值为0的int来实现。这确实很荒谬：

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 *可能为空指针（例如，从外部C API返回），则答案是使用该函数的const char *版本而不是std :: string一个。即

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

当然，如果要允许使用std :: string版本，也将需要它们。

通常，最好将对外部API的调用和将参数编组为有效值。