C++11 move移动语义和forward类型完美转发

已于 2022-06-10 15:41:27 修改
阅读量173 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2022-06-10 13:41:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42500831/article/details/125215311
版权

文章目录

一个自定义空间配置器的vector

template<typename T>
class Allocator {
public:
	// 开辟size字节
	T* allocate(size_t size) {
		return (T*)malloc(size);
	}

	void deallocate(void* p) {
		free(p);
	}

	void construct(T* p, const T& val) {
		new (p) T(val);  // 定位new，指定地址构造值为val的对象，调用拷贝构造函数
	}

	void destroy(T* p) {
		p->~T();
	}
};

const int INIT_SIZE = 10;

template<typename T, typename Alloc = Allocator<T>>
class Vector {
public:
	Vector(int size = INIT_SIZE, const Alloc& alloc = Allocator<T>())
		: allocator_(alloc)
	{
		// first_ = new T[size];
		first_ = allocator_.allocate(size * sizeof(T));
		last_ = first_;
		end_ = first_ + size;
	}

	~Vector() {
		// delete[] first_;

		// 析构时，只析构容器中有效元素[first_, last - 1]
		for (T* p = first_; p != last_; p++) {
			allocator_.destroy(p);
		}
		// 释放整个容器空间
		allocator_.deallocate(first_);
		last_ = first_ = end_ = nullptr;
	}

	Vector(const Vector<T>& src) {
		// 深拷贝
		// 开辟空间
		int size = src.end_ - src.first_;
		// first_ = new T[size];
		first_ = allocator_.allocate(sizeof(T) * size);

		// 拷贝有效元素
		int len = src.last_ - src.first_;
		for (int i = 0; i < len; i++) {
			// first_[i] = src.first_[i];
			allocator_.construct(first_ + i, src.first_[i]);
		}
		last_ = first_ + len;
		end_ = first_ + size;
	}

	Vector<T>& operator=(const Vector<T>& src) {
		if (this == &src) {
			return *this;
		}
		// 释放当前对象原来的资源
		// delete[] first_;
		for (T* p = first_; p != last_; p++) {
			allocator_.destroy(p);
		}
		allocator_.deallocate(first_);
		last_ = first_ = end_ = nullptr;

		// 开辟空间
		int size = src.end_ - src.first_;
		// first_ = new T[size];
		first_ = allocator_.allocate(sizeof(T) * size);

		// 拷贝有效元素
		int len = src.last_ - src.first_;
		for (int i = 0; i < len; i++) {
			allocator_.construct(first_ + i, src.first_[i]);
		}
		last_ = first_ + len;
		end_ = first_ + size;
		// 支持连续赋值
		return *this;
	}

	bool inline full() const {
		return last_ == end_;
	}

	bool inline empty() const {
		return first_ == last_;
	}

	bool inline size() const {
		return last_ - first_;
	}

	// 在容器末尾构造一个值为val的对象
	void push_back(const T& val) {
		if (full()) {
			expand();
		}
		allocator_.construct(last_, val);
		last_++;
	}

	void push_back(T&& val) {
		if (full()) {
			expand();
		}
		allocator_.construct(last_, std::move(val));
		last_++;
	}

	// 从末尾删除元素
	void pop_back() {
		if (empty()) {
			return;
		}
		last_--;
		allocator_.destroy(last_);
	}

	T back() const {
		return *(last_ - 1);
	}

private:
	void expand() {
		int size = end_ - first_;
		// T* tmp = new T [2 * size];
		T* tmp = allocator_.allocate(2 * sizeof(T) * size);
		for (int i = 0; i < size; i++) {
			allocator_.construct(tmp + i, first_[i]);
		}

		// delete[] first_;
		for (T* p = first_; p != last_; p++) {
			allocator_.destroy(p);
		}
		allocator_.deallocate(first_);

		first_ = tmp;
		last_ = first_ + size;
		end_ = first_ + 2 * size;
	}

	T* first_;   // 指向数组起始位置
	T* last_;    // 指向数组中有效元素的后继位置
	T* end_;     // 指向数组空间的后继位置
	Alloc allocator_;
};

当push_back方法的参数是一个临时对象时，我们希望匹配带右值引用参数的push_back，直接把临时对象的资源转移到vector数组中，并将临时对象指向资源的指针置为nullptr

