Quel est le but de std :: make_pair vs le constructeur de std :: pair?

La différence est que, avec std::pair vous devez spécifier les types des deux éléments, alors que std::make_pair crée une paire avec le type des éléments qui lui sont transmis, sans que vous ayez besoin de le dire. C’est ce que je pouvais rassembler de divers documents.

Voir cet exemple à l’ adresse http://www.cplusplus.com/reference/std/utility/make_pair/

 pair  one; pair  two; one = make_pair (10,20); two = make_pair (10.5,'A'); // ok: implicit conversion from pair 

Mis à part le bonus de conversion implicite, si vous n’avez pas utilisé make_pair, vous devez le faire

 one = pair(10,20) 

chaque fois que vous en avez assigné une, ce qui serait ennuyeux avec le temps …

Comme @MSalters a répondu ci-dessus, vous pouvez maintenant utiliser des accolades pour le faire en C ++ 11 (juste vérifié avec un compilateur C ++ 11):

 pair p = {1, 2}; 

Il n’y a pas de différence entre l’utilisation de make_pair et l’appel explicite du constructeur de pair avec les arguments de type spécifiés. std::make_pair est plus pratique lorsque les types sont verbeux car une méthode de modèle a une déduction de type basée sur ses parameters donnés. Par exemple,

 std::vector< std::pair< std::vector, std::vector > > vecOfPair; std::vector emptyV; // shorter vecOfPair.push_back(std::make_pair(emptyV, emptyV)); // longer vecOfPair.push_back(std::pair< std::vector, std::vector >(emptyV, emptyV)); 

Il convient de noter que ceci est un idiome commun dans la programmation de modèles C ++. Il est connu sous le nom d’Idiom Object Generator, vous pouvez trouver plus d’informations et un bel exemple ici .

Modifier Comme quelqu’un l’a suggéré dans les commentaires (depuis supprimé), voici un extrait légèrement modifié du lien en cas de rupture.

Un générateur d’objects permet la création d’objects sans spécifier explicitement leurs types. Il est basé sur une propriété utile des modèles de fonction dont les modèles de classe ne disposent pas: Les parameters de type d’un modèle de fonction sont déduits automatiquement de ses parameters réels. std::make_pair est un exemple simple qui renvoie une instance du modèle std::pair fonction des parameters réels de la fonction std::make_pair .

 template  std::pair  make_pair(T t, U u) { return std::pair  (t,u); } 

Les arguments du modèle de classe n’ont pas pu être déduits du constructeur avant C ++ 17

Avant C ++ 17, vous ne pouviez pas écrire quelque chose comme:

 std::pair p(1, 'a'); 

car cela impliquerait des types de modèles à partir des arguments du constructeur.

C ++ 17 rend cette syntaxe possible et par conséquent make_pair redondante.

Avant C ++ 17, std::make_pair nous permettait d’écrire du code moins verbeux:

 MyLongClassName1 o1(); MyLongClassName2 o2(); auto p = std::make_pair(o1, o2); 

au lieu de plus verbeux:

 std::pair p{o1, o2}; 

qui répète les types, et peut être très long.

L’inférence de type fonctionne dans ce cas pré-C ++ 17, car make_pair n’est pas un constructeur.

make_pair est essentiellement équivalent à:

 template std::pair my_make_pair(T1 t1, T2 t2) { return std::pair(t1, t2); } 

Le même concept s’applique à l’ insert_iterator vs insert_iterator .

Voir également:

• Pourquoi ne pas déduire le paramètre template du constructeur?
• https://fr.wikibooks.org/wiki/More_C++_Idioms/Object_Generator

make_pair crée une copie supplémentaire sur le constructeur direct. Je tape toujours mes paires pour fournir une syntaxe simple.
Cela montre la différence (exemple par Rampal Chaudhary):

 class Sample { static int _noOfObjects; int _objectNo; public: Sample() : _objectNo( _noOfObjects++ ) { std::cout<<"Inside default constructor of object "<<_objectNo< map; map.insert( std::make_pair( 1, sample) ); //map.insert( std::pair( 1, sample) ); return 0; }