每个C++开发者都应该学习和使用的C++11特性

Hi,大家好！本文讨论了所有开发人员都应该学习和使用的一系列 C++11特性。该语言和标准库中有很多新增功能，本文只是触及了皮毛。但是，我相信其中一些新功能应该成为所有C++开发人员的日常工作。

• 本节目录

unsetunset1、autounsetunset

在C++中，auto是一个关键字，用于进行类型推导。它的引入是为了简化代码并提高可读性。使用auto关键字声明变量时，编译器会根据变量的初始值自动推导出其类型。

下面是auto的一些重要特点和用法：

类型推导： 使用auto关键字可以根据变量的初始值推导出变量的类型。

auto x = 42;            // x的类型为int
auto y = 3.14;          // y的类型为double
auto ptr = new int(5);  // ptr的类型为int*

与模板一起使用： auto特别适用于模板编程，因为它可以自动推导出模板类型。

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

迭代器和范围循环： 在使用迭代器和范围循环时，auto可以简化迭代器的类型声明和范围循环中的迭代变量类型声明。

std::vector<int> vec = {1, 2, 3, 4, 5};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    // 使用 *it 处理迭代器指向的元素
}

for (auto& elem : vec) {
    // 使用 elem 处理容器中的元素
}

结合使用decltype： auto可以与decltype结合使用，以便将一个表达式的类型推导给另一个变量。

auto x = 42;
decltype(x) y; // y的类型为int

函数返回类型推导： 在函数返回类型不确定或依赖于表达式时，可以使用auto来推导函数的返回类型。

auto add(int a, int b) -> decltype(a + b) {
    return a + b;
}

auto关键字的引入使得C++代码更加简洁和灵活，但需要注意的是，过度使用auto可能会降低代码的可读性。因此，应该根据具体情况谨慎使用。

unsetunset2、nullptrunsetunset

在 C++11 中引入了 nullptr，用于表示空指针常量。nullptr 是一个关键字，它代表一个空指针，具有明确的空指针类型，不同于传统的 C++ 中使用 NULL 或 0 表示空指针的方式。

1. 为什么引入 nullptr？

在传统的 C++ 中，空指针可以用 NULL 宏或者字面常量 0 表示。但这种方式存在一些问题，比如：

• 在重载函数或者模板中，如果同时存在参数为指针类型和整数类型的函数，传递 NULL 或 0 可能会导致调用了错误的重载版本。
• NULL 和 0 都可以隐式地转换为整数类型，可能引入一些不符合预期的行为。

为了解决这些问题，C++11 引入了 nullptr，它是一个明确的空指针常量，不具有整数类型，可以显式地表示空指针。

2. 使用示例

int* ptr1 = nullptr;     // 使用 nullptr 初始化指针
int* ptr2 = NULL;         // 合法，但不推荐
int* ptr3 = 0;            // 合法，但不推荐

void func(int* ptr) {
    // Do something
}

int main() {
    func(nullptr);        // 传递 nullptr 给函数
    return 0;
}

3. 特点

• 明确的类型：nullptr 是一个特殊的空指针常量，没有整数类型，而 NULL 和 0 可能会被隐式地转换为整数类型。
• 安全性：在重载函数或者模板中，使用 nullptr 可以避免因为整数类型的隐式转换导致的调用错误的重载版本的问题。
• 语法清晰：使用 nullptr 可以让代码更加清晰明了，表达程序员的意图。

总的来说，nullptr 是 C++11 引入的一个有益的改进，它能够提高代码的可读性和安全性，并且在模板编程和重载函数等场景下尤为有用。因此，建议在新的代码中使用 nullptr 来表示空指针。

unsetunset3、基于范围的for循环unsetunset

C++11引入了基于范围的for循环（Range-based for loop），也称为foreach循环。它是一种简化遍历容器、数组和其他类似数据结构的循环语法。

基于范围的for循环的语法形式如下：

for (declaration : expression) {
    // 循环体
}

其中：

• declaration：在每次循环迭代中，声明一个变量，用于接收容器中的元素。
• expression：表示要遍历的容器、数组或其他可迭代对象。
• 循环体：在每次迭代中执行的操作。

例如，遍历一个数组：

int arr[] = {1, 2, 3, 4, 5};
for (int x : arr) {
    std::cout << x << " ";
}
// 输出：1 2 3 4 5

或者遍历一个容器：

std::vector<int> vec = {1, 2, 3, 4, 5};
for (int x : vec) {
    std::cout << x << " ";
}
// 输出：1 2 3 4 5

