现代C++特性深度探索：模板扩展、类增强、STL更新与Lambda表达式

template<class ...Args>
void emplace_back(Args... args)
{
	emplace(end(), forward<Args>(args)...);
}
template<class ...Args>
iterator emplace(iterator pos,Args&&... args)
{
	Node* cur = pos._node;
	Node* newnode = new Node(forward<Args>(args)...);
	Node* prev = cur->_prev;
	// prev newnode cur
	prev->_next = newnode;
	newnode->_prev = prev;
	newnode->_next = cur;
	cur->_prev = newnode;
	return iterator(newnode);
}

template <class... Args>
ListNode(Args&&... args)
	: _next(nullptr)
	, _prev(nullptr)
	, _data(std::forward<Args>(args)...)
{}

class MyQueue
{
	std::stack _pushSt;
	std::stack _popSt;
};

namespace carrot
{
    class string
    {
    public:
        typedef char* iterator;
        typedef const char* const_iterator;

        iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str + _size;
        }

        const_iterator begin() const
        {
            return _str;
        }

        const_iterator end() const
        {
            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);
        }

        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;

            reserve(s._capacity);
            for (auto ch : s)
            {
                push_back(ch);
            }
        }

        // 移动构造
        string(string&& s)
        {
            cout << "string(string&& s) -- 移动构造" << endl;
            swap(s);
        }

        string& operator=(const string& s)
        {
            cout << "string& operator=(const string& s) -- 拷贝赋值" << endl;
            if (this != &s)
            {
                _str[0] = '\0';
                _size = 0;

                reserve(s._capacity);
                for (auto ch : s)
                {
                    push_back(ch);
                }
            }

            return *this;
        }

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

        ~string()
        {
            //cout << "~string() -- 析构" << endl;
            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)
        {
            push_back(ch);
            return *this;
        }

        const char* c_str() const
        {
            return _str;
        }

        size_t size() const
        {
            return _size;
        }
    private:
        char* _str = nullptr;
        size_t _size = 0;
        size_t _capacity = 0;
    };
}
class Person
{
public:
    Person(const char* name="张三",int age=18)
        :_name(name)
        ,_age(age)
    {}
private:
    bit::string _name;
    int _age;
};
int main()
{
    Person s1;//构造
    Person s2 = s1;//拷贝构造
    Person s3 = std::move(s2);//右值，移动构造
    return 0;
}

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

    reserve(s._capacity);
    for (auto ch : s)
    {
        push_back(ch);
    }
}

// 移动构造
string(string&& s)
{
    cout << "string(string&& s) -- 移动构造" << endl;
    swap(s);
}

class Person
{
public:
    Person(const char* name="张三",int age=18)
        :_name(name)
        ,_age(age)
    {}
private:
    carrot::string _name;
    int _age;
};
int main()
{
    Person s1;
    Person s2 = s1;
    Person s4("李四", 20);
    s4 = std:: move(s2);
    return 0;
}

//赋值重载
string& operator=(const string& s)
{
    cout << "string& operator=(const string& s) -- 拷贝赋值" << endl;
    if (this != &s)
    {
        _str[0] = '\0';
        _size = 0;

        reserve(s._capacity);
        for (auto ch : s)
        {
            push_back(ch);
        }
    }

    return *this;
}

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

class Person
{
public:
    Person(const char* name="张三",int age=18)
        :_name(name)
        ,_age(age)
    {}
    //C++11 
    //不想让别人去调用这个拷贝构造函数
    Person(const Person& p) = delete;

    //强制生成默认移动构造函数
    Person(Person&& p) = default;
private:
    //C++98 中不想让别人去调用这个拷贝构造函数
    //在private中只定义这个函数，但不实现
    Person(const Person& p);
    carrot::string _name;
    int _age;
};
int main()
{
    Person s1;
    Person s2 = s1;
    Person s4("李四", 20);
    s4 = std:: move(s2);
    return 0;
}

[capture-list] (parameters) -> return type { function boby }

int main()
{
	auto add1 = [](int x, int y)->int {return x + y; };
	cout << add1(2, 3) << endl;
	return 0;
}

int main()
{
	int x = 1;
	int y = 2;
	cout << x << ":" << y << endl;
    //返回值类型为void，可以省略
	auto swap = [](int& x, int& y)
		{
            //若函数体较长，不必写在同一行
			int tmp = x;
			x = y;
			y = tmp;
		};

	swap(x, y);
	cout << x << ":" << y << endl;

	return 0;
}

#include<vector>	
struct Goods
{
	string _name;//名字
	double _price;//价格
	int _evaluate;//评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "⾹蕉", 3, 4 }, { "橙⼦", 2.2, 3}, { "菠萝", 1.5, 4 } };
	return 0;
}

