How to avoid temporary copies when using emplace to add to a std::map? - c++11

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;
}
In terms of preventing temporary copies, is the above a correct usage of emplace? Is the above form better than
fooMap.emplace(make_pair<int, FooStruct>(0, {1, 2}));
Or are these forms equivalent and both of them avoid creating a temporary copy of FooStruct?

Answer 1

If you define "correctness" as brevity, you may want to use std::map::insert instead of std::map::emplace like this:
fooMap.insert({0, {1, 2}});
With emplace you will have to either specify types explicitly like in your example or define a constructor in FooStruct explicitly in the case suggested by #max66:
fooMap.emplace(std::piecewise_construct,
std::forward_as_tuple(0),
std::forward_as_tuple(1, 2));
(which also lacks brevity).
fooMap.insert({0, {1, 2}}); should not be different from
fooMap.emplace(make_pair<int, FooStruct>(0, {1, 2}));
in terms of amount of objects created as it also uses move-constructor of std::pair as #Swift pointed out.
If "correct" means "compilable and works as expected on runtime", then both your examples are correct.

Answer 2

EDIT:
Of the three forms discussed in this thread, the one that avoids unnecessary copies is the form proposed by #max66. The following code and its output captures these three forms in 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;
};
Output:
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 (WRONG)
I was little lazy and didn't try to dig deeper before posting the question. I now see that all these three forms (third form comes from #max66's comment) are equivalent in that all three of them avoid the creation of a temporary copy of 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;
}
The above code (built with Visual C++ 2015) produces the following output:
FooStruct Parametrized Constructor
FooStruct Parametrized Constructor
FooStruct Parametrized Constructor
PS: I did verify that each line in the above output corresponds to a single emplace call above