C++11新特性

什么是C++11

C++11标准为C++编程语言的第三个官方标准，正式名叫ISO/IEC 14882:2011 - Information technology – Programming languages – C++。在正式标准发布前，原名C++0x。它将取代C++标准第二版ISO/IEC 14882:2003 - Programming languages – C++成为C++语言新标准。

C++11是对目前C++语言的扩展和修正， C++11不仅包含核心语言的新机能，而且扩展了C++的标准程序库（STL） ，并入了大部分的C++ Technical Report 1（TR1） 程序库(数学的特殊函数除外)。

C++11包括大量的新特性：包括lambda表达式，类型推导关键字auto、 decltype，和模板的大量改进。

类型推导

auto

auto的自动类型推导，用于从初始化表达式中推断出变量的数据类型。从这个意义上讲，auto并非一种“类型”声明，而是一个类型声明时的“占位符”，编译器在编译时期会将auto替换为变量实际的类型。

注意：

1. 定义变量时必须初始化；
2. 不支持函数形参（C++11）；
3. 不能作为自定义类型的成员变量；
4. 不能作为模板实例化时的参数；
5. 不能出现在顶级数组类型。

void fun(auto x = 1) {}  // 2: auto函数参数，有些编译器无法通过编译
struct str
{
    auto var = 10;   // 3: auto非静态成员变量，无法通过编译
};

int main()
{
    auto a;     // 1: 无法推导，无法通过编译
    vector<auto> b = {1}; // 4: auto模板参数（实例化时），无法通过编译
    auto c[3] = { 1, 2, 3 }; // 5: auto数组，无法通过编译
    return 0;
}

​

decltype

decltype可以从一个变量或表达式中得到其类型。

追踪返回类型

返回类型后置：在函数名和参数列表后面指定返回类型。

template <typename T1, typename T2>
auto mul(const T1 & t1, const T2 & t2) -> decltype(t1 * t2)
{
    return t1 * t2;
}

易用性的改进

初始化

1. 类内成员初始化
2. 初始化列表
3. 使用列表初始化可以防止类型收窄

基于范围的for循环

使用基于范围的for循环，其for循环迭代的范围必须是可确定的。

int func(int a[])//形参中数组是指针变量，无法确定元素个数
{
    for(auto e: a) // err, 编译失败
    {
        cout << e;
    }
}

int main()
{
    int a[] = {1, 2, 3, 4, 5};
    func(a);

    return 0;
}

静态断言

C/C++提供了调试工具assert，这是一个宏，用于在运行阶段对断言进行检查，如果条件为真，执行程序，否则调用abort()。

C++ 11新增了关键字static_assert，可用于在编译阶段对断言进行测试。

静态断言的好处：

• 更早的报告错误，我们知道构建是早于运行的，更早的错误报告意味着开发成本的降低

• 减少运行时开销，静态断言是编译期检测的，减少了运行时开销

noexcept

C++11 使用noexcept替代throw()代表此函数不能抛出异常，如果抛出，就会异常。

nullptr

nullptr是为了解决原来C++中NULL的二义性问题而引进的一种新的类型，因为NULL实际上代表的是0。

强类型枚举

C++ 11引入了一种新的枚举类型，即“枚举类”，又称“强类型枚举”。声明请类型枚举非常简单，只需要在enum后加上使用class或struct。如：

enum Old{Yes, No};          // old style
enum class New{Yes, No};    // new style
enum struct New2{Yes, No};  // new style

“传统”的C++枚举类型有一些缺点：它会在一个代码区间中抛出枚举类型成员（如果在相同的代码域中的两个枚举类型具有相同名字的枚举成员，这会导致命名冲突），它们会被隐式转换为整型，并且不可以指定枚举的底层数据类型。

int main()
{
    enum Status{Ok, Error};
    //enum Status2{Ok, Error};//err, 导致命名冲突, Status已经有成员叫Ok, Error
 
    return 0;
}

