C++11（上）：重塑 C++ 的现代革命

struct Point
{
    int _x;
    int _y;
};
int main()
{
    int array1[] = { 1, 2, 3, 4, 5 };
    int array2[5] = { 0 };
    Point p = { 1, 2 };
    cout << p._x << " " << p._y << endl;

    return 0;
}

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}
	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{
		cout << "Date(const Date& d)" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

void Insert(const Date& d)
{

}

Date func()
{
	/*Date d{ 2025,11,16 };
	return d;*/

	//return { 2025,11,16 };

	//返回默认构造
	Date d;
	return d;

	//return {};
}

int main()
{
	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[5] = { 0 };

	//自定义类型
	Point p = { 1, 2 };
	cout << p._x << " " << p._y << endl;

	Date d2 = 1025;//单参数的隐式类型转换
	Date d2 = { 2025,11,17 };
	Date d3{ 2025,11,17 };
	Date d4{};//调用默认构造，用缺省值
	Date d5;  //也是调用默认构造，用缺省值

	Insert(2025);
	Insert({ 2025,11,17 });
	
	//内置类型
	int i = 0;
	int j = { 1 };
	int k{ 2 };
	int m{};


	// C++11⽀持的
	// 内置类型⽀持
	int x1 = { 2 };
	// ⾃定义类型⽀持
	// 这⾥本质是⽤{ 2025, 1, 1}构造⼀个Date临时对象
	// 临时对象再去拷⻉构造d1，编译器优化后合⼆为⼀变成{ 2025, 1, 1}直接构造初始化d1
	// 运⾏⼀下，我们可以验证上⾯的理论，发现是没调⽤拷⻉构造的
	Date d1 = { 2025, 1, 1 };

	// 这⾥d2引⽤的是{ 2024, 7, 25 }构造的临时对象
	const Date& d2 = { 2024, 7, 25 };

	// 需要注意的是C++98⽀持单参数时类型转换，也可以不⽤{}
	Date d3 = { 2025 };
	Date d4 = 2025;

	// 可以省略掉=
	Point p1{ 1, 2 };
	int x2{ 2 };
	Date d6{ 2024, 7, 25 };
	const Date& d7{ 2024, 7, 25 };

	// 不⽀持，只有{}初始化，才能省略=
	// Date d8 2025;

	vector<Date> v;
	v.push_back(d1);
	v.push_back(Date(2025, 1, 1));

	// ⽐起有名对象和匿名对象传参，这⾥{}更有性价⽐
	v.push_back({ 2025, 1, 1 });

	return 0;
}

int main()
{
	vector<int> v1 = { 1,2,3,4,5,6 };
	vector<int> v2{ 7,8,9 };

	//vector(initializer_list<T> l) vector传给initializer_list<T>
	//{
	//	for (auto e : l)
	//		push_back(e)
	//}

	map<string, string>dict = { {"sort","排序"},{"string","字符串"} };

	v1 = { 10,20,30 };

	auto il = { 10,20,30 };
	cout << typeid(il).name() << endl;

	std::initializer_list<int> mylist;
	mylist = { 10, 20, 30 };
	cout << sizeof(mylist) << endl;

	// 这⾥begin和end返回的值initializer_list对象中存的两个指针
	// 这两个指针的值跟i的地址跟接近，说明数组存在栈上
	int i = 0;
	cout << mylist.begin() << endl;
	cout << mylist.end() << endl;
	cout << &i << endl;

	return 0;
}

//左值
int a=1;
char b=c;
int *p=&a;

//右值
10;
"11111"

int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	int* p = new int(0);
	int b = 1;
	const int c = b;
	*p = 10;
	string s("111111");
	s[0] = 'x';

	cout << &p << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &(*p) << endl;
	cout << &s << endl;
	cout << (void*) & s[0] << endl;

	// 右值：不能取地址
	double x = 1.1, y = 2.2;
	// 以下⼏个10、x + y、fmin(x, y)、string("11111")都是常⻅的右值
	10;
	x + y;
	fmin(x, y);
	string("11111");

	//编译报错
	//cout << &10 << endl;
	//cout << &(x+y) << endl;
	//cout << &(fmin(x, y)) << endl;
	//cout << &string("11111") << endl;


	return 0;
}

int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	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];

	return 0;
}

int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	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&& rr1 = 10;
	double&& rr2 = x + y;
	double&& rr3 = fmin(x, y);
	string&& rr4 = string("11111");

	return 0;
}

int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	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;

	// 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值
	//int& rx1 = 10;
	const int& rx1 = 10;
	const double& rx2 = x + y;
	const double& rx3 = fmin(x, y);
	const string& rx4 = string("11111");

	return 0;
}

int main()
{
	// 左值：可以取地址
	// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
	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;

	// 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)
	//int&& rrx1 = b;
	int&& rrx1 = move(b);
	int*&& rrx2 = move(p);
	int&& rrx3 = move(*p);
	string&& rrx4 = move(s);
	string&& rrx5 = (string&&)s;

	return 0;
}

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
};

int main()
{
	A aa1;

	A();

	//左值引用延长生命周期
	//const A& ref1 = A();

	//右值引用延长生命周期
	//A&& ref2 = A();

	cout << "main end" << endl;

	return 0;
}

void f(const int& x)
{
	std::cout << "到 const 的左值引用重载 f(" << x << ")\n";
}


int main()
{
	f(10);

	int a = 20;
	f(a);

	const int b = 30;
	f(b);

	//右值引用本身的属性是左值
	int&& x = 1;
	f(x);		// 调⽤ f(int& x)
	f(move(x)); // 调⽤ f(int&& x)

	return 0;
}

void f(int& x)
{
	std::cout << "左值引用重载 f(" << x << ")\n";
}

void f(const int& x)
{
	std::cout << "到 const 的左值引用重载 f(" << x << ")\n";
}

void f(int&& x)
{
	std::cout << "右值引用重载 f(" << x << ")\n";
}

int main()
{
	f(10);

	int a = 20;
	f(a);

	const int b = 30;
	f(b);

	//右值引用本身的属性是左值
	int&& x = 1;
	f(x);		// 调⽤ f(int& x)
	f(move(x)); // 调⽤ f(int&& x)

	return 0;
}

class Solution {
public:
	// 传值返回需要拷⻉
	string addStrings(string num1, string num2) {
		string str;
		int end1 = num1.size() - 1, end2 = num2.size() - 1;
		// 进位
		int next = 0;
		while (end1 >= 0 || end2 >= 0)
		{
			int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
			int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
			int ret = val1 + val2 + next;
			next = ret / 10;
			ret = ret % 10;
			str += ('0' + ret);
		}
		if (next == 1)
			str += '1';
		reverse(str.begin(), str.end());
		return str;
	}
};