一. 零碎新功能

新类型：
long long 和 unsigned long long，支持64位（或更宽）的整型。
char16_t 和 char32_t，支持16位和32位的字符表示。

列表初始化可以用于new表达式中：
int *ar=new int[4] {2,4,6,7};
Stump s2{5,43.4}; //构造函数为：Stump(int r,double w): roots(r),weight(w){}
初始化列表禁止缩窄：如double到char的自动转换是禁止的。但允许转换为更宽的类型，例如int到double的转换。

initializer_list是一个C++11提供的新类型，定义在<initializer_list>头文件中。

有了initializer_list之后，对于STL的container的初始化就方便多了,比如以前初始化一个vector需要这样：

int a[] = {0, 1, 2, 3};
std::vector<int> vec(a, a+sizeof(a));

//或
std::vector v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);

有了initializer_list后，就可以直接像初始化数组一样：

std::vector v = { 1, 2, 3, 4 };

并且，C++11允许构造函数和其他函数把初始化列表当做参数：

#include <iostream>
#include <vector>

class MyNumber
{
public:
    MyNumber(const std::initializer_list<int> &v) {
        for (auto itm : v) {
            mVec.push_back(itm);
        }
    }

    void print() {
    for (auto itm : mVec) {
        std::cout << itm << " ";
    }
  }
private:
    std::vector<int> mVec;
};

int main()
{
    MyNumber m = { 1, 2, 3, 4 };
    m.print();  // 1 2 3 4

    return 0;
}

nullptr：
不会指向有效数据的指针，以前C++源代码中用0表示这种指针，但内部表示可能不同。这使得0既可以表示指针常量，又可以表示整型常量。
C++11中的新增关键字nullptr，是指针类型，不能转换为整型类型。但仍允许用0来表示空指针，如nullptr==0是true。

C++11摒弃了auto_ptr，新增了：unique_ptr、shared_ptr、weak_ptr三种智能指针。详细看：C++中智能指针和野指针

基于范围的for循环：
一般情况下在C++下遍历一个容器的方法是这样的：

std::vector<int> array = {1, 2, 3, 4, 5};
 
for(auto it=array.begin(), it !=array.end(); ++it)
{
	std::cout << *it << "\t";
}

//或
void do_cout(int n)
{
	std::cout << n << "\t";
}
std::for_each(array.begin(), array.end(), do_cout);

现在，C++11中有了基于范围的for循环，那么之前我们写的遍历容器的方法就可以写成这样：

for(int item : array)
{
	cout << item << "\t";
}

二. Lambda表达式

或许，Lambda 表达式算得上是 C++ 11 新增特性中最激动人心的一个。简而言之，Lambda 表达式就是用于创建匿名函数的。
为什么说 lambda 表达式如此激动人心呢？举一个例子。标准 C++ 库中有一个常用算法的库，其中提供了很多算法函数，比如 sort() 和 find()。这些函数通常需要提供一个“谓词函数 predicate function”。所谓谓词函数，就是进行一个操作用的临时函数。比如 find() 需要一个谓词，用于查找元素满足的条件；能够满足谓词函数的元素才会被查找出来。这样的谓词函数，使用临时的匿名函数，既可以减少函数数量，又会让代码变得清晰易读。

1. 声明Lambda表达式

Lambda表达式完整的声明格式如下：

[capture list] (params list) mutable exception-> return type { function body }

各项具体含义如下

①capture list：捕获外部变量列表
②params list：形参列表
③mutable指示符：用来说用是否可以修改捕获的变量
④exception：异常设定
⑤return type：返回类型
⑥function body：函数体

此外，我们还可以省略其中的某些成分来声明“不完整”的Lambda表达式，常见的有以下几种：

序号	格式
1	[capture list] (params list) -> return type {function body}
2	[capture list] (params list) {function body}
3	[capture list] {function body}

其中：

格式1声明了const类型的表达式，这种类型的表达式不能修改捕获列表中的值。
格式2省略了返回值类型，但编译器可以根据以下规则推断出Lambda表达式的返回类型：（1）：如果function body中存在return语句，则该Lambda表达式的返回类型由return语句的返回类型确定；（2）：如果function body中没有return语句，则返回值为void类型。
格式3中省略了参数列表，类似普通函数中的无参函数。

2. 一个例子

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

bool cmp(int a, int b)
{
    return  a < b;
}

int main()
{
    vector<int> myvec{ 3, 2, 5, 7, 3, 2 };
    vector<int> lbvec(myvec);

    sort(myvec.begin(), myvec.end(), cmp); // 旧式做法
    cout << "predicate function:" << endl;
    for (int it : myvec)
        cout << it << ' ';
    cout << endl;

    sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });   // Lambda表达式
    cout << "lambda expression:" << endl;
    for (int it : lbvec)
        cout << it << ' ';
}

3. 捕获外部变量

Lambda表达式可以使用其可见范围内的外部变量，但必须明确声明（明确声明哪些外部变量可以被该Lambda表达式使用）。那么，在哪里指定这些外部变量呢？Lambda表达式通过在最前面的方括号[]来明确指明其内部可以访问的外部变量，这一过程也称过Lambda表达式“捕获”了外部变量。

#include <iostream>
using namespace std;

int main()
{
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    f(); // 输出：123

    //或通过“函数体”后面的‘()’传入参数
    auto x = [](int a){cout << a << endl;}(123); 
}

上面这个例子先声明了一个整型变量a，然后再创建Lambda表达式，该表达式“捕获”了a变量，这样在Lambda表达式函数体中就可以获得该变量的值。

类似参数传递方式（值传递、引入传递、指针传递），在Lambda表达式中，外部变量的捕获方式也有值捕获、引用捕获、隐式捕获。

①值捕获
值捕获和参数传递中的值传递类似，被捕获的变量的值在Lambda表达式创建时通过值拷贝的方式传入，因此随后对该变量的修改不会影响影响Lambda表达式中的值。

这里需要注意的是，如果以传值方式捕获外部变量，则在Lambda表达式函数体中不能修改该外部变量的值。

示例如下：

int main()
{
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    a = 321;
    f(); // 输出：123
}

②引用捕获
使用引用捕获一个外部变量，只需要在捕获列表变量前面加上一个引用说明符&。如下：

int main()
{
    int a = 123;
    auto f = [&a] { cout << a << endl; }; 
    a = 321;
    f(); // 输出：321
}

③隐式捕获
上面的值捕获和引用捕获都需要我们在捕获列表中显示列出Lambda表达式中使用的外部变量。除此之外，我们还可以让编译器根据函数体中的代码来推断需要捕获哪些变量，这种方式称之为隐式捕获。隐式捕获有两种方式，分别是[=]和[&]。[=]表示以值捕获的方式捕获外部变量，[&]表示以引用捕获的方式捕获外部变量。

隐式值捕获示例：

int main()
{
    int a = 123;
    auto f = [=] { cout << a << endl; };    // 值捕获
    f(); // 输出：123
}

隐式引用捕获示例：

int main()
{
    int a = 123;
    auto f = [&] { cout << a << endl; };    // 引用捕获
    a = 321;
    f(); // 输出：321
}

参考文章：

C++ 11 Lambda表达式

C++11 新功能