在C++11中，强类型枚举解决了这些问题：

int main()
{
    enum class Status {Ok, Error};
    enum struct Status2{Ok, Error};
 
    //Status flag2 = Ok; // err，必须使用强类型名称
    Status flag3 = Status::Ok;
 
    enum class C : char { C1 = 1, C2 = 2};//指定枚举的底层数据类型
    enum class D : unsigned int { D1 = 1, D2 = 2, Dbig = 0xFFFFFFF0U };
 
    cout << sizeof(C::C1) << endl;   // 1
    cout << sizeof(D::D1) << endl;     // 4
    cout << sizeof(D::Dbig) << endl;   // 4
 
    return 0;
}

常量表达式

常量表达式主要是允许一些计算发生在编译时，即发生在代码编译而不是运行的时候。

这是很大的优化：假如有些事情可以在编译时做，它将只做一次，而不是每次程序运行时都计算。

constexpr函数的限制：

• 函数中只能有一个return语句（有极少特例）

• 函数必须返回值（不能是void函数）

• 在使用前必须已有定义（不能先声明）

• return返回语句表达式中不能使用非常量表达式的函数、全局数据，且必须是一个常量表达式

常量表达式的构造函数有以下限制：

• 函数体必须为空
• 初始化列表只能由常量表达式来赋值

用户定义字面量

用户自定义字面值，或者叫“自定义后缀”更直观些，主要作用是简化代码的读写。

long double operator"" _mm(long double x) { return x / 1000; }
long double operator"" _m(long double x)  { return x; }
long double operator"" _km(long double x) { return x * 1000; }
 
int main()
{
    cout << 1.0_mm << endl; //0.001
    cout << 1.0_m  << endl; //1
    cout << 1.0_km << endl; //1000
 
    return 0;
}

根据 C++ 11 标准，只有下面参数列表才是合法的，最后四个对于字符串相当有用，第二个参数会自动推断为字符串的长度。

char const *
unsigned long long
long double
char const *, size_t
wchar_t const *, size_t
char16_t const *, size_t
char32_t const *, size_t

原生字符串字面值

原生字符串字面值(raw string literal)使用户书写的字符串“所见即所得”。C++11中原生字符串的声明相当简单，只需在字符串前加入前缀，即字母R，并在引号中使用括号左右标识，就可以声明该字符串字面量为原生字符串了。

int main()
{
    cout << R"(hello,\n
         world)" << endl;
 
    return 0;
}

类的改进

继承构造

C++ 11允许派生类继承基类的构造函数（默认构造函数、复制构造函数、移动构造函数除外）。

class A
{
public:
    A(int i) { cout << "i = " << i << endl; }
    A(double d, int i) {}
    A(float f, int i, const char* c) {}
    // ...
};
 
class B : public A
{
public:
    using A::A; // 继承构造函数
    // ...
    virtual void ExtraInterface(){}
};

注意：

• 继承的构造函数只能初始化基类中的成员变量，不能初始化派生类的成员变量

• 如果基类的构造函数被声明为私有，或者派生类是从基类中虚继承，那么不能继承构造函数

• 一旦使用继承构造函数，编译器不会再为派生类生成默认构造函数

委托构造

和继承构造函数类似，委托构造函数也是C++11中对C++的构造函数的一项改进，其目的也是为了减少程序员书写构造函数的时间。

如果一个类包含多个构造函数，C++ 11允许在一个构造函数中的定义中使用另一个构造函数，但这必须通过初始化列表进行操作，如下：

class Info
{
public:
    Info() : Info(1) { }    // 委托构造函数
    Info(int i) : Info(i, 'a') { } // 既是目标构造函数，也是委托构造函数
    Info(char e): Info(1, e) { }
 
private:
    Info(int i, char e): type(i), name(e) { /* 其它初始化 */ } // 目标构造函数
    int  type;
    char name;
    // ...
};

继承控制

