713-C++11容器emplace方法原理剖析

最新推荐文章于 2024-10-11 19:16:39 发布
最新推荐文章于 2024-10-11 19:16:39 发布
阅读量2.2k 收藏 13
点赞数 2
分类专栏： C++的学习 文章标签： c++ 容器 vector
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LINZEYU666/article/details/120929452
版权

C++11容器emplace方法的现象

C++11容器的push和insert方法，都匹配了emplace的新的方法，也是用来添加数据的。
emplace使用的时候感觉和之前的功能是一样的，都是添加新的元素，但是到底有什么不同呢？

示例代码1

#include<iostream>
#include<vector>
using namespace std;

class Test
{
public:
	Test(int a) { cout << "Test(int)"<<endl; }
	Test(int a, int b) { cout << "Test(int,int)"<<endl; }
	Test(const Test&a) { cout << "Test(const Test&)" << endl; }
	Test(const Test&&a) { cout << "Test(const Test&&)" << endl; }
	~Test() { cout << "~Test()" << endl; }
};

int main()
{
	Test t1(10);//是左值哦
	vector<Test>v; 
	v.reserve(100);//只开辟空间，没有构建对象
	cout << "=====================" << endl;
	v.push_back(t1);//匹配的是带左值引用参数的拷贝构造函数
	v.emplace_back(t1);//匹配的是带左值引用参数的拷贝构造函数
	cout << "=====================" << endl;

	return 0;
}

在这里插入图片描述
如果是直接插入 已存在的 是左值的 对象，两个方法是没有区别的，都是调用带左值引用参数的拷贝构造函数构建vector上的对象

示例代码2

如果插入的是临时对象呢？

#include<iostream>
#include<vector>
using namespace std;

class Test
{
public:
	Test(int a) { cout << "Test(int)"<<endl; }
	Test(int a, int b) { cout << "Test(int,int)"<<endl; }
	Test(const Test&a) { cout << "Test(const Test&)" << endl; }
	Test(const Test&&a) { cout << "Test(const Test&&)" << endl; }
	~Test() { cout << "~Test()" << endl; }
};

int main()
{
	Test t1(10);//是左值哦
	vector<Test>v; 
	v.reserve(100);//只开辟空间，没有构建对象
	cout << "=====================" << endl;
	v.push_back(Test(20));//匹配的是带右值引用参数的拷贝构造函数
	v.emplace_back(Test(20));//匹配的是带右值引用参数的拷贝构造函数
	cout << "=====================" << endl;

	return 0;
}

临时对象的生命周期很短，只存在当前语句中。
在这里插入图片描述
都是生成临时对象，然后调用带右值引用参数的拷贝构造函数构建vector上的对象
这两种方法还是没有区别啊！

只要是插入对象，这2种方法是没有区别的！！！

示例代码3

我们现在传入的是整数参数

#include<iostream>
#include<vector>
using namespace std;

class Test
{
public:
	Test(int a) { cout << "Test(int)"<<endl; }
	Test(int a, int b) { cout << "Test(int,int)"<<endl; }
	Test(const Test&a) { cout << "Test(const Test&)" << endl; }
	Test(const Test&&a) { cout << "Test(const Test&&)" << endl; }
	~Test() { cout << "~Test()" << endl; }
};

int main()
{
	vector<Test>v; 
	v.reserve(100);//只开辟空间，没有构建对象
	cout << "=====================" << endl;
	v.emplace_back(20);
	v.emplace_back(20, 40);
	cout << "=====================" << endl;

	return 0;
}

在这里插入图片描述
现在相当于是实参在传递的过程中，没有定义过对象，没有生成过临时对象！！！
直接传入你要构建Test对象所需要的参数（构造函数的参数），然后直接在vector底层调用了相应的构造函数—在vector底层直接构造Test对象了。
在这里插入图片描述
这样做，当然好，效率直接就提升了啊！而且写起来特别简单，不需要像push_back必须要传Test对象参数：

在这里插入图片描述
在这里插入图片描述

代码示例4

int main()
{
	unordered_map<int, string>map;
	map.insert(make_pair(10, "linzeyu"));
	//构建临时对象，然后拿临时对象调用右值引用参数的拷贝构造函数构造map上的对象
	//在map底层构建好对象后，出了这条语句，临时对象析构。

	map.emplace(10, "zhang san");
	//直接传入构建对象所需要的参数，在map底层直接调用普通构造函数生成对象了，
	//没有产生临时对象等额外的对象，没有额外的函数的调用
	return 0;
}

在这里插入图片描述

我们看看emplace的实现原理

emplace是通过可变参模板参数来实现的。我们可以理解成C语言的可变参函数：printf
在这里插入图片描述

