在Cocos2dx3.x中提供了对C++11标准的支持,其中Lambda表达式、function模板、bind模板在游戏编程中比较常用，本文简要介绍一下这三个C++11方面的特性。

1.Lambda表达式

(1)Lambda表达式语法格式：[捕捉列表](参数列表)<mutable>->返回值类型{函数体}
(1.1).捕捉列表：捕捉列表能够捕捉上下文的变量供lambda函数使用。捕捉列表有如下几种形式：
[var]:按值传递方式捕捉变量var
[=]:按值传递方式捕捉父作用域所有变量，包括this
[&]:按引用传递方式捕获父作用域所有变量，包括this
[&var]:按引用传递方式捕获变量var
[this]：按值传递方式捕获当前的this指针，这样就可以使用lambda表达式所在类的所有成员
(1.2).参数列表：lambda函数参数
(1.3).mutable:默认lambda函数是const的，如果你不需要const的，加上mutable取消其常量性
(1.4).返回值类型：如果不需要返回值类型，可以和->一起省略
(1.5).函数体：可以使用参数列表的参数和捕捉列表的参数(2)Lambda表达式程序示例

#include <iostream>

using namespace std;

class TestLambda
{
public:
	void testFunc();
public:
	int data;
};


void TestLambda::testFunc()
{
	int var1 = 1;
	int var2 = 2;

	/*无捕捉、无参数lambda函数*/
	auto fun1=[](){std::cout << "无捕捉、无参数lambda函数" << endl; };
	fun1();

	/*捕捉this指针*/
	auto fun2=[this](){
		this->data = 10;
	};
	fun2();

	/*用值传递方式捕捉特定变量*/
	auto fun3=[var1]()mutable{
		std::cout << "用值传递方式捕获到了"<<var1 << endl;
		var1 = 11;
	};
	fun3();
	std::cout << "var1改变了吗？" + var1 << endl;


	/*用值传递方式捕获所有变量，包括this*/
	auto fun4=[=](){
		std::cout << var1 << " " << var2 << " " << this->data << endl;
	};
	fun4();

	/*用引用传递捕获特定变量*/
	auto fun5=[&var2](){
		std::cout << var2 << endl;
		var2 = 22;
	};
	fun5();
	std::cout << "var2变了吗？"<<var2 << endl;

	/*用引用传递捕获所有变量，包括this*/
	auto fun6=[&](){
		std::cout << var1 << " " << var2 << " " << this->data << endl;
	};
	fun6();

	/*带参数的lambda*/
	auto fun7=[=](int var3){
		std::cout << "var1+var2+var3=" << var1 + var2 + var3 << endl;
	};
	fun7(3);

	/*带参数和返回值的lambda*/
	auto fun8 = [this](int var4)->int{
		return this->data - var4;
	};
	std::cout << fun8(10) << endl;

}


int main()
{
	TestLambda t1;
	t1.data = 20;
	t1.testFunc();
	return 0;
}

2.function模板：function是一个函数包装模板类，提供了泛型回调机制。function和函数指针比较类似，优点在于它允许用户在目标的实现上具有更大的弹性，即允许目标是普通函数，仿函数对象，类成员函数，甚至lambda表达式。

(1).function对象声明：function<返回值类型(参数类型)> 对象名

例：function<int(int,int)>f;//声明了一个返回值类型为int,两个参数皆为int的function对象f

特别地，由于类的成员函数含有一个隐含的参数this指针，function对象声明如下：(类，参数列表)> f;

例：classCAdd

{

public:

int add(int a,int b){returna+b;}

}

function<int(CAdd,int,int)> f=&CAdd::add;

CAdd c;

f(c,2,3);

(2)function模板使用举例：

#include <iostream>
#include<functional>

using namespace std;

class TestFunction
{
public:
	int add(int a,int b)
	{
		return a + b;
	}

	static void test()
	{
		cout << "类静态成员函数" << endl;
	}
};

int max(int a,int b)
{
	return a > b?a:b;
}

