C++11常用的一部分新特性

#include<iostream>
using namespace std;
int main()
{
	int arr1[] = { 1,2,3,4,5,6 };
	int arr2[]{ 1,2,3,4,5,6 };
	for (auto e : arr1)
	{
		cout << e << " ";
	}
	cout << endl;
	for (auto e : arr2)
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

#include<iostream>
using namespace std;
struct Point
{
 int _x;
 int _y;
};
int main()
{
	Point* p1 = new Point[2]{ {1,1},{2,2} };
	return 0;
}

#include<iostream>
using namespace std;
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;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	//这三个效果是相同的
	Date d1(2023, 5, 25);
	Date d2{ 2023, 5, 25 };
	Date d3 = { 2023, 5, 25 };
	return 0;
}

#include<iostream>
#include<vector>
#include<list>
using namespace std;
int main()
{
	vector<int> arr{1, 2, 3, 4, 5, 6};//这里的初始化为什么可以随意改变元素数量呢？
	auto a = { 10,20,30 };//来看看这个花括号初始化成了什么类型
	cout << typeid(a).name() << endl;//这里拿到的是类型的字符串
	return 0;
}

//这里就不用初始化一个pair类型的然后在插入map中了，因为里面是匿名对象的初始化
map<string, string> str = { {"字符串","string"},{"排序","sort"} };//里面的两个小花括号也可以理解为一个pair类型的initializer_list数组

#include<iostream>

using namespace std;

int main()
{
	int x = 0;
	cout << typeid(x).name() << endl;
	decltype(x) y;
	cout << typeid(y).name() << endl;

	return 0;
}

#include<iostream>

using namespace std;
template<class T1, class T2>
void F(T1 t1, T2 t2)
{
	decltype(t1 * t2) ret = t1 * t2;//这里万一涉及到整型提升，不知道提升到哪个类型就可以自动推导，不至于丢失精度
	cout << typeid(ret).name() << endl;
	cout << ret << endl;
}
int main()
{
	F(1, 2);
	F(1, 2.2);
	return 0;
}

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

#include<iostream>
using namespace std;
int main()
{
	// 左值引用只能引用左值，不能引用右值。
	int a = 10;
	int& ra1 = a;//ra为a的别名
	//int& ra2 = 10;//编译失败，因为10是右值
	//const左值引用既可引用左值，也可引用右值。
	const int& ra3 = 10;
	const int& ra4 = a;
	int a = 10;
	int&& r2 = a;
	// error C2440: “初始化”: 无法从“int”转换为“int &&”
	// message : 无法将左值绑定到右值引用
	
	// 右值引用可以引用move以后的左值
	int&& r3 = std::move(a);
	return 0;
}

template<class T>
T func(const int x)
{
	T ret;
	return ret;//这里ret是局部变量，出作用域就会销毁，所以是一个传值返回
}

#include<iostream>
#include<cassert>
#include<algorithm>
using namespace std;
namespace baiye
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		// s1.swap(s2)
		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;
			string tmp(s._str);
			swap(tmp);
		}
		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}
namespace baiye
{
	baiye::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}
		baiye::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;
			str += ('0' + x);
		}
		if (flag == false)
		{
			str += '-';
		}
		reverse(str.begin(), str.end());
		return str;
	}
}
int main()
{
	baiye::string str = baiye::to_string(-1234);
	return 0;
}

		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			swap(s);
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			swap(s);
			return *this;
		}

#include<iostream>

using namespace std;
template<class T>
void func(T&& x)//这里也可以称为引用折叠，如果传的是左值，就折叠成一个引用符号
{

}
int main()
{
	int x = 10;
	func(x);//左值也可以
	func(2);//右值也可以
	const int y = 20;
	func(y);//const左值
	func(move(y));//const右值
	return 0;
}

#include<iostream>

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 func(T&& x)
{
	Fun(x);
}
int main()
{
	int x = 10;
	func(x);//左值
	func(2);//右值
	const int y = 20;
	func(y);//const左值
	func(move(y));//const右值
	return 0;
}

