Missbrauch der Komma-Operator

Question

Ich bin auf der Suche nach einer einfachen Möglichkeit, ein Array von Zeichenfolgen zur Kompilierzeit zu erstellen. Für einen Test habe ich eine Klasse mit dem Namen Strings zusammen, die folgenden Mitglieder hat:

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

diese verwenden, kann ich erfolgreich Code wie folgt zusammenstellen:

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

Der s="Hello" Teil die operator= ruft die zurück a Strings& und dann die operator, für "World!" abgerufen werden.

Was kann ich nicht an die Arbeit (in MSVC, haben alle anderen Compiler noch nicht ausprobiert) ist

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

Ich würde hier davon aus, dass Strings s="Hello" den Kopierkonstruktor nennen würde und dann würde alles verhalten das gleiche wie im ersten Beispiel. Aber ich habe den Fehler: error C2059: syntax error : 'string'

Das funktioniert aber fein:

Strings s="Hello"; 

So weiß ich, dass die Kopie Konstruktor tut zumindest Arbeit für einen String. Irgendwelche Ideen? Ich möchte wirklich, dass die zweite Methode funktioniert, nur um den Code ein wenig sauberer zu machen.

Answer 1

Ich denke, dass das Komma in Ihrem zweiten Beispiel nicht der Komma-Operator, sondern das Grammatikelement für mehrere Variablendeklarationen ist.

zB die gleiche Art und Weise, die Sie schreiben können:

int a=3, b=4 

Es scheint mir, dass Sie das Schreiben im Wesentlichen:

Strings s="Hello", stringliteral 

So der Compiler den Punkt nach dem Komma erwartet das sein Name einer Variablen und stattdessen sieht sie ein String-Literal und kündigt einen Fehler an. Mit anderen Worten, der Konstruktor wird auf "Hello" angewendet, aber das Komma ist danach nicht der Komma-Operator von Strings.

Übrigens ist der Konstruktor nicht wirklich ein Kopierkonstruktor. Es erstellt ein Strings-Objekt aus einem Literal-String-Parameter ... Der Begriff Copy-Konstruktor wird normalerweise auf denselben Typ angewendet.

Answer 2

Verwenden Sie boost::list_of.

Answer 3

Ich würde diese Art von API nicht empfehlen. Sie werden weiterhin Fälle ermitteln, die nicht wie erwartet funktionieren, da Komma der Operator mit der niedrigsten Priorität ist.Zum Beispiel wird dieser Fall nicht funktionieren:

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

Sie können in der Lage sein, die Dinge zum Laufen zu bringen, wenn Sie Klammern jedes Mal, um den Satz von Saiten verwenden, wie folgt aus:

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

Und meine Beispiel oben würde wie folgt aussehen:

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

, die wahrscheinlich gemacht werden kann, arbeiten, aber die Stenografie Syntax ist wahrscheinlich nicht wert, die heikele Semantik, die mit ihm gekommen.

Answer 4

Sie könnten eine Reihe von Zeichenzeiger

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

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

Strings s(input); 

und innerhalb des Konstruktors verwenden, durch die Zeiger durchlaufen, bis Sie die null getroffen.

Answer 5

Wenn Sie C++ 0x, haben sie neue inializer lists für diese! Ich wünschte, du könntest diese benutzen. Zum Beispiel:

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

Answer 6

Wenn die einzige Aufgabe von Strings ist eine Liste von Strings zu speichern, dann könnte boost::assign tun, um die Arbeit besser mit Standard-Containern, denke ich :)

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

Answer 7

Es ist möglich zu machen diese Arbeit, für eine ausreichend lose Definition von "Arbeit". Hier ist ein Arbeitsbeispiel, das ich vor einigen Jahren auf eine ähnliche Frage geschrieben habe. Es hat Spaß gemacht, als Herausforderung, aber ich würde es nicht in echten Code verwenden:

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