Abusar del operador de coma

Question

Estoy buscando una manera fácil de crear una matriz de cadenas en tiempo de compilación. Para una prueba, he creado una clase llamada Strings que tiene los siguientes miembros:

Strings(); 
Strings(const Strings& that); 
Strings(const char* s1); 
Strings& operator=(const char* s1); 
Strings& operator,(const char* s2); 

Usando esto, puedo compilar correctamente código como este:

Strings s; 
s="Hello","World!"; 

La parte s="Hello" invoca el operator= que devuelve a Strings& y luego se llama al operator, para "World!".

Lo que no puedo ir a trabajar (en MSVC, no he probado otros compiladores aún) es

Strings s="Hello","World!"; 

Me asumir aquí que Strings s="Hello" llamarían el constructor de copia y luego todo se comportarían lo mismo que el primer ejemplo. Pero me sale el error: error C2059: syntax error : 'string'

Sin embargo, esto funciona bien:

Strings s="Hello"; 

así que sé que el constructor de copia hace al menos trabajo para una cadena. ¿Algunas ideas? Me gustaría que el segundo método funcione solo para que el código sea un poco más limpio.

Answer 1

Creo que la coma en su segundo ejemplo no es el operador de coma sino el elemento de gramática para varias declaraciones de variables.

por ejemplo, de la misma manera que se puede escribir:

int a=3, b=4 

Me parece que está esencialmente escribiendo:

Strings s="Hello", stringliteral 

Así el compilador espera que el artículo después de la coma para ser el nombre de una variable, y en su lugar ve una cadena literal y anuncia un error. En otras palabras, el constructor se aplica a "Hola", pero la coma después es no el operador de coma de Cadenas.

Por cierto, el constructor no es realmente un constructor de copia. Crea un objeto Strings a partir de un parámetro de cadena literal ... El término constructor de copia generalmente se aplica al mismo tipo.

Answer 2

Use boost::list_of.

Answer 3

No recomendaría este tipo de API. Continuará descubriendo casos que no funcionan como se esperaba, ya que coma es el operador con la precedencia más baja.Por ejemplo, este caso no va a funcionar bien:

if ("Hello","world" == otherStrings) { ... } 

Usted puede ser capaz de hacer las cosas de trabajo si utiliza soportes cada vez que todo el conjunto de cadenas, como esto:

Strings s=("Hello","World!"); 

Y mi ejemplo anterior sería el siguiente:

if (("Hello","world") == otherStrings) { ... } 

que probablemente se puede hacer para trabajar, pero la sintaxis abreviada es probablemente no vale la semántica difíciles que vienen con él.

Answer 4

Se podría utilizar un conjunto de punteros a carácter

Strings::Strings(const char* input[]); 

const char* input[] = { 
    "string one", 
    "string two", 
    0}; 

Strings s(input); 

y dentro del constructor, iterar a través de los punteros hasta llegar a la nula.

Answer 5

¡Si tienes C++ 0x, tienen el nuevo inializer lists para esto! Ojalá pudieras usar esos. Por ejemplo:

std::vector<std::string> v = { "xyzzy", "plugh", "abracadabra" }; 
std::vector<std::string> v{ "xyzzy", "plugh", "abracadabra" }; 

Answer 6

Si el único trabajo de Strings es almacenar una lista de cadenas, a continuación, boost::assign podría hacer el trabajo mejor con los contenedores estándar, creo :)

using namespace boost::assign; 
vector<string> listOfThings; 
listOfThings += "Hello", "World!"; 

Answer 7

Es posible hacer este trabajo, para una definición suficientemente holgada de "trabajo". Aquí hay un ejemplo de trabajo que escribí en respuesta a una pregunta similar hace algunos años. Fue divertido como un desafío, pero no lo usaría en el código real:

#include <iostream> 
#include <algorithm> 
#include <iterator> 
#include <vector> 

void f0(std::vector<int> const &v) { 
    std::copy(v.begin(), v.end(), 
     std::ostream_iterator<int>(std::cout, "\t")); 
    std::cout << "\n"; 
} 

template<class T> 
class make_vector { 
    std::vector<T> data; 
public: 
    make_vector(T const &val) { 
     data.push_back(val); 
    } 

    make_vector<T> &operator,(T const &t) { 
     data.push_back(t); 
     return *this; 
    } 

    operator std::vector<T>() { return data; } 
}; 

template<class T> 
make_vector<T> makeVect(T const &t) { 
    return make_vector<T>(t); 
} 

int main() { 
    f0((makeVect(1), 2, 3, 4, 5)); 
    f0((makeVect(1), 2, 3)); 
    return 0; 
}