#include<iostream>
using namespace std;
class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p)
		:_name(p._name)
		, _age(p._age)
	{}
	Person(Person && p) = default;//强制生成
private:
	string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = std::move(s1);
	return 0;
}

#include<iostream>
using namespace std;
class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p) = delete;
private:
	string _name;
	int _age;
};
int main()
{
	Person s1;
	Person s2 = s1;
	Person s3 = move(s1);
	return 0;
}

#include<iostream>
using namespace std;
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
int main()
{

	return 0;
}

#include<iostream>
using namespace std;
template <class ...Args>
void ShowList(Args... args)
{
	cout << sizeof...(args) << endl;//查看参数包有几个参数
}
int main()
{
	ShowList(1);
	ShowList(1, 2.2);
	ShowList(1, 2.2, string("xxx"));

	return 0;
}

#include<iostream>
using namespace std;
// 递归终止函数
void ShowList()//当参数包中的参数变成0个的时候就会调用这个函数
{
	cout << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)//第一个参数传给value，剩下的参数传给args参数包
{
	cout << value << " ";
	ShowList(args...);
}
int main()
{
	ShowList(1);//这里1传给value，然后参数包没有参数调用终止函数
	ShowList(1, 2.2);//这里第一次1传给value，2.2传给参数包，第二次2.2传给value，参数包没有值，调用终止函数
	ShowList(1, 2.2, string("xxx"));
	return 0;
}

#include<iostream>
using namespace std;
template <class T>
void PrintArg(T t)
{
	cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{
	int arr[] = { (PrintArg(args), 0)... };
	cout << endl;
}
int main()
{
	ShowList(1);
	ShowList(1, 'A');
	ShowList(1, 'A', std::string("sort"));
	return 0;
}

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	vector<pair<int, string>>arr;
	arr.emplace_back(1, "xxx");//这里可以这样初始化(直接构造),push_back只能构造一个对象去传，当然emplace_back也可以构造一个对象传
	
	return 0;
}

#include<iostream>
#include<vector>
#include <algorithm>
#include <functional>
using namespace std; 
struct Goods
{
	string _name;// 名字
	double _price;// 价格
	int _evaluate;// 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
	sort(v.begin(), v.end(), ComparePriceLess());
	sort(v.begin(), v.end(), ComparePriceGreater());
	return 0;
}

#include<iostream>
#include<vector>
#include <algorithm>
#include <functional>
using namespace std; 
struct Goods
{
	string _name;// 名字
	double _price;// 价格
	int _evaluate;// 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._price < g2._price; });//按照价格排序
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
		return g1._evaluate < g2._evaluate; });//按照评价排序
	return 0;
}

#include<iostream>
using namespace std;
int main()
{
	//其实lambda就是要给可调用的对象
	auto compare = [](int x, int y) {return x > y; };//这个类型编译器认识，但是我们不认识
	cout << compare(1, 2) << endl;
	return 0;
}

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto add1 = []() { return a + b; };
	return 0;
}

auto add1 = [a, b]() { return a + b; };

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto swap1 = [a, b]()
	{
		int c = a;
		a = b;
		b = c;
	};
	return 0;
}

	auto swap1 = [a, b]()mutable
	{
		int c = a;
		a = b;
		b = c;
	};

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto swap1 = [&a, &b]()//这里虽然是外部a和b的别名，但是不能修改a和b的名字，不然就不能捕捉了
	{
		int c = a;
		a = b;
		b = c;
	};
	return 0;
}

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	auto add1 = [=]() { return a + b; };
	auto swap1 = [&]()
	{
		int c = a;
		a = b;
		b = c;
	};
	return 0;
}

