C++标准库 第三章 语言新特性

1. auto 关键字：自动类型推断

2. lambda 表达式：匿名函数

3. range-based for 循环：基于范围的 for 循环

4. nullptr 关键字：空指针常量

5. constexpr 关键字：编译时常量表达式

6. static_assert 关键字：静态断言

7. 右值引用：移动语义和完美转发

8. 智能指针：shared_ptr、unique_ptr、weak_ptr

9. 多线程支持：std::thread、std::mutex、std::condition_variable 等

10. 变长参数模板：可变参数模板函数和类模板

11. 委托构造函数：构造函数之间相互调用

12. 默认函数：使用默认值的函数参数和成员变量

13. override 和 final 关键字：重写和禁止重写

14. Unicode 字符串字面量：u8、u、U、L 前缀

15. 原生字符串字面量：R 前缀

16. 强类型枚举：enum class

17. constexpr 函数的扩展：允许包含控制流语句

18. 新的标准库组件：std::array、std::forward_list、std::unordered_map 等。

以下是使用 auto 完成类型自动推导的 C++ 标准库例子：

1. 使用 auto 推导 vector 容器中的元素类型：

#include <vector>

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

    for (auto it = v.begin(); it != v.end(); ++it)
    {
        // auto 推导出的类型为 int
        auto element = *it;
        std::cout << element << " ";
    }

    return 0;
}

2. 使用 auto 推导 map 容器中的键值对类型：

#include <map>

int main()
{
    std::map<std::string, int> m = {{"apple", 1}, {"banana", 2}, {"orange", 3}};

    for (auto it = m.begin(); it != m.end(); ++it)
    {
        // auto 推导出的类型为 std::pair<const std::string, int>
        auto key_value = *it;
        std::cout << key_value.first << " " << key_value.second << std::endl;
    }

    return 0;
}

3. 使用 auto 推导 lambda 表达式的返回类型：

#include <iostream>

int main()
{
    auto add = [](int a, int b) -> int {
        return a + b;
    };

    // auto 推导出的类型为 int
    auto result = add(3, 4);
    std::cout << result << std::endl;

    return 0;
}

一致性初始化（Uniform Initialization）和初值列（Initializer List）是 C++11 引入的新特性，它们可以用于初始化各种类型的对象，包括数组、结构体、类等。

以下是一些示例：

1. 数组的一致性初始化和初值列：

int arr1[3] = {1, 2, 3};  // 传统的初始化方式
int arr2[3] {1, 2, 3};    // 一致性初始化
int arr3[] {1, 2, 3};     // 一致性初始化，自动推导数组大小

2. 结构体的一致性初始化和初值列：

struct Point {
    int x;
    int y;
};

Point p1 = {1, 2};        // 传统的初始化方式
Point p2 {1, 2};          // 一致性初始化
Point p3 = { .y = 2, .x = 1 };   // 使用初值列初始化部分成员

3. 类的一致性初始化和初值列：

class Person {
public:
    Person(std::string name, int age) : name_(name), age_(age) {}
private:
    std::string name_;
    int age_;
};

Person p1("Alice", 20);    // 传统的初始化方式
Person p2 {"Alice", 20};   // 一致性初始化

4. STL 容器的一致性初始化和初值列：

std::vector<int> v1 = {1, 2, 3};    // 传统的初始化方式
std::vector<int> v2 {1, 2, 3};      // 一致性初始化
std::map<int, std::string> m1 = {{1, "one"}, {2, "two"}};    // 传统的初始化方式
std::map<int, std::string> m2 {{1, "one"}, {2, "two"}};      // 一致性初始化

C++11 引入了一种新的循环语句，即 Range-Based for 循环，它可以方便地遍历容器、数组等序列类型的对象。以下是一些示例：

1. 遍历数组：

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

2. 遍历 STL 容器：

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

3. 遍历字符串：

std::string str = "hello";
for (char c : str) {
    std::cout << c << " ";
}
// 输出：h e l l o

4. 遍历 C++11 引入的初始化列表：

for (int x : {1, 2, 3}) {
    std::cout << x << " ";
}
// 输出：1 2 3

Range-Based for 循环可以避免手动计算容器的大小，也可以避免使用迭代器等复杂的语法，使代码更加简洁易懂。