在循环体中，x 依次取 expression 中的每个元素的值，而不是索引或指针。这种语法形式简洁清晰，避免了传统for循环中需要显式地使用迭代器或索引的繁琐。

需要注意的是，基于范围的for循环适用于任何支持迭代器（Iterator）的容器，包括STL容器（如vector、list、map等）、数组、字符串等。对于用户自定义类型，可以通过重载迭代器相关操作来支持基于范围的for循环。

unsetunset4、override和finalunsetunset

在 C++11 中，override 和 final 是两个关键字，用于在派生类中重写（override）和禁止重写（final）基类的虚函数。

1. override 关键字

override 关键字用于显式地标记派生类中的成员函数，以指明该函数是对基类中的虚函数的重写。它帮助提高代码的可读性和可维护性，并且可以帮助编译器检查是否正确地重写了基类的虚函数。

class Base {
public:
    virtual void func();
};

class Derived : public Base {
public:
    void func() override; // 显式标记对基类虚函数的重写
};

在派生类中使用 override 关键字，如果没有正确地重写基类中的虚函数，编译器会产生错误。这样可以避免一些常见的错误，如函数签名不匹配等。

2. final 关键字

final 关键字用于修饰类和虚函数，表示禁止派生类继续派生或者禁止派生类重写该虚函数。它可以用于阻止继承层次中的进一步扩展，提高代码的安全性和稳定性。

class Base {
public:
    virtual void func() final; // 表示禁止派生类重写该虚函数
};

class Derived : public Base {
public:
    // 尝试重写 func() 会导致编译错误
    // void func() override; // 错误：无法重写 final 函数
};

同样地，final 关键字也可以用于类的定义，表示该类不能被继承。

class FinalClass final {
    // ...
};

// 尝试继承 FinalClass 会导致编译错误
// class Derived : public FinalClass {}; // 错误：不能继承 final 类

使用 final 关键字可以明确地告诉编译器某个类或者某个虚函数不允许再次派生或者重写，从而帮助提高代码的安全性和稳定性。

unsetunset5、强类型枚举unsetunset

C++11 引入了强类型枚举（Strongly Typed Enumeration），也称为枚举类（Enum Class）。与传统的 C 风格枚举相比，强类型枚举提供了更加类型安全和更加灵活的枚举定义方式。

强类型枚举的定义语法如下：

enum class EnumName {
    Enumerator1,
    Enumerator2,
    // ...
};

其中：

• EnumName 是枚举类型的名称。
• Enumerator1、Enumerator2 等是枚举成员。

与传统的 C 风格枚举相比，强类型枚举有以下特点：

作用域限制： 强类型枚举的作用域受限于枚举类的作用域，因此枚举成员的名称不会污染外部作用域。

默认底层类型是整数： 强类型枚举的底层类型是 int，但可以显式指定底层类型。

enum class EnumName : underlying_type {
    Enumerator1,
    Enumerator2,
    // ...
};

类型安全： 强类型枚举的枚举成员不会隐式地转换为整数，从而提高了类型安全性。

enum class Color {
    Red,
    Green,
    Blue
};

Color c = Color::Red;
int x = static_cast<int>(c); // 编译错误，无法将 Color 类型隐式转换为 int

前置声明： 强类型枚举可以进行前置声明。

enum class Color : int; // 前置声明

强类型枚举在很多方面都比传统的 C 风格枚举更加安全和灵活，因此在现代 C++ 编程中被广泛应用。使用强类型枚举可以减少错误并提高代码的可读性和可维护性。

unsetunset6、智能指针unsetunset

C++11引入了智能指针（Smart Pointers），它们是一种管理动态内存的方式，能够帮助程序员避免内存泄漏和其他内存管理问题。智能指针自动管理内存的生命周期，当不再需要时自动释放所管理的资源，从而减少了手动内存管理的工作量，并提高了程序的安全性和可维护性。

C++11中提供了三种主要的智能指针：

std::unique_ptr： 独占所有权的智能指针。它不能被复制，但可以被移动。当指针超出作用域或被显式释放时，它所管理的资源将被释放。

std::unique_ptr<int> ptr(new int(42));

std::shared_ptr： 共享所有权的智能指针。它可以被多个 std::shared_ptr 实例共享，使用引用计数来管理资源的生命周期。当最后一个指向资源的 std::shared_ptr 被销毁时，资源将被释放。

std::shared_ptr<int> ptr1(new int(42));
std::shared_ptr<int> ptr2 = ptr1;