#include<iostream>
using namespace std;
class Rate
{
public:
	Rate(double rate) : _rate(rate)
	{}
	double operator()(double money, int year)
	{
		return money * _rate * year;
	}
private:
	double _rate;
};
int main()
{
	// 函数对象
	double rate = 0.49;
	Rate r1(rate);
	r1(10000, 2);
	// lamber
	auto r2 = [=](double monty, int year)->double {return monty * rate * year;};
	r2(10000, 2);
	return 0;
}

#include<iostream>
using namespace std;
template<class F, class T>
T useF(F f, T x)
{
	static int count = 0;
	cout << "count:" << ++count << endl;
	cout << "count:" << &count << endl;
	return f(x);
}
double f(double i)
{
	return i / 2;
}
struct Functor
{
	double operator()(double d)
	{
		return d / 3;
	}
};
int main()
{
	// 函数名
	cout << useF(f, 11.11) << endl;
	// 函数对象
	cout << useF(Functor(), 11.11) << endl;
	// lamber表达式
	cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
	return 0;
}

#include<iostream>
#include<functional>
using namespace std;
int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
int main()
{
	function<int(int, int)> f1;//第一个int是返回值，括号里面的是参数
	f1 = f;//封装到f1中
	cout << f1(1, 2) << endl;
	function<int(int, int)> f2(f);//这种方法也可以将f封装到f2中
	cout << f2(1, 2) << endl;
	function<int(int, int)> f3 = Functor();
	cout << f3(1, 2) << endl;
	/*function<int(int, int)> f4(Functor());//这里不可以，因为编译器会识别成为函数指针
	cout << f4(1, 2) << endl;*/
	function<int(int, int)> f5 = [](const int a, const int b){return a + b; };
	cout << f5(1, 2) << endl;
}

#include<iostream>
#include<functional>
using namespace std;
class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	int plusd(int a, int b)
	{
		return a + b;
	}
};
int main()
{
	//这里存入的是函数指针
	function<int(int, int)> f1 = &Plus::plusi;//静态成员函数可以不加&
	cout << f1(1, 2) << endl;
	function<int(Plus, int, int)> f2 = &Plus::plusd;//非静态成员函数必须加&，这里还要加一个参数，因为传参还有一个this指针
	cout << f2(Plus(), 1, 2) << endl;//这里是传进去一个Plus类型的对象，其实就是利用这个对象调用该成员函数而已
}

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        map<string, function<int(int, int)>> opMap=
        {
            {"+",[](int x, int y){return x+y;}},
            {"-",[](int x, int y){return x-y;}},
            {"/",[](int x, int y){return x/y;}},
            {"*",[](int x, int y){return x*y;}}
        };//这里就是统一了类型
        for(auto& e:tokens)//在map中查找符号
        {
            if(opMap.count(e))
            {
                int a = st.top();
                st.pop();
                int b = st.top();
                st.pop();

                st.push(opMap[e](b, a));//找到之后就将栈中的两个值通过map中储存的包装器中的lamber表达式进行运算，这里要注意数的顺序，先去取出来的在左边，后取出来的在右边
            }
            else
            {
                st.push(stoi(e));
            }
        }
        return st.top();
    }
};

// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
// with return type (2) 
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

#include<iostream>
#include <functional>
using namespace std;
int Plus(int a, int b)
{
	return a - b;
}
int main()
{
	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
	function<int(int, int)> func1 = bind(Plus, placeholders::_1,placeholders::_2);//placeholders是占位对象
	cout << func1(1, 2) << endl;
	//_1代表本来的第一个参数，_2代表本来的第二个参数
	//这里调参数
	function<int(int, int)> func3 = bind(Plus, placeholders::_2, placeholders::_1);
	cout << func3(1, 2) << endl;
	return 0;
}

#include<iostream>
#include <functional>
using namespace std;
class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	function<int(int, int)> func1 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);
	cout << func1(1, 2) << endl;//这里本来是三个参数，但是第一个参数已经被绑定了，包装器的参数也不用写三个了，这里也不用传三个参数了
	return 0;
}