C++11特性大杂烩

	int* ptr1 = new int[4]{ 1,2,3,4 };

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(2002, 12, 20);//()传参构造函数初始化
	Date d2{ 2001,3,28 };//通过{}列表初始化的方式构造函数初始化
    Date d3 = { 2000,11,24 };//也可以带=
	return 0;
}

	vector<int> vt{ 1,2,3,4,5 };
	list<int> lt{ 3,4,5,6,7 };

vector<int> vt{ 1,2,3,4,5 };
list<int> lt{ 3,4,5,6,7 };

	template<typename T>
	class vector
	{
	public:
		typedef T* iterator;
		
		vector()//构造函数
			//初始化列表-必要用的情况：const成员；没有默认构造的自定义类型成员
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr){}
			
				vector(const  initializer_list<T>& il)//initializer_list构造函数
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
			reserve(il.size());
		/*	typename initializer_list<T>::iterator ilt = il.begin();
			while (ilt != il.end())
			{
				push_back(*ilt);
				ilt++;
			}*/
			for (auto& e : il)
			{
				push_back(e);
			}
		}
		
        		vector<T>& operator=(const initializer_list<T>& il)
		{
			vector<T> tmp(il);
			std::swap(_start, tmp._start);
			std::swap(_finish, tmp._finish);
			std::swap(_endofstorage, tmp._endofstorage);
			return *this;
		}
        
		size_t size()const
		{
			return _finish - _start;
		}
		size_t capacity() const//容量
		{
			return _endofstorage - _start;
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}
		
			void reserve(size_t n)//扩容
		{
			
			if (n > capacity())
			{
				size_t oldsize = size();
				T* tmp = new T[n];//构造一个tmp
				//memcpy-浅拷贝
				//if (_start )//需要拷贝---有数据才要拷贝
				//{
				//	//memcpy(tmp, _start, sizeof(T) * oldsize);浅拷贝·1
				//	tmp = _start;
				//	delete[] _start;
				//}
				if (_start)
				{
					for (size_t i = 0; i < oldsize; i++)
					{
						tmp[i] = _start[i];
						
					}
					delete[] _start;
				}
				

				_start = tmp;
				//operator=-深拷贝
				_finish = _start + oldsize;
				_endofstorage = _start + n;
			}

		}
		
		
		void push_back(const T& val)//尾插
		{
			if (_finish == _endofstorage)//容量为0或者满了都要扩容
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = val;
			++_finish;
		}
				void swap(vector<T>& v)//交换
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_endofstorage, v._endofstorage);

		}
		
			private:
		iterator _start;//0的位置
		iterator _finish;//最后一个成员变量的下一个位置
		iterator _endofstorage;//

	};

	void testinlist1()
	{
		vector<int> vt1{ 1,2,3,4,5 };
		for (auto e : vt1)
		{
			cout << e << " ";
		}
		cout << endl;
		vt1 = { 10,20,30,40,50 };
		for (auto e : vt1)
		{
			cout << e << " ";
		}
		cout << endl;
	}

   //C++98auto的用法
	int a = 10;//自动生命周期
	auto int b = 10;//自动生命周期

	auto dou = 1.34;//返回值类型为double，auto推导变量dou的类型也为double
	auto str = "jinitaimei";//返回值类型为string，auto推导变量str的类型也为string
	list<int> lt;
	lt.push_back(11);
	lt.push_back(12);
	lt.push_back(13);
	lt.push_back(14);
	list<int>::iterator it1 = lt.begin();//这里迭代器的类型是list<int>::iterator
	cout << *it1 << endl;
	auto it2 = lt.begin();//这里=的右边的返回值类型是list<int>::iterator，所以auto在等号在=左边自动推导变量it2的类型为list<int>::iterator
	cout << *it2 << endl;

	int a = 10;
	cout << typeid(a).name() << endl;   //变量a的类型：int
	cout << typeid(typeid(a).name()).name() << endl;   //变量名int的类型：const char *
	const int b = 7;
	cout << typeid(b).name() << endl;   //加const不改变类型：int
	int& c = a;
	cout << typeid(c).name() << endl;   //加引用&不改变类型：int
	const int& f = a;  
	cout << typeid(f).name() << endl;   //int
	int* d;
	cout << typeid(d).name() << endl;   //int *
	const int* e;  
	cout << typeid(e).name() << endl;   //const int *

template<class T1,class T2>
void multis(T1 t1, T2 t2)
{
	decltype(t1 * t2) ret;//这里ret没有接收返回值，所以不能用auto来推导ret的类型；但可以通过decltype来推导
	cout <<"ret的类型为：" << typeid(ret).name() << endl;
}

