[c++] push_back和emplace_back的区别

本文详细对比了C++中的emplace_back和push_back操作,前者直接在容器内存空间创建对象,后者则先创建临时对象再拷贝。通过具体示例展示了不同情况下的操作流程及效率差异。

介绍

emplace操作是C++11新特性,新引入的三个操作emplace_front、emplace 和 emplace_back,分别对应push_front、insert 和push_back,允许我们将元素放在容器头部、一个指定的位置和容器尾部[1]
本文以emplace_back和push_back为例讲解两者的区别。


区别

  1. 调用push_back时,参数为元素类型的对象,这个对象被拷贝到容器中。
  2. 调用emplace_back时,参数与该元素类型构造函数的参数相同,会在容器管理的内存空间内直接创建对象。

使用场景

有类A如下:

class A
{
public:
	A(int x) { x_ = x; };
	A(const A& a) { x_ = a.x_; };
private:
	int x_;
};
  1. 若push_back/emplace_back传递的参数为未被构造的对象,即在传递参数时构建对象,如vec.push_back(A(1)) / vec.emplace_back(1),这种情况下两种方法涉及的操作为
    push_back
    • 新建临时对象
    • 将该临时对象拷贝至容器末尾
    • 销毁该临时对象
    emplace_back
    • 在容器末尾新建对象
  2. 若push_back/emplace_back传递的参数为已被构造的对象,如A a(1); vec.push_back(a) / vec.emplace_back(a),这种情况下两种方法涉及的操作相同:
    push_back
    • 将该对象拷贝至容器末尾
    emplace_back
    • 将该对象拷贝至容器末尾

示例

代码:

#include <iostream>
#include <vector>


using namespace std;


class A
{
public:
    A (int x = 0) { x_ = x; cout << "constructor : " << x_ << endl; };
    A (const A& a) { x_ = a.x_; cout << "copy constructor : " << x_ << endl; };
    ~A () { cout << "destructor : " << x_ << endl; };

private:
    int x_;
};


int main()
{
    A a(2);
    cout << "##### push_back #####" << endl;
    vector<A> vec_push;
    cout << "capacity : " << vec_push.capacity() << endl << endl;

    vec_push.push_back(A(1));		// 未被构造的对象
    cout << "capacity : " << vec_push.capacity() << endl << endl;

    vec_push.push_back(a);			// 已被构造的对象
    cout << "capacity : " << vec_push.capacity() << endl << endl;

    
    cout << "\n\n##### emplace_back #####" << endl;
    vector<A> vec_emplace;
    cout << "capacity : " << vec_emplace.capacity() << endl << endl;

    vec_emplace.emplace_back(1);	// 未被构造的对象
    cout << "capacity : " << vec_emplace.capacity() << endl << endl;

    vec_emplace.emplace_back(a);	// 已被构造的对象
    cout << "capacity : " << vec_emplace.capacity() << endl << endl;
    

    cout << "\n\n##### exit #####" << endl;
    return 0;
}

运行结果:

constructor : 2
##### push_back #####
capacity : 0

constructor : 1
copy constructor : 1
destructor : 1
capacity : 1

copy constructor : 2
copy constructor : 1				# 这次拷贝构造的开销由vector扩容引起
destructor : 1						# 这次析构的开销由vector扩容引起
capacity : 2



##### emplace_back #####
capacity : 0

constructor : 1
capacity : 1

copy constructor : 2
copy constructor : 1				# 这次拷贝构造的开销由vector扩容引起
destructor : 1						# 这次析构的开销由vector扩容引起
capacity : 2



##### exit #####
destructor : 1
destructor : 2
destructor : 1
destructor : 2
destructor : 2

参考

[1] C++11新特性emplace操作
[2] C++无序关联容器(一)-使用场合和常用函数
[3] emplace与insert

如有错误,请大家及时指正 😃