#include <iostream>
using namespace std;

//定义容器的空间配置器，和C++标准库的allocator实现一样
template<typename T>
struct MyAllocator//模板类 struct定义 默认公有的 
{
	T* allocate(size_t size)//负责内存开辟
	{
		return (T*)malloc(sizeof(T) * size);
	}
	void deallocate(void* p)//负责内存释放
	{
		free(p);
	}
	template<typename...Types>
	void construct(T* p, Types&& ...args)
	{
		//如果args是个Test对象，T是Test类型，调用的是Test的拷贝构造函数了
		//如果args是构建对象的参数，匹配的也就是相应的构造函数了
		new (p) T(std::forward<Types>(args)...);
	}
	void destroy(T* p)//负责对象析构
	{
		p->~T();// ~T()代表了T类型的析构函数
	}

};
template<typename T, typename Alloc = MyAllocator<T>>//初始化，让用户不用指定，用默认的 
class Vector
{
public:
	Vector(int size = 10)//构造函数 
	{
		//需要把内存开辟和对象构造分开处理
		//_first = new T[size];
		_first = _allocator.allocate(size);
		_last = _first;
		_end = _first + size;
	}
	~Vector()//析构函数 
	{
		//析构容器有效的元素，然后释放_first指针指向的堆内存
		//delete[]_first;
		for (T* p = _first; p != _last; ++p)
		{
			_allocator.destroy(p);//把_first指针指向的数组的有效元素进行析构操作
		}
		_allocator.deallocate(_first);//释放堆上的数组内存
		_first = _last = _end = nullptr;
	}
	Vector(const Vector<T>& rhs)//拷贝构造函数 
	{
		int size = rhs._end - rhs._first;//空间大小 
		//_first = new T[size];
		_first = _allocator.allocate(size);
		int len = rhs._last - rhs._first;//有效数据的长度 
		for (int i = 0; i < len; ++i)
		{
			//_first[i] = rhs._first[i];
			_allocator.construct(_first + i, rhs._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
	}
	Vector<T>& operator=(const Vector<T>& rhs)//赋值函数 
	{
		if (this == &rhs)
			return *this;

		//delete[]_first;
		for (T* p = _first; p != _last; ++p)
		{
			_allocator.destroy(p);//把_first指针指向的数组的有效元素进行析构操作
		}
		_allocator.deallocate(_first);

		int size = rhs._end - rhs._first;
		//_first = new T[size];
		_first = _allocator.allocate(size);
		int len = rhs._last - rhs._first;
		for (int i = 0; i < len; ++i)
		{
			//_first[i] = rhs._first[i];
			_allocator.construct(_first + i, rhs._first[i]);
		}
		_last = _first + len;
		_end = _first + size;
		return *this;
	}
	/*void push_back(const T& val)//向容器末尾添加元素
	{
		if (full())
			expand();
		//*_last++ = val;   _last指针指向的内存构造一个值为val的对象
		_allocator.construct(_last, val);
		_last++;
	}
	void push_back(T&& val)//接收右值 一个右值引用变量本身还是一个左值
	{
		if (full())
			expand();

		_allocator.construct(_last, std::move(val));
		//val本身还是左值啊。匹配的还是左值的construct。怎么办？ 
		//使用std::move把val 强转成右值引用类型 
		_last++;
	}*/

	template<typename Ty>//函数模板的类型推演 + 引用折叠
	void push_back(Ty&& val)//Ty CMyString& + && = CMyString&
	{
		if (full())
			expand();

		//move(左值)：移动语义，得到右值类型   (int&&)a
		//forward:类型完美转发，能够识别左值和右值类型
		_allocator.construct(_last, std::forward<Ty>(val));
		_last++;
	}

	void pop_back()//从容器末尾删除元素
	{
		if (empty())
			return;
		//--_last; //不仅要把_last指针--，还需要析构删除的元素
		--_last;
		_allocator.destroy(_last);
	}
	T back()const//返回容器末尾的元素的值
	{
		return *(_last - 1);
	}
	bool full()const { return _last == _end; }
	bool empty()const { return _first == _last; }
	int size()const { return _last - _first; }

	//引用折叠，这个概念在我的《理解C++的右值引用并进行应用(CMyStirng）》博客中有解释
	//可接收实参的左值或者右值，动态可变
	template<typename...Types>//可变参模板参数
	void emplace_back(Types&&...args)//右值引用，而且函数可以接受多个参数，不固定的任意的
	//我们可以传很多个参数，但是它底层看Test构造函数需要几个参数，如果传入的参数超过了，就报错
	{
		_allocator.construct(_last, std::forward<Types>(args)...);
		_last++;
	}

private:
	T* _first;//指向数组起始的位置
	T* _last; //指向数组中有效元素的后继位置
	T* _end;//指向数组空间的后继位置
	Alloc _allocator;//定义容器的空间配置器对象

	void expand()//容器的二倍扩容
	{
		int size = _end - _first;
		//T *ptmp = new T[2 * size];
		T* ptmp = _allocator.allocate(2 * size);
		for (int i = 0; i < size; ++i)
		{
			//ptmp[i] = _first[i];
			_allocator.construct(ptmp + i, _first[i]);
		}
		//delete[]_first;
		for (T* p = _first; p != _last; ++p)
		{
			_allocator.destroy(p);
		}
		_allocator.deallocate(_first);
		_first = ptmp;
		_last = _first + size;
		_end = _first + 2 * size;
	}
};


class Test
{
public:
	Test(int a) { cout << "Test(int)" << endl; }
	Test(int a, int b) { cout << "Test(int,int)" << endl; }
	Test(const Test& a) { cout << "Test(const Test&)" << endl; }
	Test(const Test&& a) { cout << "Test(const Test&&)" << endl; }
	~Test() { cout << "~Test()" << endl; }
};

int main()
{
	Vector<Test>v;
	cout << "=====================" << endl;
	v.emplace_back(20);
	v.emplace_back(20, 40);
	cout << "=====================" << endl;

	return 0;
}

在这里插入图片描述
非常的OK！！！

我摘出emplace的实现核心代码如下，方便大家观看：

//定义容器的空间配置器，和C++标准库的allocator实现一样
template<typename T>
struct MyAllocator//模板类 struct定义 默认公有的 
{
	T* allocate(size_t size)//负责内存开辟
	{
		return (T*)malloc(sizeof(T) * size);
	}
	void deallocate(void* p)//负责内存释放
	{
		free(p);
	}
	template<typename...Types>
	void construct(T* p, Types&& ...args)
	{
		//如果args是个Test对象，T是Test类型，调用的是Test的拷贝构造函数了
		//如果args是构建对象的参数，匹配的也就是相应的构造函数了
		new (p) T(std::forward<Types>(args)...);
	}
	void destroy(T* p)//负责对象析构
	{
		p->~T();// ~T()代表了T类型的析构函数
	}

};

//引用折叠，这个概念在我的《理解C++的右值引用并进行应用(CMyStirng）》博客中有解释
//可接收实参的左值或者右值，动态可变
template<typename...Types>//可变参模板参数
void emplace_back(Types&&...args)//右值引用，而且函数可以接受多个参数，不固定的任意的
//我们可以传很多个参数，但是它底层看Test构造函数需要几个参数，如果传入的参数超过了，就报错
{
	_allocator.construct(_last, std::forward<Types>(args)...);
	_last++;
}
林林林ZEYU
关注
专栏目录
C++11容器emplace方法原理剖析
GeniusAng的博客
07-21 495
施磊C++语言高级进阶课程，主要讲解C++11中的新特性emplace方法
C++的emplace
sinat_31608641的博客
11-18 8150
一、背景 在C++开发过程中，我们经常会用STL的各种容器，比如vector，map，set等，这些容器极大的方便了我们的开发。在使用这些容器的过程中，我们会大量用到的操作就是插入操作，比如vector的push_back，map的insert，set的insert。这些插入操作会涉及到两次构造，首先是对象的初始化构造，接着在插入的时候会复制一次，会触发拷贝构造。但是很多时候我们并不需要两次构造带来效率的浪费，如果可以在插入的时候直接构造，就只需要构造一次就够了。 参考： https://..
c++ emplace
最新发布
weixin_43881088的博客
10-11 1044
emplace系列函数通过在容器内原地构造对象来提高性能，特别是当对象的构造和复制代价较高时。相比于push_back和insertemplace更加高效，因为它避免了临时对象的构造、复制或移动。常见的emplaceemplace，不同容器会提供不同的emplace函数，根据容器特性来使用。
c++之emplace的使用
热门推荐
FairLikeSnow的博客
08-26 1万+
使用c++三四年了，说实话emplace,今天才是第一次接触，有一种想见恨晚的感觉。先看看代码，看看结果，你就知道它的妙处！ #include<iostream> #include <list> using namespace std; class TyData{ public: TyData(int a, int b) { x = a; y = b; cout << "这是构造函数\n"; } TyData(const TyData &d)
C++之emplace
weixin_39187443的博客
02-03 998
最近在写一段代码的时候，突然很好奇C++11中对push_back有没有什么改进以增加效率，上网搜了一些资料，发现果然新增了emplace_back方法，比push_back的效率要高很多。 首先，写了一个类用于计时， //time_interval.h #pragma once #include <iostream> #include <memory> #include <string> #ifdef GCC #include <sys/time....
C++11 容器的emplace方法分析
qq_20756957的博客
04-02 1715
经常在学习和开发中听到，vector要少用push_back()方法，而是用emplace_back()方法进行数据插入，会提高性能，但是具体的原理没有深入了解。今天深入了解并进行了源码剖析，在此记录下。
145-C++11容器emplace方法
Edward_LF的博客
05-04 446
C++11标准以后，给STL标准库的每一个容器（基本的线性容器：vector，list,deque，关联容器：set,map）的push和insert方法，都匹配了emplace的新的方法，也是用来添加数据的。 insert对应emplace； push_back对应emplace_back； push_front对应emplace_front； emplace使用的时候感觉和之前的功能是一样的，都是添加新的元素，但是到底有什么不同呢？ 例1—传入左值对象 #include<iostream&gt.
C++11容器emplace源码剖析
04-02
C++11引入了一系列新的特性，其中容器类的`emplace`函数是一个重要的改进，它允许我们在容器中直接构建对象，而无需先创建临时对象或拷贝。本文将深入探讨`emplace`的原理，以及与传统的`push_back`操作相比的性能...
Master-Class-C++11.pdf
05-13
- C++11概念：提供一种模板编程的方法，用于参数化类型，从而使得模板更具有通用性。 - 委托构造函数：允许构造函数调用另一个构造函数来执行共同的初始化工作。 - 自动类型推断（auto关键字）：简化变量声明，让...
[C++深入] --- vector容器浅析
M2嵌入式
06-27 1129
如果type是内置类型，emplace_back和push_back无差异。
C++ emplace_back 与 push_back
m0_73935863的博客
03-03 1619
C++ emplace_back 与 push_back
04-众多C++容器如何挑选？
或许没有的博客
04-21 450
目录前言无规律容器vectordequelist&forward_listqueue&stack有规律容器priority_queue有序关联容器无序关联容器array选择方法总结 前言 相信大家在学习C++过程中都会学习STL容器，至于容器实现的原理可以去看侯捷老师《STL源码剖析》。网上也有很多资源，为了支持正版这里就不放出来了，有需要可以评论区留言。STL容器的实现很复杂但是...
【1++的C++进阶】之emplace详解
m0_63135219的博客
09-15 2651
通过运行结果我们可以发现，insert在插入时，由于我们传的是右值，其调用了构造和移动构造，而emplace只调用了构造函数。也就是说，emplace是在插入位置直接构造元素，而不是和insert一样，先是构造好，再移动或复制到插入位置。
c++笔记提高效率-emplace函数
嵌入式大师之路
06-26 1056
使用emplace方法可以提高插入操作的效率，避免不必要的复制或移动操作。它直接在容器内部构造元素，使得构造过程更加高效和直接。在实际应用中，优先选择emplace方法来代替insert或push方法，尤其是在插入需要多个参数构造的元素时。
C++11新特性之十一：emplace
草上爬的博客
05-21 7576
emplace操作是C++11新特性，新引入的的三个成员emlace_front、empace 和 emplace_back,这些操作构造而不是拷贝元素到容器中，这些操作分别对应push_front、insert 和push_back，允许我们将元素放在容器头部、一个指定的位置和容器尾部。两者的区别当调用insert时，我们将元素类型的对象传递给insert，元素的对象被拷贝到容器中，而当我们使...
C++11容器中的emplace相关函数的使用
Captain--Jack
03-12 2806
在C++开发过程中，我们经常会用STL的各种容器，比如vector，map，set等，这些容器极大的方便了我们的开发。在使用这些容器的过程中，我们会大量用到的操作就是插入操作，比如vector的push_back，map的insert，set的insert。这些插入操作会涉及到两次构造，首先是对象的初始化构造，接着在插入的时候会复制一次，会触发拷贝构造。但是很多时候我们并不需要两次构造带来效率的浪...
C++之std::queue::emplace
jzjhome的博客
06-22 1382
是 C++ STL 中std::queue容器的成员函数，它用于在队列的末尾就地构造一个新元素。这个函数类似于，但是emplace允许你通过传递参数来构造元素，而不需要显式地创建一个元素对象。
C++11 容器中的emplace类方法
Fishfishfishfishcat
01-10 2053
一、emplace是什么？ emplace在英文里是放置的意思，他是为了解决insert需要经历复制和移动过程效率较低的问题而出现的。 二、函数原型 template <class... Args> iterator emplace (const_iterator position, Args&&... args); 其中： position 插入位置。 args ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林林林ZEYU

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值