C++11之前，一直没有继承控制关键字，禁用一个类的进一步衍生比较麻烦。

C++ 11添加了两个继承控制关键字：final和override。

• final阻止类的进一步派生和虚函数的进一步重写

• override确保在派生类中声明的函数跟基类的虚函数有相同的签名

类默认函数的控制

1. =default
   • 编译器将为显式声明的 =default函数自动生成函数体
   • 仅适用于类的特殊成员函数，且该特殊成员函数没有默认参数
   • 函数既可以在类体里（inline）定义，也可以在类体外（out-of-line）定义
2. =delete
   • 在函数声明后加上=delete，就可将该函数禁用
   • 可用于禁用类的某些转换构造函数，从而避免不期望的类型转换
   • 禁用某些用户自定义的类的 new 操作符，从而避免在自由存储区创建类的对象

模板的改进

右尖括号的改进

在C++98/03的泛型编程中，模板实例化有一个很繁琐的地方，就是连续两个右尖括号>>会被编译解释成右移操作符，而不是模板参数表的形式，需要一个空格进行分割，以避免发生编译时的错误。

在实例化模板时会出现连续两个右尖括号，同样static_cast、dynamic_cast、reinterpret_cast、const_cast表达式转换时也会遇到相同的情况。C++98标准是让程序员在>>之间填上一个空格，在C++11中，这种限制被取消了。在C++11标准中，要求编译器对模板的右尖括号做单独处理，使编译器能够正确判断出>>是一个右移操作符还是模板参数表的结束标记。

别名

#include <iostream>
#include <type_traits> //std::is_same
using namespace std;
 
using uint = unsigned int; // CPP11
typedef unsigned int UINT;
using sint = int;
 
int main()
{
    //std::is_same 判断类型是否一致
    //这个结构体作用很简单，就是两个一样的类型会返回true
    cout << is_same<uint, UINT>::value << endl; // 1
 
    return 0;
}

函数模板的默认模板参数

C++11之前，类模板是支持默认的模板参数，却不支持函数模板的默认模板参数。类模板的默认模板参数必须从右往左定义，数模板的默认模板参数则没这个限定。

可变参数模板

在C++11之前，类模板和函数模板只能含有固定数量的模板参数。C++11增强了模板功能，允许模板定义中包含0到任意个模板参数，这就是可变参数模板。

可变参数模板和普通模板的语义是一样的，只是写法上稍有区别，声明可变参数模板时需要在typename或class后面带上省略号...：

#include <iostream>
using namespace std;

//可变参数的模板函数
template<class ... T> //T叫模板参数包
void func(T... args)//args叫函数参数包
{

}

int main()
{
    func();
    func<int>(10);
    func<int, int>(10, 20);
    func<char, int>('a', 10);
    func<char, const char*, int>('a', "abc", 250);

    return 0;
}

省略号...的作用有两个：

• 声明一个参数包，这个参数包中可以包含0到任意个模板参数
• 在模板定义的右边，可以将参数包展开成一个一个独立的参数

应用：

1. 函数的递归调用
2. 类的递归继承

右值引用

左值引用、右值引用

左值引用是对一个左值进行引用的类型，右值引用则是对一个右值进行引用的类型。

左值引用和右值引用都是属于引用类型。无论是声明一个左值引用还是右值引用，都必须立即进行初始化。而其原因可以理解为是引用类型本身自己并不拥有所绑定对象的内存，只是该对象的一个别名。

左值引用是具名变量值的别名，而右值引用则是不具名（匿名）变量的别名。

int &a = 2;       // 左值引用绑定到右值，编译失败, err
int b = 2;        // 非常量左值
const int &c = b; // 常量左值引用绑定到非常量左值，编译通过, ok
const int d = 2;  // 常量左值
const int &e = c; // 常量左值引用绑定到常量左值，编译通过, ok
const int &b = 2; // 常量左值引用绑定到右值，编程通过, ok

