#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的地址跟接近，說明數(shù)組存在棧上 
	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是左值，推導(dǎo)出T為const int&，引?折疊，模板實例化為void Function(const int& t)
				// 所以Function內(nèi)部會編譯報錯，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;
}