#include<vector>	
#include<algorithm>
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& g1, const Goods& g2)
	{
		return g1._price < g2._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._price > g2._price;
	}
};
struct CompareEvaluateLess
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._evaluate < g2._evaluate;
	}
};
struct CompareEvaluateGreater
{
	bool operator()(const Goods& g1, const Goods& g2)
	{
		return g1._evaluate > g2._evaluate;
	}
};
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());
	sort(v.begin(), v.end(), CompareEvaluateLess());
	sort(v.begin(), v.end(), CompareEvaluateGreater());
	return 0;
}

int main()
{
	int a = 0, b = 1, c = 2, d = 3;
	//显示捕捉，用谁就捕捉谁
	auto func1 = [a, &b]
		{
			//a++;  //值捕捉的变量不能修改
			++b;//引用捕捉的对象可以修改
			int ret = a + b;
			return ret;
		};
	cout << func1() << endl;
	return 0;
}

int main()
{
	int a = 0, b = 1, c = 2, d = 3;
	//显示捕捉，用谁就捕捉谁
	auto func1 = [a, &b]()mutable
		{
			a++;//值捕捉的变量可以修改，但不影响外面的那个
			++b;//引用捕捉的对象可以修改，影响外面的那个
			int ret = a + b;
			return ret;
		};
	cout << func1() << endl;
	return 0;
}

int x = 10;
int main()
{
	int a = 0, b = 1, c = 2, d = 3;

	//捕捉列表中为 = 表示当前域的全部值捕捉
	//全局域的值不需要捕捉，也不能捕捉，可以直接用
	auto func2 = [=]
		{
			return a + b + c+x;
		};
	cout << func2() << endl;

	//捕捉列表中为 & 表示当前域的全部引用捕捉
	auto func3 = [&]
		{
			++a;
			++b;
			++c;
			return a + b + c + x;
		};
	cout << func3() << endl;
	return 0;
}

int x = 10;
int main()
{
	int a = 0, b = 1, c = 2, d = 3;
	//混合捕捉1
	//a和b是值捕捉，其余元素为引用捕捉
	auto func4 = [&, a, b]
		{
			//a++;//值捕捉，不能修改
			//b++;//值捕捉，不能修改
			c++;//引用捕捉，可以修改
			d++;//引用捕捉，可以修改
			return a + b + c + d;
		};
	cout << func4() << endl;

	//混合捕捉2
	//a和b引用捕捉，其余元素值捕捉
	auto func5 = [=, &a, &b]
		{
			a++;//引用捕捉，可以修改
			b++;//引用捕捉，可以修改
			//d++;//值捕捉，不能修改
			//c++;//值捕捉，不能修改
			return a + b + c + d;
		};
	cout << func5() << endl;
	return 0;
}

int x = 10;
int main()
{
	int a = 0, b = 1, c = 2, d = 3;
	static int y = 20;
	auto func6 = [a, b, c, d]
		{
			return a + b + c + d + x+y;//局部的静态变量和全局变量可以直接使用
		};
	cout << func6() << endl;
    return 0;
}

class A
{
public:
	void func()
	{
		int x = 2, y = 3;
		auto func1 = [=]//隐式值捕捉
			{
                ++_b;//可以修改成员变量
				return x + y + _a + _b;
			};
		cout << func1() << endl;
	}
private:
	int _a = 10;
	int _b = 20;
};
int main()
{
	A a;
	a.func();
	return 0;
}

class A
{
public:
	void func()
	{
		int x = 2, y = 3;
		auto func1 = [x,y]//显示捕捉，值捕捉x和y
			{
				return x + y + _a + _b;
			};
		cout << func1() << endl;
	}
private:
	int _a = 10;
	int _b = 20;
};
int main()
{
	A a;
	a.func();
	return 0;
}

class A
{
public:
	void func()
	{
		int x = 2, y = 3;
		//显示捕捉this指针，就可以使用成员变量了
		auto func1 = [x,y,this]
			{
				return x + y + _a + _b;
			};
		cout << func1() << endl;
	}
private:
	int _a = 10;
	int _b = 20;
};
int main()
{
	A a;
	a.func();
	return 0;
}

class A
{
public:
	void func()
	{
		int x = 2, y = 3;
		//显示捕捉this指针，就可以使用成员变量了
		auto func1 = [x,y,this]
			{
				++_a;//可以修改成员变量
				return x + y + _a + _b;
			};
		cout << func1() << endl;
		cout << _a << endl;
	}
private:
	int _a = 10;
	int _b = 20;
};
int main()
{
	A a;
	a.func();
	return 0;
}