int printf( const char *format , ... );

template<class ...Args> //Args全稱：arguments
返回類型 函數(shù)名（Args... args）
{
    //函數(shù)體
}

template <class ...Args>
void ShowList(Args... args)
{}

template<class ...Args>
void ShowList(Args... args)
{
	cout << sizeof...(args) << endl;
}


int main()
{
	ShowList(1);
	ShowList(1, 2);
	ShowList(1, 2, string("dict"));
	map<string, int> m1;
	ShowList(1, 2, 3, m1);

	return 0;
}

template<class ...Args>
void ShowList(Args... args)
{
	//error
	for (int i = 0; i < sizeof...(args); ++i)
	{
		cout << args[i] << endl;
	}
}

void _ShowList()
{
	cout << endl;
}

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

int main()
{
	_ShowList(1, 2, string("dict"));

	return 0;
}

template<class T>
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, 2, string("dict"));

	return 0;
}

template<class T, class ...Args>
void ShowList(T value, Args... args)
{
	cout << value << ' ';
	if (sizeof...(args))
	{
		return;
	}
	ShowList(args...);
}

template<class T>
void CPPprint(const T& value)
{
	cout << value << ' ';
}

template<class ...Args>
void ShowList(Args... args)
{
	int array[] = {( CPPprint(args), 0)...};
	cout << endl;
}

int array[] = {( CPPprint(args), 0), CPPprint(args), 0),  CPPprint(args), 0),  CPPprint(args), 0)};

template<class T>
int CPPprint(const T& value)
{
	cout << value << ' ';
	return 0;
}

template<class ...Args>
void ShowList(Args... args)
{
	int array[] = { (CPPprint(args))... };
	cout << endl;
}

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Data()~構(gòu)造函數(shù)" << endl;
	}

	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{
		cout << "Date()~拷貝構(gòu)造" << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

template<class ...Args>
Date* Init(Args&&... args)
{
	Date* ret = new Date(args...);

	return ret;
}

int main()
{
	Date* p1 = Init();
	Date* p2 = Init(2024);
	Date* p3 = Init(2024, 11);
	Date* p4 = Init(2024, 11, 12);

	Date d1(2, 3, 3);
	Date* p5 = Init(d1);
	return 0;
}

int main()
{
	list<pair<nxbw::string, int>> mylist;
	pair<nxbw::string, int> kv("nxbw", 10);
	mylist.emplace_back(kv); //傳左值
	mylist.emplace_back(make_pair("nxbw", 10)); //傳右值
	mylist.emplace_back("nxbw", 10); //傳參數(shù)包

	mylist.push_back(kv); //傳左值
	mylist.push_back(make_pair("nxbw", 10)); //傳右值
	mylist.push_back({ "nxbw", 10 }); //使用列表初始化

	return 0;
}

namespace nxbw
{
	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);
		}
		// 拷貝構(gòu)造
		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;
		}
		// 移動構(gòu)造
		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()
		{
			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; // 不包含最后做標(biāo)識的\0
	};
}

int main()
{
	list<pair<nxbw::string, int>> mylist;
	pair<nxbw::string, int> kv("nxbw", 10); //構(gòu)造
	mylist.emplace_back(kv); //傳左值，
	mylist.emplace_back(pair<nxbw::string, int>("nxbw", 10)); //傳右值
	mylist.emplace_back("nxbw", 10); //傳參數(shù)包

	return 0;
}

int main()
{
	list<pair<nxbw::string, int>> mylist;
	pair<nxbw::string, int> kv("nxbw", 10);

	mylist.push_back(kv); //傳左值
	mylist.push_back(pair<nxbw::string, int>("nxbw", 10)); //傳右值
	mylist.push_back({ "nxbw", 10 }); //使用列表初始化

	return 0;
}

namespace nxbw
{
	// 模擬實(shí)現(xiàn)list在之前的章節(jié)有提過，這里只是將原來的代碼多增加一些接口的片段代碼

	// 這是list需要用到的節(jié)點(diǎn)類
	template<class T>
	struct __list_node
	{
		__list_node(const T& val = T())
			:_data(val), _prev(nullptr), _next(nullptr)
		{}
		// 這里需要在原來的基礎(chǔ)上需要增加一個(gè)可變模板參數(shù)模板的構(gòu)造函數(shù),方便下面使用new
		template<class ...Args>
		__list_node(Args&& ...args)
			: _data(std::forward<Args>(args)...), _prev(nullptr), _next(nullptr)
		{}


		T _data;
		__list_node* _prev;
		__list_node* _next;
	};


	template<class T>
	struct list
	{
		template<class ...Args>
		iterator emplace(iterator position, Args&&... args)
		{

			node* cur = position._node;
			node* prev = cur->_prev;
			// 函數(shù)參數(shù)包的完美轉(zhuǎn)發(fā)
			node* newnode = new node(forward<Args>(args)...);

			prev->_next = newnode;
			newnode->_prev = prev;

			newnode->_next = cur;
			cur->_prev = newnode;

			return iterator(cur);
		}

		template<class ...Args>
		void emplace_back(Args&&... args)
		{
			// 函數(shù)參數(shù)包的完美轉(zhuǎn)發(fā)
			emplace(end(), forward<Args>(args)...);
		}

        // 獲取節(jié)點(diǎn)函數(shù),這里更新成了萬能引用版的
		template<class T>
		node* get_node(T&& val = T())
		{
			node* new_node = new node(forward<T>(val)); // 完美轉(zhuǎn)發(fā)
			new_node->_prev = new_node;
			new_node->_next = new_node;
			return new_node;
		}

	private:
		__list_node<T>* _head; // 指向節(jié)點(diǎn)類的指針
	};
};