const 类型 &为 “万能”的引用类型，它可以接受非常量左值、常量左值、右值对其进行初始化。

右值引用，使用&&表示：

int && r1 = 22;
int x = 5;
int y = 8;
int && r2 = x + y;
T && a = ReturnRvalue();

通常情况下，右值引用是不能够绑定到任何的左值的。

移动语义

右值引用是用来支持转移语义的。转移语义可以将资源 ( 堆，系统对象等 ) 从一个对象转移到另一个对象，这样能够减少不必要的临时对象的创建、拷贝以及销毁，能够大幅度提高 C++ 应用程序的性能。临时对象的维护 ( 创建和销毁 ) 对性能有严重影响。

转移语义是和拷贝语义相对的，可以类比文件的剪切与拷贝，当我们将文件从一个目录拷贝到另一个目录时，速度比剪切慢很多。

通过转移语义，临时对象中的资源能够转移其它的对象里。

转移构造函数

class MyString
{
public:
    ...
    //移动构造函数
    //参数是非const的右值引用
    MyString(MyString && t)
    {
        str = t.str; //拷贝地址，没有重新申请内存
        len = t.len;
 
        //原来指针置空，必须修改
        t.str = NULL;
        cout << "移动构造函数" << endl;
    }
    ...
private:
    char *str = NULL;
    int len = 0;
};

和拷贝构造函数类似，有几点需要注意：

• 参数（右值）的符号必须是右值引用符号，即&&。
• 参数（右值）不可以是常量，因为我们需要修改右值。
• 参数（右值）的资源链接和标记必须修改，否则，右值的析构函数就会释放资源，转移到新对象的资源也就无效了。

有了右值引用和转移语义，我们在设计和实现类时，对于需要动态申请大量资源的类，应该设计转移构造函数和转移赋值函数，以提高应用程序的效率。转移赋值函数

class MyString
{
public:
    ...
        
    //移动赋值函数
    //参数为非const的右值引用
    MyString &operator=(MyString &&tmp)
    {
        if(&tmp == this)
        {
            return *this;
        }

        //先释放原来的内存
        len = 0;
        delete [] str;

        //无需重新申请堆区空间
        len = tmp.len;
        str = tmp.str; //地址赋值
        tmp.str = NULL;

        cout << "移动赋值函数\n";

        return *this;
    }

   ...

private:
    char *str = NULL;
    int len = 0;
};

标准库函数 std::move()

如果已知一个命名对象不再被使用而想对它调用转移构造函数和转移赋值函数，也就是把一个左值引用当做右值引用来使用。标准库提供了函数 std::move()，这个函数以非常简单的方式将左值引用转换为右值引用。

完美转发 std::forward()

完美转发适用于这样的场景：需要将一组参数原封不动的传递给另一个函数。

“原封不动”不仅仅是参数的值不变，在 C++ 中，除了参数值之外，还有一下两组属性：左值／右值和 const/non-const。完美转发就是在参数传递过程中，所有这些属性和参数值都不能改变，同时，而不产生额外的开销，就好像转发者不存在一样。在泛型函数中，这样的需求非常普遍。

C++11是通过引入一条所谓“引用折叠”（reference collapsing）的新语言规则，并结合新的模板推导规则来完成完美转发。

C++11中的引用折叠规则：

TR的类型定义	声明v的类型	v的实际类型
T &	TR	T &
T &	TR &	T &
T &	TR &&	T &
T &&	TR	T &&
T &&	TR &	T &
T &&	TR &&	T &&

一旦定义中出现了左值引用，引用折叠总是优先将其折叠为左值引用。

智能指针

C++11中有unique_ptr、shared_ptr与weak_ptr等智能指针(smart pointer)，定义在<memory>中。可以对动态资源进行管理，保证任何情况下，已构造的对象最终会销毁，即它的析构函数最终会被调用。

unique_ptr

unique_ptr持有对对象的独有权，同一时刻只能有一个unique_ptr指向给定对象（通过禁止拷贝语义、只有移动语义来实现）。

