c++ - not - nullptr

¿Cómo evito que surjan problemas con std:: string que se construye 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 a string::string(const char*, const Allocator &a = Allocator()) . Lo cual, por supuesto, es inútil, porque el puntero NULL no es un puntero válido para una cadena-c. Esta mala interpretación no surge cuando trato de llamar a foo(1) , esto produce un error en tiempo de compilación.

¿Existe alguna posibilidad de obtener un error o advertencia de este tipo en tiempo de compilación cuando accidentalmente llamo una función como

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

con la bar(0) , olvidarse de la string y, en realidad, significa tener i=0 ?

Answer 1

En realidad, las afirmaciones estáticas también funcionan. considera 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 usar static_assert, que es una característica próxima en C ++ y ya está implementada en varios compiladores; primordialmente los que soportan C ++ 0x. Ahora, si no está utilizando C ++ 0x, puede usar el método alternativo, que básicamente tipifica un entero con un valor negativo en caso de falla. Algo que no está permitido y producirá un error en tiempo de compilación

Answer 2

Esto es un poco feo, pero podría crear una plantilla que generará un error cuando se ejemplifique:

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);
}

Entonces usándolo:

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

Answer 3

Una solución algo limpia ...

#include <cassert>

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

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