std::weak_ptr： 弱引用智能指针，它不会增加资源的引用计数。通常用于解决 std::shared_ptr 循环引用的问题。当需要使用资源时，需要先将 std::weak_ptr 转换为 std::shared_ptr。

std::weak_ptr<int> weak_ptr = ptr1;
std::shared_ptr<int> shared_ptr = weak_ptr.lock(); // 获取 shared_ptr

这些智能指针都位于 <memory> 头文件中，并且都是模板类。它们提供了成员函数来访问管理的资源，如 .get()、.reset()、.release() 等。此外，C++标准库还提供了其他智能指针，如 std::auto_ptr（在C++11已弃用）、std::scoped_ptr（C++11之前的实现）、std::unique_ptr的数组版本std::unique_ptr<T[]>等。

智能指针的使用可以有效地管理动态分配的资源，并减少内存泄漏的风险。在编写现代C++代码时，推荐优先使用智能指针而不是裸指针来管理资源。

unsetunset7、匿名函数unsetunset

Lambda表达式是C++11引入的一种新的语法特性，用于创建匿名函数，它提供了一种更加灵活和方便的方式来编写内联的函数对象。Lambda表达式可以作为函数参数传递给STL算法、标准库函数，也可以用于创建函数对象、回调函数等场景。

Lambda表达式的基本语法形式如下：

[capture list] (parameter list) -> return type {
    // 函数体
}

其中：

• capture list：捕获列表，用于指定在lambda表达式中使用的外部变量的方式。可以按值捕获、按引用捕获，也可以使用&表示按引用捕获、=表示按值捕获。
• parameter list：参数列表，与普通函数的参数列表类似。
• return type：返回类型，可以省略，编译器可以根据返回语句自动推断返回类型。
• {}：函数体，与普通函数的函数体类似。

以下是一些示例：

Lambda表达式不捕获任何外部变量，且不带参数和返回类型：

[] {
    std::cout << "Hello, Lambda!" << std::endl;
}();

Lambda表达式带参数和返回类型：

[](int a, int b) -> int {
    return a + b;
}(10, 20);

Lambda表达式捕获外部变量：

int x = 10;
int y = 20;
auto result = [&x, y] {
    return x + y;
}();

使用标准库算法和Lambda表达式：

std::vector<int> vec = {1, 2, 3, 4, 5};
std::for_each(vec.begin(), vec.end(), [](int val) {
    std::cout << val << " ";
});

Lambda表达式的使用使得C++中函数式编程的风格更加灵活和方便，尤其在STL算法、多线程、回调函数等场景下能够大大简化代码，提高代码的可读性和可维护性。

unsetunset8、非成员的 begin() 和 end() 函数unsetunset

在 C++11 中，引入了非成员的 begin() 和 end() 函数，用于获取容器的起始迭代器和结束迭代器，以便与标准库算法和范围-based for 循环一起使用。这些非成员函数使得 STL 容器的使用更加灵活和通用。

1. begin() 和 end() 函数：

这两个函数被定义在 <iterator> 头文件中，它们通常用于访问容器的起始迭代器和结束迭代器，例如：

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

auto start = std::begin(vec); // 获取容器的起始迭代器
auto end = std::end(vec);     // 获取容器的结束迭代器

for (auto it = start; it != end; ++it) {
    std::cout << *it << " ";
}

在这个示例中，std::begin(vec) 返回了 vec 的起始迭代器，std::end(vec) 返回了 vec 的结束迭代器。这使得我们可以轻松地遍历容器，并且不需要担心容器的具体类型。

2. 使用范围-based for 循环：

在 C++11 中，我们还可以使用范围-based for 循环来遍历容器，它自动使用 begin() 和 end() 函数获取容器的迭代器。

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

for (auto& elem : vec) {
    std::cout << elem << " ";
}

在这个例子中，elem 会依次取 vec 中的每个元素的值，而不需要显式地使用迭代器。

这些非成员函数的引入使得代码更加通用，因为它们适用于所有的 STL 容器，包括数组、向量、列表、集合、映射等。此外，它们还可用于用户自定义的容器，只要这些容器提供了符合规范的 begin() 和 end() 成员函数或全局函数。

unsetunset9、static_assert 和 Type Traitsunsetunset

在 C++11 中，static_assert 和类型特征（Type Traits）是两个非常有用的工具，用于在编译时进行静态检查和类型推导。它们提供了一种更加安全和灵活的方式来编写模板代码和通用代码。