vector类添加带右值引用参数的push_back

	void push_back(T&& val) {
		if (full()) {
			expand();
		}
		allocator_.construct(last_, val);
		last_++;
	}

空间配置器添加带右值引用参数的construct

	void construct(T* p, T&& val) {
		new (p) T(val);  // 定位new，指定地址构造值为val的对象，调用拷贝构造函数
	}

int main() {
	String str1("hello ");
	Vector<String> vec;

	cout << "=========================" << endl;
	vec.push_back(str1);
	vec.push_back("123");
	cout << "=========================" << endl;

	return 0;
}

String类定义见下方完整代码

在这里插入图片描述

move移动语义，将左值转为右值

虽然"123"调用普通构造函数生成的String是一个右值，匹配的也是带右值引用参数的push_back，但右值引用变量实际上是一个左值，push_back中调用construct，匹配的还是construct(T* p, const T& val)

在vector类中添加带右值引用参数的push_back，用move将左值变量强转成右值

	void push_back(T&& val) {
		if (full()) {
			expand();
		}
		allocator_.construct(last_, std::move(val));
		last_++;
	}

虽然匹配的是带右值引用参数的construct，但形参val本身是 一个左值，还需要将val转换为左值，才能匹配String(String &&)

	void construct(T* p, T&& val) {
		new (p) T(std::move(val)); 
	}

注意，这里不要把T&& val写成const T&& val，否则std::move返回的是右值，不能匹配const T&& val

int main() {
	String str1("hello ");
	Vector<String> vec;

	vec.push_back(str1);
	cout << "=========================" << endl;
	vec.push_back(String("123"));
	cout << "=========================" << endl;
	
	return 0;
}

在这里插入图片描述
由于是用临时对象给Vector底层数组构造元素，所以匹配的是带右值引用的push_back，接着匹配带右值引用的construct，最后匹配带右值引用的String构造函数

而使用带右值引用的构造函数时，是直接转移资源，而不是开辟空间再进行数据拷贝

上述添加的两段代码中，虽然传入的实参是右值，然后右值引用形参变量本身是个左值，所以函数内使用形参变量时，如果我们想要得到右值形式，需要使用move。我们提供了分别提供了两个带左值引用参数和带右值引用参数的push_back和construct，实际上同一个函数不需要提供两个带左值引用参数和带右值引用参数的函数，使用函数模板的类型推演 + 引用折叠 + forward后使用一个函数即可

forward类型完美转发

template<typename Ty>
void push_back(Ty&& val) {
	// 实参是String&&，引用折叠后，则val是String&&
	// 实参是String&，引用折叠后，则val是String&
	if (full()) {
		expand();
	}
	allocator_.construct(last_, std::forward<Ty>(val));
	last_++;
}

template<typename Ty>
void construct(T* p, Ty&& val) {
	new (p) T(std::forward<Ty>(val));
}

传入的实参是右值，引用折叠后，val还是右值引用，是一个左值；传入的实参是左值，引用折叠后，val还是左值引用，是一个左值。使用forward可以获取传入的实参的类型，传入左值返回左值，传入右值返回右值

string&& + && = string&&
string& + && = string&

在这里插入图片描述

完整代码如下：

#include <iostream>

using namespace std;

class String{
public:
	String(const char* str = nullptr){
		cout << "String(const char*)" << endl;
		if (str != nullptr){
			m_data = new char[strlen(str) + 1];
			strcpy(m_data, str);
		}
		else{
			m_data = new char[1];
			*m_data = '\0';
		}
	}

	
	String(String&& src) {
		cout << "String(String&& src)" << endl;
		m_data = src.m_data;
		src.m_data = nullptr;
	}

	String(const String& src){
		cout << "String(const String& src)" << endl;
		m_data = new char[strlen(src.m_data) + 1];
		strcpy(m_data, src.m_data);
	}

	~String(){
		cout << "~String()" << endl;
		delete[]m_data;
		m_data = nullptr;
	}

	//调用String&是为了支持连续的operator=赋值操作
	String& operator=(const String& src){
		cout << "operator=(const String& src)" << endl;
		if (&src == this){
			return *this;
		}
		delete[]m_data;

		m_data = new char[strlen(src.m_data) + 1];
		strcpy(m_data, src.m_data);
		return *this;
	}

