Comment éviter les copies temporaires lors de l'utilisation de emplace pour ajouter à une carte std :: map?

Question

#include <iostream> 
#include <map> 
using namespace std; 

struct FooStruct 
{ 
    int a; 
    int b; 
}; 

int main() 
{ 
    map<int, FooStruct> fooMap; 
    fooMap.emplace<int, FooStruct>(0, {1, 2}); 
    return 0; 
} 

En termes de prévention des copies temporaires, est-ce que l'utilisation correcte de l'emplace est la suivante? Est-ce le formulaire ci-dessus mieux que

fooMap.emplace(make_pair<int, FooStruct>(0, {1, 2})); 

Ou sont ces formes équivalentes et les deux éviter de créer une copie temporaire de FooStruct?

Answer 1

EDIT:

des trois formes décrites dans ce fil, celui qui évite des copies inutiles est la forme proposée par @ max66. Le code suivant et sa sortie capte ces trois formes dans l'action

#include <iostream> 
#include <map> 
using namespace std; 

struct FooStruct 
{ 
    FooStruct() 
    { 
     cout << "FooStruct Default Constructor" << endl; 
    } 
    FooStruct(const FooStruct& other) 
    { 
     this->a = other.a; 
     this->b = other.b; 
     cout << "FooStruct Copy Constructor" << endl; 
    } 
    FooStruct(int a, int b) 
    { 
     this->a = a; 
     this->b = b; 
     cout << "FooStruct Parametrized Constructor" << endl; 
    } 
    int a; 
    int b; 
}; 

sortie:

foo.emplace<int, FooStruct>(0, {1, 2}) 
FooStruct Parametrized Constructor 
FooStruct Copy Constructor 
fooMap.emplace(make_pair<int, FooStruct>(1, { 2, 3 })) 
FooStruct Parametrized Constructor 
FooStruct Copy Constructor 
FooStruct Copy Constructor 
fooMap.emplace(std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple(2, 4)) 
FooStruct Parametrized Constructor 

============

ORIGINAL (MAL)

J'étais un peu paresseux et je n'ai pas essayé de creuser plus avant de poster la question. Je vois maintenant que toutes ces trois formes (la troisième forme vient du commentaire de @ max66) sont équivalentes en ce qu'elles évitent toutes trois la création d'une copie temporaire de FooStruct.

#include <iostream> 
#include <map> 
using namespace std; 

struct FooStruct 
{ 
    FooStruct() { cout << "FooStruct Default Constructor" << endl; } 
    FooStruct(int a, int b) { this->a = a; this->b = b; cout << "FooStruct Parametrized Constructor" << endl; } 
    int a; 
    int b; 
}; 

int main() 
{ 
    map<int, FooStruct> fooMap; 
    fooMap.emplace<int, FooStruct>(0, {1, 2}); 
    fooMap.emplace(make_pair<int, FooStruct>(1, { 2, 3 })); 
    fooMap.emplace(std::piecewise_construct, std::forward_as_tuple(2), std::forward_as_tuple(2, 4)); 
    return 0; 
} 

Le code ci-dessus (construite avec Visual C++ 2015) produit la sortie suivante:

FooStruct Parametrized Constructor 
FooStruct Parametrized Constructor 
FooStruct Parametrized Constructor 

PS: je ne vérifie que chaque ligne de la sortie ci-dessus correspond à un seul appel emplace ci-dessus

Answer 2

Si vous définissez la « décision correcte » comme brièveté, vous pouvez utiliser std::map::insert au lieu de std::map::emplace comme ceci:

fooMap.insert({0, {1, 2}}); 

Avec emplace vous devrez soit spécifier les types explicitement comme dans votre exemple ou définir un constructeur en FooStruct explicitement dans le cas suggéré par @ max66:

fooMap.emplace(std::piecewise_construct, 
    std::forward_as_tuple(0), 
    std::forward_as_tuple(1, 2)); 

(qui manque aussi la brièveté).

fooMap.insert({0, {1, 2}}); ne devrait pas être différent de

fooMap.emplace(make_pair<int, FooStruct>(0, {1, 2})); 

en termes de quantité d'objets créés car il utilise également déplacer constructeur de std::pair comme @Swift souligné.

Si "correct" signifie "compilable et fonctionne comme prévu lors de l'exécution", alors vos deux exemples sont corrects.