Come inserire la coppia nella mappa

Question

Ho la seguente struttura di mappa: map < pair < int,int >, object* > e desidero inserirla.

Come potrei farlo perché sto cercando di inserire una coppia e un oggetto e devo fare un paio fuori da questo?

Devo creare una nuova coppia utilizzando make_pair() della coppia e dell'oggetto che ho? Se è così, potresti per favore fatemi sapere come fare questo?

Answer 1

object * myObject = // get an object somehow 
myMap.insert(std::make_pair(std::make_pair(1,2), myObject)); 

o

typedef map<pair<int, int>, object *> MapType; 
object * myObject = // get an object somehow 
myMap.insert(MapType::value_type(std::make_pair(1,2), myObject)); 

Answer 2

Ci sono due modi:

typedef std::map<int,Object> map_t; 
map_t map; 
Object obj; 

std::pair<map_t::iterator, bool> result = map.insert(std::make_pair(1,obj)); // 1 

map[1] = obj; // 2 

1. funziona solo se la chiave non è già presente, i punti di iteratore alla coppia con il valore della chiave e il bool indica se è stato inserito o meno.

2. Più facile, ma se non esiste già l'oggetto viene prima di default costruito e poi assegnato, invece di essere la copia costruito

Se non si deve preoccupare di prestazioni, basta scegliere da se o non si desidera cancellare la voce precedente.

Answer 3

si Supponendo che sta utilizzando C++ 11 o successivo, l'approccio migliore è probabilmente:

object * myObject = // get an object somehow 
myMap.emplace({1,2}, myObject); 

Per le mappe, emplace può essere pensato come una versione di insert che prende la chiave e il valore come separato argomenti (può effettivamente prendere qualsiasi combinazione di argomenti che i costruttori del tipo pair corrispondente possano prendere). Oltre ad essere sintatticamente più pulito, è anche potenzialmente più efficiente di make_pair, poiché lo standard make_pair di solito produce un'uscita il cui tipo non corrisponde esattamente allo value_type del contenitore e pertanto incorre in una conversione di tipo non necessaria.

ho usato per consigliare questo, che anche funziona solo in C++ 11 o versioni successive:

object * myObject = // get an object somehow 
myMap.insert({{1,2}, myObject}); 

questo modo si evita l'uso un po 'sorprendente di emplace, ma in passato non ha funzionato se la chiave o il valore il tipo è solo di spostamento (es. unique_ptr). Questo è stato corretto nello standard, ma l'implementazione della libreria standard potrebbe non aver ancora risolto la correzione. Questo potrebbe anche teoricamente essere leggermente meno efficiente, ma in un modo che qualsiasi compilatore a metà strada decente può facilmente ottimizzare.