C++11 引入了 Move 语义和 Rvalue Reference 这两个新特性，它们可以提高代码的性能和效率，尤其是在处理大量数据时。以下是一些示例：

1. Move 语义：

std::string str1 = "hello";
std::string str2 = std::move(str1);  // 使用 Move 语义将 str1 移动到 str2
std::cout << str1 << std::endl;      // 输出空字符串
std::cout << str2 << std::endl;      // 输出 "hello"

在上面的例子中，使用 std::move() 函数将 str1 移动到 str2 中，这样可以避免复制字符串的操作，提高了代码的效率。

2. Rvalue Reference：

void foo(std::string&& str) {  // 使用 Rvalue Reference 作为参数
    std::cout << str << std::endl;
}

std::string str = "hello";
foo(std::move(str));  // 将 str 移动到 foo() 函数中

在上面的例子中，foo() 函数使用了 Rvalue Reference 作为参数，这样可以接受一个右值引用，即可以接受一个临时对象或者使用 std::move() 函数移动的对象。在调用 foo() 函数时，使用 std::move() 函数将 str 移动到函数中，避免了复制字符串的操作，提高了代码的效率。

3. 完美转发：

template<typename T>
void bar(T&& arg) {  // 使用完美转发的函数模板
    foo(std::forward<T>(arg));  // 将参数 arg 完美转发到 foo() 函数中
}

std::string str = "hello";
bar(str);  // 调用 bar() 函数，将 str 完美转发到 foo() 函数中

在上面的例子中，使用了完美转发的函数模板 bar()，它可以接受任意类型的参数，并将参数完美转发到 foo() 函数中。在调用 bar() 函数时，将 str 作为参数传入，bar() 函数会将 str 完美转发到 foo() 函数中，避免了复制字符串的操作，提高了代码的效率。

C++11 引入了一种新的字符串字面常量（String Literal）的写法，即在字符串前加上前缀 "u8"、"u"、"U" 或 "L"，用以表示不同的字符编码方式。以下是一些示例：

1. UTF-8 编码的字符串：

const char* str1 = u8"hello";  // 使用 "u8" 前缀表示 UTF-8 编码
std::cout << str1 << std::endl;  // 输出 "hello"

2. UTF-16 编码的字符串：

const char16_t* str2 = u"hello";  // 使用 "u" 前缀表示 UTF-16 编码
std::wcout << str2 << std::endl;  // 输出 L"hello"（宽字符类型）

3. UTF-32 编码的字符串：

const char32_t* str3 = U"hello";  // 使用 "U" 前缀表示 UTF-32 编码
std::wcout << str3 << std::endl;  // 输出 L"hello"（宽字符类型）

4. 宽字符编码的字符串：

const wchar_t* str4 = L"hello";  // 使用 "L" 前缀表示宽字符编码
std::wcout << str4 << std::endl;  // 输出 L"hello"

使用新式的字符串字面常量可以方便地表示不同编码方式的字符串，避免了手动转换编码的麻烦。

C++11 引入了一个新的关键字 noexcept，用于声明函数是否可能抛出异常。以下是一些示例：

1. 声明函数不会抛出异常：

void foo() noexcept {
    // 函数体
}

在上面的例子中，使用 noexcept 关键字声明了函数 foo() 不会抛出异常。这样可以让编译器进行一些优化，提高代码的性能和效率。

2. 声明函数可能抛出异常：

void bar() noexcept(false) {
    // 函数体
}

在上面的例子中，使用 noexcept(false) 关键字声明了函数 bar() 可能抛出异常。这样可以让代码更加清晰明了，提高代码的可读性。

3. 使用 noexcept 进行函数重载：

void baz() noexcept;
void baz(int) noexcept(false);

在上面的例子中，使用 noexcept 关键字进行函数重载。第一个 baz() 函数声明不会抛出异常，第二个 baz() 函数声明可能抛出异常。这样可以让代码更加灵活，提高代码的可维护性。

函数重载（Function Overloading）是指在同一个作用域内，定义多个函数名称相同但参数列表不同的函数，以实现不同的功能。

