T* put(K key, T value)
T& operator[] ( const K& x ) { T& result = myMap[x] = 4; //myMap is a std::map std::cout<<"Operatore [], passato KEY:"<<x<<endl; return result; }
myContainer[key] = value;
Ho tentato di effettuare un overload di tale operatore così:Codice: [Seleziona]T& operator[] ( const K& x ) { T& result = myMap[x] = 4; //myMap is a std::map std::cout<<"Operatore [], passato KEY:"<<x<<endl; return result; }il fatto è che quando istanzio il mio oggetto, poi vorrei usare tale operatore nella consueta maniera:Codice: [Seleziona]myContainer[key] = value;
int vettore[10];int & operator[] ( const int &x ){ return &(vettore[x]);}
template <typename K, typename V>class Insert_Order_Map : public std::map<K,V>{ };Insert_Order_map<string,int> myMap;myMap["primo"] = 1;//...
T* put(K key, T value) { DictionaryType::iterator it = mDictionary.find(key); if (it == mDictionary.end() ) { T* tmp = &(mDictionary[key] = value); mHistory->push_front(tmp); return tmp; }
V& operator[]( const K&& key ) { typename std::map<K,V>::iterator __i = find(key); if (__i == std::map<K,V>::end()) //se non l'ho trovato... { __i = insert(__i, std::make_pair(std::move(key), V()) ); } return (*__i).second; }
template <typename K, typename V>class FJM_Map : public std::map<K,V>{ //...
template <typename K, typename V>class FJM_Map : public std::map<K,V>{ public: V& operator[]( const K&& key ) { //Come già riportato in altro post } typename std::map<K,V>::iterator cbegin() const { return *mHistory.cbegin(); } typename std::map<K,V>::iterator cend() const { return *mHistory.cend(); } private: std::list<typename std::map<K,V>::iterator> mHistory;};using namespace std;int main(){ FJM_Map<string,int> myMap; myMap["1"] = 1; myMap["23"] = 23; myMap["-3"] = -3; myMap["23"] = 28; myMap["ultimo"] = 33; // std::cout<<myMap.cbegin()->first; for (auto x = myMap.cbegin(); x != myMap.cend(); ++x) cout<<(*x).first <<"t"<<x->second<<endl; return 0;
evidentemente qualcuno degli elementi della lista punta chissà dove (magari a end() oppure non è inizializzato, oppure è un puntatore nullo).
V& operator[]( const K&& key ) { typename std::map<K,V>::iterator __i = find(key); if (__i == std::map<K,V>::end()) //se non l'ho trovato... { __i = insert(__i, std::make_pair(std::move(key), V()) ); mHistory.push_back(__i); std::cout<<"Sto inserendo: "<<key<<std::endl; } return (*__i).second; }
Ora ricordo una cosa abbastanza subdola e bastarda: gli iteratori delle mappe, dal momento che si tratta di una struttura dati "ordinata", vengono rimescolati ad ogni inserimento, diventando di fatto non validi.Quindi nella tua lista dovresti metterci un puntatore all'elemento Value, non un iteratore della mappa.
Altra cosa, in quel codice stai inserendo elementi vuoti dentro la lista. Se ti funzionano gli assegnamenti è solo per pura fortuna.