C++进阶：C++11(列表初始化、右值引用与移动构造移动赋值、可变参数模版...Args、lambda表达式、function包装器)

#include<iostream>

using namespace std;

struct Point
{
	int _x;
	int _y;
};

int main()
{
	int a1 = 1;
	int a2 = { 1 };
	int a3{ 1 };//这些都能初始化

	int a4(1);
	int a5 =int(1);//这两个是模版支持的基本类型int构造和拷贝构造

	int array1[] = { 1, 2, 3, 4, 5 };
	int array2[]{ 1, 2, 3, 4, 5 };//也能省略


	Point p1 = { 1, 2 };
	Point p2 = { 1 };// _y默认初始化成0了
	return 0;
}

int main()
{
	Point p1 = { 1, 2 };//本质就是：构造 + 拷贝构造 -> 优化，直接构造
	//相应的构造函数支持隐式类型转换，产生的临时对象是Point类型（构造出来的）
	Point* pp = new Point[2]{ {1,2},{2,3} };//这样的的意义比较大
	return 0;
}

int main()
{
	Point p1 = { 1, 2 };
	vector<int> v = { 1,2,3,4 };
	//这里两个是一样的吗？
	//不一样，前者数量限定死了；后者还可以随便加减
	return 0;
}

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

int main()
{
	pair<const char*, const char*> kv3("sort", "排序");
	pair<const string, string> kv4(kv3);//明明是不同类型，但是却可以初始化
	return 0;
}

int main()
{
	map<string, string> dict2 = { {"sort", "排序"}, {"string", "字符串"} };
	auto it2 = dict2.begin();
	map<string, string> ::iterator it2 = dict2.begin();
	//这样看是不是auto真香啊
	return 0;
}

int x = 10;
decltype(x) y = 20; // y的类型为int，与x相同  这里decltype(x)就是一个类型

int& fun1()
{
	static int a = 1;
	return a;
}

int fmin(int a,int b)
{
	if (a < b)
		return a;
	else
		return b;
}

int main()
{
	int a = 0;
	int* pa = &a;
	int& ret = fun1();//这里a，pa，fun1的返回值都是左值，都能取地址

	// 以下几个都是常见的右值
	10;
	a + ret;
	fmin(a, ret);

	return 0;
}

	// 以下几个都是对右值的右值引用
	int&& r1 = 10;
	double&& r2 = a + ret;
	double&& r3 = fmin(a, ret);

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

    // const左值引用既可引用左值，也可引用右值。
    const int& ra2 = 10;
    const int& ra3 = a;
 //----------------------------------------------------------------
    // 右值引用只能右值，不能引用左值。
    int&& r1 = 10;

    // 右值引用可以引用move以后的左值，move会返回右值引用
    int&& r2 = std::move(a);

    return 0;
}

	mystring::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;//负数变正数
		}

		mystring::string str;//这里是定义了一个局部的string
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;

			str += ('0' + x);
		}

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

		std::reverse(str.begin(), str.end());
		return str;//最后返回这个局部的string，不能返回左值引用。目前采取的是传值返回
		//核心问题是，出了作用域就销毁了，返回什么引用都不行
	}

		// 拷贝构造 -- 左值
		//一开始只有这个拷贝构造时，因为const 左值引用能给右值取别名
		//所以左值走这个，右值也走这个
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s)--正常拷贝构造" << endl;

			_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}

		//现在我们为右值特地编写一个构造函数，右值引用就走这个了
		// 移动构造 -- 右值(将亡值)
		string(string&& s)
		{
			cout << "string(string&& s)-- 移动拷贝" << endl;//方便观察结果
			swap(s);
		}

		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);

			return *this;
		}

		//移动赋值
		string& operator=(string&& s)//接收右值
		{
			swap(s);//移动将亡值的资源，并且把不要空间给将亡值，让将亡值帮着释放
			return *this;
		}

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 test(T&& t)
{
	cout << "void test(T&& t)" << endl;
	Fun(t);
}

int main()
{
	test(10); // 右值
	cout << "----------------------------------------------------" << endl;
	int a;
	test(a); // 左值
	cout << "----------------------------------------------------" << endl;
	test(std::move(a)); // 右值
	cout << "----------------------------------------------------" << endl;
	return 0;
}

class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}

	Person(const Person& p) = delete;//禁止生成

	Person(Person&& p) = default;//强制生成
private:
	string _name;
	int _age;
};

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>//不一定非要叫Args
void ShowArgs(Args... args)
{

}

void _ShowArgs()//编译时递归的结束条件
{
	cout << endl;
}

template <class T, class ...Args>
void _ShowArgs(const T& t, Args... args)//把第一个参数拿出来
{
	cout << t << endl;
	_ShowArgs(args...);
}

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowArgs(Args... args)
{
	_ShowArgs(args...);
}


int main()
{
	ShowArgs(1, "abc", 'c');
	return 0;
}

class Date
{
public:
	Date(int year, int month, int day)
		:_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 = 200;
	int _month = 1;
	int _day = 1;
};

