habe ein seltsames Problem mit den Keys für eine <map>.
Und zwar habe ich eine std::map<char*, char*> definiert, mit welcher ich das folgende mache:

std::map<char*, char*> theMap;

    char* testString = "theTest";
    char* trimString = trim("   \t   theTest    \n");

    theMap["theTest"] = "hier ist ein wert drin";
    printf("%s\n", theMap["theTest"]);
    printf("%s\n", theMap[testString]);
    printf("%s\n", theMap[trimString]);

Die trim()-Funktion habe ich selbst geschrieben, da ich bisher leider nichts vergleichbares in der Standardlib finden konnte. Sie sieht folgendermaßen aus:

char* trim(const char* str)
{
    int len = strlen(str);
    int start = 0;
    int end = len;

    for(int i=0; i<len; i++)
        if (str[i] > 0x20)
        {
            start = i;
            break;
        }

    for(int i=len; i>0; i--)
        if (str[i] > 0x20)
        {
            end = i+1;
            break;
        }

    len = end - start;
    char* result = new char[len];
    strncpy(result, str + start, len);
    return result;
}

So, nun zum Problem: Ich füge also einen Wert unter einem bestimmten Key ("theTest") in die Map ein, und versuche nun, diesen auf drei unterschiedliche Arten wieder auszulesen. Bei der ersten, also einem literalen String, funktioniert es, bei der zweiten, über ein char*, funktioniert es ebenfalls.
Bei der dritten jedoch nicht.

Jetzt ist die erste Überlegung natürlich, daß es an der eigenen trim()-Funktion liegt. Daher habe ich nun einfach mal versucht, den zurückgegebenen String mit dem anderen zu vergleichen, aber der Vergleich bestätigt mir eigentlich, daß die trim()-Funktion wie erwartet funktioniert:

printf("%i\n", strcmp("theTest", "theTest"));   // nur um rauszufinden, daß bei Gleichheit eine 0 rauskommen muß
printf("%i\n", strcmp("theTest", trimString));
printf("%i\n", strcmp(testString, trimString));

Eigentlich müßte doch dann auch der Map-Zugriff ohne Probleme funktionieren, aber das ist eben nicht der Fall. Woran kann das liegen?

Ich hoffe ihr könnt mir helfen!

Lösung: Nimm std::string.

printf("%s\n", theMap["theTest"]); 
    printf("%s\n", theMap[testString]);

Könnte das an einer Compiler-Optimierung liegen?

Hmmm die std::strings sollen aber teilweise ihre Problemchen haben, hab ich zumindest gehört... oder was meint ihr dazu?

Hmmm die std::strings sollen aber teilweise ihre Problemchen haben, hab ich zumindest gehört...

So, hast Du gehört? Ich nicht

Wo hast Du das denn gehört und von welchen Problemchen war die Rede?

@ (D)Evil: Jepp, funktioniert werde das jetzt wohl so nutzen.

Vielen Dank!

Rock Lobster schrieb:

Hmmm okay, das klingt natürlich einleuchtend. Aber warum geht dann das hier?

printf("%s\n", theMap["theTest"]); 
    printf("%s\n", theMap[testString]);

testString ist ein Zeiger auf ein String-Literal. Und wenn der Compiler feststellt, daß ein identisches Literal schon besteht, muß er es nur einmal anlegen. Anders würde es aussehen, wenn du char testString[]="theTest"; geschrieben hättest.

PS: Auf string-Ebene wäre die trim-Funktion um einiges kürzer:

string trim(const string& src)
{
  size_t start=src.find_first_not_of(" \n\t");
  size_t ende =src.find_last_not_of(" \n\t");
  return src.substr(start,ende-start+1);
}

(achtung - nicht getestet)