	String& operator=(String&& src) {
		cout << "operator=(String&& src)" << endl;
		if (&src == this) {
			return *this;
		}
		delete[]m_data;
		m_data = src.m_data; // 改变堆区资源指向
		src.m_data = nullptr; // 临时对象的指针置空，防止析构的时候释放资源
		return *this;
	}

	const char* c_str() const {
		return m_data;
	}

	friend String operator+(const String& str1, const String& str2);
	friend ostream& operator<<(ostream& out, const String& str);

private:
	char* m_data;//用于保存字符串
};

String operator+(const String& str1, const String& str2) {
	String tmp;
	tmp.m_data = new char[strlen(str1.m_data) + strlen(str2.m_data) + 1];
	strcpy(tmp.m_data, str1.m_data);
	strcat(tmp.m_data, str2.m_data);
	return tmp;
}
ostream& operator<<(ostream& out, const String& str) {
	out << str.m_data;
	return out;
}

String get_string(String& str) {
	const char* pstr = str.c_str();
	String tmp(pstr);
	return tmp;
}



template<typename T>
class Allocator {
public:
	// 开辟size字节
	T* allocate(size_t size) {
		return (T*)malloc(size);
	}

	void deallocate(void* p) {
		free(p);
	}

	template<typename Ty>
	void construct(T* p, Ty&& val) {
		new (p) T(std::forward<Ty>(val));
	}

	//void construct(T* p, const T& val) {
	//	new (p) T(val);  // 定位new，指定地址构造值为val的对象，调用拷贝构造函数
	//}

	void destroy(T* p) {
		p->~T();
	}
};

const int INIT_SIZE = 10;

template<typename T, typename Alloc = Allocator<T>>
class Vector {
public:
	Vector(int size = INIT_SIZE, const Alloc& alloc = Allocator<T>())
		: allocator_(alloc)
	{
		// first_ = new T[size];
		first_ = allocator_.allocate(size * sizeof(T));
		last_ = first_;
		end_ = first_ + size;
	}

	~Vector() {
		// delete[] first_;

		// 析构时，只析构容器中有效元素[first_, last - 1]
		for (T* p = first_; p != last_; p++) {
			allocator_.destroy(p);
		}
		// 释放整个容器空间
		allocator_.deallocate(first_);
		last_ = first_ = end_ = nullptr;
	}

	Vector(const Vector<T>& src) {
		// 深拷贝
		// 开辟空间
		int size = src.end_ - src.first_;
		// first_ = new T[size];
		first_ = allocator_.allocate(sizeof(T) * size);

		// 拷贝有效元素
		int len = src.last_ - src.first_;
		for (int i = 0; i < len; i++) {
			// first_[i] = src.first_[i];
			allocator_.construct(first_ + i, src.first_[i]);
		}
		last_ = first_ + len;
		end_ = first_ + size;
	}

	Vector<T>& operator=(const Vector<T>& src) {
		if (this == &src) {
			return *this;
		}
		// 释放当前对象原来的资源
		// delete[] first_;
		for (T* p = first_; p != last_; p++) {
			allocator_.destroy(p);
		}
		allocator_.deallocate(first_);
		last_ = first_ = end_ = nullptr;

		// 开辟空间
		int size = src.end_ - src.first_;
		// first_ = new T[size];
		first_ = allocator_.allocate(sizeof(T) * size);

		// 拷贝有效元素
		int len = src.last_ - src.first_;
		for (int i = 0; i < len; i++) {
			allocator_.construct(first_ + i, src.first_[i]);
		}
		last_ = first_ + len;
		end_ = first_ + size;
		// 支持连续赋值
		return *this;
	}

	bool inline full() const {
		return last_ == end_;
	}

	bool inline empty() const {
		return first_ == last_;
	}

	bool inline size() const {
		return last_ - first_;
	}

	template<typename Ty>
	void push_back(Ty&& val) {
		if (full()) {
			expand();
		}
		allocator_.construct(last_, std::forward<Ty>(val));
		last_++;
	}


	// 从末尾删除元素
	void pop_back() {
		if (empty()) {
			return;
		}
		last_--;
		allocator_.destroy(last_);
	}

