C++ 11

介绍

本文将以背景、定义、作用、示例代码、实用技巧、注意事项的框架来介绍每个新特性，只有了解每个特性的背景、作用，我们才能知道为什么会推出这个新特性，它解决了什么问题，给出的示例代码加深理解，最后是使用新特性需要注意的事项。

C++11包括以下新的语言特性：

• 移动语义
• 可变参数模板
• 右值引用
• 转发引用
• 初始化列表
• 静态断言
• auto关键字
• lambda表达式
• decltype关键字
• 类型别名
• nullptr
• 强类型枚举
• 属性
• constexpr关键字
• 委托构造函数
• 用户定义的字面量
• 显式虚函数重载
• final说明符
• 默认函数
• 已删除函数
• 基于范围的for循环
• 用于移动语义的特殊成员函数
• 转换构造函数
• 显式转换函数
• 内联命名空间
• 非静态数据成员初始化器
• 右尖括号
• 引用限定成员函数
• 尾返回类型
• noexcept说明符
• char32_t和char16_t
• 原始字符串字面量

C++11包括以下新的库特性：

• std::move
• std::forward
• std::thread
• std::to_string
• 类型特性
• 智能指针
• std::chrono
• 元组
• std::tie
• std::array
• 无序容器
• std::make_shared
• std::ref
• 内存模型
• std::async
• std::begin/end

C++11语言特性

移动语义

背景

在C++98标准中，当对象被赋值或传递时，通常会进行深拷贝。这种深拷贝操作会造成不必要的性能开销，尤其是对于包含大量数据的对象。C++11引入移动语义，通过引入右值引用（rvalue references），解决了深拷贝导致的性能问题。

定义

移动语义通过右值引用实现，它允许对象的资源从一个对象转移到另一个对象，而不是进行拷贝。右值引用使用&&语法表示。

int &&rref = 42; // 42是一个右值，rref是一个右值引用

作用

移动语义的主要作用是避免不必要的深拷贝，提高程序性能。它特别适用于涉及大量数据的类对象，如容器类（std::vector, std::string等）。通过移动语义，可以将数据的所有权转移到新的对象，而不是复制数据。

示例代码

下面是一个简单的例子，展示了如何使用移动语义：

#include <iostream>
#include <vector>

class MoveableClass {
public:
    std::vector<int> data;
    
    // 默认构造函数
    MoveableClass() : data(1000000) { }
    
    // 移动构造函数
    MoveableClass(MoveableClass&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Move constructor called\n";
    }
    
    // 移动赋值运算符
    MoveableClass& operator=(MoveableClass&& other) noexcept {
        if (this != &other) {
            data = std::move(other.data);
            std::cout << "Move assignment operator called\n";
        }
        return *this;
    }
};

int main() {
    MoveableClass obj1;
    MoveableClass obj2 = std::move(obj1); // 触发移动构造函数
    MoveableClass obj3;
    obj3 = std::move(obj2); // 触发移动赋值运算符
    return 0;
}

在这个例子中，MoveableClass包含一个大数据成员data。移动构造函数和移动赋值运算符使用std::move将数据的所有权转移，而不是复制数据。

实用技巧

1. 优先考虑移动语义：在实现资源管理类时，优先实现移动构造函数和移动赋值运算符。
2. 使用std::move：当你明确知道某个对象不再需要时，可以使用std::move将其转换为右值，以触发移动语义。
3. 防止悬挂引用：在使用右值引用时，确保不会产生悬挂引用，避免访问已经被转移的资源。

注意事项

1. 右值引用和左值引用的区别：右值引用（T&&）只能绑定到右值，而左值引用（T&）只能绑定到左值。不要混淆二者。
2. std::move并不移动：std::move只是一个类型转换，将左值转换为右值。实际的移动操作由移动构造函数和移动赋值运算符完成。
3. 资源的有效状态：移动后的对象应处于有效但未定义的状态，确保在移动操作后不再使用被移动的对象。

右值引用

背景

在C++98标准中，对象赋值和传递时往往需要进行深拷贝操作，这会导致性能瓶颈。特别是对于大对象或包含大量数据的对象，频繁的拷贝操作会显著影响效率。为了解决这一问题，C++11引入了右值引用，配合移动语义使用，减少不必要的拷贝操作，从而提升性能。

定义

右值引用是一种可以绑定到右值（临时对象或即将销毁的对象）的引用类型。右值引用的语法为T&&，其中T是某种数据类型。与传统的左值引用（T&）不同，右值引用专门用于捕获右值。

int &&rref = 42; // 42是一个右值，rref是一个右值引用

作用

右值引用的主要作用包括：

1. 实现移动语义：通过右值引用，可以实现对象资源的转移，而不是进行深拷贝，从而提高性能。
2. 完美转发：右值引用与模板结合，可以实现完美转发（perfect forwarding），即将函数参数无损地传递给另一个函数。

示例代码

以下示例展示了右值引用的基本用法和其在移动构造函数与移动赋值运算符中的应用：

#include <iostream>
#include <vector>

class MoveableClass {
public:
    std::vector<int> data;
    
    // 默认构造函数
    MoveableClass() : data(1000000) { }
    
    // 移动构造函数
    MoveableClass(MoveableClass&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Move constructor called\n";
    }
    
    // 移动赋值运算符
    MoveableClass& operator=(MoveableClass&& other) noexcept {
        if (this != &other) {
            data = std::move(other.data);
            std::cout << "Move assignment operator called\n";
        }
        return *this;
    }
};

int main() {
    MoveableClass obj1;
    MoveableClass obj2 = std::move(obj1); // 触发移动构造函数
    MoveableClass obj3;
    obj3 = std::move(obj2); // 触发移动赋值运算符
    return 0;
}

实用技巧

1. 使用std::move：当你希望将对象作为右值传递时，可以使用std::move将其转换为右值引用。
2. 实现移动构造和移动赋值：在自定义类中，实现移动构造函数和移动赋值运算符，以充分利用右值引用的性能优势。
3. 避免不必要的拷贝：在函数返回值或传递参数时，尽量使用右值引用，避免不必要的拷贝操作。

注意事项

1. 右值引用与左值引用的区别：右值引用只能绑定到右值，而左值引用只能绑定到左值。在实现函数重载时，需要注意区分二者。
2. std::move并不移动：std::move只是将左值转换为右值引用，实际的移动操作需要依赖移动构造函数或移动赋值运算符。
3. 移动后的对象状态：使用右值引用后，被移动的对象应处于有效但未定义的状态，避免在未处理的情况下继续使用被移动的对象。
4. 完美转发中的陷阱：在使用右值引用实现完美转发时，需要注意参数的类型匹配，避免误用导致的编译错误或性能问题。

转发引用

背景

在C++98中，模板参数的传递和处理存在一定的局限性，特别是当需要在模板函数中处理左值和右值时，编写代码变得复杂且冗长。C++11引入转发引用，通过类型推导和完美转发的结合，简化了模板函数中参数的传递和处理，提升了代码的灵活性和性能。

定义

转发引用是指在模板中，通过类型推导得到的右值引用。具体来说，当模板参数使用T&&形式且通过类型推导（而非显式指定）得到时，该引用即为转发引用。

template<typename T>
void func(T&& param); // param是转发引用

作用

转发引用的主要作用包括：

1. 完美转发：可以将参数无损地转发给其他函数，保留参数的左值或右值属性。
2. 简化泛型编程：通过类型推导和转发引用，简化了泛型编程中参数传递的代码编写。

示例代码

以下是一个使用转发引用实现完美转发的示例：

#include <iostream>
#include <utility>

// 目标函数，接收左值引用
void target(int& x) {
    std::cout << "Left value reference\n";
}

// 目标函数，接收右值引用
void target(int&& x) {
    std::cout << "Right value reference\n";
}

// 泛型转发函数
template<typename T>
void forwarder(T&& arg) {
    target(std::forward<T>(arg)); // 使用std::forward实现完美转发
}

int main() {
    int a = 10;
    forwarder(a);         // 输出：Left value reference
    forwarder(20);        // 输出：Right value reference
    forwarder(std::move(a)); // 输出：Right value reference
    return 0;
}

实用技巧

1. 使用std::forward：在转发引用中，应使用std::forward进行参数转发，以保留参数的左值或右值属性。
2. 结合std::move使用：在需要将左值转换为右值时，可以结合std::move使用，但要注意不要过度使用，避免错误地转移资源。
3. 模板参数类型推导：在使用转发引用时，尽量依赖模板参数的类型推导，避免显式指定参数类型。

注意事项

1. 区分转发引用与普通右值引用：转发引用是通过类型推导得到的右值引用，而普通右值引用则是显式指定的T&&类型。不要混淆二者。
2. 避免悬挂引用：在使用转发引用时，确保不会产生悬挂引用，特别是在转发资源时，要确保被转发的对象在其生命周期内不会被销毁。
3. 正确使用std::forward：在实现完美转发时，一定要使用std::forward，而不是std::move，以确保参数的左值或右值属性得以保留。
4. 警惕隐式类型转换：在使用转发引用时，注意隐式类型转换可能导致的问题，确保参数类型与目标函数参数类型匹配。

可变参数模板

背景

在C++98中，编写接受可变数量参数的模板函数或类非常困难，需要通过递归继承等复杂技巧实现。C++11引入可变参数模板，简化了这种需求的实现，提升了模板编程的灵活性和表达能力。

定义

可变参数模板允许模板接受可变数量的模板参数。使用…语法来定义和展开参数包。

template<typename... Args>
void func(Args... args);

在上述定义中，Args…表示一个模板参数包，而args…表示一个函数参数包。

作用

可变参数模板的主要作用包括：

1. 支持任意数量的参数：允许函数或类接受任意数量和类型的参数。
2. 简化代码：通过模板参数包，可以避免复杂的递归继承，简化代码编写。
3. 实现灵活的泛型编程：可变参数模板使得泛型编程更加灵活，可以更方便地实现元编程等高级功能。

示例代码

以下示例展示了一个简单的可变参数模板函数，它可以接受任意数量的参数并将它们打印出来：

#include <iostream>

// 基础模板函数，不接受任何参数
void print() {
    std::cout << "End of parameter list\n";
}

// 可变参数模板函数，接受任意数量的参数
template<typename T, typename... Args>
void print(T first, Args... args) {
    std::cout << first << std::endl;
    print(args...); // 递归调用自身，展开参数包
}

int main() {
    print(1, 2.5, "Hello, world!", 'a');
    return 0;
}

在这个例子中，print函数接受任意数量和类型的参数，并递归展开参数包进行打印。

实用技巧

1. 递归展开参数包：通过递归调用函数，可以逐步展开并处理参数包中的每一个参数。
2. 使用sizeof…获取参数数量：sizeof…(Args)可以用来获取参数包中参数的数量。
3. 结合std::forward实现完美转发：在可变参数模板中，结合std::forward可以实现参数的完美转发。

注意事项

1. 递归终止条件：在使用递归展开参数包时，确保有一个基础模板函数作为递归终止条件，否则会导致无限递归。
2. 参数包展开顺序：在展开参数包时，注意参数的顺序，以确保正确处理参数。
3. 编译器支持：确保使用支持C++11及以上标准的编译器，因为可变参数模板是C++11引入的新特性。
4. 避免过度复杂的递归：尽量避免编写过于复杂的递归模板代码，以保持代码的可读性和可维护性。

初始化列表

背景

在C++98标准中，对象的初始化有多种方式，语法上不统一，使用起来也较为繁琐。例如，数组初始化和STL容器初始化方式不同。为了解决这些问题，C++11引入了初始化列表，使初始化方式更加统一和简洁。

定义

初始化列表允许使用大括号{}来统一初始化对象。它的实现依赖于std::initializer_list类模板。

std::initializer_list<int> init_list = {1, 2, 3, 4};

作用

初始化列表的主要作用包括：

1. 统一初始化语法：使用统一的语法来初始化数组、容器和自定义类型。
2. 简化代码：使对象的初始化更加直观和简洁。
3. 提高代码的可读性：通过初始化列表，代码变得更易读，减少了错误的可能性。

示例代码

以下示例展示了如何使用初始化列表来初始化各种类型的对象：

#include <iostream>
#include <vector>
#include <initializer_list>

// 自定义类，支持初始化列表
class MyClass {
public:
    std::vector<int> data;
    
    MyClass(std::initializer_list<int> init_list) : data(init_list) {
        std::cout << "MyClass initialized with initializer list\n";
    }
    