函数重载的实现方式是通过函数名称相同但参数列表不同的特性，让编译器能够根据调用时传递的参数类型和数量，自动选择匹配的函数进行调用。函数重载可以增加代码的复用性和可读性，使代码更加灵活和易于维护。

例如，可以定义多个名为 max 的函数，分别用于计算两个整数、两个浮点数和两个字符串中的最大值：

int max(int a, int b)
{
    return a > b ? a : b;
}

float max(float a, float b)
{
    return a > b ? a : b;
}

string max(string a, string b)
{
    return a > b ? a : b;
}

在上面的代码中，定义了三个名为 max 的函数，分别用于计算两个整数、两个浮点数和两个字符串中的最大值。当调用 max 函数时，编译器会自动选择匹配的函数进行调用，例如：

int a = 3, b = 5;
int c = max(a, b); // 调用 int max(int, int)

float x = 2.5, y = 1.8;
float z = max(x, y); // 调用 float max(float, float)

string s1 = "hello", s2 = "world";
string s3 = max(s1, s2); // 调用 string max(string, string)

在上面的代码中，根据传递的参数类型和数量，编译器自动选择匹配的函数进行调用，实现了函数重载的功能。

C++11 标准引入了关键字 constexpr，用于声明常量表达式（Constant Expression），即在编译期间就能计算出结果的表达式。使用 constexpr 声明的常量表达式可以提高程序的性能和可读性。

下面是一个使用 constexpr 声明常量表达式的例子：

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

int main()
{
    constexpr int n = 5;
    constexpr int result = factorial(n);
    cout << "factorial(" << n << ") = " << result << endl;
    return 0;
}

在上面的代码中，使用 constexpr 声明了一个递归计算阶乘的函数 factorial，然后在 main 函数中使用 constexpr 声明了一个常量 n，并计算了 n 的阶乘，最后输出结果。

需要注意的是，使用 constexpr 声明常量表达式时，表达式的计算必须在编译期间完成，不能依赖于运行时的输入或状态。如果表达式无法在编译期间计算出结果，则会导致编译错误。

C++17 引入了一些新的模板特性，包括：

1. 变量模板（Variable Templates）

变量模板允许我们声明一个模板变量，可以像普通变量一样使用。例如：

template <typename T>
constexpr T pi = T(3.1415926535897932385);

上面的代码定义了一个变量模板 pi，它的类型是模板参数 T，值是 3.1415926535897932385。我们可以像使用普通变量一样使用它：

double x = pi<double>;

2. 折叠表达式（Fold Expressions）

折叠表达式是一种新的语法，可以用来简化模板元编程中的一些常见操作，如计算类型列表中所有类型的大小。例如：

template <typename... Ts>
constexpr size_t total_size = (sizeof(Ts) + ...);

上面的代码定义了一个变量模板 total_size，它的类型是 size_t，值是类型列表 Ts 中所有类型的大小之和。我们可以这样使用它：

size_t s = total_size<int, double, char>;

3. if constexpr

if constexpr 是一种新的语法，可以在编译期间判断一个条件是否成立，并根据结果选择不同的代码执行路径。例如：

template <typename T>
void print(T t) {
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << t << std::endl;
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "double: " << t << std::endl;
    } else {
        static_assert(std::is_same_v<T, int> || std::is_same_v<T, double>, "unsupported type");
    }
}

上面的代码定义了一个函数 print，如果参数类型是 int，则输出 int:，如果参数类型是 double，则输出 double:，否则会触发一个编译期错误。我们可以这样使用它：

print(10);      // 输出 int: 10
print(3.14);    // 输出 double: 3.14
print("hello"); // 编译期错误：unsupported type

Lambda 是 C++11 引入的一种新的函数对象（Function Object）语法，它可以用来定义一个匿名函数，可以捕获外部变量，可以作为参数传递给其他函数。

Lambda 表达式的一般形式如下：

[capture-list](parameter-list) -> return-type { body }

其中，capture-list 表示捕获外部变量的方式，可以是值捕获、引用捕获或混合捕获；parameter-list 表示函数参数列表；return-type 表示返回值类型；body 表示函数体。

Lambda 表达式可以作为函数对象使用，例如：

auto add = [](int a, int b) { return a + b; };
int x = add(1, 2); // x = 3

Lambda 表达式也可以作为函数参数传递，例如：

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

