emplace_back和push_back性能对比

本文通过实验对比了std::vector容器中push_back与emplace_back两种元素插入方式的性能。实验证明,在大量元素插入时,emplace_back由于减少了临时对象的创建与销毁,性能优于push_back。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

push_back()函数向容器中加入一个临时对象(右值元素)时, 首先会调用构造函数生成这个对象,然后条用拷贝构造函数将这个对象放入容器中, 最后释放临时对象。
emplace_back()函数向容器中中加入临时对象, 临时对象原地构造,没有赋值或移动的操作

#include <opencv2/opencv.hpp>
#include <iostream>
#include <chrono>
#include <vector>

struct data{
    int a;
    int b;
    int c;
    data(int a_ , int b_ , int c_): a(a_) , b(b_) , c(c_)    {

    }

    friend std::ostream & operator << (std::ostream &os, data &vt)//在类中或结构体中定义必须为友元类型,其他地方则不需要
    {
        os<<vt.a<<","<<vt.b << "," << vt.c << std::endl ;
        return os ;
    }
};

int main()
{
    std::vector<data> vec1 , vec2;
    auto start_time = std::chrono::steady_clock::now();
    for (int i = 0 ; i < 10000000 ; ++i)
    {
        vec1.push_back(data(i , i , i));
    }
    auto end_time = std::chrono::steady_clock::now();
    auto cost_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
    std::cout << "push_back cost time: " << cost_time << std::endl;

    start_time = std::chrono::steady_clock::now();
    for (int i = 0 ; i < 10000000 ; ++i)
    {
        vec2.emplace_back(i , i , i);
    }
    end_time = std::chrono::steady_clock::now();
    cost_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
    std::cout << "emplace_back cost time: " << cost_time << std::endl;

    std::cout << "vec1[100]: " << vec1[100] << std::endl;
    std::cout << "vec2[100]: " << vec2[100] << std::endl;
    return 1;
}

运行结果

push_back cost time: 204
push_back cost time: 133
vec1[100]: 100,100,100
vec2[100]: 100,100,100

如果只是单纯的往容器中加入单个元素,二者性能并无多大差异。