int main()
{
	/*普通函数*/
	function<int(int,int)> f1 = max;
	cout << f1(2,3) << endl;

	/*类成员函数*/
	function<int(TestFunction,int)> f2 = &TestFunction::add;
	TestFunction t;
	cout << f2(t,3) << endl;

	/*类静态函数*/
	function<void()> f3 = TestFunction::test;
	f3();

	/*lambda表达式*/
	function<int(int,int)> f4 = [](int a,int b)->int{
		return a + b;
	};
	cout<<f4(2,3)<<endl;

	return 0;
}

3.bind模板：bind是一个用于函数绑定的模板。bind可以绑定普通函数，仿函数，类成员函数等等。对于某个函数进行绑定时，可以指定全部或部分参数，还可以调整参数的顺序。对于未指定的参数，可以用占位符std::placeholders::_1,std::placeholders::_2,std::placeholders::_3，...来代替，其中_1表示参数表里的第一个参数。(1).bind使用示例：

#include<iostream>
#include<functional>

using namespace std;

class TestBind
{
public:
	int add(int a,int b)
	{
		return a + b;
	}
};


void fun1(int a,float b,char c)
{
	cout << a << '\t' << b << '\t' << c << endl;
}

class MaxFunctor
{
public:
	int operator()(int a,int b)
	{
		return a > b ? a : b;
	}
};

int main()
{
	/*普通函数*/
	auto testBind1 = bind(fun1,placeholders::_1,placeholders::_2,placeholders::_3);
	testBind1(1,1.0f,'1');
	/*使用占位符*/
	auto testBind2 = bind(fun1,std::placeholders::_1,'2');
	testBind2(2.0f,2);

	/*仿函数对象*/
	MaxFunctor max;
	auto testBind3 = bind(max,placeholders::_2);
	cout << testBind3(2,3) << endl;

	/*类成员函数*/
	TestBind t;
	auto testBind4 = bind(&TestBind::add,t,placeholders::_2);
	cout << testBind4(2,3) << endl;

	return 0;
}

#include<iostream>
#include<functional>
#include<vector>

using namespace std;

class Event//仅供测试
{

};

class Touch//仅供测试
{

};

class InputHandler
{
public:
	static InputHandler* getInstance();
	void onTouch(Event*,Touch*);
	friend void operator+=(InputHandler*,function<void(Event*,Touch*)>);

private:
	InputHandler();
	virtual ~InputHandler();

private:
	static InputHandler* instance;
	vector<function<void(Event*,Touch*)>> myDelegate;
};

InputHandler* InputHandler::instance = new InputHandler;

InputHandler::InputHandler()
{

}

InputHandler::~InputHandler()
{
	if (instance != nullptr)
		delete instance;
}

InputHandler* InputHandler::getInstance()
{
	return instance;
}

void operator+=(InputHandler* in,Touch*)> f)
{
	in->myDelegate.push_back(f);
}

void InputHandler::onTouch(Event* e,Touch* t)
{
	for (auto f : myDelegate)
	{
		f(e,t);
	}
}

/*类成员函数*/

class TestInput
{
public:
	void fun1(Event* e,Touch* t)
	{
		cout << "fun1被调用" << endl;
	}
};

/*仿函数对象*/

class TestFunctor
{
public:
	void operator()(Event* e,Touch* t)
	{
		cout << "仿函数对象被调用" << endl;
	}
};

/*普通函数*/
void fun2(Event* e,Touch* t)
{
	cout << "fun2被调用" << endl;
}

int main()
{
	Event* e = new Event;
	Touch* t = new Touch;
	InputHandler* input=InputHandler::getInstance();

	/*类成员函数*/
	TestInput testInput;
	input += bind(&TestInput::fun1,testInput,placeholders::_2);
	
	/*仿函数对象*/
	TestFunctor testFunctor;
	input += bind(testFunctor,placeholders::_2);

	/*普通函数*/
	input += bind(fun2,placeholders::_2);

	/*lambda表达式*/
	input += [](Event* e,Touch* t){
		cout << "lambda表达式被调用" << endl;
	};

	input->onTouch(e,t);
	delete e;
	delete t;
	return 0;
}