【C++ STL 深入解析】insert 与 emplace 的区别与联系（以 multimap 为例）

目录

• 前言
• [一、insert 与 emplace 的基本语法](#一、insert 与 emplace 的基本语法)
• 二、底层机制分析
• • [1. `insert` 的工作方式](#1. insert 的工作方式)
  • [2. `emplace` 的工作方式](#2. emplace 的工作方式)
• [三、性能差异：insert vs emplace](#三、性能差异：insert vs emplace)
• 四、隐式类型转换时的区别
• [五、是否可以用 emplace 完全取代 insert？](#五、是否可以用 emplace 完全取代 insert？)
• • [1. 已经有完整对象的情况](#1. 已经有完整对象的情况)
  • [2. 构造函数参数存在歧义时](#2. 构造函数参数存在歧义时)
  • [3. 隐式类型转换支持不同](#3. 隐式类型转换支持不同)
  • [4. 语义与可读性差异](#4. 语义与可读性差异)
• 六、性能实际差距
• 七、总结对比表
• 八、实战建议
• 九、结语
• • 参考总结

---

前言

在使用 C++ STL 容器时，我们经常会遇到两种插入元素的方式：insert() 和 emplace()。

它们看起来功能类似，但底层机制与性能差异却很大，尤其是在 map / multimap / set 等关联容器中更为明显。

本文将深入分析这两者的区别、使用场景及性能差异，并回答一个常见问题：

"既然 emplace 更高效，那它能完全取代 insert 吗？"

---

一、insert 与 emplace 的基本语法

在 STL 容器中：

multimap<string, int> dict;

// 使用 insert 插入
dict.insert(std::make_pair("apple", 1));

// 使用 emplace 插入
dict.emplace("banana", 2);

两种方式最终效果一致：都在容器中插入一个键值对。

但它们的底层实现机制不同：

• insert()：先构造一个对象，再将其拷贝或移动进容器；
• emplace()：直接在容器内部原地构造对象。

---

二、底层机制分析

1. insert 的工作方式

当你调用：

dict.insert(std::make_pair("a", 1));

发生的事情是：

1. 调用 std::make_pair("a", 1) 创建一个临时对象；
2. 将这个临时对象拷贝或移动到容器中。

也就是说，insert 至少会涉及一次构造 + 一次拷贝/移动。

---

2. emplace 的工作方式

当你调用：

dict.emplace("a", 1);

时，emplace 会在容器内部直接调用构造函数构造 pair<const string, int> 对象。

整个过程只有一次原地构造，没有临时对象。

---

三、性能差异：insert vs emplace

来看一个演示代码：

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

struct Item {
    string name;
    Item(string n) : name(n) {
        cout << "构造: " << name << endl;
    }
    Item(const Item& other) {
        cout << "拷贝构造: " << other.name << endl;
    }
};

int main() {
    multimap<int, Item> dict;

    cout << "--- insert ---" << endl;
    dict.insert(std::make_pair(1, Item("A")));

    cout << "--- emplace ---" << endl;
    dict.emplace(2, "B");
}

运行输出：

--- insert ---
构造: A
拷贝构造: A
--- emplace ---
构造: B

可以看到：

• insert 发生了构造 + 拷贝构造；
• emplace 只有一次构造。

---

四、隐式类型转换时的区别

有时我们会直接写：

dict.insert({"apple", 1});

这行代码虽然看起来简洁，但仍然会：

1. 先把 {"apple", 1} 转换成 std::pair<const string, int>；
2. 然后拷贝或移动到容器中。

也就是说，即使使用隐式转换，insert 仍然会产生临时对象。

而：

dict.emplace("banana", 2);

则会直接调用构造函数，不会构造临时对象。

所以：

即使 insert 使用了隐式类型转换，它依然没有 emplace 高效。

---

五、是否可以用 emplace 完全取代 insert？

这是最常见、也是最容易误解的问题。

很多人认为：

"emplace 更高效，那以后都用 emplace 不就好了？"

但实际上，这样做并不总是合适。原因如下👇

---

1. 已经有完整对象的情况

pair<string, int> p("apple", 1);
dict.insert(p);      // ✅ 合法，直接插入
dict.emplace(p);     // ❌ 错误！无法匹配构造函数

emplace 需要参数能构造出新对象，而不是接收一个现成对象。

此时使用 insert 更自然、语义更清晰。

---

2. 构造函数参数存在歧义时

struct A {
    A(int x, int y) {}
    A(pair<int, int> p) {}
};

multimap<int, A> m;
m.emplace(1, 1, 2);  // ❌ 编译器可能歧义
m.insert({1, A(1, 2)}); // ✅ 明确无误

insert 的显式语义更强，不会引起构造函数选择的歧义。

---

3. 隐式类型转换支持不同

• insert 支持隐式类型转换；
• emplace 不支持，要求参数严格匹配构造函数。

例如：

dict.insert({"a", 1}); // ✅ 自动转为 pair<const string, int>
dict.emplace({"a", 1}); // ❌ 编译错误

因此在一些初始化写法中，insert 更宽容。

---

4. 语义与可读性差异

insert 表示：

"我已经有一个完整对象，要放进容器中。"

emplace 表示：

"我需要直接在容器中构造一个新对象。"

这在代码语义上也有明显区别。

比如：

users.insert(user);      // 插入已存在对象
users.emplace(name, id); // 原地构造新对象

---

六、性能实际差距

在现代编译器下（如 g++ -O2 或 MSVC 优化开启时），

如果对象支持移动构造，那么多出来的那次"移动"操作开销非常小。

只有在以下场景下 emplace 才表现出显著优势：

• 插入对象构造成本高（例如包含复杂成员或字符串）；
• 插入操作非常频繁（如百万次循环插入）。

---

七、总结对比表

特性	insert	emplace
原地构造	❌ 否	✅ 是
临时对象	✅ 会产生	❌ 不产生
已有对象插入	✅ 合适	⚠️ 不便
支持隐式转换	✅ 支持	❌ 不支持
构造歧义风险	低	⚠️ 可能有
性能	稍慢	✅ 稍快
语义	插入现成对象	原地构造对象
可读性	✅ 明确	表达"构造并插入"的意图

---

八、实战建议

1. 优先使用 emplace

   当你直接传递构造参数时，用 emplace 能避免临时对象。

   dict.emplace("key", 100);

2. 已有对象时使用 insert

   例如从另一个容器中复制对象、或已有完整 pair 时：

   pair<string, int> p("key", 100);
   dict.insert(p);

3. 模板或泛型代码中慎用 emplace

   因为参数匹配严格，可能导致模板代码编译失败。

---

九、结语

emplace 是 C++11 引入的一种"原地构造"机制，它在多数情况下比 insert 更高效，也更现代。

但这并不意味着 insert 已经"过时"或"应当废弃"。

简单来说：

• "我已经有对象" → 用 insert
• "我想直接构造对象" → 用 emplace

理解这两者的语义差异，才能在实际项目中写出既高效又清晰的代码。

---

参考总结

• insert：插入已有对象。
• emplace：原地构造新对象。
• 性能差距通常很小，但语义选择更重要。

---

封面图来源于网络，如有侵权，请联系删除！