C++11新特性全解析新的类功能、lambda、包装器详解

class Base {
public:
    virtual void foo() {}
};
class Derived : public Base {
public:
    void foo() override {} // 明确表示重写
};
class Base
 {
public
:
    virtual void foo() final {} // 禁止重写
};
class Derived : public
 Base {
public
:
    // void foo() {} // 错误：无法重写 final 方法
};

int x = 0;
//捕捉列表必须为空，因为全局变量不用捕捉就可以使用，没有可被捕捉的变量
auto func1 = []()
	{
		x++;
	};
int main()
{
	int a = 0, b = 1, c = 2, d = 3;
	//只能用当前lambda局部域和捕捉的对象和全局对象
	auto func1 = [a, &b]
		{
			//值捕捉的变量不能被修改，引用可以
			//a++报错
			b++;
			int ret = a + b;
			return ret;
		};
	cout << func1() << endl;
	//隐式值捕捉，用了哪些捕哪些
	auto func2 = [=]
		{
			int ret = a + b + c;
			return ret;
		};
	cout << func2() << endl;
	auto func3 = [&]
		{
			a++;
			b++;
			c++;
		};
	func3();
	cout << a << " " << b << " " << c <<" "<<d << endl;
	auto func4 = [&, a, b]//混合捕捉，除了a，b其他的都引用捕捉
		{
			//a++;
			//b++;
			c++;
			d++;
			return a + b + c + d;
		};
	func4();
	cout << a << " " << b << " " << c << " " << d << endl;
	auto func5 = [=, &a, &b]//混合捕捉，除了a，b其他的都传值捕捉
		{
			a++;
			b++;
			/*c++;
			d++;*/
			return a + b + c + d;
		};
	func5();
	cout << a << " " << b << " " << c << " " << d << endl;
	//局部的静态变量和全局变量不能捕捉，也不用捕捉
	static int m = 0;
	auto func6 = []
		{
			int ret = x + m;
			return ret;
		};
	//传值捕捉本身是一种拷贝，并且被const修饰
	//mutable相当于去掉const修饰
	//但是修改了不会影响外面被捕的值，因为是一种拷贝
	auto func7 = [=]()mutable
		{
			a++;
			b++;
			c++;
			d++;
		};
	return 0;
}

#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& 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} };
	//类似这样的场景，我们实现仿函数对象或者函数指针来比较，相对比较麻烦，那么用lambda就很好
	sort(v.begin(), v.end(), comparepriceless());
	sort(v.begin(), v.end(), comparepricegreater());
	sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)
		{
			return gl._price < gr._price;
		});
	sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)
		{
			return gl._price >gr._price;
		});
	sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)
		{
			return gl._evaluate < gr._evaluate;
		});
	sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)
		{
			return gl._evaluate > gr._evaluate;
		});
	return 0;
}

#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:
	Plus(int n = 10)
		:_n(n)
	{ }
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return (a + b) * _n;
	}
private:
	int _n;
};
int main()
{
	function<int(int, int)>f1 = f;
	function<int(int, int)>f2 = Functor();
	function<int(int, int)>f3 = [](int a, int b) {return a + b; };
	cout << f1(1, 1) << endl;
	cout << f2(1, 1) << endl;
	cout << f3(1, 1) << endl;
	//包装静态成员函数
	//成员函数要指定类域且前面加&才能获得地址
	function<int(int, int)>f4 = &Plus::plusi;
	cout << f4(1, 1) << endl;
	//包装普通成员函数
	//普通成员函数还有一个隐含的this指针参数，所以绑定时传对象的指针或者对象都ok
	function<double(Plus*, double, double)>f5 = &Plus::plusd;
	Plus pd;
	cout << f5(&pd, 1.1, 1.1) << endl;
	function<double(Plus, double, double)>f6 = &Plus::plusd;
	cout << f6(pd, 1.1, 1.1) << endl;
	cout << f6(Plus(), 1.1, 1.1) << endl;//匿名对象，不用再定义pd对象
	function<double(Plus&&, double, double)>f7 = &Plus::plusd;
	cout << f6(move(pd), 1.1, 1.1) << endl;
	cout << f6(Plus(), 1.1, 1.1) << endl;//匿名对象.匹配右值引用
	return 0;
}

class Solution {
public:
    int evalRPN(vector<string>& tokens) 
    {
        // stack<int>s;
        // for(auto e:tokens)
        // {
        //     if(e=="+"||e=="-"||e=="*"||e=="/")
        //     {
        //         int right=s.top();
        //         s.pop();
        //         int left=s.top();
        //         s.pop();
        //         if(e=="+")s.push(left+right);
        //         if(e=="-")s.push(left-right);
        //         if(e=="*")s.push(left*right);
        //         if(e=="/")s.push(left/right);
        //     }
        //     else
        //     {
        //         s.push(stoi(e));
        //     }
        // }
        // return s.top();
//法2：
        stack<int>s;
        map<string,function<int(int,int)>>opfunmap={
        {"+",[](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)
        {
            if(opfunmap.count(e))
            {
                int r=s.top();
                s.pop();
                int l=s.top();
                s.pop();
               int ret= opfunmap[e](l,r);
               s.push(ret);
            }
            else{
                s.push(stoi(e));
            }
        }
        return s.top();
    }
};

#include<functional>
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int Sub(int a, int b)
{
	return (a - b) * 10;
}
int Subx(int a, int b,int c)
{
	return (a - b-c) * 10;
}
class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};
int main()
{
	auto sub1 = bind(Sub, _1, _2);
	cout << sub1(10, 5) << endl;//输出50
	// bind 本质返回的⼀个仿函数对象 
    // 调整参数顺序（不常⽤） 
    // _1代表第⼀个实参 
    // _2代表第⼆个实参 
    // ...
	//function<int(int, int)>f1 = bind(Sub, _1, _2);
	auto sub2 = bind(Sub, _2, _1);
	cout << sub2(10, 5) << endl;//输出-50
	//调整参数个数（常用）
	auto sub3 = bind(Sub, 100, _1);
	cout << sub3(5) << endl;//绑死了a=100；
	auto sub4 = bind(Sub, _1, 100);
	cout << sub4(5) << endl;//绑死了b=100
	//分别绑死第123个参数
	auto sub5 = bind(Subx, 100, _1, _2);
	auto sub6= bind(Subx, _1, 100, _2);
	auto sub6 = bind(Subx, _1, _2,100);
	//成员函数对象继续绑定，就不用每次传了
	function<double(Plus&&, double, double)>f6 = &Plus::plusd;
	Plus pd;
	cout << f6(move(pd), 1.1, 1.1) << endl;
	cout << f6(Plus(), 1.1, 1.1) << endl;//匿名对象.匹配右值引用
	//bind直接绑死
	function<double( double, double)>f7 = bind(&Plus::plusd, Plus(), _1, _2);
	auto fun = [](double rate, double money, int year)
		{
			double ret = money;
			for (int i = 0; i < year; i++)
			{
				ret = ret * rate + ret;
			}
			return ret - money;
		};
	function<double(double)>f1 = bind(fun, 0.015, _1, 3);
	function<double(double)>f2 = bind(fun, 0.015, _1, 5);
	//....
	return 0;
}