C++11中的{}初始化,initializer_list,右值引用全解

#include<iostream>
#include<vector>
using namespace std;
struct Point
{
	int _x;
	int _y;
};
class Date
{
public:
	Date(int month, int day, int year)
		:_month(month),
		_year(year),
		_day(day)
	{};
private:
	int _month=0;
	int _year=0;
	int _day=0;
};
int main()
{
	int x{ 2 };
	Date d1{ 2,3,4 };
	const Date& d2 = { 2024, 7, 25 };
	Point p1{ 1, 2 };
	return 0;
}

int main()
{
	std::initializer_list<int> mylist;
	mylist = { 10, 20, 30 };
	cout << sizeof(mylist) << endl;
    // 这⾥begin和end返回的值initializer_list对象中存的两个指针 
    // 这两个指针的值跟i的地址跟接近，说明数组存在栈上 
	cout << mylist.begin() << " " << mylist.end() << endl;
	vector<int> v1(mylist);
	vector<int> v2 = { 1,2,3,4,5 };
	vector<int> v3({ 1,2,3,4 });
	return 0;
}

int main()
{
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';
	double x = 1.1, y = 2.2;
	// 左值引⽤给左值取别名 
	int& r1 = b;
	int*& r2 = p;
	int& r3 = *p;
	string& r4 = s;
	char& r5 = s[0];
	// 右值引⽤给右值取别名 
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);
	string&& rr4 = string("11111");
	// 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值 
	const int& rx1 = 10;
	const double& rx2 = x + y;
	const double& rx3 = fmin(x, y);
	const string& rx4 = string("11111");
	// 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值) 
	int&& rrx1 = move(b);
	int*&& rrx2 = move(p);
	int&& rrx3 = move(*p);
	string&& rrx4 = move(s);
	string&& rrx5 = (string&&)s;
	return 0;
}

int main()
{
	string&& s1 = "test";
	const string& s2 = s1 + s1;//cosnt左值引用无法改变
	string&& s3 = s1 + s1;
	s3 += "abg";//右值引用是左值可以改变
	cout << s3;
	return 0;
}

// 由于引⽤折叠限定，f1实例化以后总是⼀个左值引⽤ 
template<class T>
void f1(T& x)
{}
// 由于引⽤折叠限定，f2实例化后可以是左值引⽤，也可以是右值引⽤ 
template<class T>
void f2(T&& x)
{}
int main()
{
	typedef int& lref;
	typedef int&& rref;
	int n = 0;
	lref& r1 = n; // r1 的类型是 int& 
	lref&& r2 = n; // r2 的类型是 int& 
	rref& r3 = n; // r3 的类型是 int& 
	rref&& r4 = 1; // r4 的类型是 int&&
	// 没有折叠->实例化为void f1(int& x) 左值引用的左值引用是左值引用
	f1<int>(n);
	//f1<int>(0); // 报错 左值引用不能引用临时对象（右值）
	// 折叠->实例化为void f1(int& x) 
	f1<int&>(n);
	//f1<int&>(0); // 报错 
	// 折叠->实例化为void f1(int& x) 
	f1<int&&>(n);
	//f1<int&&>(0); // 报错
	// 折叠->实例化为void f1(const int& x) 
	f1<const int&>(n);
	f1<const int&>(0);//const 左值引用可以引用右值
	// 折叠->实例化为void f1(const int& x) 
	f1<const int&&>(n);
	f1<const int&&>(0);
	// 没有折叠->实例化为void f2(int&& x) 
	//f2<int>(n); // 报错 右值引用不能引用左值 
	f2<int>(0);
	// 折叠->实例化为void f2(int& x) 
	f2<int&>(n);
	//f2<int&>(0); // 报错 
	// 折叠->实例化为void f2(int&& x) 
	//f2<int&&>(n); // 报错 
	f2<int&&>(0);
	return 0;
}

template<class T>
void Function(T&& t)
{
	int a = 0;
	T x = a;
	x++;
	cout << x;
}
int main()
{
	Function(10);//传右值T被推到为int,int&&是右值引用
	int a = 0;
	Function(a);//传左值T被推到为int& ，int& &&是int&
	const int b = 8;
	Function(b);// b是左值，推导出T为const int&，引⽤折叠，模板实例化为void Function(const int& t)
				// 所以Function内部会编译报错，x不能++ 
	Function(move(b));//b是右值，推到出T为const int，x不能++；
	return 0;
}

using namespace std;
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<class T>
void Function(T&& t)
{
	Fun(t);
}
template<class T>
void Function1(T&& t)
{
	Fun(forward<T>(t));
}
int main()
{
	Function(10);
	Function1(10);
	const int b = 8;
	Function(b);
	Function1(b);
	Function(move(b));
	Function1(move(b));
	return 0;
}