在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;
}
4.综合示例：利用function,bind等特性实现一个处理输入的委托。
#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;
}