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;
}

在防止临时复制方面，上面是正确的使用安置吗？以上形式是否优于

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

或者这些表单是否等效，并且它们都避免创建FooStruct的临时副本？

Answer 1

如果您将“正确性”定义为简洁，则可能需要使用std::map::insert代替std::map::emplace，如下所示：

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

使用emplace，您必须明确指定类型，例如在FooStruct中明确定义类型，在@ max66建议的情况下：

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

（也缺乏简洁）。

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

不同

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

就创建的对象数量而言，它也使用std::pair的move-constructor作为@Swift指出。

如果“正确”表示“可编译并在运行时按预期工作”，那么您的示例都是正确的。

Answer 2

编辑：

在本主题中讨论的三种形式中，避免不必要副本的形式是@ max66提出的形式。以下代码及其输出捕获了这三种形式的实际操作

#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;
};

输出：

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）

我有点懒，在发布问题之前没有尝试深入挖掘。我现在看到所有这三种形式（第三种形式来自@ max66的评论）都是等同的，因为它们都避免创建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;
}

上面的代码（使用Visual C ++ 2015构建）产生以下输出：

FooStruct Parametrized Constructor
FooStruct Parametrized Constructor
FooStruct Parametrized Constructor

PS：我确实验证了上面输出中的每一行都对应于

上面的一个emplace调用

使用emplace添加到std :: map时如何避免临时副本？

2 个答案: