[C++知识库]C++11常用新特性

C++11是一种目前最常用的C++标准，可以说不同标准下的语言，给人的感觉如同不同语言。

面试中的C++，除了基本语法和基本特性（如：三大特性：封装、继承、多态，虚函数等）对C++11标准的考察也是重中之重。

一般会围绕智能指针、lambda、auto关键字等典型特性来询问。下面是关于C++11标准的回答。

1、C++11有哪些新特性？

• nullptr代替了NULL
• 引入了auto和decltype这两个关键字实现了类型推导
• 基于范围的for循环 for(auto& i: res)
• 类和结构体中的初始化列表
• Lambda表达式（匿名函数）
• std::forward_list （单向列表）
• 右值引用和move的语义

2、nullptr
nullptr见名知意，空指针的意思，其出现的目的就是为了代替NULL。某种意义上说，传统C++会将NULL、0视作可等价替换的对象，这取决于编辑器如何定义NULL，有些编辑器会将NULL定义为((void)0)，有些则会直接将其定义为0。
C++不允许直接将(void) 隐式转换成其他类型，但如果NULL被定义为((void)*0)，那么当编译char *ch=NULL， NULL只好被定义成0；
而就算这样，依旧存在问题，这将导致C++中重载特性发生混乱，考虑：

void foo(char *);
void foo(int)

对于这两个函数来说，如果NULL又被定义成了0，那么foo(int) 这个语句将会调用foo(int) 从而导致代码违反coder的本意。

解决办法：
C++引入新的空指针关键字nullptr，专门用来区分空指针、0；
nullptr的类型为nullptr_t，能够隐式转换为任何指针的类型，也能和他们进行相等和不等的比较。
需要用空指针的地方，直接换上nullptr就完事了。

3、类型推导
C++11 引入了 auto 和 decltype 这两个关键字实现了类型推导，让编译器来操心变量的类型。

• auto

auto 在很早以前就已经进入了 C++，但是他始终作为一个存储类型的指示符存在，与 register 并存。在传统 C++ 中，如果一个变量没有声明为 register 变量，将自动被视为一个 auto 变量。而随着 register 被弃用，对 auto 的语义变更也就非常自然了。

使用 auto 进行类型推导的一个最为常见而且显著的例子就是迭代器。在以前我们需要这样来书写一个迭代器：

for(vector<int>::const_iterator itr = vec.cbegin(); itr != vec.cend(); ++itr)

很明显，代码臃肿，coder也麻烦，有了auto后，迭代器就成了：

// 由于 cbegin() 将返回 vector<int>::const_iterator 
// 所以 itr 也应该是 vector<int>::const_iterator 类型
for(auto itr = vec.cbegin(); itr != vec.cend(); ++itr);

不再需要coder去考虑数据类型，将繁重的工作量对给了编译器；
当然也存在其他的用法：

auto i = 5; //i被推导成int
auto arr = new auto(10);	//arr被推导成int *

但是值得注意的是：auto不能用于函数传参，无法通过编译，如：

int add(auto x, auto y)

此外，auto还不能用于推导数组的类型，如：

auto i = 5;

int arr[10] = {0};
auto auto_arr = arr;
auto auto_arr2[10] = arr;

• decltype
  decltype关键字是为了解决auto只能对变量进行类型推导的缺陷进行了，用法和sizeof很像：

decltype(表达式)

在此过程中，编译器分析表达式并得到它的类型，却不实际计算表达式的值，如：

auto x = 1;
auto y = 2;
decltype(x + y) z;

拖尾返回类型、auto与decltype相配合
你可能会思考，auto能不能用于推导函数的返回类型，考虑这样一个例子加法函数的例子，在传统 C++ 中我们必须这么写：

template<typename R, typename T, typename U>
R add(T x, U y) {
    return x+y
}

这样的代码其实变得很丑陋，因为程序员在使用这个模板函数的时候，必须明确指出返回类型。但事实上我们并不知道 add() 这个函数会做什么样的操作，获得一个什么样的返回类型。
在 C++11 中这个问题得到解决。虽然你可能马上回反应出来使用 decltype 推导 x+y 的类型，写出这样的代码：

decltype(x+y) add(T x, U y);

但事实上这样的写法并不能通过编译。这是因为在编译器读到 decltype(x+y) 时，x 和 y 尚未被定义。为了解决这个问题，C++11 还引入了一个叫做拖尾返回类型（trailing return type），利用 auto 关键字将返回类型后置：

template<typename T, typename U>
auto add(T x, U y) -> decltype(x+y) {
    return x+y;
}

从 C++14 开始是可以直接让普通函数具备返回值推导，因此下面的写法变得合法：

template<typename T, typename U>
auto add(T x, U y) {
    return x+y;
}

4、区间迭代
基于范围的for循环，由于C++11引入的特性，我们也可以写出和python一般简介的循环语句。
代码量从：

std::vector<int> arr(5, 100);
for(std::vector<int>::iterator i = arr.begin(); i != arr.end(); ++i) {
    std::cout << *i << std::endl;
}

变得很简单：

// & 启用了引用
for(auto &i : arr) {    
    std::cout << i << std::endl;
}

妈妈再也不用担心我不会指针了！！！

5、初始化列表

C++11 提供了统一的语法来初始化任意的对象，例如：

struct A {
    int a;
    float b;
};
struct B {

    B(int _a, float _b): a(_a), b(_b) {}
private:
    int a;
    float b;
};

A a {1, 1.1};    // 统一的初始化语法
B b {2, 2.2};

C++11 还把初始化列表的概念绑定到了类型上，并将其称之为 std::initializer_list，允许构造函数或其他函数像参数一样使用初始化列表，这就为类对象的初始化与普通数组和 POD 的初始化方法提供了统一的桥梁，例如：

#include <initializer_list>

class Magic {
public:
    Magic(std::initializer_list<int> list) {}
};

Magic magic = {1,2,3,4,5};
std::vector<int> v = {1, 2, 3, 4};

未完待续。。。