unique_ptr指针本身的生命周期：从unique_ptr指针创建时开始，直到离开作用域。

离开作用域时，若其指向对象，则将其所指对象销毁(默认使用delete操作符，用户可指定其他操作)。

#include <iostream>
#include <memory>
using namespace std;
 
int main()
{
    unique_ptr<int> up1(new int(11));   // 无法复制的unique_ptr
    //unique_ptr<int> up2 = up1;        // err, 不能通过编译
    unique_ptr<int> up3 = move(up1);    // 现在p3是数据的唯一的unique_ptr
    up3.reset();            // 显式释放内存
    up1.reset();            // 不会导致运行时错误
    
    up4.reset(new int(44)); //"绑定"动态对象
    
    up4 = nullptr;//显式销毁所指对象，同时智能指针变为空指针。与up4.reset()等价
    
    unique_ptr<int> up5(new int(55));
    int *p = up5.release(); //只是释放控制权，不会释放内存
    delete p; //释放堆区资源
    
    return 0;
}

shared_ptr

shared_ptr允许多个该智能指针共享第“拥有”同一堆分配对象的内存，这通过引用计数（reference counting）实现，会记录有多少个shared_ptr共同指向一个对象，一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。

int main()
{
    shared_ptr<int> sp1(new int(22));
    shared_ptr<int> sp2 = sp1;
    
    cout << "count: " << sp2.use_count() << endl; //打印引用计数2
    
    sp1.reset();    //显式让引用计数减1
    cout << "count: " << sp2.use_count() << endl; //打印引用计数1
    
    return 0;
}

通常情况下shared_ptr可以正常运转，但是在循环引用的场景下，shared_ptr无法正确释放内存。循环引用，顾名思义，A指向B，B指向A，在表示双向关系时，是很可能出现这种情况的，例如：

#include <iostream>
#include <memory>
using namespace std;

class Son;

class Father {
public:
    shared_ptr<Son> son_;
    Father() {
        cout << __FUNCTION__ << endl;
    }
    ~Father() {
        cout << __FUNCTION__ << endl;
    }
};

class Son {
public:
    shared_ptr<Father> father_;
    Son() {
        cout << __FUNCTION__ << endl;
    }
    ~Son() {
        cout << __FUNCTION__ << endl;
    }
};

int main()
{
    auto son = make_shared<Son>();
    auto father = make_shared<Father>();
    son->father_ = father;
    father->son_ = son;
    cout << "son: " << son.use_count() << endl;
    cout << "father: " << father.use_count() << endl;
    return 0;
}

输出：

Son
Father
son: 2
father: 2

可以看到，程序分别执行了Son和Father的构造函数，但是没有执行析构函数，出现了内存泄漏。

weak_ptr

weak_ptr是为配合shared_ptr而引入的一种智能指针来协助shared_ptr工作，它可以从一个shared_ptr或另一个weak_ptr对象构造，它的构造和析构不会引起引用计数的增加或减少。没有重载 * 和-> 但可以使用lock获得一个可用的shared_ptr对象

weak_ptr的使用更为复杂一点，它可以指向shared_ptr指针指向的对象内存，却并不拥有该内存，而使用weak_ptr成员lock，则可返回其指向内存的一个share_ptr对象，且在所指对象内存已经无效时，返回指针空值nullptr。

#include <iostream>
#include <memory>

using namespace std;

int main()
{
    shared_ptr<int> sp1(new int(22));
    shared_ptr<int> sp2 = sp1;
    weak_ptr<int> wp = sp1; // 指向shared_ptr<int>所指对象

    cout << "count: " << wp.use_count() << endl; //打印计数器 2

    sp1.reset();
    cout << "count: " << wp.use_count() << endl; // 1

    sp2.reset();
    cout << "count: " << wp.use_count() << endl; // 0

    return 0;
}

解决循环引用的问题：

class Son;

