32_「C++11」右值引用和移动语义

int main()
{
	// 以下的p、b、c、*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;

	// 以下几个是对上面左值的左值引用
	int*& rp = p;
	int& rb = b;
	const int& rc = c;
	int& pvalue = *p;
	return 0;
}

int main()
{
	double x = 1.1, y = 2.2;
	// 以下几个都是常见的右值
	10;
	x + y;
	fmin(x, y);

	// 以下几个都是对右值的右值引用
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);

	// 这里编译会报错：error C2106: “=”: 左操作数必须为左值,右值不能出现在赋值符号的左边
	//10 = 1;
	//x + y = 1;
	//fmin(x, y) = 1;

	return 0;
}

int main()
{
	double x = 1.1, y = 2.2;
	int&& rr1 = 10;
	const double&& rr2 = x + y;
	rr1 = 20;
	rr2 = 5.5; // 报错
	return 0;
}

int main()
{
	// 左值引用只能引用左值，不能引用右值。
	int a = 10;
	int& ra1 = a; // ra为a的别名

	// int& ra2 = 10; // 编译失败，因为10是右值
	
	// const左值引用既可引用左值，也可引用右值。
	const int& ra3 = 10;
	const int& ra4 = a;
	return 0;
}

int main()
{
	// 右值引用只能右值，不能引用左值。
	int&& r1 = 10;

	// error C2440: “初始化”: 无法从“int”转换为“int &&”: 无法将左值绑定到右值引用
	int a = 10;
	int&& r2 = a;

	// 右值引用可以引用 move以后的左值
	int&& r3 = std::move(a);
	return 0;
}

namespace fy
{
	class string
	{
	public:
		//构造函数
		string(const char* str = "")
		{
			_size = strlen(str);//字符串大小
			_capacity = _size;//构造时，容量大小默认与字符串大小相同
			_str = new char[_capacity + 1];//为字符串开辟空间（多开一个用于存放'\0'）
			strcpy(_str, str);//将C字符串拷贝到已开好的空间
		}
		//析构函数
		~string()
		{
			delete[] _str; //释放_str指向的空间
			_str = nullptr;
			_size = _capacity = 0;
		}
		//拷贝构造 -- 现代写法
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			,_capacity(0)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;
			string tmp(s._str);//复用构造函数，构造 tmp对象
			swap(tmp);//交换
		}
		//赋值重载 -- 现代写法1
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 深拷贝" << endl;
			if (this == &s)//检查自我赋值
			{
				return *this;
			}
			string tmp(s);//复用拷贝构造函数，用s拷贝构造出对象tmp
			swap(tmp);
			return *this;//返回左值，目的是为了支持连续赋值
		}

		typedef char* iterator;//迭代器

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		//更改容量大小
		void reserve(size_t n)
		{
			if (n > _capacity)//n大于现有容量，增容，n小于现有容量则不改变容量
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;//更新容量
			}
		}

		//交换两个字符串
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}

		const char* c_str()const
		{
			return _str;
		}
		
		//尾插一个字符
		void push_back(char c)
		{
			if (_size == _capacity)//判断是否需要增容
			{
				size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newCapacity);
			}
			_str[_size] = c;
			++_size;
			_str[_size] = '\0';
		}

		//+= 一个字符
		string& operator+=(char c)
		{
			push_back(c);
			return *this;
		}

	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

namespace fy
{
  //模拟实现一个int版本的to_string函数
	string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}
		fy::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;

			str += ('0' + x);
		}
		if (flag == false)
		{
			str += '-';
		}

		std::reverse(str.begin(), str.end());
		return str;
	}
}

int main()
{
	fy::string s1 = fy::to_string(11111);
	return 0;
}

string(const string& s) -- 深拷贝

// 移动构造
string(string&& s)
	:_str(nullptr)
	, _size(0)
	, _capacity(0)
{
	cout << "string(string&& s) -- 移动语义" << endl;//更明显观察是否调用了该函数
	swap(s);//与右值的资源进行直接交换，不进行深拷贝
}

int main()
{
	fy::string s1 = fy::to_string(11111);
	return 0;
}

string(string&& s) -- 移动语义

int main()
{
	//fy::string s1 = fy::to_string(11111);

	//不是连续构造，编译器不进行优化
	fy::string s1;
	s1 = fy::to_string(11111);
	return 0;
}

// 移动赋值
string& operator=(string&& s)
{
	cout << "string& operator=(string&& s) -- 移动语义" << endl;//使更明显观察是否调用了该函数
	swap(s);//与右值的资源进行直接交换，不进行深拷贝
	return *this;//支持连续赋值
}

int main()
{
	fy::string s1;
	s1 = fy::to_string(11111);
	return 0;
}

string(string&& s) -- 移动语义
string& operator=(string&& s) -- 移动语义 

template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
    // forward _Arg as movable
    return ((typename remove_reference<_Ty>::type&&)_Arg);
}

int main()
{
	fy::string s1("hello world");
	// 这里s1是左值，调用的是拷贝构造
	fy::string s2(s1);

	// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
	// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的资源被转移给了s3，s1被置空了。
	fy::string s3(std::move(s1));
	return 0;
}

template<class T>
void PerfectForward(T&& t)// 这里的 && 是万能引用
{
	//...
}

void Fun(int& x) 
{ 
	cout << "左值引用" << endl; 
}
void Fun(const int& x) 
{ 
	cout << "const 左值引用" << endl; 
}
void Fun(int&& x) 
{ 
	cout << "右值引用" << endl; 
}
void Fun(const int&& x) 
{ 
	cout << "const 右值引用" << endl; 
}
// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);//调用Fun函数
}
int main()
{
	PerfectForward(10); // 右值
	int a;
	PerfectForward(a); // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b); // const 左值
	PerfectForward(std::move(b)); // const 右值
	return 0;
}

左值引用
左值引用
左值引用
const 左值引用
const 左值引用

template<typename T>
void PerfectForward(T&& t)
{
	Fun(std::forward<T>(t));//调用Fun函数
}

右值引用
左值引用
右值引用
const 左值引用
const 右值引用

「 作者 」 枫叶先生
「 更新 」 2023.4.17
「 声明 」 余之才疏学浅，故所撰文疏漏难免，
          或有谬误或不准确之处，敬请读者批评指正。