¿Cómo evito que los problemas derivados de std :: string se construyan a partir de `0`?

Question

void foo (const std::string &s) {} 

int main() { 
    foo(0); //compiles, but invariably causes runtime error 
    return 0; 
} 

El compilador (g ++ 4.4) aparentemente interpreta 0 como char* NULL, y construye s llamando string::string(const char*, const Allocator &a = Allocator()). Lo cual es, por supuesto, inútil, porque el puntero NULL no es un puntero válido para una cadena de caracteres. Esta mala interpretación no se produce cuando intento llamar al foo(1), esto produce un error en tiempo de compilación.

¿Hay alguna posibilidad de conseguir un error o advertencia como en tiempo de compilación cuando accidentalmente llama a una función como

void bar(const std::string &s, int i=1); 

con bar(0), olvidándose de la string, y en realidad lo que significa tener i=0?

Answer 1

Esto es un poco feo, pero se puede crear una plantilla que va a producir un error cuando una instancia:

template <typename T> 
void bar(T const&) 
{ 
    T::youHaveCalledBarWithSomethingThatIsntAStringYouIdiot(); 
} 

void bar(std::string const& s, int i = 1) 
{ 
    // Normal implementation 
} 

void bar(char const* s, int i = 1) 
{ 
    bar(std::string(s), i); 
} 

Luego de usarlo:

bar(0); // produces compile time error 
bar("Hello, world!"); // fine 

Answer 2

Una solución algo limpio ...

#include <cassert> 

void foo (const std::string &s) 
{ 
    // Your function 
} 

void foo(const char *s) 
{ 
    assert(s != 0); 
    foo(std::string(s)); 
} 

Answer 3

Actually static asertos funcionaría también. considere esto:

void foo (const std::string &s) 
{ 
    // Your function 
} 

void foo(const char *s) 
{ 
    #ifdef CPP_OH_X 
    static_assert(s == 0, "Cannot pass 0 as an argument to foo!"); 
    #else 
    typedef int[(s != 0) ? 1 : -1] check; 
    #endif 
    foo(std::string(s)); 
} 

La idea aquí es utilizar static_assert que es una característica próxima en C++ y ya se implementa en varios compiladores; primordialmente los que soportan C++ 0x. Ahora bien, si no está utilizando C++ 0x, puede usar el método alternitivo, que tipicamente tipifica un entero con un valor negitive en caso de falla. Algo que no está permitido y producirá un error al compile time