emplace_back()和push_back()的对比，前者不能替代后者的例子

我就是我 2022-11-27 03:29 191阅读 0赞

### 文章目录 ###

*  emplace\_back()
 *   *  以list为例
     *  以vector为例
 *  测试代码：emplace\_back()少一次复制操作，所以效率更高
 *   *  例子2
 *  emplace\_back()无法替代push\_back()的例子

# emplace\_back() #

所有顺序容器都有这个函数  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70_pic_center]

## 以list为例 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70_pic_center 1]

*  顺序式容器都有这个成员函数，以list容器为例(上图)，其参数是右值引用，C++17之前没有返回值，之后有了返回值，返回的是刚插入的结点的引用。  
    ![在这里插入图片描述][2020090313133950.png_pic_center]
 *  一般使用**定位new**来分配一个新位置并放置。
 *  完成这个操作后，链表list没有任何迭代器或者引用会失效。（当然啦，对于链表来说，插入一个新结点，完全不会影响到已有结点的嘛）

![在这里插入图片描述][20200903131519799.png_pic_center]

*  常数复杂度，o(1)，毕竟是链表嘛，插入删除都是o(1)
 *  异常这部分我没看懂昂

## 以vector为例 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70_pic_center 2]  
每一次插入新元素，如果size没超过capacity，那么最终只有超尾迭代器失效；而如果size超过了capacity，则所有的迭代器和引用全部都会失效。

> 总之，不管什么容器的emplace\_back函数，其参数都是右值引用。传入的参数的值是右值，实参是对它们的右值引用。

# 测试代码：emplace\_back()少一次复制操作，所以效率更高 #

这俩代码都是别的网友写的，我看到觉得很棒，搬移故来了

这个代码说明参数为左值引用的push\_back方法要调用构造函数和复制构造函数，说明确实要先构造一个临时对象，再把临时对象用copy构造拷贝到数组最后面，确实费时。

#include <iostream>
    #include <cstring>
    #include <vector>
    using namespace std;
     
    class A { 
    public:
        A(int i){ 
            str = to_string(i);
            cout << "构造函数" << endl; 
        }
        ~A(){ }
        A(const A& other): str(other.str){ 
            cout << "拷贝构造" << endl;
        }
     
    public:
        string str;
    };
     
    int main()
    { 
        vector<A> vec;
        vec.reserve(10);
        for(int i=0;i<10;i++){ 
            vec.push_back(A(i)); //调用了10次构造函数和10次拷贝构造函数,
    // vec.emplace_back(i); //调用了10次构造函数一次拷贝构造函数都没有调用过
        }
     
    }

下面这个代码详细分析了五种原型，左值参数的，右值参数的push\_back,以及emplace\_back。发现：

*  左值参数的push\_back要调用构造函数和复制构造
 *  右值参数的push\_back要调用构造函数和移动构造
 *  emplace\_back要调用一次构造而已

#include <vector>
    #include <string>
    #include "time_interval.h"
    
    class Foo { 
    public:
        Foo(std::string str) : name(str) { 
            std::cout << "constructor" << std::endl;
        }
        Foo(const Foo& f) : name(f.name) { 
            std::cout << "copy constructor" << std::endl;
        }
        Foo(Foo&& f) : name(std::move(f.name)){ 
            std::cout << "move constructor" << std::endl;
        }
    
    private:
        std::string name;
    };
    int main() { 
    
    
        std::vector<Foo> v;
        int count = 10000000;
        v.reserve(count);       //预分配十万大小，排除掉分配内存的时间
    
        { 
            TIME_INTERVAL_SCOPE("push_back T:");
            Foo temp("ceshi");
            v.push_back(temp);// push_back(const T&)，参数是左值引用
            //打印结果：
            //constructor
            //copy constructor
        }
    
        v.clear();
        { 
            TIME_INTERVAL_SCOPE("push_back move(T):");
            Foo temp("ceshi");
            v.push_back(std::move(temp));// push_back(T &&), 参数是右值引用
            //打印结果：
            //constructor
            //move constructor
        }
    
        v.clear();
        { 
            TIME_INTERVAL_SCOPE("push_back(T&&):");
            v.push_back(Foo("ceshi"));// push_back(T &&), 参数是右值引用
            //打印结果：
            //constructor
            //move constructor
        }
    
        v.clear();
        { 
            std::string temp = "ceshi";
            TIME_INTERVAL_SCOPE("push_back(string):");
            v.push_back(temp);// push_back(T &&), 参数是右值引用
            //打印结果：
            //constructor
            //move constructor
        }
    
        v.clear();
        { 
            std::string temp = "ceshi";
            TIME_INTERVAL_SCOPE("emplace_back(string):");
            v.emplace_back(temp);// 只有一次构造函数，不调用拷贝构造函数，速度最快
            //打印结果：
            //constructor
        }
    }

## 例子2 ##

cpp reference网站给的对比示例：以双向链表容器list为例

#include <list>
    #include <string>
    #include <iostream>
    
    struct President
    { 
        std::string name;
        std::string country;
        int year;
    
        President(std::string p_name, std::string p_country, int p_year)
            : name(std::move(p_name)), country(std::move(p_country)), year(p_year)
        { 
            std::cout << "I am being constructed.\n";
        }
        President(President&& other)
            : name(std::move(other.name)), country(std::move(other.country)), year(other.year)
        { 
            std::cout << "I am being moved.\n";
        }
        President& operator=(const President& other) = default;
    };
    
    int main()
    { 
        std::list<President> elections;
        std::cout << "emplace_back:\n";
        elections.emplace_back("Nelson Mandela", "South Africa", 1994);//直接把成员参数传给emplace_back
    
        std::list<President> reElections;
        std::cout << "\npush_back:\n";
        reElections.push_back(President("Franklin Delano Roosevelt", "the USA", 1936));//传给push_back的却必须是一个已经构造好的对象，所以要先构造，push_back内部再调用移动构造实现添加到容器末尾的功能
    
        std::cout << "\nContents:\n";
        for (President const& president: elections) { 
            std::cout << president.name << " was elected president of "
                      << president.country << " in " << president.year << ".\n";
        }
        for (President const& president: reElections) { 
            std::cout << president.name << " was re-elected president of "
                      << president.country << " in " << president.year << ".\n";
        }
    }

可以看到，emplace\_back直接构造，通过把参数直接传给构造函数实现。

但是push\_back先构造，然后把构造的这个对象用移动构造再构造一遍。所以构造了两次。

emplace_back:
    I am being constructed.
    
    push_back:
    I am being constructed.
    I am being moved.
    
    Contents:
    Nelson Mandela was elected president of South Africa in 1994.
    Franklin Delano Roosevelt was re-elected president of the USA in 1936.

# emplace\_back()无法替代push\_back()的例子 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70_pic_center 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/a7da3d98cfe849d8b29b76466e07adf8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221124/09f3ddeaf150440c96b2a5eefb64b0a1.png
[2020090313133950.png_pic_center]: /images/20221124/ec98f231df8942208ec7926653ae98e5.png
[20200903131519799.png_pic_center]: /images/20221124/bd0f5e066ae841f39162e349fca6f7cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221124/fa140422dbf54216b38a19cccd00732a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221124/18db3af805ac496a8d472b7f26d9d1e0.png