	T back() const {
		return *(last_ - 1);
	}

private:
	void expand() {
		int size = end_ - first_;
		// T* tmp = new T [2 * size];
		T* tmp = allocator_.allocate(2 * sizeof(T) * size);
		for (int i = 0; i < size; i++) {
			allocator_.construct(tmp + i, first_[i]);
		}

		// delete[] first_;
		for (T* p = first_; p != last_; p++) {
			allocator_.destroy(p);
		}
		allocator_.deallocate(first_);

		first_ = tmp;
		last_ = first_ + size;
		end_ = first_ + 2 * size;
	}

	T* first_;   // 指向数组起始位置
	T* last_;    // 指向数组中有效元素的后继位置
	T* end_;     // 指向数组空间的后继位置
	Alloc allocator_;
};

int main() {
	String str1("hello ");
	Vector<String> vec;

	vec.push_back(str1);
	cout << "=========================" << endl;
	vec.push_back(String("123"));
	cout << "=========================" << endl;

	return 0;
}
bugcoder-9905
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
详解C++11中的右值引用与移动语义
08-31
本篇文章主要介绍了详解C++11中的右值引用与移动语义，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
C++11中value category（值类别）及move semantics（移动语义）的介绍
08-27
主要给大家介绍了C++11中value category（值类别）及move semantics（移动语义）的介绍，文中介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
C/C++ move/forward/完美转发
m0_66776925的博客
04-01 559
本节针对于std::move，std::forward，左右引用做一个基本得归纳和整理； 一、为什么需要： 之所以需要说白了还是在构造对象的性能优化上； 针对于构造方式，无非是：深拷贝，浅拷贝 两种； 所以一般而言，对象内部应该实现两种构造函数，移动构造函数和拷贝构造函数； 前者用于直接转让内部对象，避免复制耗时，而后者主要是直接进行全量复制； 例如下例： class A { public: A() { cout << "construct.." << end
【转载】C++11 forward完美转发
yaoyaoqiekenaoo的博客
07-19 113
前言 继续阅读之前，你最好了解了左值，右值，左值引用，右值引用等概念。 最好阅读了C++11 move带来的高效 引入 这里我借上一篇C++11 move带来的高效中的CMyString类用一下，代码如下 class CMyString{public: CMyString(char* pStr) : m_pStr(NULL) , m_nLen(0) { if (NULL != pStr) { ...
突破编程_C++_C++11新特性（完美转发 forward）
最新发布
突破编程
03-21 703
C++11 新特性：完美转发 forward
C++之std::forward(完美转发)
红军不怕远征难，万水千山只等闲
12-14 3267
注意这声变量在声明时一般会先给初始值。因此。
Linux内存uncache区域拷贝优化
非专业业余程序员
03-20 2057
1.概述 内存非cache区域拷贝速度很慢，严重影响了系统性能，因此采用多种方法进行优化，主要有对齐拷贝、批量拷贝、减少循环次数、NEON拷贝方法。 2.高级SIMD和浮点寄存器介绍 2.NEON指令 2.1 VLDR VLDR指令可从内存中将数据加载到扩展寄存器中。 VLDR{<c>}{<q>}{.64} <Dd>, [<Rn> {, #+/-<imm>}] Encoding T1/A1, immediate form VLDR{<c
浅析C++11中的右值引用、转移语义和完美转发
09-01
对于c++11来说移动语义是一个重要的概念，一直以来我对这个概念都似懂非懂。最近翻翻资料感觉突然开窍，因此顺便记录下C++11中的右值引用、转移语义和完美转发，方便大家查阅参考。
深入了解c++11 移动语义与右值引用
08-18
主要介绍了c++ 移动语义与右值引用的相关资料，帮助大家更好的理解和学习c++,感兴趣的朋友可以了解下
c++11：std::forward，完美转发
李白
05-15 4825
目录 1、不完美转发 2、完美转发 2.1、引用折叠 2.2、std::forward 1、不完美转发 所谓完美转发，是指在函数模板中，完全按照模板的参数的类型，将参数传递给函数模板中调用的另一个函数。比如： template <typename T> void IamForwording(T t) { IrunCodeActually(t); } 上面的例子中，IamForwarding是一个转发函数模板。而函数IrunCodeActually则是真正执行代码的目
c++11 完美转发 std::forward()
热门推荐
coolwriter的博客
07-09 3万+
其实对于 std::move来说，只做了一件事。可以初步的理解为 (不过当然是错误的) template&amp;lt;typename T&amp;gt; T&amp;amp;&amp;amp; move(T&amp;amp; val) { return static_cast&amp;lt;T&amp;amp;&amp;amp;&amp;gt;(val); } move 只是纯粹的将一个左值转化为了一个右值，STL实
C++11新特性之 std::forward(完美转发)
一蓑烟雨任平生 也无风雨也无晴
01-08 3万+
上篇博客对右值、右值引用都做了简要介绍。我们也要时刻清醒，有时候右值会转为左值，左值会转为右值。 （也许“转换”二字用的不是很准确）如果我们要避免这种转换呢？ 我们需要一种方法能按照参数原来的类型转发到另一个函数中，这才完美，我们称之为完美转发。std::forward就可以保存参数的左值或右值特性。因为是这样描述的： When used according to the following
C++11 forward完美转发
Barry的博客
10-26 6150
前言 继续阅读之前，你最好了解了左值，右值，左值引用，右值引用等概念。 引入 这里我借上一篇C++11 move带来的高效中的CMyString类用一下，代码如下 class CMyString { public: CMyString(char* pStr) : m_pStr(NULL) , m_nLen(0) { if (NULL != pStr) { m_nL
C++11中移动语义(std::move)和完美转发(std::forward)
欢迎关注公众号：【码农突围】，公号后台回复9999，可以获取一份500页的LeetCode刷题笔记。
09-26 8132
前言所有的手段都是为了解决已存在的问题。std::move和std::forward是C++11中的特性，是为了解决C++98/C++0x中遗留的问题，虽从理解上来看比较复杂，却是较好的解决手段。左值(lvalue)与右值(rvalue)左值与右值的概念其实在C++0x中就有了。概括的讲，凡是能够取地址的可以称之为左值，反之称之为右值，C++中并没有对左值和右值给出明确的定义，从其解决手段来看类似上
C++ 完美转发forward理解
qq_24447809的博客
05-20 2577
概述 完美转发 std::forward 实现完美转发，作用就是保持传参参数属性不变，如果原来的值是左值，经std::forward处理后该值还是左值；如果原来的值是右值，经std::forward处理后它还是右值。 详细说明见代码注释 代码 #include <iostream> #include <string> #include<algorithm> using namespace std; //左值引用 void process(int& x) { co
C++11：forward及完美转发
luoyayun361的专栏
04-10 1555
代码 using namespace std; template<typename T> void PrintT(int &t) { cout << "lvalue" << endl; } template<typename T> void PrintT(int &&t) { cout << "rvalue" << endl; } template<typename T> voi
C++ move使用
昔拉的博客
01-09 8317
move作用主要可以将一个左值引用转换成右值引用，从而可以调用C++11右值引用的拷贝构造函数，在对象拷贝的时候，在运行时，它们不会产生一行代码原先的对象也会清空， 可以减少资源创建和释放。 ...
C++: forward 完美转发
qq_44144025的博客
09-07 1019
需要先深刻理解拷贝构造和移动构造的作用后，才能理解forword存在的理由 首先 明确forword的作用 std::forword(u) 有两个参数T和u。 当T为左值引用类型时，u将被转化成T类型的左值引用。 当T为左值时，u将被转化成T类型的右值。 当T为右值时，可以不考虑这种情况。 然后 明确forword的用途 forword是为了解决 在函数模板中，使用右值引用参数(T ＆＆)，传递右值进去以后，类型会变为左值的问题。 当传入的参数是一个对象时，右值变左值就会出问题，因为 左值 调用 拷贝构
c 完美转发和移动语义
07-08
完美转发（perfect forwarding）是...在实际使用中，完美转发和移动语义常常结合使用，以提高代码的效率和灵活性。通过完美转发，可以将参数以原样转发给其他函数，包括移动语义相关的函数，从而避免不必要的拷贝操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

bugcoder-9905

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

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

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

打赏作者

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

抵扣说明：

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

余额充值