Lambda 表达式还可以捕获外部变量，例如：

int x = 10;
auto f = [x](int y) { return x + y; };
int y = f(20); // y = 30

上面的代码中，Lambda 表达式捕获了外部变量 x，可以在函数体中使用它。在捕获列表中，可以使用 [] 表示不捕获任何变量，也可以使用 [=] 表示值捕获所有变量，使用 [&] 表示引用捕获所有变量，使用 [x] 表示值捕获变量 x，使用 [&x] 表示引用捕获变量 x。

decltype 是 C++11 引入的一种新的类型推导（Type Inference）语法，它可以根据表达式的类型推导出变量的类型，包括 const、引用和 volatile 修饰符。

decltype 的一般形式如下：

decltype(expression)

其中，expression 表示要推导类型的表达式。

例如，我们可以使用 decltype 推导出一个变量的类型：

int x = 10;
decltype(x) y = 20; // y 的类型为 int

我们也可以使用 decltype 推导出一个表达式的类型：

int x = 10;
int y = 20;
decltype(x + y) z = 30; // z 的类型为 int

decltype 还可以用来推导函数返回值的类型，例如：

int add(int a, int b) { return a + b; }
decltype(add(1, 2)) x = 3; // x 的类型为 int

需要注意的是，当表达式是一个变量时，decltype 推导出的类型会包括变量的修饰符，例如 const、引用和 volatile。例如：

int x = 10;
const int& y = x;
decltype(y) z = 20; // z 的类型为 const int&

C++11 引入了一种新的函数声明语法，它可以让函数声明更加清晰、简洁，同时支持函数模板的默认参数和类型推导。

新的函数声明语法的一般形式如下：

auto function_name(parameter_list) -> return_type;

其中，auto 表示使用类型推导推导函数返回值类型；function_name 表示函数名；parameter_list 表示函数参数列表；return_type 表示函数返回值类型。

例如，我们可以使用新的函数声明语法声明一个函数：

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

我们也可以使用新的函数声明语法声明一个函数模板：

template<typename T1, typename T2 = int>
auto max(T1 a, T2 b) -> decltype(a + b)
{
    return a > b ? a : b;
}

上面的代码中，max 函数模板的返回值类型使用 decltype 推导，可以支持函数模板的默认参数和类型推导。

需要注意的是，新的函数声明语法只是一种语法糖，其本质仍然是传统的函数声明语法，只是将返回值类型放在了箭头后面，这种语法在一些场合下可以让函数声明更加清晰、简洁。

C++11 引入了带领域的枚举（Scoped Enumeration），也称为枚举类（Enum Class）。与传统的枚举相比，带领域的枚举具有更强的类型安全性和可读性，可以避免命名冲突和隐式类型转换。

带领域的枚举的一般形式如下：

enum class enum_name : underlying_type { enumerator_list };

其中，enum_name 表示枚举类型的名称；underlying_type 表示枚举类型的底层类型，可以是 int、char、short 等整数类型；enumerator_list 表示枚举值的列表。

例如，我们可以定义一个带领域的枚举类型：

enum class Color : int { Red, Green, Blue };

上面的代码定义了一个名为 Color 的枚举类型，底层类型为 int，包含三个枚举值 Red、Green 和 Blue。

我们可以使用带领域的枚举类型定义变量：

Color c = Color::Red;

需要注意的是，带领域的枚举类型的枚举值不能隐式转换为整数类型，必须使用 static_cast 显式转换：

int i = static_cast<int>(c); // 将枚举值转换为整数类型

带领域的枚举类型还可以指定枚举值的底层类型为无符号整数类型：

enum class Color : unsigned int { Red, Green, Blue };

这样可以避免枚举值被解释为负数。

C++11 引入了一些新的基础类型（New Fundamental Data Type），包括：

1. nullptr_t：表示空指针类型，用于取代 NULL 宏。
2. 带符号整数类型 long long int 和无符号整数类型 unsigned long long int：用于表示更大的整数范围，可以使用后缀 ll 或 LL 表示 long long int 类型的字面量。
3. 可变长参数模板参数包（Variadic Template Parameter Pack）：用于处理可变数量的模板参数，可以使用模板参数包展开运算符（...）来实现。

