Mapa STL do generycznego wektora C++

Question

Chcę zaimplementować mapę, która mapuje ciąg do ogólnego wektora.

chcę to zrobić:

std::map<std::string, std::vector<class T> > myMap; 

Zakładając proponowane MyMap miał następującą włożona do niego, może być stosowany jako taki:

vector<int> intVec = myMap["ListOfInts"]; // Works because "ListOfInts" maps to a vector<int> 
vector<string> stringVec = myMap["ListOfStrings"]; // Works because "ListOfInts" maps to a vector<string> 

Kiedy Oświadczam mapę z powyższych Składnia kompilator ma atak serca.

Czy ktokolwiek może sugerować? Lub lepszą opcję tablicy asocjacyjnej w C++ (sugeruje brak wzmocnienia przed podbiciem).

Answer 1

Skoro znasz typ chcesz podczas pisania kodu, proponuję takie podejście (niesprawdzone):

// base class for any kind of map 
class BaseMap { 
public: 
    virtual ~BaseMap() {} 
}; 

// actual map of vector<T> 
template<typename T> 
class MapT : public BaseMap, public std::map<std::string, std::vector<T>> {}; 

class MultiMap { 
public: 
    template<typename T> 
    std::vector<T>& get(const std::string& key) { 
    std::unique_ptr<BaseMap>& ptr = maps_[std::type_index(typeid(T))]; 
    if (!ptr) ptr.reset(new MapT<T>()); 
    return ptr->second[key]; 
    } 
private: 
    std::map<std::type_index, std::unique_ptr<BaseMap>> maps_; 
} 

int main() { 
    MultiMap map; 
    std::vector<int>& intVec = map.get<int>("ListOfInts"); 
    std::vector<std::string>& stringVec = map.get<std::string>("ListOfStrings"); 
} 

Answer 2

Argumenty szablonów muszą być określone jako czas kompilacji. Jeśli chcesz, aby każdy klucz mapy odpowiadał wektorowi innego typu, to tak naprawdę nie zadziała. Możesz obejść to z polimorficznym pojemnikiem, który zwraca pustkę *, którą rzucasz do poprawnego typu, ale sugerowałbym próbę znalezienia innego sposobu zrobienia tego, co chcesz zrobić z twoją mapą.

Answer 3

Może to może pracować dla Ciebie:

template <typename T> 
class MyMap { 
    std::map<std::string, std::vector<typename T> > map; 
public: 
    /*...*/ 
}; 

Answer 4

z C++ 11, można użyć using, robi dokładnie to, co chcesz:

#include <vector> 
#include <map> 
#include <string> 

template<typename T> using mymap = std::map<std::string, std::vector<T>>; 

int main() 
{ 
    mymap<int> intmap; 
    mymap<std::string> stringmap; 

    std::vector<int> intvec = intmap["test"]; 
    std::vector<std::string> stringvec = stringmap["test"]; 

    return 0; 
} 

Live Demo

Answer 5

Jak powiedział mattnewport, jedną z opcji jest boost::variant.

Aby obsłużyć wszystkie typy, należy użyć boost::any, jawnie podając any_cast.

Biorąc pod uwagę zwiększenie obciążenia, może to być duża waga, może można odkryć nowe koło i uprościć je, aby nie było już więcej doładowania? lol