很多进入 C++ 领域的朋友都是从 C 转行而来，会天然地将 C 的语法用在 C++ 代码中。

随着 C++ 的现代化进程在加快，前段时间有些朋友和我提起，现在的 C++ 语法他/她已经看不懂了。

所以，有必要让初进 C++ 的朋友对 C++ 语言的现代化版本有更全面的认识，藉此机会，我们就一起聊聊现代化的起点版本 C++ 11 引入了哪些比较有用的新特性？

1. Lambda 表达式

Lambda 表达式其实就是无名函数，如果函数名字对于使用者来说没有意义，就很适合使用 Lambda 表达式替代。

比如往接口 interface() 传递回调函数时，以往一般采用传递函数地址，需要专门定义一个函数，特意为它起名还想了很久，而且自己从来不调用它，就很尴尬。

有了 Lambda 表达式，你可以：

interface([](int x, int y) { return x + y; });

2. enum class

之前我们使用的枚举 enum 有个非常让人懊恼的问题：

cppenum Color { Red, Blue, Green, Yellow };
enum TrafficLights { Red, Yellow, Green };

这样的定义会导致编译错误，因为枚举值的作用域是公共的，在 Color 中定义的枚举值 Red 会和 TrafficLights 中定义的 Red 之间有命名冲突。

C++ 11 引入了 enum class 强类型枚举，可以有效避免命名冲突，因为所有枚举值都被声明在特定的作用域内，引用时必须使用作用域解析符：

cppColor c = Color::Red;

除此之外，传统的枚举值可以被隐式转换成整数类型，而强类型枚举不能隐式转换，如需转换可用 static_cast:

cppint val = static_cast<int>(Color::Red);

3. 范围 for 循环

在之前的版本里，for 循环有很死板的写法，以遍历容器 vector 为例：

cppstd::vector<int> v(5, 2);
for (std::vector<int>::iterator i = v.begin(); i != v.end(); ++ i) {
    std::cout << *i << " ";
}

基本格式是:

for (初始化语句; 循环条件判断; 执行语句) {}

C++ 11 把 for 循环的格式扩展添加了对范围的遍历，改写上面的例子：

cppstd::vector<int> v(5, 2);
for (int i : v) {
    std::cout << i << " ";
}

范围 for 循环的写法简化了对容器、数组等类型数据的遍历。

4. 自动类型推导 auto

很多时候有些类型书写起来会很长，然后又要大量使用，想想都觉得头皮发麻。

就比如上面对容器执行迭代时，需要获取容器的迭代器，这个迭代器的类型是定义在容器内部的，声明容器的迭代器要书写的篇幅会很长，很不利于阅读：

std::vector<int>::iterator i;

所以，C++ 11 赋予了关键词 auto 新的功能，只要使用 auto 声明变量，编译器就可以自动推导变量的类型，减少代码的冗余。

比如下面的表达式中，编译器可以依据右侧的操作数推断左侧新建的变量类型:

cppauto x = 5; // int
auto y = 3.14; // double

5. 空指针 nullptr

传统的代码里，我们随处可见到空指针的引用，比如常用于表示空指针的宏定义 NULL：

cpp#define NULL    0

或者

cpp#define NULL    (void*)0

无论定义成哪种，编译器可以隐式将其转换成整形或者任何类型的指针，这是类型不安全的。

如果类内重载了这样一个方法：

cpp// 声明 function
function(int x);
function(char *x);

那么调用时传入 NULL，编译器应该选择哪个方法？

cppfunction(NULL);

NULL 的用意不明确，同时也会带来阅读困难。

所以，C++ 11 引入了关键词 nullptr 专门表示空指针，它不能隐式转换成整形，也就没有了语义不明的问题。

cppint* p = nullptr;

若大家觉得看文章不过瘾，可以来拿C/C++视频学习包，给大家整理了一个教程合集（内含：C++基础，网络编程，数据库，组件，中间件，框架，分布式架构，项目实战等）↓看下图↓↓↓↓↓↓↓。

6. constexpr

以往的代码里，有时想定义一个长度由变量定义的数组：

cppint array[num];

但是，这样的代码在 C++ 11 之前，编译器是会报错的。