例如，我们可以使用 nullptr_t 类型来定义一个空指针：

int* ptr = nullptr;

我们也可以使用 long long int 类型来表示更大的整数范围：

long long int a = 123456789012345LL;
unsigned long long int b = 9876543210987654321ULL;

最后，我们可以使用可变长参数模板参数包来实现一个可变参数的函数模板：

template<typename... Args>
void print(Args... args)
{
    (std::cout << ... << args) << std::endl;
}

int main()
{
    print("Hello", "World", 123);
    return 0;
}

上面的代码中，print 函数模板使用 Args... 来表示可变长参数模板参数包，使用展开运算符（...）来展开参数列表，实现了一个可变参数的打印函数。

C++ 标准库中有一些虽旧犹新的语言特性，它们在 C++11 之前已经存在，但在 C++11 中得到了进一步的改进和增强。以下是其中的几个特性：

1. 模板元编程（Template Metaprogramming，TMP）：模板元编程是一种利用模板机制实现编译期计算的技术，可以在编译期间生成代码，提高程序的性能和灵活性。C++11 中增加了一些新的模板元编程特性，如可变长参数模板参数包、模板别名、模板模板参数等。
2. Lambda 表达式：Lambda 表达式是一种匿名函数，可以在代码中定义一个函数对象，方便地实现一些简单的功能。Lambda 表达式可以捕获外部变量，也可以指定返回值类型和参数列表。例如：

auto func = [](int x, int y) -> int { return x + y; };
int result = func(1, 2); // result = 3

3. 右值引用和移动语义：右值引用和移动语义是 C++11 中最重要的特性之一，可以避免不必要的对象拷贝和内存分配，提高程序的性能。右值引用可以绑定到临时对象或将要销毁的对象上，移动语义可以将这些对象的资源转移到新的对象中，避免了不必要的内存拷贝。例如：

std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2 = std::move(vec1); // vec2 获得 vec1 的资源，vec1 变为空

4. 委托构造函数：委托构造函数是一种在一个类中调用另一个构造函数的方法，可以减少代码重复和维护成本。例如：

class Point
{
public:
    Point() : Point(0, 0) {} // 委托构造函数
    Point(int x, int y) : m_x(x), m_y(y) {}
private:
    int m_x, m_y;
};

上面的代码中，Point() 构造函数使用了委托构造函数调用 Point(int, int) 构造函数，避免了代码重复。

C++11 引入了基础类型的明确初始化（Explicit Initialization for Fundamental Type）特性，可以在定义变量时显式地进行初始化，避免了一些隐式初始化可能引起的问题。

在 C++11 之前，基础类型的初始化是隐式进行的，例如：

int a; // 隐式初始化为 0

但是，隐式初始化可能会引起一些不必要的问题，例如：

int b; // 隐式初始化为 0
int c = b + 1; // c 的值不确定

在上面的代码中，b 被隐式初始化为 0，但是在计算 c 的时候，b 的值并没有被明确初始化，因此 c 的值也是不确定的。

C++11 中引入了基础类型的明确初始化特性，可以在定义变量时显式地进行初始化，例如：

int a{}; // 显式初始化为 0
int b{42}; // 显式初始化为 42

在上面的代码中，使用花括号进行初始化可以显式地指定变量的值，避免了隐式初始化可能引起的问题。

C++ 标准库中的 main() 定义式是指可以在程序中定义多个 main() 函数，每个 main() 函数都可以作为程序的入口点。这个特性在 C++11 中被引入，可以方便地实现一些特定的需求，例如测试多个函数或模块的功能。

在使用 main() 定义式时，每个 main() 函数都需要指定一个不同的名称，例如：

int main1()
{
    // 第一个入口点的代码
}

int main2()
{
    // 第二个入口点的代码
}

int main()
{
    // 默认入口点的代码
}

在上面的代码中，定义了三个 main() 函数，分别命名为 main1、main2 和默认的 main。当程序被编译和链接后，可以通过指定不同的入口点来执行不同的代码。

需要注意的是，使用 main() 定义式时需要保证每个入口点的代码是相互独立的，不会相互干扰或产生副作用。此外，一些编译器可能不支持 main() 定义式特性，因此需要根据实际情况进行选择。