almacenamiento de instancias struct en un std :: mapa

Question

Estoy intentando trazar algunas estructuras a algunos otros casos, como este:

template <typename T> 
class Component { 
public: 

    typedef std::map<EntityID, T> instances_map; 

    instances_map instances; 

    Component() {}; 

    T add(EntityID id) { 
     T* t = new T(); 
     instances[id] = *t; 
     return *t; 
    }; 
}; 

Entonces lo uso como esto:

struct UnitInfos { 
    int owner_id; 
    int health; 
    float x, y; 
}; 

class LogicComponent : public Component<UnitInfos> {}; 

El problema es que cuando más tarde recuperar datos más adelante, así:

comp.instance[id]; 

consigo un nuevo objeto Breand con propiedades inicializadas a valores por defecto.

¿Hay algo intrínsecamente incorrecto con este fragmento de código, o estoy omitiendo información sobre el problema?

---

según la sugerencia @aaa, puedo cambiar el código para

typedef std::map<EntityID, T> instances_map; 
instances_map instances; 
T& add(EntityID id) { 
    instances[id] = T(); 
    return instances[id]; 
}; 

pero cuando puedo acceder a él

UnitInfos &info = logic_c.instances[id]; 

el valor de info.x sigue siendo 0. Cualquier punteros?

---

El problema era cómo Almacené la referencia a LogicComponent en otra clase. utilizando LogicComponent logic_c; en lugar de LogicComponent& logic_c;. Ahora funciona, pero estoy almacenando punteros en el mapa (en lugar de la sugerencia de @aaa). ¿Es una mala idea?

Answer 1

Aclare las operaciones que desea realizar en LogicComponent. Suponiendo que usted está tratando de lograr algo como esto:

Paso 1: Agregar una nueva entrada en el mapa:

LogicComponent comp; 
EntityID id = 99; 
UnitInfos info = comp.add(id); 

Paso 2: Iniciar el Info:

info.x = 10.0; 
info.y = 11.0 
// etc 

Paso 3: Obtener la información objeto nuevo:

UnitInfos info2 = comp.instances[id]; // this is uninitialized. 

Luego, unos comentarios de código están en orden:

El objeto de información devuelto por comp.add es una COPIA del objeto que ha agregado al mapa. Al modificarlo, no está modificando lo que está en el mapa.

La solución más simple es crear un mapa de punteros al objeto en lugar del objeto en sí.

typedef std::map<EntityID, T*> pinstances_map; 

T * add(EntityID id) { 
    T* t = new T(); 
    instances[id] = t; 
    return t; 
}; 

// initialize as 
UnitInfo *info = comp.add(id); 
info->x = 10.0; 
info->y = 11.0; 

// retrieve as 
UnitInfos *info = comp.instances[id]; 

Además, utilice un método de acceso para obtener el valor asignado, en lugar de exponer el objeto del mapa como público. Haga que las instancias estén protegidas y agregue un método get público().

Editar: Este código funciona bien para mí:

#include <map> 
#include <iostream> 
using namespace std; 

template<typename T> 
class Component 
{ 
public: 
     typedef map<long, T*> pinstances_map; 
     pinstances_map instances; 

     T * add(long id) 
     { 
       T *t = new T(); 
       instances[id] = t; 
       return t; 
     } 
}; 

struct UnitInfo 
{ 
     float x, y; 
}; 

class LogicComponent: public Component<UnitInfo> {}; 

int main() 
{ 
     LogicComponent comp; 
     UnitInfo *info = comp.add(99); 
     info->x = 10.0; 
     info->y = 11.0; 

     UnitInfo *info2 = comp.instances[99]; 
     cout << info2->x << " " << info2->y; 

     return 0; 
} 

Answer 2

podría ser que

T add(EntityID id) { 
    T* t = new T(); 
    instances[id] = *t; 
    return *t; // return value and map instance are not the same anymore 
}; 

debería ser

T& add(EntityID id) { 
    instances[id] = T(); 
    return instances[id]; 
}; 

Answer 3

Suena como que ha definido el operador de indexación como:

template <typename T> 
T& Component::operator[](EntityID id) 
{ 
    return instances[id]; 
} 

O algo por el estilo.

El posible efecto inesperado de esto es que insertará automáticamente la instancia construida por defecto de T en el mapa y luego lo devolverá para las entradas no existentes. Esto se hace en std::map por lo que funciona la sintaxis de asignación natural como instances[10] = t;.

El punto clave aquí es constness. Definir exactamente como antes, excepto por el valor de regresar y con un atributo const:

template <typename T> 
T Component::operator[](EntityID id) const 
{ 
    return instances[id]; 
} 

De esta manera obtendrá una excepción cuando intenta recuperar por la clave no existe.Mejor aún, tal como se typedef abajo y acabar de una vez:

typedef std::map<EntityID,UnitInfos> EntityUnitMap; 

Otros ya mencionado de que no es necesario asignar dinámicamente un objeto - se almacena una copia en el contenedor de todos modos - y que usted pérdida de memoria cuando haces eso