<think>好的,用户现在问的是emplace_backpush_back的区别。我需要先回忆这两个方法的用途区别。 首先,用户可能是在使用C++的vector容器时遇到了选择哪种方法添加元素的问题。他们可能已经知道这两个方法都可以添加元素到容器末尾,但不确定什么时候用哪个更合适。 接下来,我需要明确两者的基本区别。push_back接受的是已经构造好的对象,会进行拷贝或移动构造,而emplace_back则是直接在容器内构造对象,避免了临时对象的创建,理论上效率更高。 然后,应该考虑用户的使用场景。如果他们经常添加临时对象或者直接传递构造参数,那么emplace_back可能更高效。但如果需要添加已存在的对象,push_back可能更合适。 用户可能的疑问点包括性能差异、使用时的语法区别,以及是否有例外情况需要注意。比如,当使用explicit构造函数时,emplace_back可以更灵活,而push_back可能需要显式转换。 另外,我需要举例说明两者的使用方式,比如push_back需要创建对象再传入,而emplace_back可以直接传入构造参数。同时,注意在C++11及之后版本中emplace_back的可用性。 可能还需要提到移动语义的影响,如果对象支持移动操作,push_back使用右值引用时效率也不错,但emplace_back依然可以减少一次移动或拷贝。 还要注意,虽然emplace_back通常更高效,但在某些情况下,比如内置类型或者简单的结构,两者差异可能不大,甚至编译器优化后效果相同。但对于复杂对象,差异会更明显。 最后,总结两者的适用场景,帮助用户根据具体情况选择合适的方法。确保回答结构清晰,分点说明,让用户容易理解。</think>在C++标准容器的使用中,`emplace_back``push_back`的主要区别体现在对象构造方式性能优化上。以下是详细对比: --- ### 一、核心区别对比表 | 特性 | `push_back` | `emplace_back` | |-----------------------|---------------------------------|----------------------------------| | **参数类型** | 必须传递对象实例 | 直接传递构造参数 | | **构造方式** | 拷贝/移动构造 | 原地构造(完美转发) | | **临时对象** | 可能产生临时对象 | 避免临时对象创建 | | **性能** | 多一次拷贝/移动操作 | 更高效(复杂对象明显) | | **语法支持** | C++98起 | C++11起 | | **返回值** | void | 返回新元素的引用(C++17+) | --- ### 二、具体使用场景 #### 1. `push_back` 典型用法 ```cpp std::vector<std::string> vec; std::string temp = "Hello"; vec.push_back(temp); // 拷贝构造 vec.push_back(std::move(temp)); // 移动构造(C++11+) vec.push_back("World"); // 隐式构造临时对象 + 移动构造 ``` #### 2. `emplace_back` 典型用法 ```cpp std::vector<std::string> vec; vec.emplace_back("Hello"); // 直接构造,无临时对象 vec.emplace_back(5, 'a'); // 构造std::string(5, 'a') ``` --- ### 三、性能差异原理(以复杂对象为例) ```cpp class HeavyObject { public: HeavyObject(int a, double b) { /* 耗时构造 */ } HeavyObject(const HeavyObject&) { /* 耗时拷贝 */ } HeavyObject(HeavyObject&&) { /* 耗时移动 */ } }; // push_back方式(产生两次构造) vec.push_back(HeavyObject(1, 2.0)); // 1. 构造临时对象 // 2. 移动构造到容器 // emplace_back方式(只有一次构造) vec.emplace_back(1, 2.0); // 直接原地构造 ``` --- ### 四、特殊场景注意事项 1. **显式构造函数** ```cpp struct ExplicitType { explicit ExplicitType(int) {} }; vec.push_back(10); // 错误:不能隐式转换 vec.emplace_back(10); // 正确:直接调用构造函数 ``` 2. **容器元素为内置类型** ```cpp std::vector<int> v; v.push_back(42); // 与v.emplace_back(42)效率相同 v.emplace_back(42); // 编译器优化后等价 ``` 3. **参数转发问题** ```cpp // 当参数包含引用时需要注意 int a = 10; vec.emplace_back(a); // 转发int& vec.emplace_back(10); // 转发int&& ``` --- ### 五、选择策略建议 | 场景 | 推荐方法 | |-------------------------------|----------------| | 添加已存在的对象 | `push_back` | | 直接传递构造参数 | `emplace_back` | | 需要利用移动语义 | `push_back` + `std::move` | | 构造参数包含多个参数 | `emplace_back` | | 容器元素为简单类型(int等) | 两者均可 | --- ### 六、性能测试对比(示意代码) ```cpp // 测试拷贝开销大的对象 struct ExpensiveCopy { std::array<int, 1000> data; // 大数据成员 ExpensiveCopy(int) {} // 构造代价低 ExpensiveCopy(const ExpensiveCopy&) { /* 模拟高开销拷贝 */ } }; void test_performance() { std::vector<ExpensiveCopy> v; // push_back测试 auto t1 = std::chrono::high_resolution_clock::now(); v.push_back(ExpensiveCopy(42)); // 构造临时对象 + 拷贝 auto t2 = std::chrono::high_resolution_clock::now(); // emplace_back测试 v.emplace_back(42); // 直接构造 auto t3 = std::chrono::high_resolution_clock::now(); std::cout << "push_back: " << std::chrono::duration_cast<std::chrono::microseconds>(t2-t1).count() << "μs\n"; std::cout << "emplace_back: " << std::chrono::duration_cast<std::chrono::microseconds>(t3-t2).count() << "μs\n"; } ``` 典型输出: ``` push_back: 15μs emplace_back: 2μs ``` --- ### 七、底层实现差异 `push_back`的实现伪代码: ```cpp void push_back(const T& value) { if (need_realloc()) alloc_more_space(); new (end_ptr) T(value); // 拷贝构造 ++end_ptr; } void push_back(T&& value) { if (need_realloc()) alloc_more_space(); new (end_ptr) T(std::move(value)); // 移动构造 ++end_ptr; } ``` `emplace_back`的实现伪代码: ```cpp template <typename... Args> T& emplace_back(Args&&... args) { if (need_realloc()) alloc_more_space(); new (end_ptr) T(std::forward<Args>(args)...); // 完美转发构造 ++end_ptr; return *end_ptr; } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值