int main()
{
	std::list<Date> lt1;
	lt1.push_back({ 2024,3,30 });
	cout << endl;
	//支持这个因为隐式类型转换，构造出一个节点后，再push
	
	//lt1.emplace_back({ 2024,3,30 });
	// 不支持。因为底层是模版，根据这个推出不data类
	// 

	// 这样是可以的，可以自己推导
	lt1.emplace_back(2024, 3, 30);
	cout << "----------------------------------------------------" << endl;

	Date d1(2023, 1, 1);
	lt1.push_back(d1);
	cout << endl;
	lt1.emplace_back(d1);
	cout << "----------------------------------------------------" << endl;

	lt1.push_back(Date(2023, 1, 1));
	cout << endl;
	lt1.emplace_back(Date(2023, 1, 1));

	return 0;
}

#include<algorithm>
struct Good
{
	string _name;  // 名字
	double _price; // 价格
	int _evaluate; // 评价

	Good(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};

struct ComparePriceLess
{
	bool operator()(const Good& gl, const Good& gr)
	{
		return gl._price < gr._price;
	}
};

struct ComparePriceGreater
{
	bool operator()(const Good& gl, const Good& gr)
	{
		return gl._price > gr._price;
	}
};

int main()
{
	vector<Good> v = { { "apple", 2.1, 5 }, { "banana", 3, 4 }, { "orange", 2.2,3 }};

	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());//这里我们想要比较就只能自己给出仿函数
}

[capture-list](parameters) mutable -> return-type {
    // Lambda函数体
    // 可以使用捕捉列表中的变量和参数列表中的参数
    return expression; // 可选
}

int main()
{
	vector<Good> v = { { "apple", 2.1, 5 }, { "banana", 3, 4 }, { "orange", 2.2,3 }};

	auto add = [](int a, int b) {return a + b; };
	cout << add(1, 2) << endl;

	auto swap1 = [](int& a, int& b)->void {
		int tmp = a;
		a = b;
		b = tmp;
	};

	auto print = [] {
		cout << "auro print" << endl;
	};//这个就是能省的都省了，当然函数体里面也能什么都不写

	print();//调用上面这个

	return 0;
}

#include<algorithm>
struct Good
{
	string _name;  // 名字
	double _price; // 价格
	int _evaluate; // 评价

	Good(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};

int main()
{
	vector<Good> v = { { "apple", 2.1, 5 }, { "banana", 3, 4 }, { "orange", 2.2,3 } };
	sort(v.begin(), v.end(), [](const Good& g1, const Good& g2) {
		return g1._price < g2._price;
		});
	sort(v.begin(), v.end(), [](const Good& g1, const Good& g2) {
		return g1._price > g2._price;
		});

	sort(v.begin(), v.end(), [](const Good& g1, const Good& g2) {
		return g1._evaluate < g2._evaluate;
		});
	return 0;
}

int main()
{
	int x = 1, y = 2;

	// 传引用捕捉
	auto swap = [&x, &y]{
		int tmp = x;
		x = y;
		y = tmp;
	};

	swap();
	cout << x << endl;
	cout << y << endl;

	int m = 3, n = 4;
	// 传值捕捉当前域的所有对象
	auto func1 = [=] {
		return x + y * m - n;
	};

	cout << func1() << endl;

	// 传引用捕捉当前域的所有对象
	auto func2 = [&] {
		x++;
		m++;
		return x + y * m - n;
	};

	cout << func2() << endl;
	cout << x << endl;
	cout << m << endl;

	// 传引用捕捉当前域的所有对象，对个别对象传值捕捉
	auto func3 = [&, n] {
		x++;
		m++;

		// n++; 不行
		return x + y * m - n;
	};

	cout << func3() << endl;
	cout << x << endl;
	cout << m << endl;

	//----------------------------------
	auto DateLess = [](const Date* p1, const Date* p2){
				return p1 < p2;
			};//只能用auto来接收，这样也表明不能得到具体的类型。要结合decltype使用
	priority_queue<Date*, vector<Date*>, decltype(DateLess)> p1(DateLess);
	return 0;
}

// 类模板原型如下
template <class T> function;     // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
//模板参数说明：
//Ret: 被调用函数的返回类型
//Args…：被调用函数的形参

function<return_type(parameters)> func;

#include<functional>

double fun1(double i)
{
	return i * 2;
}
struct Function
{
	double operator()(double f)
	{
		return f / 3;
	}
};

int main()
{
	// 函数指针
	function<double(double)> fc1 = fun1;
	fc1(1.1);

	// 函数对象
	function<double(double)> fc2 = Function();
	fc2(1.1);

	// lambda表达式
	function<double(double)> fc3 = [](double d)->double { return d / 4; };
	fc3(1.1);

	return 0;
}

class Plus
{
public:
	static int plus_static(int a, int b)//静态成员函数
	{
		return a + b;
	}

	double plus(double a, double b)//普通成员函数
	{
		return a + b;
	}
};

int main()
{
	//包装静态的
	function<int(int, int)> fun1 = Plus::plus_static;//注意要指明类域
	cout << fun1(1, 1) << endl;
	//包装普通
	function<double(Plus,double, double)> fun2 = &Plus::plus;//注意要指明类域
	function<double(Plus*,double, double)> fun3 = &Plus::plus;//这两种都行

	cout << fun1(1, 1) << endl;
	return 0;
}