还有，如果定义了一个函数执行计算:

cppint square(int x) {
    return x * x;
}

调用时如果输入的参数是常量，难道非得要在运行时才费时执行计算吗？

cppint area = square(9);

C++ 11 引入了新关键词 constexpr，表示常量表达式，目标是榨干编译器的性能，减轻运行时负担，达到性能优化。

使用 constexpr 修饰变量，该变量在编译期就确定了值，在所有引用位置都会直接嵌入代码中，因而可以用于数组的长度定义。而 const 修饰的变量允许在运行时才确定。

cppconstexpr int array[num];

而使用 constexpr 修饰函数，在调用该函数并输入常量或者 constexpr 修饰的量时，编译器会尝试执行计算并返回结果，这样运行时又可省略计算负担而直接得到结果：

cppconstexpr int square(int x) {
    return x * x;
}

int area = square(9);

7. 新关键词 override、final、noexcept

• override 作为修饰词放在函数声明的末尾，声明当前函数是父类虚函数的重写，促使编译器去检查父类中是否有这样的虚函数，如果没有则报错。

class Base {
public:
    virtual void func() const { ... } // 基类虚函数
};

class Derived : public Base {
public:
    void func() const override { ... }
};

• final 作为修饰词放在类名或者函数声明的末尾，它的作用是防止类被进一步继承或虚函数被进一步重写。

class Base {
   virtual void func() { ... }
};

class Derived1 : public Base {
   virtual void func() final {
      // Derived1::func() 是最后一个版本
      // Derived1 的任何派生类中都不能再重写 func()
   }
};

class Derived2 final : public Derived1 {
   // Derived2 是最终类，不能再被继承
};

• noexcept 作为修饰词放在函数声明的末尾，显式声明函数在任何情况下都不会抛出异常。

class MyClass {
public:
    MyClass(MyClass&&) noexcept = default; // 确保移动构造不会抛异常
    ~MyClass() noexcept = default;         // 确保析构不会抛异常
};

使用修饰符 noexcept 有什么好处吗？

标准库里有些操作，在发生错误时，要求能够回滚操作，这样就需要安全的操作，包括不会抛出异常的操作，所以声明为 noexcept 的函数是客观需要的。

另外，移动操作比拷贝操作要有效率，但标准库在无法确定安全性的情况下，会选择更慢但更安全的拷贝操作，所以声明为 noexcept 的函数也对性能优化有帮助。

如果被声明为 noexcept 的函数却抛出了异常，系统会调用 terminate() 终止进程。

8. 统一的初始化语法

在传统的写法里，为了创建对象，会经常使用小括号 () 语法初始化对象，目的是调用构造函数初始化对象，但是有时会与函数声明产生混肴：

struct S {
    S(int, int) {}
};

S obj1(1, 2); // 构造一个 S 对象
S obj2();  // 这是函数声明，函数名为 obj2，返回类型为 S 的对象

这种初始化的方式有很大的弊端。

有时初始化赋值，又有可能从较大范围的值隐式转换为较小范围的值，也就是窄化转换，会引发潜在的错误：

cppint x = 3.14; // 允许，x 将变为 3

在 C++ 11 之前，花括号 {} 主要用于数组初始化、聚合类型（如结构体）的初始化，以及通过构造函数的初始化列表进行成员初始化。

C++ 11 引入了统一初始化（也称为列表初始化），使得花括号可以在各种情况下使用，简化了不同类型的初始化方式，例如对象、数组、类成员等，都可以使用花括号进行初始化。

更重要的是，统一初始化解决了上面遇到的那些典型问题。

S obj3{1, 2};   // 明确表示构造一个 S 对象
int y{3.14};  // 错误，编译器禁止窄化转换

9. 右值引用 &&

在传统的写法里，有对左值的引用操作，但是缺乏对右值的引用操作，右值引用能优化对资源的使用，所以 C++ 11 引入了右值引用符号，用 && 表示。

比如定义类的移动构造函数时，需要将形参声明为右值引用：

MyClass(MyClass&& other) noexcept : data(std::move(other.data)) {
   std::cout << "Move Constructor\n";
}