ich stehe zur Zeit vor folgendem Problem:
Ich verwende eine map<string, string>.

Wenn ich bei einer Map auf ein nicht existierendes Element zugreife wie
zum Beispiel:

map<string, string> myMap;
myMap["hallo"] = "jajaja";

dann wird ja das Element mit dem "Index" hallo eingefügt.
Nun würde ich gerne sicherstellen, dass in diese Map nur Indizes kleingeschrieben
eingetragen werden.
D.h. wenn ich auf myMap["HuHu"] zugreife, soll er es verwenden wie myMap["huhu"].
Und sollte mit groß-geschrieben zugegriffen werden hätte ich gerne die
Möglichkeit mit cout oder sonstwie eine Meldung in die Konsole zu jagen.

Das heißt meiner Meinung nach, dass ich den Operator [] überladen muss.
Da map aber ein Template ist habe ich (auch nach einiger Zeit googlen) nicht so
wirklich herausgefunden, wie ich NUR diesen Operator soweit abändern kann,
dass oben genannte Funktionalität gegeben ist,
ALLE anderen Funktionalitäten aber bleiben wie sie sind.

Vielleicht kann mir von euch ja jemand helfen.
Vielen Dank.
greetz
Marius

mach dir doch ein spezialisiertes Template für string wo du dir den operator überschreibst

*g* Tjo... mein Problem ist, dass ich bisher noch keine Erfahung mit Überschreiben von Operatoren usw. hab.
Und bei den Google-Ergebnissen habe ich immer nur neue Klassen gefunden,
bei denen dann Operatoren definiert wurden.
Ich brauche aber ja sozusagen dann ne eigene Map Klasse, die alle Eigenschaften der map<string, string> hat und in der nur der eine Operator dann irgenwie(*g*) anders ist.

Leider habe ich null Plan, wie ich das anstellen sollte.

Mach ne externe Funktion. An std::map brauchst und solltest du nicht rumfummeln.

Rumfummeln will ich da auch nicht dran.
Ich möchte nur eine Klasse oder ein Template haben, das genauso ist wie ne map<string, string> oder map allgemein, nur halt der [] Operator anders.
Und ich kann auch nicht alles so umprogrammieren, dass ich vor der Nutzung der Map den String prüfe, da der Code so ca. 20.000 Zeilen haben wird mittlerweile und alles mit map implementiert ist.
Daher brauche ich eine Lösung, die möglichst einfach im "Umbau" ist.

Sieht dann in etwa so aus

struct StringCaseInsensitiveLess : public std::binary_function<std::string, std::string, bool>
{
   bool operator()( const std::string& lhs, const std::string& rhs) const
   {
      /// beide Strings nach lower oder upper Käs umwandeln
      /// und dann true zurückgeben, wenn der erste lexikographisch
      /// kleiner ist
   }
};

map<std::string, std::string, StringCaseInsensitiveLess> klaus;

Edit: von binary_function abgeleitet

Schreib Dir ein Komparator-Objekt und steck das in die Map
--- snip ---

Aber bringt mir das denn was, wenn ich nicht nur beim anlegen eines Elements
sondern auch bei theoretisch jedem Zugriff mit dem Operator [] diese Funktion nutzen will?
Dachte das ist nur für die interne Sortierung der Map sinnvoll diese Funktion.

Der Witz ist eben, dass die Map nicht auf Gleichheit, sondern auf Äquivalenz vergleicht.

== wird in etwa so definiert (in einer Map wohlgemerkt!):

bool operator == ( const T& lhs, const T& rhs) const
{
  return !comp( lhs, rhs) && !comp( rhs, lhs);
}

wobei comp das Komparator-Objekt ist, dass Du in die Map gesteckt hast.

Wenn jetzt "HuHu" schon drinsteht, würde "huhu" nicht mehr eingefügt (weil äquivalent zu "HuHu" und damit schon vorhanden)