    void print() {
        for (int i : data) {
            std::cout << i << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    // 使用初始化列表初始化STL容器
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    
    // 使用初始化列表初始化自定义类
    MyClass obj = {6, 7, 8, 9, 10};
    obj.print();
    
    return 0;
}

在这个例子中，我们展示了如何使用初始化列表初始化std::vector和自定义类MyClass。

实用技巧

1. 使用统一的初始化语法：尽量使用初始化列表进行对象初始化，提高代码的可读性和一致性。
2. 结合std::initializer_list：在自定义类中，定义接受std::initializer_list参数的构造函数，支持初始化列表。
3. 初始化STL容器：初始化列表特别适用于初始化STL容器，如std::vector, std::map, std::set等。

注意事项

1. 优先级问题：在某些情况下，初始化列表可能与其他构造函数发生冲突，导致编译器无法确定调用哪个构造函数。需要注意避免此类问题。
2. 性能问题：尽管初始化列表使代码更加简洁，但在某些情况下可能会引入额外的拷贝操作，影响性能。要根据具体情况选择最优的初始化方式。
3. 列表初始化和赋值：注意区分列表初始化和赋值操作，避免在使用过程中混淆。

静态断言

背景

在C++98中，断言（assert）通常是在运行时进行的，这意味着只有在程序运行时才能发现某些错误。对于一些可以在编译时检查的条件，如果能在编译时捕获错误，将极大地提高程序的可靠性，并减少调试时间。C++11引入静态断言，允许开发者在编译时验证程序的某些条件，避免运行时错误。

定义

静态断言使用static_assert关键字，它在编译时检查一个常量表达式。如果表达式为false，编译器会生成错误信息并终止编译。static_assert有两种形式：

static_assert(condition, message); // 带消息的静态断言
static_assert(condition); // 不带消息的静态断言

作用

静态断言的主要作用包括：

1. 编译时错误检查：在编译时检查程序中的某些条件，避免运行时错误。
2. 增强代码安全性：通过早期发现错误，增强代码的安全性和可靠性。
3. 文档化代码意图：通过静态断言，可以明确代码的假设和前提条件，提高代码的可读性。

示例代码

以下示例展示了如何使用静态断言进行编译时检查：

#include <type_traits>

// 静态断言示例
template<typename T>
void checkType() {
    // 检查T是否为整数类型
    static_assert(std::is_integral<T>::value, "Template parameter must be an integral type");
}

int main() {
    checkType<int>(); // 编译通过
    // checkType<double>(); // 编译错误：Template parameter must be an integral type

    // 另一个静态断言示例
    static_assert(sizeof(int) == 4, "int size is not 4 bytes");

    return 0;
}

在这个例子中，checkType模板函数使用静态断言检查模板参数是否为整数类型。在main函数中，checkType<int>编译通过，而checkType<double>则会导致编译错误。

实用技巧

1. 检查类型特性：使用静态断言可以在编译时检查类型特性，例如类型是否为整数、是否为指针等。
2. 验证编译时常量：在编译时验证常量表达式，例如数组大小、类型大小等。
3. 防御性编程：通过静态断言，在编译时捕获潜在的编程错误，提高代码的健壮性。

注意事项

1. 编译器支持：确保使用支持C++11及以上标准的编译器，因为静态断言是C++11引入的新特性。
2. 错误消息的清晰性：在使用带消息的静态断言时，确保错误消息简明扼要，便于理解和调试。
3. 常量表达式：静态断言的条件必须是一个常量表达式，否则编译器无法在编译时进行检查。

auto关键字

背景

在C++98标准中，声明变量时必须显式指定变量类型。对于简单类型，如int或double，这并不是一个问题，但对于复杂的模板类型，显式指定类型可能会导致代码冗长且难以维护。为了解决这一问题，C++11引入了auto关键字，允许编译器自动推导变量的类型。

定义

auto关键字用于根据初始化表达式自动推导变量的类型。编译器根据赋值表达式的类型确定变量的类型。

auto var = expr; // var的类型由expr的类型推导得出

作用

auto关键字的主要作用包括：

1. 简化代码：通过自动类型推导，减少显式指定类型的冗长代码，使代码更加简洁。
2. 提高可读性：尤其在处理复杂类型时，auto可以提高代码的可读性和可维护性。
3. 适应泛型编程：在模板编程中，auto关键字非常有用，可以自动推导出返回值类型，简化函数定义。

示例代码

以下示例展示了auto关键字的基本用法：

#include <iostream>
#include <vector>
#include <map>
#include <string>

int main() {
    // 自动推导简单类型
    auto x = 42; // x的类型是int
    auto y = 3.14; // y的类型是double
    auto z = "Hello, World!"; // z的类型是const char*

    std::cout << x << ", " << y << ", " << z << std::endl;

    // 自动推导复杂类型
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 在泛型编程中的应用
    std::map<std::string, int> myMap = {{"one", 1}, {"two", 2}, {"three", 3}};
    for (auto& [key, value] : myMap) {
        std::cout << key << ": " << value << std::endl;
    }

    return 0;
}

实用技巧

1. 使用auto简化迭代器声明：在STL容器中，迭代器类型通常较为复杂，使用auto可以简化迭代器的声明。
2. 结合decltype使用：在某些情况下，可以结合decltype关键字，获取表达式的类型。
3. 用于返回类型推导：在C++14中，可以在函数返回类型中使用auto进行类型推导，使泛型编程更加灵活。

注意事项

1. 类型清晰性：虽然auto可以简化代码，但在某些情况下，显式指定类型更能提高代码的清晰性和可读性。特别是在变量类型对理解代码逻辑至关重要时，应避免滥用auto。
2. 避免混淆：在使用auto时，确保推导出的类型符合预期，避免因类型推导导致的意外行为。例如，auto在推导数组类型时，会推导为指针类型。
3. 不适用场景：auto不能用于函数参数类型和类成员变量的声明中，应该仅用于局部变量或函数返回类型。

lambda表达式

Lambda表达式是C++11引入的一项新特性，旨在提供一种简洁的方式来定义和使用匿名函数。以下从背景、定义、作用、示例代码、实用技巧和注意事项等几个方面详细介绍Lambda表达式。

背景

在C++98中，函数对象和仿函数通常用于定义和传递短小的可执行代码片段。然而，这种方法需要定义额外的类和运算符重载，显得冗长且不直观。为了简化这一过程，C++11引入了Lambda表达式，使得定义匿名函数变得更加简单和易读。

定义

Lambda表达式是一种内联的匿名函数，其语法如下：

[capture](parameters) -> return_type { body }

• capture：捕获外部变量的方式，可以是按值捕获或按引用捕获。
• parameters：函数参数列表。
• return_type：函数的返回类型（可选，可以通过类型推导确定）。
• body：函数体，包含要执行的代码。

作用

Lambda表达式的主要作用包括：

1. 简化代码：使得在需要定义临时函数时，不必定义额外的类或函数。
2. 增强可读性：通过在代码中直接嵌入函数逻辑，提高代码的可读性和可维护性。
3. 便于STL算法使用：在使用STL算法时，Lambda表达式可以作为简洁的回调函数。

示例代码

以下示例展示了Lambda表达式的基本用法：

#include <iostream>
#include <vector>
#include <algorithm>

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

    // 使用Lambda表达式打印元素
    std::for_each(vec.begin(), vec.end(), [](int x) {
        std::cout << x << " ";
    });
    std::cout << std::endl;

    // 使用Lambda表达式计算和
    int sum = 0;
    std::for_each(vec.begin(), vec.end(), [&sum](int x) {
        sum += x;
    });
    std::cout << "Sum: " << sum << std::endl;

    // 使用Lambda表达式对元素进行排序
    std::sort(vec.begin(), vec.end(), [](int a, int b) {
        return b < a; // 降序排序
    });
    std::for_each(vec.begin(), vec.end(), [](int x) {
        std::cout << x << " ";
    });
    std::cout << std::endl;

    return 0;
}

实用技巧

1. 捕获外部变量：Lambda表达式可以捕获外部变量，按值捕获使用[=]，按引用捕获使用[&]。可以混合使用具体变量的捕获，例如[=, &x]表示按值捕获其他变量，但按引用捕获x。
2. 省略返回类型：如果Lambda表达式的返回类型可以从函数体自动推导出来，可以省略返回类型。
3. 用于STL算法：Lambda表达式非常适合用于STL算法，如std::for_each, std::sort, std::find_if等，使代码更加简洁。

注意事项

1. 捕获列表的副作用：捕获列表中使用引用捕获时，需要确保外部变量在Lambda表达式的整个生命周期内有效，避免悬挂引用。
2. Lambda表达式的可读性：虽然Lambda表达式简洁，但过度使用复杂的Lambda表达式可能会降低代码的可读性，应该平衡简洁性和可读性。
3. 性能考虑：在性能关键的代码中，应该注意Lambda表达式的捕获方式对性能的影响，特别是在频繁调用时，按值捕获可能会导致不必要的拷贝。

decltype关键字

背景

在C++98中，确定一个复杂表达式的类型可能非常困难，尤其是在泛型编程中。为了解决这一问题，C++11引入了decltype关键字，使得开发者可以轻松地获取表达式的类型，从而编写更加简洁和灵活的代码。

定义

decltype关键字用于推导表达式的类型。编译器会根据给定表达式的类型，确定decltype所表示的类型。

decltype(expression) var;

作用

decltype关键字的主要作用包括：

1. 自动推导类型：可以自动推导复杂表达式的类型，避免手动指定类型的繁琐和错误。
2. 结合auto使用：与auto关键字结合使用，可以增强类型推导的灵活性。
3. 在模板编程中使用：在泛型编程中，decltype可以用于推导返回值类型和中间变量类型，使模板代码更加通用。

示例代码

以下示例展示了decltype关键字的基本用法：

#include <iostream>
#include <vector>

int main() {
    int x = 42;
    double y = 3.14;
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用decltype推导变量类型
    decltype(x) a = x; // a的类型是int
    decltype(y) b = y; // b的类型是double
    decltype(vec[0]) c = vec[0]; // c的类型是int&

    std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;

    // 在模板中使用decltype
    auto lambda = [](auto&& container) -> decltype(container.size()) {
        return container.size();
    };

    std::cout << "Vector size: " << lambda(vec) << std::endl;

    return 0;
}

实用技巧

1. 推导复杂表达式类型：使用decltype可以轻松推导出复杂表达式的类型，例如函数调用的返回类型。
2. 结合auto使用：在变量声明时，先用auto推导类型，再用decltype确认类型。例如，auto var = expr; decltype(var) another_var = expr2;。
3. 用作返回类型：在模板函数中，可以用decltype推导返回类型，使得函数更通用。

注意事项

1. 区别于auto：auto用于根据初始化表达式推导变量的类型，而decltype直接根据表达式推导类型，不需要初始化表达式。
2. 推导规则：decltype的推导规则与auto不同。decltype保留表达式的引用性和常量性，例如decltype(x)和decltype((x))的推导结果可能不同。
3. 避免过度使用：虽然decltype很强大，但过度使用可能会使代码变得晦涩难懂。应在确实需要类型推导时使用，避免滥用。

类型别名

背景

在C++98中，使用typedef关键字定义类型别名。然而，typedef存在一些局限性，尤其是在模板编程中，定义模板类型别名显得繁琐且不直观。C++11引入using关键字，用于定义类型别名，简化了类型定义过程。

定义

C++11引入的类型别名使用using关键字，其语法如下：

using alias = existing_type;

这种语法不仅简洁，而且在模板编程中更加灵活和直观。

作用

类型别名的主要作用包括：

1. 简化类型定义：通过定义类型别名，可以简化复杂类型的定义，提高代码的可读性。
2. 增强模板编程灵活性：在模板编程中，类型别名使得模板参数和返回类型定义更加直观。
3. 提高代码可维护性：使用类型别名，可以避免直接使用复杂类型，增强代码的可维护性和一致性。

示例代码

以下示例展示了如何使用类型别名：

#include <iostream>
#include <vector>
#include <map>

// 简化复杂类型定义
using Vec = std::vector<int>;
using Map = std::map<std::string, int>;

// 定义模板类型别名
template<typename T>
using VecT = std::vector<T>;

int main() {
    // 使用类型别名
    Vec v = {1, 2, 3, 4, 5};
    for (const auto& elem : v) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    Map m = {{"one", 1}, {"two", 2}, {"three", 3}};
    for (const auto& [key, value] : m) {
        std::cout << key << ": " << value << std::endl;
    }

    // 使用模板类型别名
    VecT<double> v_double = {1.1, 2.2, 3.3};
    for (const auto& elem : v_double) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

实用技巧

1. 简化复杂类型：对于复杂的模板类型，可以定义类型别名，以简化类型声明。
2. 模板类型别名：在模板编程中，类型别名可以使模板参数和返回类型更加简洁和直观。
3. 结合现代C++特性：类型别名可以与其他现代C++特性结合使用，如decltype、auto等，进一步增强代码的灵活性。

注意事项

1. 与typedef区别：using和typedef都可以定义类型别名，但using在模板编程中更具优势。尽量使用using代替typedef。
2. 代码可读性：虽然类型别名可以简化类型声明，但过度使用可能导致代码难以理解。应在保证代码可读性的前提下使用类型别名。
3. 命名冲突：在大型代码库中，注意避免类型别名命名冲突，保持命名的一致性和规范性。

nullptr

背景

在C++98中，使用NULL表示空指针。然而，NULL通常被定义为0，这可能导致一些模棱两可的情况，特别是在函数重载和模板编程中。为了引入一个更加明确且类型安全的空指针表示法，C++11引入了nullptr。

定义

nullptr 是一个类型为std::nullptr_t的常量。std::nullptr_t 是一个新引入的类型，专门用于表示空指针。

std::nullptr_t null_pointer = nullptr;

作用

nullptr 的主要作用包括：

1. 明确表示空指针：使用nullptr可以明确表示一个指针为空，避免了NULL可能导致的歧义。
2. 类型安全：nullptr 是类型安全的，不会被误解为整数类型0，避免了类型混淆。
3. 函数重载：在函数重载时，nullptr 可以帮助选择正确的重载函数，提高代码的可读性和安全性。

示例代码

以下示例展示了nullptr的基本用法：

#include <iostream>

// 重载函数示例
void f(int* p) {
    std::cout << "Pointer overload\n";
}

void f(int n) {
    std::cout << "Integer overload\n";
}

int main() {
    int* ptr = nullptr;
    f(ptr); // 调用f(int* p)

    // 如果使用NULL，会调用f(int)，因为NULL通常被定义为0
    f(NULL); // 这可能会导致意外的重载选择
    // 正确的做法是使用nullptr来明确表示空指针
    f(nullptr); // 调用f(int* p)

    return 0;
}

实用技巧

1. 使用nullptr替代NULL：在所有需要表示空指针的地方，使用nullptr替代NULL，以获得更好的类型安全性和可读性。
2. 在模板中使用nullptr：在模板编程中，使用nullptr可以避免类型混淆，提高代码的通用性和安全性。
3. 避免整数混淆：使用nullptr可以避免将NULL解释为整数类型0，减少函数重载和模板推导中的歧义。

注意事项

1. nullptr与NULL的区别：虽然nullptr和NULL都可以表示空指针，但nullptr是类型安全的，而NULL在某些情况下可能被解释为整数0。
2. 兼容性问题：在使用旧版C++标准编写的代码中，NULL仍然被广泛使用。在维护旧代码时，可以逐步替换为nullptr。
3. 与其他指针类型的比较：nullptr可以与任何指针类型进行比较，而不会产生类型不匹配的错误。

强类型枚举

背景

在C++98中，枚举类型（enum）存在一些问题，如作用域污染和类型不安全。枚举常量被提升为整数类型，可能会导致意外的类型转换和比较操作。为了解决这些问题，C++11引入了强类型枚举，使枚举类型更加安全和易于管理。

定义

强类型枚举使用enum class或enum struct关键字定义，其语法如下：

enum class EnumName { enumerator1, enumerator2, enumerator3 };

强类型枚举与普通枚举的主要区别在于：

1. 作用域：枚举常量在枚举类型的作用域内，不会污染全局命名空间。
2. 类型安全：枚举类型不会隐式转换为整数类型，需要显式转换。

作用

强类型枚举的主要作用包括：

1. 增强类型安全性：避免隐式类型转换，防止枚举类型与整数类型混用。
2. 作用域管理：枚举常量在枚举类型的作用域内，避免命名冲突。
3. 代码可读性：通过限定作用域和强类型，增强代码的可读性和可维护性。

示例代码

以下示例展示了强类型枚举的基本用法：

#include <iostream>

enum class Color { Red, Green, Blue };
enum class TrafficLight { Red, Yellow, Green };

int main() {
    Color color = Color::Red;
    TrafficLight light = TrafficLight::Green;

    // 需要显式转换为整数类型
    if (static_cast<int>(color) == static_cast<int>(light)) {
        std::cout << "Color and TrafficLight are equal\n";
    } else {
        std::cout << "Color and TrafficLight are not equal\n";
    }

    // 使用switch语句处理强类型枚举
    switch (color) {
        case Color::Red:
            std::cout << "Color is Red\n";
            break;
        case Color::Green:
            std::cout << "Color is Green\n";
            break;
        case Color::Blue:
            std::cout << "Color is Blue\n";
            break;
    }

    return 0;
}

实用技巧

1. 使用enum class或enum struct：优先使用强类型枚举来定义枚举类型，增强类型安全性。
2. 显式转换：在需要将强类型枚举转换为整数类型时，使用static_cast进行显式转换。
3. 结合命名空间使用：可以结合命名空间使用强类型枚举，进一步管理枚举常量的作用域。

注意事项

1. 与普通枚举的区别：强类型枚举不能隐式转换为整数类型，需要显式转换，这可能需要对现有代码进行调整。
2. 枚举类型比较：强类型枚举不同类型之间不能直接比较，需要显式转换为相同类型进行比较。
3. 初始化列表：在使用强类型枚举进行数组初始化时，确保使用static_cast进行类型转换。

属性

背景

在C++98中，编译器和开发者之间缺乏标准化的方式来传达一些额外的信息，如优化提示、诊断信息等。不同的编译器使用不同的扩展语法来支持这些特性，这导致了代码的可移植性和一致性问题。C++11引入了标准化的属性语法，以统一的方式传递这些信息。

定义

C++11的属性使用双方括号[[...]]语法来定义：

[[attribute1, attribute2, ...]]

属性可以用于函数、变量、类型、语句等不同的上下文。

作用

属性的主要作用包括：

1. 编译器优化：向编译器传达优化信息，帮助编译器生成更高效的代码。
2. 诊断和警告：启用或禁用特定的编译器警告，增强代码的健壮性。
3. 代码分析：为代码分析工具提供额外的信息，帮助发现潜在的问题。

示例代码

以下是几个常用属性的示例：

1. [[noreturn]]：指示函数不返回。

#include <iostream>
#include <cstdlib>

[[noreturn]] void exit_with_error(const char* msg) {
    std::cerr << "Error: " << msg << std::endl;
    std::exit(EXIT_FAILURE);
}

int main() {
    // 调用exit_with_error函数
    exit_with_error("Something went wrong!");
    // 这行代码永远不会被执行
    return 0;
}

1. [[deprecated]]：标记废弃的函数或变量，使用时会产生警告。

[[deprecated("Use new_function instead")]]
void old_function() {
    std::cout << "This function is deprecated." << std::endl;
}

void new_function() {
    std::cout << "This is the new function." << std::endl;
}

int main() {
    old_function(); // 使用时会产生警告
    new_function();
    return 0;
}

1. [[maybe_unused]]：防止编译器对未使用的变量产生警告。

int main() {
    [[maybe_unused]] int unused_var = 42; // 防止未使用警告
    return 0;
}

实用技巧

1. 用于函数优化：在性能关键的代码中，使用[[noreturn]]、[[likely]]、[[unlikely]]等属性，帮助编译器进行优化。
2. 管理代码弃用：使用[[deprecated]]属性标记旧代码，帮助开发者逐步迁移到新实现。
3. 防止未使用警告：在需要保留但暂时未使用的代码部分，使用[[maybe_unused]]属性避免编译器警告。

注意事项

1. 编译器支持：不同的编译器对属性的支持程度可能不同，确保使用的编译器支持C++11标准的属性语法。
2. 属性作用范围：属性的作用范围取决于其应用的位置，理解每个属性的适用范围非常重要。
3. 属性组合：多个属性可以组合使用，但应确保它们的组合不会产生冲突或意外行为。

constexpr关键字

背景

在C++98中，常量表达式只能使用预处理器宏或const关键字定义，这在某些情况下不够灵活。例如，const变量的初始化表达式必须是编译时常量，而不能是运行时计算的结果。C++11引入constexpr关键字，允许在编译时进行更复杂的计算，并使得代码更加简洁和高效。

定义

constexpr用于修饰变量、函数和构造函数，以指示这些实体可以在编译时求值。其语法如下：

constexpr type identifier = value; // 用于变量
constexpr return_type function_name(parameters) { /* body */ } // 用于函数

作用

constexpr的主要作用包括：

1. 编译时常量计算：允许在编译时计算复杂的表达式，提高运行时性能。
2. 增强类型安全：通过在编译时验证常量表达式，减少运行时错误。
3. 简化代码：通过在编译时求值，减少运行时计算的需求，使代码更加简洁和高效。

示例代码

以下是一些使用constexpr的示例：

1. 定义常量变量：

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

constexpr int value = square(5); // 编译时计算

1. 用于常量表达式的函数：

#include <iostream>

constexpr int factorial(int n) {
    return (n <= 1) ? 1 : (n * factorial(n - 1));
}

int main() {
    constexpr int result = factorial(5); // 编译时计算
    std::cout << "Factorial of 5 is: " << result << std::endl;
    return 0;
}

1. 用于类的构造函数：

class Point {
public:
    constexpr Point(double x, double y) : x_(x), y_(y) {}
    constexpr double x() const { return x_; }
    constexpr double y() const { return y_; }
private:
    double x_, y_;
};

int main() {
    constexpr Point p(3.0, 4.0);
    constexpr double x = p.x();
    constexpr double y = p.y();
    std::cout << "Point: (" << x << ", " << y << ")" << std::endl;
    return 0;
}

实用技巧

1. 结合常量表达式使用：constexpr函数可以与常量表达式结合使用，以实现更复杂的编译时计算。
2. 简化运行时计算：将常用的复杂计算转移到编译时，以提高运行时性能。
3. 验证常量表达式：使用constexpr确保某些表达式在编译时就能被验证，提高代码的安全性和稳定性。

注意事项

1. constexpr函数限制：constexpr函数的主体必须包含一个返回语句，且不能包含任何可能在运行时执行的语句，如循环、动态内存分配等。
2. 编译器支持：确保使用支持C++11标准的编译器，因为constexpr是C++11引入的新特性。
3. 递归限制：在使用递归constexpr函数时，注意编译器可能会对递归深度有限制，导致编译错误。

委托构造函数

背景

在C++98中，如果一个类有多个构造函数，这些构造函数通常会包含重复的初始化代码。这不仅增加了代码的复杂性，也增加了维护成本。为了简化这一过程，C++11引入了委托构造函数，使一个构造函数能够调用另一个构造函数，以减少代码重复。

定义

委托构造函数是指一个构造函数可以调用同一个类中的另一个构造函数，以实现代码复用。其语法如下：

class ClassName {
public:
    ClassName(parameters) : ClassName(other_parameters) {
        // Additional initialization code (if any)
    }
    ClassName(other_parameters) {
        // Initialization code
    }
};

作用

委托构造函数的主要作用包括：

1. 减少代码重复：通过在一个构造函数中调用另一个构造函数，避免重复的初始化代码。
2. 简化构造函数实现：使构造函数的实现更加简洁和易读。
3. 提高代码维护性：减少重复代码，使代码更易于维护和更新。

示例代码

以下示例展示了委托构造函数的基本用法：

#include <iostream>

class Example {
public:
    Example() : Example(0) {
        std::cout << "Default constructor called\n";
    }

    Example(int value) : value_(value) {
        std::cout << "Parameterized constructor called with value: " << value_ << "\n";
    }

private:
    int value_;
};

int main() {
    Example ex1; // 调用默认构造函数
    Example ex2(42); // 调用带参数的构造函数
    return 0;
}

实用技巧

1. 避免重复初始化代码：使用委托构造函数可以有效地避免在多个构造函数中重复编写相同的初始化代码。
2. 结合默认参数使用：委托构造函数可以与默认参数结合使用，进一步简化构造函数的定义。
3. 保持构造函数简洁：将复杂的初始化逻辑放在一个构造函数中，其他构造函数通过委托调用，保持代码简洁明了。

注意事项

1. 初始化顺序：在使用委托构造函数时，注意成员变量的初始化顺序。委托构造函数会先调用被委托的构造函数，然后执行自己的初始化列表和主体。
2. 避免循环调用：确保委托构造函数之间不会形成循环调用，否则会导致编译错误。
3. 性能影响：尽管委托构造函数可以减少代码重复，但要注意可能引入的额外开销，特别是在性能关键的代码中。

用户定义的字面量

背景

在C++98中，字面量（如整数、浮点数、字符、字符串等）只能用于内置类型。对于自定义类型，没有直接的方式来定义和使用字面量，这限制了代码的表达能力。为了支持自定义类型的字面量表示，C++11引入了用户定义的字面量，使得自定义类型可以像内置类型一样使用字面量语法。

定义

用户定义的字面量通过定义特殊的字面量操作符函数实现。这些操作符函数以operator""开头，后跟用户定义的后缀。字面量操作符函数可以是普通函数或模板函数。

type operator"" _suffix(params);

作用

用户定义的字面量的主要作用包括：

1. 增强可读性：通过自定义字面量后缀，可以使代码更加直观和易读。
2. 简化代码：减少了显式类型转换和函数调用，使代码更加简洁。
3. 支持自定义类型：扩展了字面量的使用范围，使自定义类型可以像内置类型一样使用字面量。

示例代码

以下示例展示了如何定义和使用用户定义的字面量：

#include <iostream>
#include <string>

// 定义用户定义的字面量用于表示时间（小时）
constexpr long double operator"" _h(long double hours) {
    return hours * 3600.0;
}

// 定义用户定义的字面量用于表示距离（公里）
constexpr long double operator"" _km(long double kilometers) {
    return kilometers * 1000.0;
}

// 定义用户定义的字面量用于表示字符串拼接
std::string operator"" _s(const char* str, std::size_t) {
    return std::string(str);
}

int main() {
    long double seconds = 2.5_h; // 将小时转换为秒
    long double meters = 5.0_km; // 将公里转换为米

    std::string greeting = "Hello, "_s + "world!";
    
    std::cout << "2.5 hours is " << seconds << " seconds.\n";
    std::cout << "5.0 kilometers is " << meters << " meters.\n";
    std::cout << greeting << std::endl;

    return 0;
}

实用技巧

1. 定义常用单位转换：使用用户定义的字面量，可以方便地定义常用单位的转换函数，如时间、距离、质量等。
2. 简化字符串操作：通过定义字符串字面量，可以简化字符串拼接和处理操作。
3. 结合模板使用：在模板编程中，用户定义的字面量可以用于定义泛型字面量操作符，提高代码的通用性和灵活性。

注意事项

1. 避免命名冲突：在定义用户定义的字面量时，确保后缀名称唯一，避免与已有的字面量后缀冲突。
2. 性能考虑：虽然用户定义的字面量可以简化代码，但在性能关键的代码中，注意其引入的开销，特别是对于复杂的字面量操作。
3. 编译器支持：确保使用支持C++11及以上标准的编译器，因为用户定义的字面量是C++11引入的新特性。

显式虚函数重载

背景

在C++98中，虚函数重载的错误（例如，函数签名不匹配）可能不会在编译时被捕捉到，导致潜在的运行时错误和意外行为。为了增强虚函数重载的安全性和明确性，C++11引入了两个新的关键字：override 和 final。

定义

1. override关键字：用于显式标记一个虚函数是重载基类中的虚函数。编译器会检查函数签名是否匹配基类中的虚函数签名。
2. final关键字：用于标记一个虚函数或类不能被进一步重载或继承。

class Base {
public:
    virtual void foo() const;
};

class Derived : public Base {
public:
    void foo() const override; // 显式重载虚函数
    void bar() final; // 该函数不能在派生类中重载
};

作用

1. 提高代码安全性：通过编译时检查，防止由于函数签名不匹配导致的虚函数重载错误。
2. 增强代码可读性：明确标识出哪些函数是重载的，哪些函数是新的或不允许重载的。
3. 防止意外重载：使用final关键字可以防止进一步的函数重载或类继承，确保类的设计意图不被破坏。

示例代码

以下是一个使用override和final关键字的示例：

#include <iostream>

class Base {
public:
    virtual void foo() const {
        std::cout << "Base foo\n";
    }

    virtual void bar() const {
        std::cout << "Base bar\n";
    }
};

class Derived : public Base {
public:
    void foo() const override {
        std::cout << "Derived foo\n";
    }

    void bar() const final {
        std::cout << "Derived bar\n";
    }
};

class FurtherDerived : public Derived {
public:
    // 错误：尝试重载final函数
    // void bar() const override {
    //     std::cout << "FurtherDerived bar\n";
    // }

    // 正确：重载基类的虚函数
    void foo() const override {
        std::cout << "FurtherDerived foo\n";
    }
};

int main() {
    Base* obj = new FurtherDerived();
    obj->foo(); // 输出：FurtherDerived foo
    obj->bar(); // 输出：Derived bar
    delete obj;
    return 0;
}

实用技巧

1. 总是使用override：在派生类中重载基类的虚函数时，尽量总是使用override关键字，以确保函数签名匹配。
2. 使用final防止进一步重载：如果不希望某个虚函数在派生类中被重载，可以使用final关键字。
3. 定期检查代码：在大型代码库中，定期检查虚函数的重载情况，确保没有遗漏override关键字。

注意事项

1. 兼容性问题：确保使用支持C++11及以上标准的编译器，因为override和final是C++11引入的新特性。
2. 编译器支持：不同的编译器对这些关键字的支持可能会有所不同，特别是在早期版本的编译器中。
3. 避免滥用final：在设计类继承结构时，合理使用final关键字，避免过度限制继承和重载的灵活性。

默认函数

背景

在C++98中，编译器会自动生成默认构造函数、拷贝构造函数、赋值运算符和析构函数。然而，在某些情况下，开发者需要显式地定义这些默认操作以确保类的行为符合预期。这通常需要编写一些冗长且重复的代码。为了解决这个问题，C++11引入了默认函数，使得开发者可以显式地指示编译器生成默认实现。

定义

默认函数使用= default语法来指示编译器生成默认实现。可以用于以下函数：

1. 默认构造函数
2. 拷贝构造函数
3. 拷贝赋值运算符
4. 移动构造函数
5. 移动赋值运算符
6. 析构函数

class ClassName {
public:
    ClassName() = default;
    ClassName(const ClassName&) = default;
    ClassName& operator=(const ClassName&) = default;
    ~ClassName() = default;
};

作用

1. 简化代码：通过显式指定默认函数，减少了手动编写重复代码的需求。
2. 增强代码可读性：明确指出哪些函数使用默认实现，增强代码的可读性。
3. 避免错误：通过显式指定默认函数，避免了不必要的复杂实现，减少了错误的可能性。

示例代码

以下是一个使用默认函数的示例：

#include <iostream>

class Example {
public:
    // 使用默认的构造函数、拷贝构造函数、拷贝赋值运算符和析构函数
    Example() = default;
    Example(const Example&) = default;
    Example& operator=(const Example&) = default;
    ~Example() = default;

    Example(int value) : value_(value) {}

    int getValue() const { return value_; }

private:
    int value_;
};

int main() {
    Example ex1(42);
    Example ex2 = ex1; // 调用默认的拷贝构造函数
    Example ex3;
    ex3 = ex1; // 调用默认的拷贝赋值运算符

    std::cout << "ex1 value: " << ex1.getValue() << std::endl;
    std::cout << "ex2 value: " << ex2.getValue() << std::endl;
    std::cout << "ex3 value: " << ex3.getValue() << std::endl;

    return 0;
}

实用技巧

1. 使用默认函数简化类定义：在类的定义中，使用= default来简化默认操作的实现。
2. 明确类的行为：通过显式指定默认函数，明确类的行为，使代码更易于理解和维护。
3. 避免不必要的复杂实现：在没有特殊需求时，使用默认函数可以避免编写复杂且容易出错的代码。

注意事项

1. 仅在适用时使用：默认函数仅适用于没有特殊初始化或清理需求的类。在需要自定义行为时，仍需手动实现这些函数。
2. 编译器支持：确保使用支持C++11及以上标准的编译器，因为默认函数是C++11引入的新特性。
3. 与其他特性结合使用：默认函数可以与其他C++11特性（如移动语义）结合使用，以实现更高效的类实现。

已删除函数

背景

在C++98中，如果不希望某些函数被使用，通常会将它们声明为私有成员并且不提供定义。然而，这种方法并不直观，且可能导致潜在的链接错误。C++11引入已删除函数，通过显式声明函数为"删除状态"，可以在编译时捕捉到对这些函数的非法调用。

定义

已删除函数使用= delete语法来显式声明一个函数为已删除状态。这样，当试图调用已删除函数时，编译器会生成错误信息。

class ClassName {
public:
    ClassName() = delete; // 禁用默认构造函数
    void someFunction() = delete; // 禁用某个成员函数
};

作用

1. 显式禁用不需要的函数：通过将函数声明为已删除，明确表示该函数不应被使用。
2. 增强代码安全性：在编译时捕捉非法调用，避免潜在的运行时错误。
3. 提高代码可读性：使代码意图更加清晰，便于维护和理解。

示例代码

以下是一个使用已删除函数的示例：

#include <iostream>

class Example {
public:
    Example() = delete; // 禁用默认构造函数
    Example(int value) : value_(value) {}

    // 禁用拷贝构造函数和赋值运算符
    Example(const Example&) = delete;
    Example& operator=(const Example&) = delete;

    int getValue() const { return value_; }

private:
    int value_;
};

int main() {
    // Example ex1; // 编译错误：默认构造函数被禁用
    Example ex2(42);
    // Example ex3 = ex2; // 编译错误：拷贝构造函数被禁用
    // ex2 = ex3; // 编译错误：赋值运算符被禁用

    std::cout << "ex2 value: " << ex2.getValue() << std::endl;
    return 0;
}

实用技巧

1. 禁用默认操作：在某些类中，可能希望禁用默认构造函数、拷贝构造函数或赋值运算符，以避免不必要的操作。
2. 防止错误使用：对于某些不希望被调用的函数，可以显式将其声明为已删除，以防止误用。
3. 结合其他特性使用：已删除函数可以与其他C++11特性（如默认函数）结合使用，提供更强的控制力。

注意事项

1. 明确删除理由：在代码中显式声明已删除函数时，最好注释说明为什么要删除该函数，以便其他开发者理解代码意图。
2. 注意编译器支持：确保使用支持C++11及以上标准的编译器，因为已删除函数是C++11引入的新特性。
3. 避免过度删除：只删除确实需要禁用的函数，避免过度使用= delete导致代码可用性降低。

基于范围的for循环

用于移动语义的特殊成员函数

背景

在C++98中，对象的拷贝操作会导致资源的深拷贝，这在处理大量数据时会造成性能瓶颈。为了提高资源管理的效率，C++11引入了移动语义，通过移动而不是拷贝对象的资源，大幅减少了不必要的资源开销。

定义

用于移动语义的特殊成员函数包括：

1. 移动构造函数（Move Constructor）
2. 移动赋值运算符（Move Assignment Operator）

它们的定义形式如下：

class ClassName {
public:
    ClassName(ClassName&& other) noexcept; // 移动构造函数
    ClassName& operator=(ClassName&& other) noexcept; // 移动赋值运算符
};

作用

1. 提高性能：通过移动资源而不是拷贝资源，显著提高程序的性能，特别是在处理大量数据时。
2. 优化资源管理：移动语义避免了不必要的资源分配和释放，提高了资源管理的效率。
3. 减少临时对象：在函数返回值优化（RVO）和其他情境中，减少临时对象的创建和销毁。

示例代码

以下示例展示了移动构造函数和移动赋值运算符的基本用法：

#include <iostream>
#include <utility> // for std::move

class Example {
public:
    int* data;

    // 默认构造函数
    Example() : data(new int[100]) {
        std::cout << "Default constructor\n";
    }

    // 移动构造函数
    Example(Example&& other) noexcept : data(other.data) {
        other.data = nullptr;
        std::cout << "Move constructor\n";
    }

    // 移动赋值运算符
    Example& operator=(Example&& other) noexcept {
        if (this != &other) {
            delete[] data; // 释放已有资源
            data = other.data;
            other.data = nullptr;
            std::cout << "Move assignment operator\n";
        }
        return *this;
    }

    // 析构函数
    ~Example() {
        delete[] data;
        std::cout << "Destructor\n";
    }
};

int main() {
    Example ex1;
    Example ex2 = std::move(ex1); // 调用移动构造函数

    Example ex3;
    ex3 = std::move(ex2); // 调用移动赋值运算符

    return 0;
}

实用技巧

1. 使用std::move：当你希望将一个对象移动而不是拷贝时，可以使用std::move将其转换为右值引用，触发移动语义。
2. 实现noexcept：确保移动构造函数和移动赋值运算符是noexcept，以便标准库和其他代码能够优化移动操作。
3. 遵循五法则：如果一个类定义了任何一个拷贝或移动操作，应考虑定义所有五个特殊成员函数（默认构造函数、拷贝构造函数、拷贝赋值运算符、移动构造函数、移动赋值运算符），以确保类的行为一致和健壮。

注意事项

1. 资源管理：在移动构造函数和移动赋值运算符中，确保正确地转移资源，并避免资源泄漏。
2. 对象状态：移动后的对象应处于有效但未定义的状态，通常应将其资源指针置为nullptr。
3. 性能测试：在性能关键的代码中，测试移动语义的效果，以确保其带来的性能提升符合预期。

转换构造函数

背景

在C++98中，类型转换构造函数（也称隐式转换构造函数）可以在没有显式指示的情况下被调用，这可能导致意外的类型转换和难以跟踪的错误。C++11引入了显式转换构造函数，通过引入explicit关键字来控制哪些构造函数可以用于隐式类型转换，从而提高代码的安全性和可读性。

定义

转换构造函数是一种特殊的构造函数，它只有一个参数（或多个参数但有默认值），用于从其他类型转换为类类型。C++11允许开发者使用explicit关键字将这些构造函数声明为显式，从而避免隐式类型转换。

class ClassName {
public:
    explicit ClassName(int value); // 显式转换构造函数
};

作用

1. 提高类型转换的安全性：通过显式标记转换构造函数，避免不必要的隐式类型转换，提高类型转换的安全性。
2. 增强代码的可读性：显式类型转换要求开发者明确指示类型转换，增强了代码的可读性和可维护性。
3. 控制类型转换行为：通过使用explicit关键字，开发者可以精细控制哪些类型转换是允许的，哪些是禁止的。

示例代码

以下是一个使用转换构造函数的示例：

#include <iostream>

class Example {
public:
    explicit Example(int value) : value_(value) {
        std::cout << "Conversion constructor called with value: " << value << "\n";
    }

    int getValue() const { return value_; }

private:
    int value_;
};

void printExample(const Example& ex) {
    std::cout << "Example value: " << ex.getValue() << "\n";
}

int main() {
    Example ex1(42); // 直接调用构造函数
    printExample(ex1);

    // Example ex2 = 42; // 错误：explicit关键字禁止隐式转换
    // printExample(42); // 错误：explicit关键字禁止隐式转换

    Example ex3 = Example(42); // 显式转换
    printExample(ex3);

    return 0;
}

实用技巧

1. 使用explicit关键字：在转换构造函数前加上explicit关键字，以避免不必要的隐式类型转换。
2. 明确类型转换意图：在需要进行类型转换的地方，使用显式类型转换（例如Example(42)）来清晰表达转换意图。
3. 检查类型转换路径：在设计类接口时，检查所有可能的类型转换路径，确保只有预期的转换是允许的。

注意事项

1. 隐式转换的风险：未标记为explicit的转换构造函数可能会导致意外的隐式转换，增加调试和维护的难度。
2. 代码可读性：过多使用显式类型转换可能会影响代码的可读性，因此在确保安全的前提下，平衡显式转换的使用频率。
3. 与其他特性结合使用：结合其他C++11特性（如std::move、std::forward等），可以实现更加灵活和高效的类型转换。

显式转换函数

背景

在C++98中，类型转换操作符（conversion operators）可以隐式调用，这可能导致意外的类型转换和难以跟踪的错误。为了增强类型转换的安全性和明确性，C++11引入了显式转换函数，通过引入explicit关键字来控制哪些类型转换可以隐式进行，哪些必须显式进行。

定义

显式转换函数使用explicit关键字修饰类型转换操作符，以禁止该操作符在隐式上下文中使用。只有在显式调用时，这些操作符才会被使用。

class ClassName {
public:
    explicit operator TypeName() const;
};

作用

1. 提高类型转换的安全性：通过显式标记转换操作符，避免不必要的隐式类型转换，提高类型转换的安全性。
2. 增强代码的可读性：显式类型转换要求开发者明确指示类型转换，增强了代码的可读性和可维护性。
3. 控制类型转换行为：通过使用explicit关键字，开发者可以精细控制哪些类型转换是允许的，哪些是禁止的。

示例代码

以下是一个使用显式转换函数的示例：

#include <iostream>

class Example {
public:
    Example(int value) : value_(value) {}

    explicit operator int() const {
        return value_;
    }

private:
    int value_;
};

void printInt(int value) {
    std::cout << "Integer value: " << value << "\n";
}

int main() {
    Example ex(42);

    // printInt(ex); // 错误：explicit关键字禁止隐式转换
    printInt(static_cast<int>(ex)); // 正确：显式转换

    int value = static_cast<int>(ex); // 显式转换
    std::cout << "Value: " << value << "\n";

    return 0;
}

实用技巧

1. 使用explicit关键字：在类型转换操作符前加上explicit关键字，以避免不必要的隐式类型转换。
2. 明确类型转换意图：在需要进行类型转换的地方，使用显式类型转换（例如static_cast<int>(ex)）来清晰表达转换意图。
3. 结合重载运算符：显式转换函数可以与其他运算符重载结合使用，提供更灵活和安全的类型转换。

注意事项

1. 隐式转换的风险：未标记为explicit的转换操作符可能会导致意外的隐式转换，增加调试和维护的难度。
2. 代码可读性：显式类型转换虽然提高了安全性，但可能会使代码显得冗长。平衡显式转换和代码可读性之间的关系。
3. 与其他特性结合使用：结合其他C++11特性（如智能指针、移动语义等），可以实现更加灵活和高效的类型转换。

内联命名空间

背景

在C++98及之前的标准中，命名空间用于组织代码、避免命名冲突。然而，随着项目的增长和版本的演进，维护多个版本的API可能会变得复杂。为了解决这些问题并简化命名空间管理，C++11引入了内联命名空间（inline namespaces）。

定义

内联命名空间是一种特殊的命名空间，它的成员可以直接作为外围命名空间的成员使用。使用inline关键字修饰命名空间，即可声明内联命名空间。

namespace Outer {
    inline namespace Inner {
        // 内联命名空间中的成员
    }
}

作用

1. 版本控制：允许在一个命名空间中管理不同版本的API，同时提供默认版本的接口。
2. 代码组织：简化命名空间的使用，使得内联命名空间中的成员可以直接访问，无需额外的命名空间前缀。
3. 向后兼容：通过内联命名空间，可以平滑地引入新版本的API，而不破坏现有代码。

示例代码

以下示例展示了内联命名空间的基本用法：

#include <iostream>

namespace Library {
    inline namespace V1 {
        void foo() {
            std::cout << "V1::foo()" << std::endl;
        }
    }

    namespace V2 {
        void foo() {
            std::cout << "V2::foo()" << std::endl;
        }
    }
}

int main() {
    Library::foo();  // 调用V1::foo()
    Library::V1::foo();  // 调用V1::foo()
    Library::V2::foo();  // 调用V2::foo()
    return 0;
}

在这个例子中，Library::foo直接调用了V1::foo，因为V1是内联命名空间。

实用技巧

1. 版本控制：在大型项目中，使用内联命名空间进行版本控制，可以方便地管理不同版本的API，并提供默认版本。
2. 简化接口：在内联命名空间中定义新功能时，可以简化接口调用，使用户代码更加简洁。
3. 平滑升级：在引入新版本时，可以使用内联命名空间保证向后兼容，同时逐步引导用户迁移到新版本。

注意事项

1. 命名冲突：虽然内联命名空间可以简化代码，但要注意不同版本之间的命名冲突，确保在设计时考虑到这一点。
2. 清晰性：过度使用内联命名空间可能导致代码可读性下降，应在保证代码简洁和清晰的前提下使用。
3. 编译器支持：确保使用支持C++11及以上标准的编译器，因为内联命名空间是C++11引入的新特性。

非静态数据成员初始化器

背景

在C++98及之前的版本中，非静态数据成员的初始化通常需要在构造函数中进行。这种方式虽然有效，但会导致构造函数中充满初始化代码，特别是在有多个构造函数时，可能会引入重复代码和初始化遗漏的问题。C++11引入非静态数据成员初始化器（NSDMI, Non-Static Data Member Initializers），简化了数据成员的初始化过程。

定义

非静态数据成员初始化器允许在类定义中直接为非静态数据成员提供初始值。其语法如下：

class ClassName {
public:
    int member = 10; // 非静态数据成员初始化器
};

作用

1. 简化代码：通过直接在类定义中初始化成员，减少了在构造函数中重复编写初始化代码的需求。
2. 提高代码可读性：使初始化代码与成员声明紧密结合，增强了代码的可读性和可维护性。
3. 防止未初始化错误：确保数据成员在所有构造函数中都有一个默认初始值，避免未初始化错误。

示例代码

以下示例展示了非静态数据成员初始化器的基本用法：

#include <iostream>

class Example {
public:
    int x = 42; // 非静态数据成员初始化器
    double y = 3.14; // 非静态数据成员初始化器

    Example() = default; // 使用默认构造函数

    Example(int a) : x(a) {} // 自定义构造函数

    void print() const {
        std::cout << "x: " << x << ", y: " << y << std::endl;
    }
};

int main() {
    Example ex1;
    ex1.print(); // 输出：x: 42, y: 3.14

    Example ex2(100);
    ex2.print(); // 输出：x: 100, y: 3.14

    return 0;
}

实用技巧

1. 使用默认值：为数据成员提供合理的默认值，简化构造函数的实现，并保证对象总是处于有效状态。
2. 简化构造函数：在构造函数中只处理那些需要特殊初始化的成员，其他成员使用默认值。
3. 结合构造函数初始化列表：在需要时，可以在构造函数初始化列表中覆盖非静态数据成员初始化器提供的默认值。

注意事项

1. 避免冲突：在构造函数初始化列表中对某个成员进行初始化时，该初始化将覆盖非静态数据成员初始化器提供的默认值。
2. 代码一致性：虽然非静态数据成员初始化器可以简化代码，但在大型代码库中，保持代码风格的一致性也很重要。团队应统一决定使用这种特性的方法。
3. 复杂初始化逻辑：对于复杂的初始化逻辑，仍然推荐使用构造函数初始化列表，以保持代码的清晰和可维护性。

右尖括号

背景

在C++98中，当嵌套模板类型定义时，需要使用多个右尖括号（>）来关闭模板声明。由于解析器的限制，这些右尖括号之间需要有空格，否则编译器会将它们误认为是右移运算符（>>）。C++11引入了一项新特性，解决了这个问题，使代码更简洁和易读。

定义

右尖括号（Right Angle Brackets）特性允许在嵌套模板声明中直接使用连续的右尖括号（>>），而无需插入空格。

作用

1. 简化代码：在嵌套模板声明中，无需插入空格，使代码更简洁。
2. 提高可读性：消除不必要的空格，增强代码的可读性和一致性。
3. 减少错误：降低了由于遗漏空格而导致的编译错误。

示例代码

以下示例展示了在C++98和C++11中的嵌套模板定义对比：

C++98

#include <iostream>
#include <vector>

int main() {
    std::vector<std::vector<int> > vec; // 注意这里的空格
    vec.push_back({1, 2, 3});
    vec.push_back({4, 5, 6});

    for (const auto& v : vec) {
        for (int i : v) {
            std::cout << i << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

C++11

#include <iostream>
#include <vector>

int main() {
    std::vector<std::vector<int>> vec; // 不需要空格
    vec.push_back({1, 2, 3});
    vec.push_back({4, 5, 6});

    for (const auto& v : vec) {
        for (int i : v) {
            std::cout << i << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

实用技巧

1. 统一代码风格：在整个代码库中统一使用C++11的右尖括号特性，以保持代码风格的一致性。
2. 更新旧代码：在维护旧代码时，可以逐步移除不必要的空格，更新为C++11的右尖括号特性。
3. 配合其他C++11特性：结合其他C++11特性，如auto关键字和范围for循环，可以进一步简化代码。

注意事项

1. 编译器支持：确保使用支持C++11及以上标准的编译器，因为右尖括号特性是C++11引入的新特性。
2. 代码可读性：虽然右尖括号特性简化了代码，但在某些复杂的嵌套模板中，仍需注意代码的可读性，可以通过适当的注释和代码格式化来保持代码清晰。

引用限定成员函数

背景

在C++98及之前的版本中，成员函数不能限制只能用于左值对象或右值对象。这种限制在某些情况下非常有用，例如，防止某些操作在临时对象上调用，从而提高代码的安全性和可读性。C++11引入了引用限定符，用于限定成员函数只能在左值或右值上调用。

定义

引用限定成员函数（Reference-Qualified Member Functions）通过在成员函数声明后添加&或&&限定符，来限定成员函数只能在左值或右值对象上调用。

class ClassName {
public:
    void function() &;  // 只能用于左值对象
    void function() &&; // 只能用于右值对象
};

作用

1. 增强代码安全性：防止成员函数在不适合的对象上下文中调用，减少潜在的运行时错误。
2. 优化性能：通过限定右值引用，可以为右值对象设计高效的成员函数实现。
3. 提高代码可读性：明确成员函数的调用语境，增强代码的可读性和维护性。

示例代码

以下示例展示了如何使用引用限定成员函数：

#include <iostream>

class Example {
public:
    void show() & {
        std::cout << "Called on lvalue object" << std::endl;
    }

    void show() && {
        std::cout << "Called on rvalue object" << std::endl;
    }
};

int main() {
    Example ex;
    ex.show();       // 输出：Called on lvalue object

    Example().show(); // 输出：Called on rvalue object

    return 0;
}

实用技巧

1. 合理使用引用限定符：在需要区分左值和右值调用语境时，使用引用限定符来限定成员函数。
2. 结合移动语义：引用限定符与移动语义结合使用，可以实现高效的右值对象操作。
3. 代码审查：在代码审查时，确保引用限定符的使用符合设计意图，避免误用。

注意事项

1. 代码可读性：使用引用限定符时，注意保持代码的可读性，避免过度复杂化。
2. 兼容性：确保项目中所有代码均支持C++11标准，以避免引用限定符引入的兼容性问题。
3. 文档化：对使用引用限定符的成员函数进行详细注释和文档化，以便团队其他成员理解其设计意图。

尾返回类型

背景

在C++98和C++03中，函数的返回类型必须在函数名之前指定，这在某些情况下会导致代码复杂和难以阅读，尤其是在涉及模板和复杂类型推导时。为了简化返回类型的指定，C++11引入了尾返回类型（Trailing Return Types），使得开发者可以在参数列表之后定义函数的返回类型。

定义

尾返回类型允许在参数列表之后使用->符号指定返回类型。这种语法使得返回类型可以依赖于参数类型，特别是在模板编程中，尾返回类型非常有用。

auto functionName(parameters) -> returnType {
    // function body
}

作用

1. 简化模板编程：在模板函数中，可以根据参数类型更方便地指定返回类型。
2. 提高可读性：在某些情况下，使函数签名更加直观和易读。
3. 支持复杂类型推导：对于复杂的返回类型，尾返回类型提供了一种更清晰的方式进行定义。

示例代码

以下示例展示了尾返回类型的基本用法：

#include <iostream>
#include <type_traits>

// 使用尾返回类型定义模板函数
template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

int main() {
    std::cout << add(1, 2) << std::endl;          // 输出：3
    std::cout << add(1.5, 2) << std::endl;        // 输出：3.5
    std::cout << add(1.5, 2.5) << std::endl;      // 输出：4
    return 0;
}

实用技巧

1. 使用decltype：在模板函数中，结合decltype使用尾返回类型，可以根据参数类型推导出返回类型。
2. 简化代码：对于复杂返回类型，使用尾返回类型可以使代码更加简洁和易读。
3. 结合auto关键字：在函数定义中使用auto关键字和尾返回类型，使得代码更加直观。

注意事项

1. 编译器支持：确保使用支持C++11及以上标准的编译器，因为尾返回类型是C++11引入的新特性。
2. 代码一致性：在一个项目中保持返回类型定义的一致性，避免混用尾返回类型和传统返回类型定义方式。
3. 复杂性控制：虽然尾返回类型可以简化代码，但过度使用可能会导致代码过于复杂和难以维护，应在需要时使用。

noexcept说明符

背景

在C++98中，异常规范（exception specification）提供了一种机制，用于声明函数是否会抛出异常。然而，这种机制在实践中并不常用且有些复杂。C++11引入了noexcept说明符，作为一种更简洁和高效的方式，声明函数不会抛出异常。

定义

noexcept说明符用于标记一个函数在其执行过程中不会抛出异常。它可以用于任何函数，包括普通函数、成员函数、运算符重载等。

void function() noexcept;

作用

1. 提高性能：编译器可以针对标记为noexcept的函数进行优化，因为它们保证不会抛出异常。
2. 增强代码安全性：明确函数的异常行为，帮助开发者更好地理解和维护代码。
3. 提高代码可读性：通过显式声明异常行为，使代码意图更加清晰。

示例代码

以下是一些使用noexcept说明符的示例：

#include <iostream>

// 普通函数使用noexcept
void foo() noexcept {
    std::cout << "This function will not throw an exception." << std::endl;
}

// 成员函数使用noexcept
class Example {
public:
    void bar() noexcept {
        std::cout << "This member function will not throw an exception." << std::endl;
    }
};

int main() {
    foo();

    Example ex;
    ex.bar();

    // noexcept表达式
    std::cout << std::boolalpha;
    std::cout << "foo is noexcept: " << noexcept(foo()) << std::endl;
    std::cout << "ex.bar is noexcept: " << noexcept(ex.bar()) << std::endl;

    return 0;
}

实用技巧

1. 使用noexcept关键字：在确定函数不会抛出异常时，尽量使用noexcept关键字，以便编译器进行优化和提高代码的安全性。
2. noexcept表达式：可以使用noexcept表达式在编译时检查某个表达式是否为noexcept。
3. 组合使用noexcept：在模板函数中，可以结合noexcept和noexcept表达式，根据模板参数确定函数是否为noexcept。

注意事项

1. 违反noexcept的行为：如果一个noexcept函数抛出异常，程序会调用std::terminate终止，这可能导致程序崩溃。因此，只在确定函数不会抛出异常时使用noexcept。
2. 与标准库函数结合：许多标准库函数在C++11中也标记为noexcept，在使用这些函数时可以确保它们不会抛出异常。
3. 影响接口设计：在接口设计中，慎重使用noexcept，确保不影响接口的灵活性和扩展性。

char32_t和char16_t

背景

在C++98和C++03中，字符类型主要有char、wchar_t，分别用于表示ASCII字符和宽字符（通常用于Unicode）。然而，wchar_t的大小和表示方式因平台而异，导致跨平台处理Unicode字符变得复杂和不一致。为了提供一致且更好的Unicode支持，C++11引入了char16_t和char32_t，分别用于表示UTF-16和UTF-32编码的字符。

定义

• char16_t：一种固定宽度的16位字符类型，用于表示UTF-16编码的字符。
• char32_t：一种固定宽度的32位字符类型，用于表示UTF-32编码的字符。

这两个类型都是新的基本类型，类似于char和wchar_t，它们保证在所有平台上具有固定的大小和编码方式。

作用

1. 统一的Unicode支持：提供一致的UTF-16和UTF-32字符类型，简化跨平台的Unicode处理。
2. 增强字符处理能力：通过固定的宽度，简化了对多字节和宽字符的处理，提高了字符操作的效率和可靠性。
3. 标准化字符表示：确保在不同平台和编译器上的一致性，使代码更加可移植。

示例代码

以下示例展示了如何使用char16_t和char32_t处理Unicode字符：

#include <iostream>
#include <string>

int main() {
    // 使用char16_t表示UTF-16字符
    char16_t utf16_char = u'\u4F60'; // 中文字符 "你"
    std::u16string utf16_str = u"你好，世界"; // UTF-16字符串

    // 使用char32_t表示UTF-32字符
    char32_t utf32_char = U'\U0001F600'; // Unicode表情字符 "😀"
    std::u32string utf32_str = U"你好，世界😀"; // UTF-32字符串

    // 打印字符和字符串的大小
    std::cout << "Size of char16_t: " << sizeof(char16_t) << " bytes" << std::endl;
    std::cout << "Size of char32_t: " << sizeof(char32_t) << " bytes" << std::endl;

    std::cout << "UTF-16 string length: " << utf16_str.size() << std::endl;
    std::cout << "UTF-32 string length: " << utf32_str.size() << std::endl;

    return 0;
}

实用技巧

1. 使用UTF-16和UTF-32字符串：使用标准库提供的std::u16string和std::u32string来处理UTF-16和UTF-32编码的字符串。
2. 字符和字符串转换：在处理多种编码时，了解如何在char、wchar_t、char16_t和char32_t之间进行转换，可以使用标准库函数和第三方库（如ICU）来完成这些转换。
3. Unicode标准理解：理解Unicode标准及其编码方式（如UTF-8、UTF-16、UTF-32），以便更好地使用char16_t和char32_t。

注意事项

1. 平台支持：确保编译器支持C++11标准，因为char16_t和char32_t是C++11引入的新特性。
2. 字符转换：注意字符编码的转换和处理，不同编码之间的转换可能会引入复杂性和性能开销。
3. 库支持：虽然标准库提供了一些基本的支持，但在处理复杂的Unicode操作时，可能需要借助第三方库（如ICU）。

原始字符串字面量

背景

在C++98及之前的版本中，字符串字面量通常使用双引号括起来，内部的特殊字符（如换行符、引号、反斜杠等）需要使用转义序列。这使得包含大量特殊字符的字符串变得难以阅读和维护。为了解决这一问题，C++11引入了原始字符串字面量（Raw String Literals），简化了包含特殊字符的字符串定义。

定义

原始字符串字面量允许在字符串中包含不转义的特殊字符和换行符，使得字符串的内容可以更自然地表示。它们使用R"delimiter(content)delimiter"的形式，其中delimiter是一个可选的分隔符，用于避免字符串内容与标识符混淆。

const char* raw_string = R"delimiter(content)delimiter";

作用

1. 简化字符串定义：不需要转义特殊字符，使得字符串内容更加直观和易读。
2. 提高代码可读性：特别是包含大量特殊字符或跨多行的字符串，原始字符串字面量使代码更清晰。
3. 减少错误：减少转义字符的使用，降低因转义错误引起的 bug 可能性。

示例代码

以下示例展示了原始字符串字面量的基本用法：

#include <iostream>

int main() {
    // 使用普通字符串字面量，需要转义字符
    const char* normal_string = "Line 1\nLine 2\n\"Quoted text\"\nBackslash: \\";

    // 使用原始字符串字面量，不需要转义字符
    const char* raw_string = R"(Line 1
Line 2
"Quoted text"
Backslash: \)";

    std::cout << "Normal string:\n" << normal_string << "\n" << std::endl;
    std::cout << "Raw string:\n" << raw_string << std::endl;

    // 使用分隔符避免内容与标识符混淆
    const char* raw_string_with_delimiter = R"delimiter(This is a raw string with a )delimiter) delimiter.)delimiter";
    std::cout << raw_string_with_delimiter << std::endl;

    return 0;
}

实用技巧

1. 选择适当的分隔符：在原始字符串字面量中使用分隔符时，选择不太可能与字符串内容冲突的分隔符，确保分隔符唯一。
2. 多行字符串：使用原始字符串字面量处理多行字符串内容，可以大大提高可读性和维护性。
3. 文档和正则表达式：在嵌入代码片段、文档内容或正则表达式时，使用原始字符串字面量可以避免大量的转义字符，使代码更易于理解。

注意事项

1. 编译器支持：确保使用支持C++11及以上标准的编译器，因为原始字符串字面量是C++11引入的新特性。
2. 避免混淆：尽量选择合适的分隔符，避免字符串内容与原始字符串字面量的边界混淆，导致编译错误。
3. 阅读和调试：虽然原始字符串字面量提高了可读性，但在阅读和调试时，需要习惯这种新的字符串表示方式。

C++11库特性

std::move

背景

在C++98中，对象的拷贝操作会导致资源的深拷贝，这在处理大量数据时会造成性能瓶颈。为了提高资源管理的效率和性能，C++11引入了移动语义和std::move函数，允许开发者通过移动而不是拷贝对象的资源来优化程序性能。

定义

std::move是C++11标准库中的一个函数模板，它的作用是将一个对象显式地转换为右值引用，从而启用对象的移动语义。通过std::move，开发者可以避免不必要的深拷贝，提高程序的性能。

template<typename T>
typename std::remove_reference<T>::type&& move(T&& t) noexcept;

作用

1. 启用移动语义：将左值转换为右值引用，从而启用移动构造函数和移动赋值运算符。
2. 提高性能：通过移动对象的资源而不是拷贝，显著提高程序的性能，尤其是在处理大量数据时。
3. 优化资源管理：减少不必要的资源分配和释放，提高资源管理的效率。

示例代码

以下示例展示了如何使用std::move实现对象的移动操作：

#include <iostream>
#include <vector>
#include <utility> // for std::move

class Example {
public:
    Example() : data(new int[100]) {
        std::cout << "Default constructor" << std::endl;
    }

    // 移动构造函数
    Example(Example&& other) noexcept : data(other.data) {
        other.data = nullptr;
        std::cout << "Move constructor" << std::endl;
    }

    // 移动赋值运算符
    Example& operator=(Example&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            other.data = nullptr;
            std::cout << "Move assignment operator" << std::endl;
        }
        return *this;
    }

    ~Example() {
        delete[] data;
        std::cout << "Destructor" << std::endl;
    }

private:
    int* data;
};

int main() {
    Example ex1;
    Example ex2 = std::move(ex1); // 调用移动构造函数

    Example ex3;
    ex3 = std::move(ex2); // 调用移动赋值运算符

    return 0;
}

实用技巧

1. 在适当的地方使用std::move：仅在需要显式地将对象转换为右值引用时使用std::move，如在需要调用移动构造函数或移动赋值运算符时。
2. 理解移动后的对象状态：移动后的对象处于有效但未定义的状态，应确保在后续代码中不再使用该对象。
3. 结合容器使用：在STL容器中使用std::move，如std::vector、std::map等，可以提高容器操作的性能。

注意事项

1. 移动后的对象：移动后的对象处于未定义状态，应避免对其进行进一步的操作。
2. 防止误用：不要对不支持移动语义的对象使用std::move，否则可能导致未定义行为。
3. noexcept：确保移动构造函数和移动赋值运算符被标记为noexcept，以便标准库和其他代码能够优化移动操作。

std::forward

背景

在C++98中，函数模板参数传递的方式只有通过值传递、引用传递和指针传递。然而，随着模板元编程的普及和复杂度的增加，这些传递方式有时并不足以满足需求。C++11引入了右值引用和完美转发，std::forward是实现完美转发的关键工具，它解决了函数模板参数传递时保留原始类型信息的问题。

定义

std::forward是C++11标准库中的一个函数模板，用于将参数完美地转发给另一个函数。完美转发意味着参数在传递过程中保持其左值或右值的特性。

template<typename T>
T&& forward(typename std::remove_reference<T>::type& t) noexcept;

作用

1. 完美转发：保留传递参数的原始类型（左值或右值），避免不必要的拷贝或移动操作。
2. 提高泛型代码的效率：在编写泛型代码时，通过std::forward可以确保参数传递的高效性。
3. 简化模板编程：提供了一种简洁的方式来处理参数转发，避免手动区分左值和右值的繁琐操作。

示例代码

以下示例展示了如何使用std::forward实现完美转发：

#include <iostream>
#include <utility>

// 泛型工厂函数，使用std::forward实现完美转发
template<typename T, typename Arg>
T create(Arg&& arg) {
    return T(std::forward<Arg>(arg));
}

class Example {
public:
    Example(int&& n) {
        std::cout << "Rvalue constructor called with " << n << std::endl;
    }

    Example(const int& n) {
        std::cout << "Lvalue constructor called with " << n << std::endl;
    }
};

int main() {
    int x = 10;
    // 调用带左值引用参数的构造函数
    Example e1 = create<Example>(x);
    // 调用带右值引用参数的构造函数
    Example e2 = create<Example>(10);

    return 0;
}

实用技巧

1. 结合右值引用：在模板函数中，使用右值引用和std::forward可以实现高效的参数传递和资源管理。
2. 避免多次转发：在完美转发的场景中，尽量避免对同一参数进行多次转发，这可能会导致未定义行为。
3. 明确转发目的：在使用std::forward时，确保理解其作用和目的，避免误用导致的性能问题或逻辑错误。

注意事项

1. 完美转发条件：std::forward仅在函数模板中使用时才能实现完美转发。直接使用右值引用和std::forward时，需要确保它们在模板上下文中被正确使用。
2. 性能考虑：虽然std::forward可以提高参数传递的效率，但在某些场景下可能会引入额外的复杂性和维护成本。

std::thread

背景

在C++98和C++03中，多线程编程通常依赖于操作系统提供的线程库，如POSIX线程（pthread）或Windows线程。这些库在不同平台上的接口和行为有所不同，导致代码的可移植性差。为了提供统一的多线程支持，C++11引入了<thread>库，标准化了线程管理。

定义

std::thread是C++11标准库中的一个类，用于创建和管理线程。通过std::thread，开发者可以在标准化的接口上进行多线程编程，从而提高代码的可移植性和一致性。

作用

1. 统一线程接口：提供跨平台一致的线程接口，简化多线程编程。
2. 提升性能：通过多线程实现并行计算，提高程序的执行效率。
3. 简化代码：通过高层次的线程管理接口，减少了直接使用操作系统线程库的复杂性。

示例代码

以下示例展示了如何使用std::thread创建和管理线程：

#include <iostream>
#include <thread>

// 线程函数
void printMessage(const std::string& message) {
    std::cout << "Thread message: " << message << std::endl;
}

int main() {
    std::string message = "Hello from thread";

    // 创建线程
    std::thread t(printMessage, std::ref(message));

    // 等待线程完成
    t.join();

    std::cout << "Main thread message: " << message << std::endl;

    return 0;
}

实用技巧

1. 使用join和detach：在主线程中使用join等待子线程完成，或使用detach使子线程在后台运行，避免线程未正确处理导致的资源泄漏。
2. 使用std::ref传递引用：在传递参数时，如果需要传递引用，使用std::ref包装参数，以确保正确传递引用而不是副本。
3. 捕获异常：在多线程代码中处理可能的异常，确保程序的健壮性和可调试性。

注意事项

1. 资源管理：确保线程在结束时正确释放资源，避免资源泄漏和未定义行为。
2. 线程同步：在多线程编程中，注意线程同步和数据竞争问题，可以使用std::mutex、std::lock_guard等同步机制。
3. 避免死锁：在使用多个锁时，注意避免死锁，可以使用std::lock函数来确保锁的获取顺序。

std::to_string

背景

在C++98及之前的版本中，将数字转换为字符串需要使用std::stringstream，这种方法虽然有效，但相对繁琐和冗长。为了简化这一常见操作，C++11引入了std::to_string，提供了一种简单而直接的方法将数值类型转换为字符串。

定义

std::to_string是C++11标准库中的一个函数模板，用于将基本数值类型转换为std::string。其定义如下：

namespace std {
    string to_string(int value);
    string to_string(long value);
    string to_string(long long value);
    string to_string(unsigned value);
    string to_string(unsigned long value);
    string to_string(unsigned long long value);
    string to_string(float value);
    string to_string(double value);
    string to_string(long double value);
}

作用

1. 简化代码：提供了一种简单、直接的方法将数值类型转换为字符串，避免了使用std::stringstream的复杂性。
2. 提高可读性：使代码更加简洁和易读，特别是在需要频繁进行数值到字符串转换的场景中。
3. 增强代码一致性：通过标准库函数进行转换，保证了跨平台的一致性和正确性。

示例代码

以下示例展示了如何使用std::to_string将不同的数值类型转换为字符串：

#include <iostream>
#include <string>

int main() {
    int i = 42;
    long l = 123456789L;
    double d = 3.14159;
    float f = 2.71828f;

    std::string str_i = std::to_string(i);
    std::string str_l = std::to_string(l);
    std::string str_d = std::to_string(d);
    std::string str_f = std::to_string(f);

    std::cout << "Integer to string: " << str_i << std::endl;
    std::cout << "Long to string: " << str_l << std::endl;
    std::cout << "Double to string: " << str_d << std::endl;
    std::cout << "Float to string: " << str_f << std::endl;

    return 0;
}

实用技巧

1. 常用转换：使用std::to_string进行常用的数值到字符串的转换，可以大大简化代码。
2. 结合其他字符串操作：转换后的字符串可以方便地与其他字符串操作（如拼接、查找等）结合使用。
3. 处理不同类型：确保传递给std::to_string的参数是支持的基本数值类型，避免类型不匹配错误。

注意事项

1. 性能考虑：虽然std::to_string使用方便，但在性能关键的代码中，可能需要评估其性能影响，尤其是在频繁调用的情况下。
2. 异常处理：std::to_string在转换过程中不会抛出异常，但在使用转换结果时，仍需注意处理可能的异常情况。
3. 格式控制：std::to_string使用默认的格式进行转换，如果需要特定的格式（如指定小数位数），可能需要使用std::stringstream进行更细粒度的控制。

类型特性

背景

在C++98和C++03中，编译时类型信息的获取和操作需要通过模板元编程技巧来实现，这通常非常复杂且不直观。为了简化这些操作并提供更强大的类型支持，C++11引入了类型特性（Type Traits）库，提供了一组模板，用于在编译时检查和操作类型信息。

定义

类型特性库是C++11标准库中的一部分，包含在<type_traits>头文件中。它提供了一组模板元函数，可以在编译时检查类型的特性和进行类型操作，如判断类型是否为某种特性、添加或移除类型修饰符等。

作用

1. 类型检查：在编译时检查类型的特性，如是否为指针、是否为整型、是否为类类型等。
2. 类型变换：在编译时进行类型变换，如添加或移除指针、引用、常量修饰符等。
3. 提高泛型编程的灵活性：通过类型特性，可以编写更加灵活和通用的模板代码。

示例代码

以下示例展示了如何使用类型特性库进行类型检查和类型变换：

#include <iostream>
#include <type_traits>

template<typename T>
void checkType() {
    if (std::is_integral<T>::value) {
        std::cout << "Type is integral." << std::endl;
    } else {
        std::cout << "Type is not integral." << std::endl;
    }

    if (std::is_pointer<T>::value) {
        std::cout << "Type is a pointer." << std::endl;
    } else {
        std::cout << "Type is not a pointer." << std::endl;
    }
}

int main() {
    checkType<int>();            // 输出：Type is integral. Type is not a pointer.
    checkType<double>();         // 输出：Type is not integral. Type is not a pointer.
    checkType<int*>();           // 输出：Type is not integral. Type is a pointer.

    // 类型变换示例
    using Type = std::remove_pointer<int*>::type;  // Type 为 int
    std::cout << std::is_same<Type, int>::value << std::endl; // 输出：1 (true)

    using ConstType = std::add_const<int>::type;  // ConstType 为 const int
    std::cout << std::is_const<ConstType>::value << std::endl; // 输出：1 (true)

    return 0;
}

实用技巧

1. 常用类型特性：熟悉并使用常见的类型特性，如std::is_integral、std::is_pointer、std::remove_const、std::add_pointer等，可以大大简化模板编程。
2. 结合静态断言：使用static_assert结合类型特性，可以在编译时进行更严格的类型检查，捕获潜在的类型错误。
3. 模板重载：结合类型特性和SFINAE（Substitution Failure Is Not An Error），可以实现更加灵活的模板重载。

注意事项

1. 编译时开销：类型特性在编译时进行类型检查和变换，可能会增加编译时间，特别是在大型模板库中使用时。
2. 类型特性的局限性：尽管类型特性提供了强大的类型操作能力，但在某些复杂场景下，仍可能需要结合其他模板元编程技巧来实现目标。

智能指针

背景

在C++98中，动态内存管理主要依赖于手动分配和释放（new和delete）。这种方式虽然灵活，但容易导致内存泄漏、悬挂指针等问题。为了简化内存管理并提高代码的安全性和可靠性，C++11引入了智能指针（Smart Pointers），它们通过RAII（Resource Acquisition Is Initialization）机制来自动管理动态分配的内存。

定义

智能指针是一种模板类，用于自动管理动态分配的对象。C++11标准库中提供了三种主要的智能指针：std::unique_ptr、std::shared_ptr和std::weak_ptr。

• std::unique_ptr：独占所有权的智能指针，不能共享所有权。
• std::shared_ptr：共享所有权的智能指针，可以有多个指针共享同一个对象。
• std::weak_ptr：辅助std::shared_ptr的智能指针，解决循环引用问题。

作用

1. 自动内存管理：智能指针通过RAII机制自动管理内存，防止内存泄漏和悬挂指针。
2. 提高代码安全性：减少手动管理内存带来的错误，提高代码的安全性和可维护性。
3. 简化资源管理：不仅适用于内存管理，还可以用于管理其他资源（如文件句柄、网络连接等）。

示例代码

以下示例展示了三种主要智能指针的基本用法：

#include <iostream>
#include <memory>

class Example {
public:
    Example() {
        std::cout << "Example constructor" << std::endl;
    }
    ~Example() {
        std::cout << "Example destructor" << std::endl;
    }
    void show() {
        std::cout << "Example::show()" << std::endl;
    }
};

void uniquePointerDemo() {
    std::unique_ptr<Example> uptr(new Example());
    uptr->show();
    // std::unique_ptr<Example> uptr2 = uptr; // 错误，不能拷贝
    std::unique_ptr<Example> uptr2 = std::move(uptr); // 可以移动
    if (!uptr) {
        std::cout << "uptr is null after move" << std::endl;
    }
}

void sharedPointerDemo() {
    std::shared_ptr<Example> sptr1(new Example());
    std::shared_ptr<Example> sptr2 = sptr1; // 可以共享
    sptr1->show();
    sptr2->show();
    std::cout << "sptr1 use count: " << sptr1.use_count() << std::endl;
    std::cout << "sptr2 use count: " << sptr2.use_count() << std::endl;
}

void weakPointerDemo() {
    std::shared_ptr<Example> sptr(new Example());
    std::weak_ptr<Example> wptr = sptr; // weak_ptr不影响shared_ptr的计数
    if (auto spt = wptr.lock()) { // 提升为shared_ptr
        spt->show();
    } else {
        std::cout << "wptr is expired" << std::endl;
    }
}

int main() {
    uniquePointerDemo();
    sharedPointerDemo();
    weakPointerDemo();
    return 0;
}

实用技巧

1. 选择合适的智能指针：根据所有权需求选择合适的智能指针类型，使用std::unique_ptr管理独占所有权的资源，使用std::shared_ptr管理共享所有权的资源。
2. 避免循环引用：在使用std::shared_ptr时，注意避免循环引用，可以使用std::weak_ptr来打破循环引用。
3. 结合工厂函数：结合std::make_unique和std::make_shared工厂函数，简化智能指针的创建。

注意事项

1. 性能开销：std::shared_ptr的引用计数机制有一定的性能开销，在性能敏感的场景下，应评估其影响。
2. 线程安全：std::shared_ptr的引用计数是线程安全的，但管理的对象操作需要额外的同步机制。
3. 避免滥用：尽量不要滥用智能指针，特别是std::shared_ptr，以免增加不必要的开销和复杂性。

std::chrono

背景

在C++98和C++03中，时间和日期处理通常依赖于C语言的<ctime>库，该库提供了一些基本的时间函数，但功能相对有限且不够现代化。为了提供更强大、更灵活的时间处理能力，C++11引入了<chrono>库，该库提供了丰富的时间和日期处理功能，并且更加类型安全。

定义

std::chrono是C++11标准库中的一个头文件，包含了一组用于时间处理的类和函数。这些类和函数支持高精度计时、时间点和时间段的计算。主要的组件包括：

1. std::chrono::duration：表示时间段的模板类。
2. std::chrono::time_point：表示时间点的模板类。
3. 时钟类型：如std::chrono::system_clock、std::chrono::steady_clock和std::chrono::high_resolution_clock。

作用

1. 高精度计时：支持纳秒级别的高精度计时，适用于性能测量和精确时间计算。
2. 类型安全：通过类型安全的时间处理，避免因单位混淆导致的错误。
3. 时间运算：支持时间点和时间段的加减运算，便于进行复杂的时间计算。

示例代码

以下示例展示了std::chrono库的基本用法，包括时间段、时间点和时钟的使用：

#include <iostream>
#include <chrono>
#include <thread>

void example_duration() {
    using namespace std::chrono;
    duration<int, std::ratio<60>> one_minute(1); // 1 minute
    std::cout << "One minute is " << one_minute.count() << " minutes." << std::endl;

    duration<double, std::milli> one_and_half_second(1500); // 1.5 seconds in milliseconds
    std::cout << "One and half second is " << one_and_half_second.count() << " milliseconds." << std::endl;
}

void example_time_point() {
    using namespace std::chrono;
    system_clock::time_point now = system_clock::now();
    std::time_t now_time = system_clock::to_time_t(now);
    std::cout << "Current time: " << std::ctime(&now_time);

    system_clock::time_point future = now + hours(1); // 1 hour later
    std::time_t future_time = system_clock::to_time_t(future);
    std::cout << "Future time: " << std::ctime(&future_time);
}

void example_high_resolution_clock() {
    using namespace std::chrono;
    auto start = high_resolution_clock::now();

    std::this_thread::sleep_for(milliseconds(100)); // Simulate work

    auto end = high_resolution_clock::now();
    duration<double, std::milli> elapsed = end - start;
    std::cout << "Elapsed time: " << elapsed.count() << " ms" << std::endl;
}

int main() {
    example_duration();
    example_time_point();
    example_high_resolution_clock();
    return 0;
}

实用技巧

1. 使用别名简化代码：使用using语句为常用的时间类型定义别名，可以简化代码，例如using namespace std::chrono。
2. 线程睡眠：使用std::this_thread::sleep_for和std::this_thread::sleep_until进行线程睡眠，提供更高精度的控制。
3. 精确计时：使用std::chrono::high_resolution_clock进行高精度的计时操作，适用于性能测量。

注意事项

1. 时钟类型选择：根据应用场景选择合适的时钟类型，例如，system_clock用于系统时间，steady_clock用于测量时间间隔，high_resolution_clock用于高精度计时。
2. 时区处理：std::chrono库不直接处理时区问题，需要结合其他库（如<ctime>）进行时区转换和处理。
3. 时间转换：在进行时间单位转换时，注意使用正确的比例，以确保结果的准确性。

元组

背景

在C++98及之前的版本中，C++缺乏一种灵活的数据结构来同时存储多种类型的元素。虽然可以使用结构体或类来解决这个问题，但这些方法需要额外的定义和代码，显得不够简洁和灵活。为了提供一种更方便的方法来存储和处理多类型的元素集合，C++11引入了元组（Tuple）。

定义

std::tuple是C++11标准库中的一个模板类，用于存储多种类型的多个值。它位于头文件<tuple>中。元组提供了一种灵活的数据结构，可以包含任意数量和类型的元素。

#include <tuple>

作用

1. 存储多种类型的元素：允许同时存储多种不同类型的元素，提供了一种灵活的数据结构。
2. 简化函数返回值：可以用于函数返回多个值，而不需要定义结构体或类。
3. 便捷的数据打包和解包：通过标准库函数方便地创建、访问和修改元组中的元素。

示例代码

以下示例展示了如何使用std::tuple进行基本操作：

#include <iostream>
#include <tuple>
#include <string>

// 创建并返回一个元组
std::tuple<int, std::string, double> createTuple() {
    return std::make_tuple(42, "Hello", 3.14);
}

int main() {
    // 创建元组
    std::tuple<int, std::string, double> myTuple = std::make_tuple(1, "example", 2.718);

    // 访问元组中的元素
    std::cout << "Integer value: " << std::get<0>(myTuple) << std::endl;
    std::cout << "String value: " << std::get<1>(myTuple) << std::endl;
    std::cout << "Double value: " << std::get<2>(myTuple) << std::endl;

    // 修改元组中的元素
    std::get<0>(myTuple) = 100;
    std::cout << "Modified integer value: " << std::get<0>(myTuple) << std::endl;

    // 从函数中获取元组
    auto returnedTuple = createTuple();
    std::cout << "Returned integer value: " << std::get<0>(returnedTuple) << std::endl;
    std::cout << "Returned string value: " << std::get<1>(returnedTuple) << std::endl;
    std::cout << "Returned double value: " << std::get<2>(returnedTuple) << std::endl;

    // 使用结构化绑定（C++17特性）
    auto [intValue, strValue, doubleValue] = createTuple();
    std::cout << "Structured binding values: " << intValue << ", " << strValue << ", " << doubleValue << std::endl;

    return 0;
}

实用技巧

1. 使用std::make_tuple：使用std::make_tuple函数可以简化元组的创建。
2. 访问和修改元组元素：通过std::get<N>函数模板访问和修改元组中的元素，N为元素索引。
3. 与结构化绑定结合使用：在C++17及之后，可以结合结构化绑定来更方便地解包元组中的元素。

注意事项

1. 元素顺序和类型：元组中的元素类型和顺序是固定的，使用时需要确保访问的索引和类型正确。
2. 性能考虑：虽然元组提供了灵活性，但在性能敏感的场景下，使用结构体或类可能更为高效。
3. 头文件依赖：使用元组时，确保包含<tuple>头文件。

std::tie

背景

在C++98及之前的版本中，提取和处理函数返回的多个值常常需要使用结构体或类，这增加了代码的复杂性。C++11引入了std::tuple，使得返回和处理多个值变得更为简单和灵活。然而，访问和解包元组中的元素仍然需要使用std::get，这在某些情况下显得不够方便。为了解决这一问题，C++11引入了std::tie，用于将元组的元素解包到多个变量中。

定义

std::tie是C++11标准库中的一个函数模板，用于创建一个元组，该元组的元素是对传入变量的引用。它通常用于将元组解包到多个变量中，简化从元组提取数据的过程。

#include <tuple>

作用

1. 解包元组：将元组中的元素解包到多个变量中，简化代码。
2. 简化多值返回处理：与std::tuple结合使用，方便地处理和解包函数返回的多个值。
3. 忽略特定元素：在解包时可以使用std::ignore来忽略不需要的元组元素。

示例代码

以下示例展示了如何使用std::tie进行元组解包和多值返回处理：

#include <iostream>
#include <tuple>
#include <string>

// 一个返回元组的函数
std::tuple<int, std::string, double> createTuple() {
    return std::make_tuple(42, "Hello", 3.14);
}

int main() {
    // 使用 std::tie 解包元组
    int intValue;
    std::string strValue;
    double doubleValue;

    std::tie(intValue, strValue, doubleValue) = createTuple();

    std::cout << "Integer value: " << intValue << std::endl;
    std::cout << "String value: " << strValue << std::endl;
    std::cout << "Double value: " << doubleValue << std::endl;

    // 忽略特定元素
    std::tie(std::ignore, strValue, doubleValue) = createTuple();
    std::cout << "Ignored integer value, String value: " << strValue << ", Double value: " << doubleValue << std::endl;

    return 0;
}

实用技巧

1. 结合std::tuple使用：std::tie与std::tuple结合使用，可以简化函数返回多个值的处理过程。
2. 使用std::ignore：当不需要元组中的某些元素时，可以使用std::ignore来忽略它们。
3. 简化交换操作：std::tie可以与std::swap结合使用，方便地交换多个变量的值。

注意事项

1. 引用有效性：std::tie创建的元组元素是对传入变量的引用，确保这些变量在使用过程中是有效的。
2. 类型匹配：确保std::tie解包的变量类型与元组中的元素类型匹配，否则可能会导致编译错误或运行时错误。
3. 头文件依赖：使用std::tie时，确保包含<tuple>头文件。

std::array

背景

在C++98和C++03中，数组主要通过内置数组类型来实现，这种数组虽然高效，但在使用上存在一些缺点，例如缺乏边界检查、不能通过拷贝或赋值进行操作、与标准库算法不兼容等。为了弥补这些不足，C++11引入了std::array，提供了一种更为安全和灵活的数组实现。

定义

std::array是C++11标准库中的一个模板类，用于创建固定大小的数组。它位于头文件<array>中，并提供了数组的全部功能，同时具有STL容器的接口。

#include <array>

作用

1. 类型安全和边界检查：std::array提供了类型安全和边界检查，避免了内置数组的潜在风险。
2. 与STL兼容：std::array具有STL容器的接口，可以与标准库算法和容器无缝结合。
3. 固定大小的高效实现：std::array在编译时确定大小，具有与内置数组相同的性能，但提供了更多的功能和安全性。

示例代码

以下示例展示了如何使用std::array进行基本操作：

#include <iostream>
#include <array>
#include <algorithm>

int main() {
    // 创建并初始化一个 std::array
    std::array<int, 5> arr = {1, 2, 3, 4, 5};

    // 访问数组元素
    std::cout << "Element at index 0: " << arr[0] << std::endl;
    std::cout << "Element at index 1: " << arr.at(1) << std::endl;

    // 修改数组元素
    arr[2] = 10;
    std::cout << "Modified element at index 2: " << arr[2] << std::endl;

    // 使用标准库算法
    std::sort(arr.begin(), arr.end());
    std::cout << "Sorted array: ";
    for (const auto& elem : arr) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 获取数组的大小
    std::cout << "Array size: " << arr.size() << std::endl;

    // 使用 ranged-for 循环
    std::cout << "Array elements: ";
    for (const auto& elem : arr) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

实用技巧

1. 使用std::array替代内置数组：尽量使用std::array替代内置数组，以获得更高的安全性和功能性。
2. 结合STL算法使用：std::array提供了标准容器接口，可以方便地与STL算法结合使用，如std::sort、std::find等。
3. 编译时确定大小：std::array的大小在编译时确定，确保在运行时不会改变，这有助于提高性能和减少错误。

注意事项

1. 固定大小：std::array的大小在编译时确定，不能在运行时修改。如果需要动态大小的数组，可以考虑使用std::vector。
2. 初始化方式：在使用std::array时，确保正确初始化数组元素，可以使用列表初始化或默认初始化。
3. 性能考虑：虽然std::array提供了更高的安全性，但在性能关键的代码中，仍需评估其性能开销。

无序容器

背景

在C++98和C++03中，标准库提供的关联容器如std::map和std::set使用红黑树实现，具有良好的性能和保证，但对于某些应用场景，哈希表实现的无序容器可能更为高效。C++11引入了无序容器（Unordered Containers），提供了基于哈希表实现的容器，如std::unordered_map和std::unordered_set，以提高查找和插入操作的效率。

定义

无序容器是基于哈希表实现的容器，它们不保证元素的顺序，但可以提供更高效的查找、插入和删除操作。主要的无序容器包括：

• std::unordered_map：存储键值对的无序关联容器。
• std::unordered_set：存储唯一元素的无序集合。
• std::unordered_multimap：允许重复键的无序关联容器。
• std::unordered_multiset：允许重复元素的无序集合。

这些容器定义在头文件<unordered_map>和<unordered_set>中。

作用

1. 高效的查找和插入：由于基于哈希表实现，无序容器在平均情况下可以提供常数时间复杂度的查找和插入操作。
2. 简单易用的接口：无序容器的接口与传统的有序容器相似，易于使用和学习。
3. 灵活的哈希函数和比较函数：支持自定义的哈希函数和比较函数，满足不同应用场景的需求。

示例代码

以下示例展示了如何使用std::unordered_map和std::unordered_set进行基本操作：

#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <string>

int main() {
    // 使用 unordered_map
    std::unordered_map<std::string, int> umap;
    umap["one"] = 1;
    umap["two"] = 2;
    umap["three"] = 3;

    // 访问元素
    std::cout << "umap['one']: " << umap["one"] << std::endl;
    std::cout << "umap['two']: " << umap.at("two") << std::endl;

    // 遍历元素
    std::cout << "unordered_map elements:" << std::endl;
    for (const auto& pair : umap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // 使用 unordered_set
    std::unordered_set<std::string> uset = {"apple", "banana", "cherry"};

    // 插入和查找元素
    uset.insert("date");
    if (uset.find("banana") != uset.end()) {
        std::cout << "banana is in the set" << std::endl;
    }

    // 遍历元素
    std::cout << "unordered_set elements:" << std::endl;
    for (const auto& elem : uset) {
        std::cout << elem << std::endl;
    }

    return 0;
}

实用技巧

1. 选择合适的无序容器：根据应用场景选择合适的无序容器，例如，使用std::unordered_map存储键值对，使用std::unordered_set存储唯一元素。
2. 自定义哈希函数：如果标准哈希函数不适用于特定类型，可以定义自己的哈希函数，并传递给无序容器。
3. 注意负载因子：无序容器的性能受负载因子影响，可以使用rehash和reserve函数来控制容器的负载因子，提高性能。

注意事项

1. 内存使用：无序容器由于哈希表的实现，通常比有序容器使用更多的内存。
2. 哈希冲突：哈希表性能依赖于哈希函数的质量，糟糕的哈希函数可能导致大量冲突，降低性能。
3. 无序性：无序容器不保证元素的顺序，如果需要元素的有序性，应使用有序容器（如std::map和std::set）。

std::make_shared

背景

在C++98和C++03中，手动管理动态内存是一项常见但容易出错的任务。C++11引入了智能指针，例如std::shared_ptr，以帮助自动管理动态内存并减少内存泄漏风险。然而，使用std::shared_ptr时需要分别调用new运算符和std::shared_ptr的构造函数，这在某些情况下会导致不必要的性能开销和代码复杂性。为了解决这些问题，C++11引入了std::make_shared函数。

定义

std::make_shared是C++11标准库中的一个模板函数，用于创建和初始化std::shared_ptr对象。它简化了std::shared_ptr的创建过程，并提供了一种更高效和安全的方式来分配和管理动态内存。

#include <memory>

作用

1. 简化代码：通过单个函数调用同时分配内存并创建std::shared_ptr对象，减少了代码复杂性。
2. 提高性能：std::make_shared通过一次内存分配创建对象和控制块，减少了内存分配的次数，提高了性能。
3. 安全性：减少了手动管理内存的错误风险，自动处理内存分配和释放。

示例代码

以下示例展示了如何使用std::make_shared创建和管理std::shared_ptr对象：

#include <iostream>
#include <memory>

class Example {
public:
    Example(int value) : value(value) {
        std::cout << "Example constructor: " << value << std::endl;
    }
    ~Example() {
        std::cout << "Example destructor: " << value << std::endl;
    }
    int getValue() const { return value; }

private:
    int value;
};

int main() {
    // 使用 std::make_shared 创建 std::shared_ptr
    std::shared_ptr<Example> ptr = std::make_shared<Example>(42);

    // 访问对象成员
    std::cout << "Value: " << ptr->getValue() << std::endl;

    // 使用 std::shared_ptr 管理的对象
    {
        std::shared_ptr<Example> ptr2 = ptr;
        std::cout << "Shared count: " << ptr.use_count() << std::endl;
    } // ptr2 超出作用域，引用计数减1

    std::cout << "Shared count after ptr2 is out of scope: " << ptr.use_count() << std::endl;

    return 0;
} // ptr 超出作用域，Example 对象被销毁

实用技巧

1. 首选std::make_shared：在需要创建std::shared_ptr对象时，优先使用std::make_shared，以获得更高的性能和简洁的代码。
2. 避免裸new操作：尽量避免使用裸new操作符直接分配内存，改用std::make_shared或其他智能指针创建函数。
3. 检查引用计数：使用use_count方法可以检查std::shared_ptr对象的引用计数，便于调试和资源管理。

注意事项

1. 控制块和对象的共享生命周期：使用std::make_shared会将控制块和对象的内存分配在一起，共享生命周期。这通常是有益的，但在需要独立管理控制块和对象的生命周期时，可能不适用。
2. 内存分配失败：尽管std::make_shared简化了内存管理，仍需考虑内存分配失败的情况，并适当处理异常。
3. 避免循环引用：使用std::shared_ptr时，要注意避免循环引用导致的内存泄漏。可以使用std::weak_ptr来打破循环引用。

std::ref

背景

在C++98和C++03中，通过模板和标准库算法传递引用有时比较繁琐，特别是当需要将引用传递给函数对象或算法时。这种需求在泛型编程中很常见，但C++98/03没有提供直接支持。为了简化引用的传递，C++11引入了std::ref和std::cref，以便更方便地在模板和标准库算法中传递引用。

定义

std::ref和std::cref是C++11标准库中的两个函数模板，分别用于创建对对象的引用包装器和对常量对象的引用包装器。它们位于头文件<functional>中。

• std::ref：创建一个包装器，用于按引用传递对象。
• std::cref：创建一个包装器，用于按常量引用传递对象。

#include <functional>

作用

1. 简化引用传递：通过包装器简化在模板和标准库算法中传递引用的过程。
2. 提高代码灵活性：使函数对象和标准库算法能够更灵活地处理引用参数。
3. 避免复制开销：通过按引用传递对象，避免不必要的复制操作，提高性能。

示例代码

以下示例展示了如何使用std::ref和std::cref进行引用传递：

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>

void print(int& n) {
    std::cout << n << " ";
}

int main() {
    int x = 10;
    int y = 20;

    // 使用 std::ref 包装器
    auto ref_x = std::ref(x);
    auto ref_y = std::ref(y);

    // 修改引用对象的值
    ref_x.get() = 15;
    ref_y.get() = 25;

    std::cout << "x: " << x << ", y: " << y << std::endl;

    // 使用 std::ref 在标准库算法中传递引用
    std::vector<std::reference_wrapper<int>> vec = {std::ref(x), std::ref(y)};
    std::for_each(vec.begin(), vec.end(), [](int& n) { n += 10; });

    std::cout << "After modification:" << std::endl;
    std::cout << "x: " << x << ", y: " << y << std::endl;

    // 使用 std::cref 包装器
    std::vector<int> nums = {1, 2, 3, 4, 5};
    std::for_each(nums.begin(), nums.end(), std::cref(print));

    return 0;
}

实用技巧

1. 使用std::ref和std::cref传递引用：在需要传递引用的地方，使用std::ref和std::cref来避免不必要的拷贝。
2. 结合标准库算法使用：在使用标准库算法（如std::for_each）时，使用std::ref和std::cref可以更方便地处理引用参数。
3. 避免引用失效：确保使用std::ref和std::cref包装的对象在其生命周期内有效，避免悬挂引用。

注意事项

1. 生命周期管理：确保被引用对象在包装器的生命周期内保持有效，避免悬挂引用。
2. 与std::bind结合使用：在使用std::bind时，使用std::ref和std::cref可以更好地管理参数传递，避免拷贝。
3. 避免误用：仅在需要传递引用时使用std::ref和std::cref，不必要时避免过度使用。

内存模型

背景

在C++98和C++03中，C++标准并未明确定义多线程程序的内存模型。这意味着，不同编译器和硬件平台上的多线程程序可能会表现出不同的行为，导致难以预测和调试的错误。为了提供一致的多线程编程模型，并确保跨平台的行为一致性，C++11引入了内存模型（Memory Model）。

定义

C++11的内存模型定义了一组规则，用于描述多线程程序中不同线程之间如何共享和访问内存。这些规则包括：

• 顺序一致性（Sequential Consistency）：所有线程都按照程序顺序执行，并且所有内存操作在所有线程中以相同的顺序出现。
• 数据竞赛（Data Race）：如果两个线程在没有同步的情况下同时访问一个共享变量，并且至少有一个是写操作，那么就会发生数据竞赛。

内存模型通过<atomic>头文件提供了一些原子操作和内存序列化规则，以帮助开发者实现安全的并发编程。

作用

1. 定义跨平台一致的行为：通过明确的内存模型定义，确保多线程程序在不同平台上的行为一致。
2. 提供线程安全的原子操作：通过标准库中的原子操作，确保对共享变量的安全访问。
3. 减少并发错误：帮助开发者理解并避免数据竞赛和其他并发错误。

示例代码

以下示例展示了如何使用C++11的内存模型和原子操作：

#include <iostream>
#include <thread>
#include <atomic>
#include <vector>

std::atomic<int> counter(0);

void increment(int iterations) {
    for (int i = 0; i < iterations; ++i) {
        ++counter; // 原子操作，避免数据竞赛
    }
}

int main() {
    const int numThreads = 10;
    const int numIterations = 1000;

    std::vector<std::thread> threads;
    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(increment, numIterations);
    }

    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Final counter value: " << counter.load() << std::endl;
    return 0;
}

实用技巧

1. 使用std::atomic进行原子操作：在多线程环境中，使用std::atomic类型进行原子操作，避免数据竞赛。
2. 理解内存序：C++11提供了不同的内存序（如memory_order_relaxed、memory_order_acquire、memory_order_release等），根据应用场景选择合适的内存序，以优化性能。
3. 避免数据竞赛：通过适当的同步机制（如互斥锁或原子操作）确保对共享数据的安全访问。

注意事项

1. 性能开销：虽然原子操作和内存序提供了线程安全性，但它们可能会带来性能开销。在性能敏感的代码中，需仔细评估其影响。
2. 正确使用内存序：不同的内存序有不同的语义和性能影响，需要根据具体场景正确使用。
3. 调试复杂性：并发编程中的错误（如数据竞赛和死锁）可能难以调试。使用内存模型和原子操作可以减少这些错误，但不能完全消除调试的复杂性。

std::async

背景

在C++98和C++03中，处理并发任务通常需要使用操作系统提供的线程库，手动管理线程的创建、同步和销毁。这不仅增加了代码复杂性，还容易引入并发错误。为了简化并发编程并提高代码的可读性和可维护性，C++11引入了std::async，提供了一种更简单的方式来启动异步任务。

定义

std::async是C++11标准库中的一个模板函数，用于启动异步任务。它可以自动管理线程的创建和销毁，并返回一个std::future对象，用于获取异步任务的结果。std::async位于头文件<future>中。

#include <future>

作用

1. 简化异步编程：std::async简化了异步任务的启动和管理，使得并发编程更加直观和易用。
2. 自动线程管理：自动处理线程的创建和销毁，减少了手动管理线程的复杂性。
3. 结果获取：通过返回std::future对象，可以方便地获取异步任务的结果，并处理可能的异常。

示例代码

以下示例展示了如何使用std::async启动异步任务并获取结果：

#include <iostream>
#include <future>
#include <thread>
#include <chrono>

// 一个模拟长时间运行的任务
int longRunningTask(int n) {
    std::this_thread::sleep_for(std::chrono::seconds(n));
    return n * n;
}

int main() {
    std::cout << "Starting async task..." << std::endl;

    // 使用 std::async 启动异步任务
    std::future<int> result = std::async(std::launch::async, longRunningTask, 3);

    std::cout << "Doing other work in main thread..." << std::endl;

    // 获取异步任务的结果
    int value = result.get();
    std::cout << "Result from async task: " << value << std::endl;

    return 0;
}

实用技巧

1. 选择启动策略：std::async的第一个参数是启动策略，使用std::launch::async明确要求异步任务在新线程中运行，使用std::launch::deferred则在调用get或wait时才运行任务。
2. 处理异常：在获取异步任务结果时（通过get方法），捕获可能的异常，确保程序的健壮性。
3. 避免竞争条件：确保异步任务和主线程或其他线程之间没有竞争条件，必要时使用同步机制（如互斥锁）保护共享数据。

注意事项

1. 启动策略：默认情况下，std::async可能使用std::launch::async或std::launch::deferred。明确指定启动策略可以避免不确定性。
2. 资源管理：虽然std::async简化了线程管理，但仍需注意资源的合理使用，避免启动过多的线程导致资源耗尽。
3. 异步任务生命周期：确保std::future对象在任务完成前保持有效，以避免任务被取消或未完成。

std::begin/end

背景

在C++98和C++03中，标准库容器（如std::vector、std::list等）提供了begin()和end()成员函数，用于获取容器的迭代器。然而，对于C风格数组或其他类型的范围，获取迭代器并不直观。为了统一获取迭代器的方式并简化代码，C++11引入了std::begin和std::end模板函数。

定义

std::begin和std::end是C++11标准库中的两个函数模板，用于获取容器或数组的起始迭代器和结束迭代器。它们定义在头文件<iterator>中。

#include <iterator>

namespace std {
    template <class C> 
    auto begin(C& c) -> decltype(c.begin());
    
    template <class C> 
    auto begin(const C& c) -> decltype(c.begin());

    template <class T, size_t N> 
    T* begin(T (&array)[N]);

    template <class C> 
    auto end(C& c) -> decltype(c.end());
    
    template <class C> 
    auto end(const C& c) -> decltype(c.end());

    template <class T, size_t N> 
    T* end(T (&array)[N]);
}

作用

1. 统一接口：为所有容器和数组提供统一的接口来获取迭代器，无需考虑容器类型。
2. 简化代码：通过std::begin和std::end，简化了遍历容器和数组的代码，提升代码的可读性和维护性。
3. 增强泛型编程：使得泛型算法能够处理更多类型的范围，包括C风格数组。

示例代码

以下示例展示了如何使用std::begin和std::end遍历不同类型的容器和数组：

#include <iostream>
#include <vector>
#include <array>
#include <iterator>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    int arr[] = {6, 7, 8, 9, 10};
    std::array<int, 5> stdarr = {11, 12, 13, 14, 15};

    // 使用 std::begin 和 std::end 遍历 std::vector
    std::cout << "std::vector: ";
    for (auto it = std::begin(vec); it != std::end(vec); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 使用 std::begin 和 std::end 遍历 C 风格数组
    std::cout << "C array: ";
    for (auto it = std::begin(arr); it != std::end(arr); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 使用 std::begin 和 std::end 遍历 std::array
    std::cout << "std::array: ";
    for (auto it = std::begin(stdarr); it != std::end(stdarr); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

实用技巧

1. 优先使用std::begin和std::end：在遍历容器或数组时，优先使用std::begin和std::end来获取迭代器，确保代码的一致性和简洁性。
2. 结合范围for循环：在C++11中，可以结合范围for循环使用std::begin和std::end，使代码更简洁。例如：for (auto& elem : vec) { ... }。
3. 泛型算法中使用：在编写泛型算法时，使用std::begin和std::end可以使算法适用于更多类型的范围，包括容器和数组。

注意事项

1. 确保头文件包含：使用std::begin和std::end时，确保包含头文件<iterator>。
2. 适用范围：std::begin和std::end适用于所有标准库容器和C风格数组，但对于自定义的容器，需要提供begin()和end()成员函数。
3. 返回类型：注意std::begin和std::end的返回类型，它们根据传入对象的类型返回相应的迭代器类型。