class Father {
public:
    SharedPtr<Son> son_;
    Father() {
        cout << __PRETTY_FUNCTION__ << endl;
    }
    ~Father() {
        cout << __PRETTY_FUNCTION__ << endl;
    }
};

class Son {
public:
    WeakPtr<Father> father_;  // 将SharedPtr改为WeakPtr
    Son() {
        cout << __PRETTY_FUNCTION__ << endl;
    }
    ~Son() {
        cout << __PRETTY_FUNCTION__ << endl;
    }
};

int main()
{
    auto son_ = new Son();  // 创建一个Son对象，返回指向Son对象的指针son_
    auto father_ = new Father();  // 创建一个Father对象，返回指向Father对象的指针father_
    SharedPtr<Son> son(son_);  // 调用SharedPtr构造函数：son.counter=1, son.weakref=0
    SharedPtr<Father> father(father_);  // 调用SharedPtr构造函数：father.counter=1, father.weakref=0
    son.resource->father_ = father;  // 调用WeakPtr赋值函数：father.counter=1, father.weakref=1
    father.resource->son_ = son;  // 调用SharedPtr赋值函数：son.counter=2, son.weakref=0
    cout << "son: " << son.use_count() << endl;
    cout << "father: " << father.use_count() << endl;
    return 0;
}

闭包实现

闭包有很多种定义，一种说法是，闭包是带有上下文的函数。即有状态的函数。

那什么叫 “带上状态” 呢？ 意思是这个闭包有属于自己的变量，这些个变量的值是创建闭包的时候设置的，并在调用闭包的时候，可以访问这些变量。

函数是代码，状态是一组变量，将代码和一组变量捆绑 (bind) ，就形成了闭包。

闭包的状态捆绑，必须发生在运行时。

仿函数：重载 operator()

仿函数实现闭包：

class MyFunctor
{
public:
    MyFunctor(int tmp) : round(tmp) {}
    int operator()(int tmp) { return tmp + round; }
private:
    int round;
};
 
int main()
{
    int round = 2;
    MyFunctor f(round);//调用构造函数
    cout << "result = " << f(1) << endl; //operator()(int tmp)
 
    return 0;
}

std::bind绑定器

std::function

在C++中，可调用实体主要包括：函数、函数指针、函数引用、可以隐式转换为函数指定的对象，或者实现了opetator()的对象。

C++11中，新增加了一个std::function类模板，它是对C++中现有的可调用实体的一种类型安全的包裹。通过指定它的模板参数，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟执行它们。

#include <iostream>
#include <functional>   //std::cout
using namespace std;
 
void func(void)
{//普通全局函数
    cout << __func__ << endl;
}
 
class Foo
{
public:
    static int foo_func(int a)
    {//类中静态函数
        cout << __func__ << "(" << a << ") ->: ";
        return a;
    }
};
 
class Bar
{
public:
    int operator()(int a)
    {//仿函数
        cout << __func__ << "(" << a << ") ->: ";
        return a;
    }
};
 
int main()
{
    //绑定一个普通函数
    function< void(void) > f1 = func;
    f1();
 
    //绑定类中的静态函数
    function< int(int) > f2 = Foo::foo_func;
    cout << f2(111) << endl;
 
    //绑定一个仿函数
    Bar obj;
    f2 = obj;
    cout << f2(222) << endl;
 
    /*
     运行结果：
        func
        foo_func(111) ->: 111
        operator()(222) ->: 222
    */
 
    return 0;
}

std::function对象最大的用处就是在实现函数回调，使用者需要注意，它不能被用来检查相等或者不相等，但是可以与NULL或者nullptr进行比较。

std::bind

std::bind是这样一种机制，它可以预先把指定可调用实体的某些参数绑定到已有的变量，产生一个新的可调用实体，这种机制在回调函数的使用过程中也颇为有用。