int main()
{
	int x = 6;
	double y = 2.66;
	multis(x, y);
    return 0;
}

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

    int* p = new int(1);
	int*& rp = p;//对p的引用
	int& p_value = *p;//对p解引用后的数据的引用
	int x = 10;
	int& rx = x;//对x的引用
	const int y = 20;
	const int& ry = y;//对y的引用

	int x = 10;
	int y = 90;
	//以下是常见的右值
	10//字面常量
	x + y;//表达式返回值
	min(x, y);//函数返回值
int &&pxy=x+y;//对x+y右值引用

	int mini(int x, int y)
{
	return x < y ? x : y;
}

	int x = 10;
	int y = 90;
	//以下是右值
10;
x+y;
mini(x,y);
//////////////左值引用右值
//int&lret=	x + y;//不能引用
const int&lret=	x + y;//可以引用
const int& lmin = mini(x, y);//可以引用
//右值引用左值
//int&& rx1 = x;//不能引用
int&& rx2 = move(x);//move之后的左值可以右值引用

template<class T>
const  T& fun3(const T& object)
{
	T ret;
	ret.resize(object.size());
	for (size_t i = 0; i < ret.size(); i++)
	{
		ret[i] = i;
	}
	//...... 这里对ret进行操作
	return ret;//函数结束，参数ret的生命周期结束销毁了，一是参数ret传不出去，二是传引用返回给外面那层，此时再访问到参数ret算是越界访问了！
}

int main()
{
	vector<int>v(10,0);
 vector<int> ret3=fun3(v);
 	}

template<class T>
void fun3(const T& object,T&retu)
{
	T ret;
	ret.resize(object.size());
	for (size_t i = 0; i < ret.size(); i++)
	{
		ret[i] = i;
	}
	//...... 这里对ret进行操作
	retu = ret;
}

int main()
{
	vector<int>v(10,0);
  vector<int> ret3;
 	fun3(v,ret3);
 	}

template<class T>
 T fun2( T& object)
{
	T ret;
	ret.resize(object.size());
	for (size_t i = 0; i < ret.size(); i++)
	{
		ret[i] = i;
	}
	//...... 这里对ret进行操作
	return ret;//传值返回
}
int main()
{
 vector<int>v(10,0);
vector<int> ret2 = fun2(v);
    
}

namespace pjl
{
	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)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::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
	};

	string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}

	pjl::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;

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

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

		std::reverse(str.begin(), str.end());
		return str;
	}
}
int main()
{
    	pjl::string s1{ "xxxxx" };//左值
	pjl::string ret1(s1);//s1为左值，用到拷贝构造
	pjl::string s2{ "aaaaa" };
	s2 = s1;//s1为左值，用到赋值重载
	pjl::string s3(move(s1));//move之后的左值为右值
    s3 = "bbbbb";//右值
    return 0;
}

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

	//// 移动赋值		
string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		}

void Func(int& x)
{
	cout << "左值引用" << endl;
}
void Func(const int& x)
{
	cout << "const 左值引用" << endl;
}
void Func(int&& x)
{
	cout << "右值引用" << endl;
}
void Func(const int&& x)
{
	cout << "const 右值引用" << endl;
}
template<class T>
void PerfectForward(T&& t)
{
	Func(t);
}
int main()
{
	int a = 10;
	PerfectForward(a);       //左值
	PerfectForward(move(a)); //右值

	const int b = 20;
	PerfectForward(b);       //const 左值
	PerfectForward(move(b)); //const 右值

	return 0;
}

template<class T>
const  T& fun3( T&& object)
{
	T ret = object;
	for (size_t i = 0; i < ret.size(); i++)
	{
		ret[i] = i;
	}
	//...... 这里对ret进行操作
	return ret;//函数结束，对象没有销毁，通过转移拷贝把对象传了回去
}
int main()
{
	vector<int>v(10, 0);
	vector<int> ret3 = fun3(v);//传了左值过去
	int flag1 = 0;//标记位

namespace pjl
{
	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)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		
		// 移动构造
		//string(string&& s)
		//	:_str(nullptr)
		//	, _size(0)
		//	, _capacity(0)
		//{
		//	cout << "string(string&& s) -- 移动构造" << endl;
		//	swap(s);
		//}
		//// 移动赋值
		//string& operator=(string&& s)
		//{
		//	cout << "string& operator=(string&& s) -- 移动赋值" << endl;
		//	swap(s);
		//	return *this;
		//}

		// 拷贝构造
		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=nullptr;
		size_t _size=0;
		size_t _capacity=0; // 不包含最后做标识的\0
	};
}

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& operator=(const Person& p)
{
if(this != &p)
{
_name = p._name;
_age = p._age;
}
return *this;
}*/
/*~Person()
{}*/
private:
	pjl::string _name;
	int _age;
};

int main()
{
	Person s1="this is the test";//左值
	Person s2 = std::move(s1);//传右值--构造
	Person s3;
	s3 = std::move(s1);//赋值
	return 0;
}