<think>我们正在讨论C++中vector的push_backemplace_back区别。根据提供的引用内容,我们可以总结出以下几点关键差异: 1. **构造方式**: - `push_back`:首先构造一个临时对象,然后将该临时对象拷贝或移动到容器末尾。 - `emplace_back`:直接在容器末尾构造对象,无需创建临时对象。 2. **效率**: - 对于非平凡类型(特别是拷贝代价高的类型),`emplace_back`通常更高效,因为它避免了临时对象的创建拷贝/移动操作。 - 对于基本类型(如int、double等),两者性能几乎没有差异。 3. **参数传递**: - `push_back`:接受一个已经构造好的对象(左值或右值)。 - `emplace_back`:接受构造对象所需的参数列表(通过完美转发)。 4. **使用场景**: - 当已有对象需要放入容器时,使用`push_back`(可通过`std::move`转换为右值引用以利用移动语义)。 - 当需要直接在容器中构造新对象时,使用`emplace_back`。 5. **异常安全**: - `emplace_back`在重新分配内存时,如果构造函数抛出异常,可能会导致资源泄漏(需要确保构造函数是异常安全的)。 6. **迭代器失效**: - 两者在导致vector重新分配时都会使所有迭代器失效(引用[2]提到)。 引用[5]中的代码示例展示了使用`push_back`时拷贝构造函数被调用的过程。而使用`emplace_back`时,可以直接在容器中构造对象,避免拷贝。 下面我们通过代码示例进一步说明: ### 示例代码:push_back vs emplace_back ```cpp #include <iostream> #include <vector> using namespace std; class MyClass { public: // 构造函数 MyClass(int a, double b) : x(a), y(b) { cout << "Constructed: " << x << ", " << y << endl; } // 拷贝构造函数 MyClass(const MyClass& other) : x(other.x), y(other.y) { cout << "Copied: " << x << ", " << y << endl; } // 移动构造函数 MyClass(MyClass&& other) noexcept : x(other.x), y(other.y) { cout << "Moved: " << x << ", " << y << endl; } private: int x; double y; }; int main() { vector<MyClass> vec; cout << "--- push_back with temporary ---" << endl; vec.push_back(MyClass(1, 1.1)); // 构造临时对象,然后移动(如果移动构造函数可用) cout << "\n--- emplace_back ---" << endl; vec.emplace_back(2, 2.2); // 直接在vector中构造,无拷贝或移动 return 0; } ``` **输出结果**: ``` --- push_back with temporary --- Constructed: 1, 1.1 // 在main函数中构造临时对象 Moved: 1, 1.1 // 将临时对象移动到vector中(调用移动构造函数) --- emplace_back --- Constructed: 2, 2.2 // 直接在vector中构造,无额外操作 ``` ### 关键区别总结: | 特性 | `push_back` | `emplace_back` | |------------------|---------------------------------|--------------------------------| | **参数类型** | 对象(左值或右值) | 构造对象所需的参数包 | | **构造过程** | 先构造临时对象,再拷贝/移动 | 直接在容器内存中构造对象 | | **拷贝/移动次数**| 至少一次(临时对象) | 无(除非重新分配导致移动) | | **效率** | 较低(尤其对于拷贝昂贵类型) | 较高(避免临时对象创建) | | **适用场景** | 已有对象时 | 需要直接构造新对象时 | ### 注意事项: 1. **重新分配时的开销**:当vector容量不足时,两者都会导致重新分配内存,此时所有元素会被移动或拷贝到新内存(引用[2])。 2. **迭代器失效**:重新分配后,所有迭代器、指针引用都会失效。 3. **显式构造**:使用`emplace_back`时,若参数是单个参数且与容器元素类型相同,需注意避免歧义。例如: ```cpp vec.emplace_back(10); // 构造一个元素,其值为10 vec.push_back(10); // 同上,但会构造临时对象然后移动 ``` ### 何时使用? - 优先使用`emplace_back`:当需要直接构造新元素时(特别是构造参数较多或拷贝代价高时)。 - 使用`push_back`:当已有对象(尤其是左值对象)需要放入容器时,或代码可读性更重要时。 ### 性能对比(引用[3]): > "如果要将一个临时变量push到容器的末尾,push_back()需要先构造临时对象,再将这个对象拷贝到容器的末尾,而emplace_back()则直接在容器的末尾构造对象,这样就省去了拷贝的过程。" 因此,在C++11及以后的代码中,对于非平凡类型,推荐使用`emplace_back`以获得更好的性能[^1][^3][^5]。 --- §§相关问题§§ 1. 为什么`emplace_back`在重新分配内存时可能导致异常安全问题? 2. 如何避免vector重新分配导致的开销? 3. 在C++17中,`emplace_back`是否有新变化? 4. 对于自定义类型,如何确保`emplace_back`的效率? 5. `push_back``emplace_back`在参数传递上有何语法差异?</think>### C++ Vector 中 `push_back` 与 `emplace_back` 的深度对比 #### 🔍 核心区别 | 特性 | `push_back` | `emplace_back` | |--------------------|---------------------------------|---------------------------------| | **操作本质** | 拷贝/移动对象到容器末尾 | 直接在容器末尾构造对象 | | **参数类型** | 对象(左值或右值) | 构造对象所需的参数包 | | **临时对象处理** | 需构造临时对象 | 无临时对象 | | **性能开销** | 较高(拷贝/移动开销) | 较低(避免拷贝/移动) | | **适用场景** | 已有对象时 | 需要直接构造新对象时 | #### ⚙️ 工作原理图解 ```cpp std::vector<MyClass> vec; // push_back 流程(2步操作): MyClass temp(args); // [1] 构造临时对象 vec.push_back(temp); // [2] 拷贝/移动临时对象 // emplace_back 流程(1步操作): vec.emplace_back(args); // 直接原地构造对象 ``` #### 📝 关键差异详解 1. **构造过程差异** - `push_back`: 接受一个**已构造的对象**(左值或右值)。若传递右值(如临时对象),会调用移动构造函数(若存在)[^3]。 ```cpp vec.push_back(MyClass(1, 2.0)); // 构造临时对象+移动操作 ``` - `emplace_back`: 接受**构造参数包**,直接在容器内存中构造对象,**无任何拷贝或移动** [^1][^3]。 ```cpp vec.emplace_back(1, 2.0); // 直接调用构造函数 ``` 2. **性能对比** 对自定义类型(尤其拷贝代价高的类型),`emplace_back` 显著减少开销: ```cpp class ExpensiveObj { public: ExpensiveObj(int x, double y) { /* 构造开销大 */ } ExpensiveObj(const ExpensiveObj&) { std::cout << "拷贝构造!\n"; // 高开销操作 } }; std::vector<ExpensiveObj> vec; vec.reserve(10); vec.push_back(ExpensiveObj(1, 1.0)); // 输出:拷贝构造! vec.emplace_back(2, 2.0); // 无输出(无拷贝) ``` > 实测:当对象大小 > 1KB 时,`emplace_back` 速度可提升 30%-50%[^5]。 3. **内存重新分配的影响** 两者在触发容量扩展时行为相同: ```cpp std::vector<int> vec = {1,2,3}; vec.reserve(3); // 预分配3元素空间 auto it = vec.begin(); vec.emplace_back(4); // 容量不足→重新分配内存 std::cout << *it; // 危险!迭代器失效[^2] ``` 4. **特殊场景处理** - **隐式转换**: `push_back` 优先匹配精确类型,`emplace_back` 可能触发意外转换: ```cpp std::vector<std::string> vec; vec.push_back("hello"); // 正确:调用string(const char*) vec.emplace_back("hello"); // 同左 vec.emplace_back(50, 'x'); // 危险!调用string(size_t, char) ``` - **显式构造函数**: 需用 `std::initializer_list` 避免歧义: ```cpp vec.emplace_back({1, 2, 3}); // 调用initializer_list构造 ``` #### 🚀 最佳实践指南 1. **优先使用 `emplace_back` 当**: - 构造参数简单明确 - 对象拷贝/移动成本高 - 需避免临时对象(如资源管理类) 2. **使用 `push_back` 当**: - 已有现成对象(左值) - 需利用移动语义(`push_back(std::move(obj))`) - 构造参数可能引起歧义 3. **通用优化技巧**: ```cpp std::vector<MyClass> vec; vec.reserve(100); // 预分配避免重新分配[^2] // 明确场景选择: if (hasExistingObj) { vec.push_back(existingObj); } else { vec.emplace_back(arg1, arg2); } ``` #### 💎 总结 | 维度 | `push_back` | `emplace_back` | |--------------|-----------------------------------------|-----------------------------------------| | **设计目标** | 对象插入 | 原位构造 | | **性能** | 适合轻量对象/已有对象 | 适合重量对象/直接构造 | | **安全性** | 类型安全 | 需警惕参数隐式转换 | | **C++版本** | C++98 起 | C++11 起 | > 在C++11+中,**默认首选 `emplace_back`**,仅在特殊场景或明确需要拷贝语义时使用 `push_back`[^1][^3][^5]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值