foo.operator[]<int>(bar);

Oder bau irgendwie künstlich ein deduzierbares Argument ein. Z.B: Bestimmt der Parameter den Rückgabetyp? Dann gib per Referenz zurück.

Also kurz gesagt: Nein, es gibt keine schönere Syntax, du musst schon noch irgendetwas ändern.

template <typename T>
T const& operator [] (std::string const& what);

Aber das geht ja nun wohl nicht. get und at gefällt mir aber irgendwie auch nicht.

Edit: Ach so, du willst einfach nachgucken ob der Wert nach T konvertierbar ist. Na ja, da würde ich es auch einfach get nennen. foo.get<int>("blubb"); sieht doch nicht so schlimm aus.

cnf.get<int>("foo");

wird intern ein dynamic_cast ausgeführt, der überprüft, ob "foo" tatsächlich vom Typ int ist. Wenn nicht -> Exception.

cnf.get<int>("foo");

Gerade editiert. Wie gesagt, ich finde das nicht schlimm so. Der Typ ist anders ja nicht auffindbar und quasi ein zusätzlicher Parameter, insofern erhöht das ja die Redundanz nicht.

Wenn die Daten ursprünglich schon als string vorliegen, warum speicherst du sie dann nicht als string ab und konvertierst sie erst beim Aufruf von get<T> nach T?

Das ist ein andere Art der Datenspeicherung. Wenn man so etwas hat wie xml, ist das natürlich der einzige Weg. Man kann ja beim einlesen auch nicht wissen (sondern nur raten), welchen Typ etwas hat.

Wenn die Datenstruktur den Typ allerdings speichert, ist das etwas anderes. Dann möchte man vielleicht auch garantiert sofort entdecken ob ein Wert zum Typ passt.
Wenn das nicht der Fall ist, wie oben gesagt, macht man die Umwandlung natürlich erst bei der Abfrage.

Edit: Argh, dauernd zu spät in letzter Zeit. -.-

Wenn alles auf einmal passiert hat das nur Nachteile, z.B. muss die ganze Datei zweimal im Speicher behalten werden (Validiert und Nutzung) und es ist langsamer, weil beim langsamen Lesen alles blockiert ist und ein Verwaltungsoverhead (dynamic_cast) da ist.

Habe ich dich richtig verstanden, dass du im Parser die Typen kennst

Ja.

Michael E. schrieb:

und als Templateparameter setzen könntest?

Wie meinst du das?

Folgendes:

//dein op[]
Proxy operator[](string const& what) {
   return Proxy(this, what);
}

//proxy sieht dann etwa so aus:
class Proxy {
private:
  DB* db; // zeiger auf die parser db wo die werte liegen
  string what;
  Proxy(DB* db, string const& what) : db(db), what(what) {}
public:
   //hier die magie
  template<typename T>
  operator T() {
     return db->get<T>(what);
  }
};

Man muss natuerlich ueberpruefen was Proxy jetzt alles genau koennen muss - aber prinzipiell ist die Idee die Ausfuehrung des Codes vom op[] in den opT zu verlagern, da wir dort auf den return Typen aufloesen koennen.

Dann laesst sich ein:

int i=conf["foo"];
double f=conf["bar"];

machen.