0.  placeholder

头文件：<functional>

namespace: placeholder

    placeholder 就是一堆帮助bind占参数位置的东西，名字分别为 _1, _2, _3, ..., _N。 它的作用是告诉编译器，这个参数我目前用它来占个坑，以后填。

1. std::function

  为了讲丑陋的函数指针简化，也为了提供现代语言一般都有的闭包，C++ 11提供了std::function类型来表示函数，同时也可以用来表示lambda 表达式（等同于Objective-C中的代码块，Java中的闭包，诸如此类），lambda表达式可以认为是将一段代码封装成一个对象使用，虽然这个解释更适合Objective-C的代码块。在调试时，lambda表达式实际上就是编译器在自动生成的匿名类中加入的成员函数。举个栗子：

    this->a = 5;
    this->b = 1;
    
    int sum = 0;
    
    auto funcSumMember = [=](){
        return (this->a + this->b);
    };
    
    sum = funcSumMember();
    
    log("Sum member: %d", sum);
    
    auto funcSumAB = [](int a, int b) {
        return (a+b);
    };
    
    sum = funcSumAB( 5, 3 );
    
    log("a+b:%d", sum);
    
    auto funcModifyMember = [&](){
        this->a = 11;
        this->b = 12;
        
        return (this->a+this->b);
    };
    
    sum = funcModifyMember();
    
    log("a(%d) + b(%d) = %d", this->a, this->b, sum);

开始的中括号[]内部放的是capture list,指定以什么形式捕获外界的值。

a. []表示这个表达式不需要知道外界的数值，见 funcSumAB(int,int)，由于需要用于加法的参数都已经在参数列表中给出，无需访问外部值。

b. [=]表示这个表达式如果需要外部数值，那么都以拷贝形式放进来，就像函数参数一样，对其修改不会影响到外部的本体。参考 funcSumMember()

c. [&]表示这个表达式如果需要外部数值，那么都以引用形式放进来，对外部数据的修改是真实有效的，参考funcModifyMember()

d. []列表中可以指定更加详细的方式，例如对变量ta不做修改，只要知道数值就好，对tb可能做出修改，那么就可以： [ta, &tb] ，虽然先前=表示将值拷贝过来，这里ta真的不能写成=ta :(. 另外我也没找到可以在这个列表中带入this->a 和this->b的正确写法，所以只好使用了局部变量ta和tb，参见 funcModifyMemberAdvanced.

目前我看来lambda表达式的好处有：

1. 减少无聊的代码：对一些只有一两行的简单函数，无需在头文件中声明然后在.cxx中实现，然后才能用作函数指针来访问，譬如对每个MenuItem的响应，不长的函数根本没必要郑重的单独拖出来。又如排序用到的compare函数，如果放在以前，用重载操作符的内部类已经算比较好的办法了，现在只需要一个lambda表达式（当然本质上也是利用了内部类）

2. 可以更灵活的将类的内部暴露给其它类。利用capture list， 可以访问到本类中的所有内容，如果将其传递给另一个类，那么另一个类就可以利用这些内容。相对于friend之类的方式，更加灵活宽容

3. 更灵活的代码重用。 现在对于重复的代码，你可以不必一定声明出一个函数来，说它其实只是用来避免重复的，你也可以将它放到一个lambda表达式里，然后随处可用

2. 参数绑定 std::bind

头文件： <functional>

参数： std::bind( Func & func, Args ... args )

返回值： std::function( Args ... args )

Func 是一个std::function类型的函数指针，bind可以绑定参数，使得返回的新函数指针无需带上完整的参数列表.对于缺了具体数值的货色，需要用0. placeholder一节中提到的placeholder来凑数：

    {
        int sum = 0;
        auto funcSum = [](int a, int b, int c){
            return (a+b+c);
        };
    
        auto funcSumBC = std::bind( funcSum, 0, std::placeholders::_1, std::placeholders::_2 );
        sum = funcSumBC( 4, 5 );
        log("sumBC=%d", sum);
        
        auto funcOnlyC = std::bind( funcSum, 0, 0, std::placeholders::_1);
        
        sum = funcOnlyC(5);
        log("OnlyC=%d", sum);
        
    }

需要注意的是，C++中的成员函数，是有自己的this指针的（当然不包括静态函数），对于这部分函数，编译器做的处理实际上是：

this->funcA(arg0, arg1, ...);

变成了：

__XX_funcA( this, arg0, arg1, ... )

这部分内容参考 Inside C++ Object Model

所以成员函数第一个参数是this指针，使用bind的时候千万不要压住人家隐形的翅膀，不然会挂掉的 XD.

cocos2dx中的应用：

CC_CALLBACK_0

CC_CALLBACK_1

...

CC_CALLBACK_N

N表示bind需要用几个placeholder凑数，也就是bind后调用需要带的参数数量。如果你全绑了，那就用CC_CALLBACK_0，缺了1个参数，就用_1，以此类推，不要忘记成员函数的this参数！

3. auto

auto可以认为是"你懂的"。考虑到某些名字实在是长得要命，譬如 cocos2d::extension::Control::EventType 这种逆天而又实在无聊的前缀，还有STL中更常见的 vector<int>::iterator这种让人不得不typedef的类型，auto拯救我等于水火之中。

用于返回值的赋值是比较理想的场合：

auto iB = something.begin(); //我知道返回的类型是什么，大家都知道，但我实在懒得打出来了！

但是让编译器去猜我们自己初始化的变量到底是什么类型就有点不靠谱：

auto factor = 1; //你知道factor到底是int,float还是double还是其它吗？

scale *= factor; 

或许编译器的一些规则可以让我们有所判断，但我感觉这种情况下用auto，对可读性是一种阻碍。

注意：虽然带着auto，但是它跟auto_ptr真不是亲戚

4. 迭代

    {
        int localArray[] = {1, 2, 3, 4, 5};
        
        for( int iLocal: localArray)
        {
            log("%d", iLocal);
        }
        
        std::string localStr = "Hello C++11";
        
        for( auto iStr: localStr)
        {
            log("%c", iStr);
        }
    }

for( ReferenceElement : container )

{

     ...

}

能够使用迭代的条件有4个：

     1、实现begin()
     2 、实现end()
     3 、实现 operator++()
     4 、实现 operator!=(class& other)

跟其它语言的遍历一样，用于无需关心迭代到什么地方的场景，如果关心迭代的index，还是老式的for更合适

5. override/final

如果一个函数带有override关键字，那么它必须符合以下两个条件，否则编译将报错：

1. 它是一个虚成员函数，也就是带virtual的

2. 它改写了父类中的方法，也就是说父类中必须也有一个同样的方法（返回类型，函数名，参数列表）

那么它有什么用呢？作用就是在子类改写了父类的方法时，能够有这么一个关键字标志，提醒你这个funcA调用的到底是哪个类的funcA。个人观点认为，有这个关键字之后，编译器对于带有override关键字的函数所发生的调用，就无需去寻找上一层的虚函数表，应该可以用于提高虚函数调用的效率。嗯，由于对这个领域不感兴趣，这部分纯属脑补 XD.

如果一个函数带有final关键字，那么它必须符合以下两个条件，否则编译将报错：

1. 它是一个虚成员函数，也就是带virtual的

2. 它的一切子类都不重写这个方法

它的作用与Java的final相同，不再做讨论

目前暂时记录这么多，如有错漏以后补