// map initialisation

#include <iostream>
#include <map>

template <typename T, typename U>
class create_map {
  private:
    std::map<T, U> m_map;
  public:
    create_map(const T& key, const U& val) {  // Methode 1
        m_map[key] = val;
    }

    create_map<T, U>& operator()(const T& key, const U& val) {  // Methode 2
        m_map[key] = val;
        return *this;
    }

    operator std::map<T, U>() {  // Methode 3
        return m_map;
    }
};

// Now set up e. g. error messages (error_number, error_message):
std::map<int,char*> errmsg = create_map<int,char*>
    (1,"Usage")
    (2,"File not found");

int main(int argc,char *argv[]) {
    return 0;
}

Irgendwie war (ist) es mir noch immer nicht ganz klar, warum man Methode 3 benötigt. Methode 1 ist klar, wird für den Funktionsaufruf von create_map(...) benötigt (das erste Klammerpaar gehört ja zur Funktion und ist kein Operator.

Methode 2 ist mir auch klar, das sind die (...)-Operatoren nach der create_map(...)-Funktion.

Ohne Methode 3 geht es aber nicht. Die wird, ich bin es mit dem Debugger durchgegangen (läuft vor main), benötigt. Zunächst wird Methode 1 für die erste Meldung (1,"Usage") aufgerufen, dann für jede weitere Meldung ab (2,"File not found") wird der überladene ()-Operator (Methode 2) aufgerufen. Ganz zum Schluss der überladene Operator (aber auch wenn es nur eine Fehlermeldung [Usage] gibt, wird der aufgerufen) aus Methode 3.

Ich habe es mir jetzt mal so klar gemacht (verstehe es aber nicht wirklich):

Er gibt die private Variable m_map der Template-Klasse create_map zurück. Aber irgendwie ist mir die Definition:

operator std::map<T, U>()

nicht ganz klar, warum ist das ein Operator (der ()-Operator aus Methode 2 ist mir klar). Aber obiger Operator ist ja eigentlich ein Operator "Klasseninstanz()" (weiß nicht wie ich das richtig ausdrücken soll), sieht für mich also nicht aus wie ein Operator.

p.s.: Und nein, ich habe kein C++-11 - da wäre obige Krücke nicht notwendig, da geht das mit:

#include <map>
using namespace std;

map<int, char> m = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};

std::map<int,char*> errmsg = create_map<int,char*>
    (1,"Usage")
    (2,"File not found");

das create_map<int, char*> Objekt überhaupt erst zu einer map konvertiert. Was sonst soll schließlich diesen Job übernehmen? Die Konstruktoren von `map` sind per se alle unpassend, schließlich haben wir uns create_map doch selbst ausgedacht.

operator std::map<T, U> (das ist der Name dieser Funktion) ist ein sog. Konvertierungsoperator

Ahhh! Jetzt (und nachdem ich es dann im Stroustrup gefunden habe - §7.3.2 in meiner deutschen 2. Auflage, "Umwandlungs-Operatoren") schnackelt es. Ich muss ja aus meiner eigenen Klasse create_map eine Konvertierung zur map-Klasse durchführen.

Danke!