C++98中，有两个函数bind1st和bind2nd，它们分别可以用来绑定functor的第一个和第二个参数，它们都是只可以绑定一个参数，各种限制，使得bind1st和bind2nd的可用性大大降低。

在C++11中，提供了std::bind，它绑定的参数的个数不受限制，绑定的具体哪些参数也不受限制，由用户指定。

lambda表达式

C++11中的lambda表达式用于定义并创建匿名的函数对象，以简化编程工作。
lambda表达式的基本构成：

1. 函数对象参数

   []，标识一个lambda的开始，这部分必须存在，不能省略。函数对象参数是传递给编译器自动生成的函数对象类的构造函数的。函数对象参数只能使用那些到定义lambda为止时lambda所在作用范围内可见的局部变量（包括lambda所在类的this）。函数对象参数有以下形式：

   • 空。没有使用任何函数对象参数。
   • =。函数体内可以使用lambda所在作用范围内所有可见的局部变量（包括lambda所在类的this），并且是值传递方式（相当于编译器自动为我们按值传递了所有局部变量）。
   • &。函数体内可以使用lambda所在作用范围内所有可见的局部变量（包括lambda所在类的this），并且是引用传递方式（相当于编译器自动为我们按引用传递了所有局部变量)。
   • this。函数体内可以使用lambda所在类中的成员变量。
   • a。将a按值进行传递。按值进行传递时，函数体内不能修改传递进来的a的拷贝，因为默认情况下函数是const的。要修改传递进来的a的拷贝，可以添加mutable修饰符。
   • &a。将a按引用进行传递。
   • a, &b。将a按值进行传递，b按引用进行传递。
   • =，&a, &b。除a和b按引用进行传递外，其他参数都按值进行传递。
   • &, a, b。除a和b按值进行传递外，其他参数都按引用进行传递。

2. 操作符重载函数参数
   标识重载的()操作符的参数，没有参数时，这部分可以省略。参数可以通过按值（如：(a,b)）和按引用（如：(&a,&b)）两种方式进行传递。

3. 可修改标示符
   mutable声明，这部分可以省略。按值传递函数对象参数时，加上mutable修饰符后，可以修改按值传递进来的拷贝（注意是能修改拷贝，而不是值本身）。

4. 错误抛出标示符

   exception声明，这部分也可以省略。

5. 函数返回值

   ->返回值类型，标识函数返回值的类型，当返回值为void，或者函数体中只有一处return的地方（此时编译器可以自动推断出返回值类型）时，这部分可以省略。

6. 是函数体
   {}，标识函数的实现，这部分不能省略，但函数体可以为空。

除去在语法层面上的不同，lambda和仿函数有着相同的内涵——都可以捕获一些变量作为初始化状态，并接受参数进行运行。

而事实上，仿函数是编译器实现lambda的一种方式，通过编译器都是把lambda表达式转化为一个仿函数对象。因此，在C++11中，lambda可以视为仿函数的一种等价形式。

lambda表达式的类型在C++11中被称为“闭包类型”，每一个lambda表达式则会产生一个**临时对象(右值)**。因此，严格地将，lambda函数并非函数指针。

不过C++11标准却允许lambda表达式向函数指针的转换，但提前是lambda函数没有捕获任何变量，且函数指针所示的函数原型，必须跟lambda函数函数有着相同的调用方式。

lambda表达式的价值在于，就地封装短小的功能闭包，可以及其方便地表达出我们希望执行的具体操作，并让上下文结合更加紧密。

线程

在C++11之前，C/C++一直是一种顺序的编程语言。顺序是指所有指令都是串行执行的，即在相同的时刻，有且仅有单个CPU的程序计数器执行代码的代码段，并运行代码段中的指令。而C/C++代码也总是对应地拥有一份操作系统赋予进程的包括堆、栈、可执行的（代码）及不可执行的（数据）在内的各种内存区域。

而在C++11中，一个相当大的变化就是引入了多线程的支持。这使得C/C++语言在进行线程编程时，不比依赖第三方库。