1. static_assert：

static_assert 是一个编译时断言，用于在编译时检查某个条件是否成立，如果条件不成立，则会导致编译错误。它的语法形式如下：

static_assert (boolean_expression, "error_message");

其中：

• boolean_expression 是一个在编译时可求值的布尔表达式。
• error_message 是一个字符串字面值，用于在编译错误时输出错误信息。

例如：

static_assert(sizeof(int) == 4, "int must be 32 bits");

这个静态断言会在编译时检查 int 类型的大小是否为 4 字节，如果不是，则会产生编译错误，并输出错误信息。

static_assert 可以用于模板编程、泛型编程中对类型或常量表达式进行静态检查，帮助程序员在编译时发现潜在的问题，提高代码的可靠性和稳定性。

2. 类型特征（Type Traits）：

类型特征是一组用于查询和操纵类型属性的工具，它们通常被定义在 <type_traits> 头文件中。类型特征可以帮助我们在编译时获取和操作类型的属性信息，例如判断某个类型是否是指针类型、是否是整数类型、是否是可调用类型等。

常用的类型特征包括：

• std::is_pointer<T>：判断类型 T 是否是指针类型。
• std::is_integral<T>：判断类型 T 是否是整数类型。
• std::is_callable<T>：判断类型 T 是否是可调用类型（函数对象或函数指针）。
• std::is_same<T, U>：判断类型 T 和 U 是否相同。
• 等等。

例如：

#include <type_traits>

static_assert(std::is_pointer<int*>::value, "int* is not a pointer");
static_assert(std::is_integral<int>::value, "int is not an integral type");
static_assert(std::is_same<int, int>::value, "int is not the same as int");

类型特征可以帮助我们在模板编程中编写更加通用和健壮的代码，根据类型的属性进行编译时的分支选择和静态断言，从而提高代码的可读性和可维护性。

unsetunset10、移动语义unsetunset

C++11引入了移动语义（Move Semantics），是一种用于提高程序性能和资源利用率的重要特性。移动语义允许对象的资源（如内存、文件句柄等）在所有权转移时进行移动而不是复制，从而避免了不必要的深拷贝，提高了程序的效率和性能。

1. 移动语义的背景：

在传统的C++中，对象的赋值和传递通常会进行复制操作，即调用拷贝构造函数或拷贝赋值运算符。对于大型对象或对象包含动态分配的资源，这种复制操作可能会导致昂贵的性能开销，尤其是在函数参数传递和返回值返回时。

2. 右值引用和移动语义：

为了解决上述问题，C++11引入了右值引用（Rvalue Reference）和移动语义。右值引用是一种新的引用类型，用于表示对临时对象或即将销毁的对象的引用。通过右值引用，可以识别出临时对象，并且在这些对象上应用移动语义。

移动语义允许将资源从一个对象转移到另一个对象，而不是复制资源。通过使用移动构造函数和移动赋值运算符，可以避免不必要的深拷贝，提高程序的效率。

3. 移动语义的使用场景：

在容器中插入临时对象： 通过移动语义，可以避免在容器中插入临时对象时进行深拷贝，提高了插入的效率。

std::vector<std::string> vec;
vec.push_back("example"); // 移动临时对象

在函数返回值中使用： 当函数返回一个临时对象时，可以通过移动语义避免不必要的复制。

std::string create_string() {
    std::string str = "example";
    return str; // 返回临时对象，触发移动语义
}

在对象间转移资源： 当需要将资源从一个对象转移到另一个对象时，可以使用移动语义，避免昂贵的深拷贝。

std::unique_ptr<int> ptr1(new int(42));
std::unique_ptr<int> ptr2 = std::move(ptr1); // 转移指针资源

4. 移动语义的实现：

为了支持移动语义，需要在类中定义移动构造函数和移动赋值运算符，并在这些函数中执行资源的转移操作。同时，也需要标记需要移动的对象为右值引用。

class MyObject {
public:
    MyObject() {}
    MyObject(MyObject&& other) noexcept {
        // 转移资源，如指针、文件句柄等
    }
    MyObject& operator=(MyObject&& other) noexcept {
        if (this != &other) {
            // 释放当前资源
            // 转移资源，如指针、文件句柄等
        }
        return *this;
    }
};

通过移动语义，可以避免不必要的深拷贝，提高了程序的性能和效率。然而，需要注意的是，移动操作可能会导致源对象的状态被修改或清空，因此需要在移动后确保源对象处于一个合理的状态。