class Person
{
public:
	Person(const char* name = "", int age = 0)
		:_name(name)
		, _age(age)
	{}
	Person(const Person& p)//拷贝构造
	:_name(p._name)
    ,_age(p._age)
{}
private:
	pjl::string _name;
	int _age;
};

class A
{
public:
	A() {}
	A(const A& aa)//拷贝构造--用传过来的对象拷贝给自己，但是函数是浅析构，析构不到位报错
		:p(aa.p)
	{}
	~A()
	{
		delete []p;//析构函数只析构一次，若对象不止一个int大小调用则报错
	}
private:
	int* p = new int[10];
};

//测试代码
int main()
{
	A aa;
	A bb(aa);
	return 0;
}

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);//调用仿函数

	// lambda
	auto r2 = [=](double monty, int year)->double {return monty * rate * year; };
	r2(10000, 2);

	auto r3 = [=](double monty, int year)->double {return monty * rate * year; };
	r3(10000, 2);
	return 0;
}

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

template<class T, class ...Args>
void showlist(const T& t)
{
	cout << t << endl;//递归终止函数
}

template<class T,class ...Args>
void showlist(T value, Args ...args)
{
	cout << value << " ";
	showlist(args...);
}

int main()
{
	showlist(1);
	showlist(1,1.1);
	showlist(1, 1.1, string("xxx"));
	return 0;
}

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, 'T');
	ShowList(1, 'T', std::string("fortunate"));
	return 0;
}

namespace pjl
{
	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)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		string(const string& s)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;

			/*string tmp(s._str);
			swap(tmp);*/
			reserve(s._capacity);
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;
		}

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

			return *this;
		}

		// 移动构造
		string(string&& s)
		{
			cout << "string(const string& s) -- 移动拷贝" << endl;

			swap(s);
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string s) -- 移动赋值" << endl;
			swap(s);

			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];
				if (_str)
				{
					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 = nullptr;
		size_t _size = 0;
		size_t _capacity = 0; // 不包含最后做标识的\0
	};

	string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}

		pjl::string str;
		while (value > 0)
		{
			int x = value % 10;
			value /= 10;

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

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

		std::reverse(str.begin(), str.end());
		return str;
	}
}

//std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

#include <functional>

int f(int a, int b)//函数
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)//仿函数
	{
		return a + b;
	}
};
class Plus
{
public:
	static int plusi(int a, int b)//类中静态成员
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}

};
int main()
{
	// 函数名(函数指针)
	std::function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;
	// 函数对象
	std::function<int(int, int)> func2 = Functor();
	cout << func2(1, 2) << endl;
	// lamber表达式
	std::function<int(int, int)> func3 = [](const int a, const int b)	{return a + b; };
	cout << func3(1, 2) << endl;
	// 类的成员函数
	std::function<int(int, int)> func4 = &Plus::plusi;
	cout << func4(1, 2) << endl;
	std::function<double(Plus, double, double)> func5 = &Plus::plusd;
	cout << func5(Plus(), 1.1, 2.2) << endl;
	return 0;
}

#include <functional>
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;
}

int main()
{
// 函数名
std::function<double(double)> func1 = f;
cout << useF(func1, 11.11) << endl;
// 函数对象
std::function<double(double)> func2 = Functor();
cout << useF(func2, 11.11) << endl;
// lamber表达式
std::function<double(double)> func3 = [](double d)->double { return d /
4; };
cout << useF(func3, 11.11) << endl;
return 0;
}

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
stack<int> st;
map<string,function<int(int,int)>>optomap={
 {"+",[](int x,int y){return x+y;}},//包装的是lambda表达式
 {"-",[](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)
{
    if(optomap.count(e)==0)//没找到字符--找到的是数字入-栈
    {
        st.push(stoi(e));
    }else
    {
        int right=st.top();
        st.pop();
        int left=st.top();
        st.pop();
        st.push(optomap[e](left,right));
    }
}
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);

//Plus、subFunc、Sub都是可调用对象
int Plus(int a, int b)
{
	return a + b;
}

int SubFunc(int a, int b)
{
	return a - b;
}

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b * x;
	}
private:
	int x = 20;
};
int main()
{
    	//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
	function<int(int, int)>fun1 = bind(Plus, placeholders::_1, placeholders::_2);
	cout << fun1(2, 3) << endl;
return 0;
}

int SubFunc(int a, int b)
{
	return a - b;
}
int main()
{
    	// 调整参数的顺序
	function<int(int, int)>fun2 = bind(SubFunc, placeholders::_2, placeholders::_1);
	cout << fun2(7, 4) << endl;
return 0;
}

class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b * x;
	}
private:
	int x = 20;
};

int main()
{
	// 绑定固定参数
	function<int(Sub, int, int)> fun3 = &Sub::sub;
cout<<	"原先的包装器调用：" << fun3(Sub(), 10, 13) << endl;

function<int(int, int)>fun4 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);

cout << "现在的bind绑定固定参数调用：" << fun4(10, 13) << endl;
    return 0;
}