Usando char * como clave en std :: map

Question

Estoy tratando de averiguar por qué el siguiente código no funciona, y supongo que es un problema con el uso de char * como tipo de clave, sin embargo, no estoy seguro cómo puedo resolverlo o por qué está ocurriendo. Todas las otras funciones que uso (en el SDK HL2) usan char*, por lo que usar std::string va a causar muchas complicaciones innecesarias.

std::map<char*, int> g_PlayerNames; 

int PlayerManager::CreateFakePlayer() 
{ 
    FakePlayer *player = new FakePlayer(); 
    int index = g_FakePlayers.AddToTail(player); 

    bool foundName = false; 

    // Iterate through Player Names and find an Unused one 
    for(std::map<char*,int>::iterator it = g_PlayerNames.begin(); it != g_PlayerNames.end(); ++it) 
    { 
     if(it->second == NAME_AVAILABLE) 
     { 
      // We found an Available Name. Mark as Unavailable and move it to the end of the list 
      foundName = true; 
      g_FakePlayers.Element(index)->name = it->first; 

      g_PlayerNames.insert(std::pair<char*, int>(it->first, NAME_UNAVAILABLE)); 
      g_PlayerNames.erase(it); // Remove name since we added it to the end of the list 

      break; 
     } 
    } 

    // If we can't find a usable name, just user 'player' 
    if(!foundName) 
    { 
     g_FakePlayers.Element(index)->name = "player"; 
    } 

    g_FakePlayers.Element(index)->connectTime = time(NULL); 
    g_FakePlayers.Element(index)->score = 0; 

    return index; 
} 

Answer 1

Debe asignar un functor de comparación al mapa; de lo contrario, compara el puntero char * y no la cadena. En general, este es el caso cada vez que desee que su clave de mapa sea un puntero.

es decir.

struct cmp_str 
{ 
    bool operator()(char const *a, char const *b) 
    { 
     return std::strcmp(a, b) < 0; 
    } 
}; 

map<char *, int, cmp_str> BlahBlah; 

EDIT: Acutally ignore mi edición, el functor es más fácil de usar.

Answer 2

No se puede utilizar char* menos que esté absolutamente seguro al 100% que se va a acceder al mapa con los mismos punteros exactas, no cadenas.

Ejemplo:

char *s1; // pointing to a string "hello" stored memory location #12 
char *s2; // pointing to a string "hello" stored memory location #20 

Si accede mapa con s1 obtendrá un lugar diferente de acceder a él con s2.

Answer 3

Estás comparando el uso de un char * con una cuerda. Ellos no son los mismos.

A char * es un puntero a un char. En definitiva, es un tipo entero cuyo valor se interpreta como una dirección válida para char.

Una secuencia es una cadena.

El contenedor funciona correctamente, pero como un contenedor para pares en el que la clave es char * y el valor es int.

Answer 4

Dos cadenas estilo C pueden tener el mismo contenido pero estar en diferentes direcciones. Y que map compara los punteros, no los contenidos.

El costo de la conversión a std::map<std::string, int> puede no ser tanto como usted cree.

Pero si realmente es necesario utilizar const char* como claves mapa, trate de:

#include <functional> 
#include <cstring> 
struct StrCompare : public std::binary_function<const char*, const char*, bool> { 
public: 
    bool operator() (const char* str1, const char* str2) const 
    { return std::strcmp(str1, str2) < 0; } 
}; 

typedef std::map<const char*, int, StrCompare> NameMap; 
NameMap g_PlayerNames; 

Answer 5

No hay ningún problema para utilizar cualquier tipo de clave, siempre que soporta la comparación (<, >, ==) y asignación.

Un punto que debe mencionarse: tenga en cuenta que está utilizando una plantilla clase. Como resultado, el compilador generará dos instancias diferentes para char* y int*. Mientras que el código real de ambos será prácticamente idéntico.

Por lo tanto, consideraría utilizar un void* como tipo de llave, y luego fundir según sea necesario. Esta es mi opinión.

Answer 6

lo puede conseguir trabajar con std::map<const char*, int>, pero no se debe utilizar no const punteros (nótese el const añadido para la llave), porque no se debe cambiar esas cadenas, mientras que el mapa se refiere a ellos como claves. (Aunque un mapa protege sus claves haciéndolos const, esto sólo constify el puntero , no la cuerda que apunta.)

Pero ¿por qué no simplemente usar std::map<std::string, int>? Funciona de la caja sin dolores de cabeza.

Answer 7

Como dicen los demás, probablemente debería usar std :: string en lugar de un char * en este caso, aunque no hay nada de malo en principio con un puntero como clave si eso es lo que realmente se necesita.

Creo que otro motivo por el que este código no funciona es porque una vez que encuentras una entrada disponible en el mapa, intentas volver a insertarla en el mapa con la misma clave (el char *). Como esa clave ya existe en su mapa, la inserción fallará. El estándar para map :: insert() define este comportamiento ... si el valor de la clave existe, la inserción falla y el valor mapeado permanece sin cambios. Luego se borra de todos modos. Tendría que eliminarlo primero y luego reinsertarlo.

Incluso si cambia el char * a std :: string este problema se mantendrá.

Sé que este hilo es bastante antiguo y lo ha arreglado todo por ahora, pero no vi a nadie mencionar este punto por el bien de los futuros espectadores que estoy respondiendo.

Answer 8

Tuve un momento difícil utilizando el char * como la clave del mapa cuando trato de encontrar un elemento en varios archivos de origen. Funciona bien cuando todo el acceso/búsqueda dentro del mismo archivo fuente donde se insertan los elementos. Sin embargo, cuando intento acceder al elemento usando find en otro archivo, no puedo obtener el elemento que definitivamente está dentro del mapa.

Resulta que la razón es como Plabo señalado, los punteros (cada unidad de compilación tiene su propia char constante *) NO son los mismos cuando se accede a ellos en otro archivo cpp.