Comment insérer une paire dans une carte

Question

J'ai la structure de carte suivante : map < pair < int,int >, object* > et je souhaite m'y insérer.

Comment dois-je procéder puisque j'essaie d'insérer une paire et un objet et je dois faire la paire de cela ?

Dois-je créer une nouvelle paire en utilisant make_pair() de la paire et de l'objet que j'ai ? Si oui, pourriez-vous m'indiquer comment procéder ?

Answer 1

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

ou

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

En supposant que vous utilisiez C++11 ou une version ultérieure, la meilleure approche est probablement :

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

Pour les cartes, emplace peut être considéré comme une version de insert qui prend la clé et la valeur comme arguments séparés (il peut en fait prendre n'importe quelle combinaison d'arguments que la fonction pair peuvent prendre). En plus d'être syntaxiquement plus propre, cette méthode est aussi potentiellement plus efficace que la méthode make_pair porque make_pair produira généralement un résultat dont le type ne correspond pas exactement à l'option value_type du conteneur, ce qui entraîne une conversion de type inutile.

J'avais l'habitude de recommander cette méthode, qui ne fonctionne également qu'avec C++11 ou une version plus récente :

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

Cela permet d'éviter l'utilisation un peu surprenante de emplace mais cela ne fonctionnait pas auparavant si le type de clé ou de valeur était de type "move-only" (par ex. unique_ptr ). Ce problème a été corrigé dans la norme, mais il se peut que l'implémentation de votre bibliothèque standard n'ait pas encore pris en compte cette correction. En théorie, cela pourrait aussi être légèrement moins efficace, mais d'une manière que n'importe quel compilateur à peu près décent peut facilement optimiser.

Answer 3

Il y a deux façons de procéder :

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. Ne fonctionne que si la clé n'est pas déjà présente, l'itérateur pointe vers la paire avec la valeur de la clé et le bool indique si elle a été insérée ou non.

2. Plus facile, mais s'il n'existe pas déjà, l'objet est d'abord construit par défaut puis assigné au lieu d'être construit par copie.

Si vous n'avez pas à vous préoccuper des performances, choisissez simplement d'effacer ou non l'entrée précédente.

Answer 4

int a=10,b=20;

map < pair < int,int >, int > m;

pair < int,int >numbers = make_pair(a,b);

int sum=a+b;

m[numbers]=sum;

Nous pouvons accéder aux valeurs entières des paires de variables en utilisant l'opérateur dot(.).