C++ cadena que puede ser NULL

Question

Estoy acostumbrado a pasar alrededor de cadena como esta en mis aplicaciones C++:

void foo(const std::string& input) 
{ 
    std::cout << input.size() << std::endl; 
} 

void bar() 
{ 
    foo("stackoverflow"); 
} 

Ahora tengo un caso en el que quiero que la cadena sea NULL:

void baz() 
{ 
    foo("stackoverflow"); 
    foo(NULL); // very bad with foo implementation above 
} 

pudiera cambiar foo a:

void foo(const std::string* input) 
{ 
    // TODO: support NULL input 
    std::cout << input->size() << std::endl; 
} 

Pero para pasar una cadena literal o copiar un char* a que la aplicación de foo tengo que escribir algo como esto:

void bar() 
{ 
    string input("hi"); // annoying temporary 
    foo(&input); 
    foo(NULL); // will work as long as foo handles NULL properly 
} 

empecé a pensar en la herencia de std::string y añadiendo una propiedad null, pero no estoy seguro de que sea una buena idea. Tal vez sea mejor simplemente usar una cadena const char* para los parámetros que pueden ser NULL, pero ¿qué ocurre si quiero guardar una copia de la cadena (o NULL) sin tener que administrar su memoria por mí mismo? (Consulte What are some of the drawbacks to using C-style strings? etc.)

¿Alguna solución inteligente?

Answer 1

Si desea que el tipo sea nulo, lo convierten en un puntero. Pase punteros de cadena en lugar de referencias, ya que esto es precisamente lo que pueden hacer los punteros, y las referencias no. Las referencias siempre apuntan al mismo objeto válido. Los punteros se pueden establecer como nulos o se vuelven a colocar para apuntar a otro objeto. Por lo tanto, si necesita las cosas que los punteros pueden hacer, use punteros.

Como alternativa, use boost :: optional, que permite una forma más segura de escribir "esta variable puede o no contener un valor".

O, por supuesto, cambie la semántica para que use cadenas vacías en lugar de nulas, pase un parámetro bool diferente que especifique si la cadena está disponible o no, o refactorizador para que no lo necesite en primer lugar.

Answer 2

Qué pasa si usted sólo tiene que utilizar:

void foo(const char *xinput) 
{ 
    if (xinput == NULL) { 
     // do something exceptional with this 
     return; 
    } 
    std::string input(xinput); 
    // remainder of code as usual 
} 

Sí, esto incurre en una asignación adicional y copia, y la llamada a la función es un poco más detallado, porque es necesario utilizar .c_str() en el caso usual, pero te da la semántica que quieres.

Answer 3

En lo personal, me gustaría cambiar la semántica para pasar alrededor vacías std :: cuerdas en lugar de NULL:

void foo(const std::string& input) 
{ 
    if (!input.empty()) 
     std::cout << input.size() << std::endl; 
} 

void bar() 
{ 
     foo(""); 
} 

Answer 4

¿Por qué no sobrecarga la función y le da a la segunda sobrecarga ningún argumento? Entonces ambas sobrecargas pueden llamar internamente a una función que proporciona la lógica de lectura y que, a su vez, pasa un puntero a std::string.

void foo_impl(string const* pstr) { … } 

void foo(string const& str) { 
    foo_impl(&str); 
} 

void foo() { 
    foo_impl(0); 
} 

Answer 5

sobrecarga de funciones al rescate ...

void foo(const std::string& input) 
{ 
    std::cout << input << std::endl; 

    // do more things ... 
} 

void foo(const char* input) 
{ 
    if (input != NULL) foo(std::string(input)); 
} 

Esto aceptará ambas matrices de char c-estilo y std :: cuerdas, e incurrirá en una carga extra en la pila si se pasa en una cadena literal o una matriz char, pero le permite mantener su implementación en un solo lugar y mantener su buena sintaxis.

Answer 6

O, la mezcla de un poco de dos respuestas anteriores:

void fooImpl(const char* input) 
{ 
    if (input != NULL) 
     std::cout << input << std::endl; 
} 

void foo(const std::string& input) 
{ 
    fooImpl(input.c_str());  
} 

void foo(const char* input) 
{ 
    fooImpl(input); 
} 

misma interfaz, ninguna copia en la pila. Podrías, si quisieras, alinear fooImpl también.

Answer 7

Absolutamente no heredan de std::string. La herencia es el acoplamiento más apretado que puede tener en C++, y que sólo está buscando nulabilidad, que se puede obtener simplemente con const char*, sobrecargas, o simplemente std::string * si realmente quiere.