C++11特性全解析

# 1. C++11新标准概述

C++11是C++语言自1998年以来最重要的更新，它不仅标准化了新的语言特性，还改进了旧的标准库。在这一章节中，我们将对C++11新标准进行一个简洁而全面的概述，为接下来的深入学习打下基础。

## 1.1 C++11产生的背景与目的

C++11是C++社区在超过10年的发展后，对语言性能、易用性和可维护性的一次重大提升。其目标是简化C++语言的使用，同时使其更加强大。它包括对模板、类型推导、并发编程及库的广泛改进，这些改进极大地提升了C++在现代编程中的适用性。

## 1.2 标准化过程和社区反馈

C++11的标准化过程是开放和透明的，广泛征求了C++开发者的反馈。这项工作始于2009年，直至2011年，国际标准化组织（ISO）正式批准了C++11标准。新标准的制定考虑了广泛的实际使用情况，并努力解决了C++11之前的版本中存在的问题和局限性。

## 1.3 C++11新特性的概览

C++11引入了大量的新特性，其中包括了自动类型推导、统一初始化器、lambda表达式、智能指针、线程库等。这些特性既包括了对现有功能的增强，也包括了全新的概念，如右值引用、移动语义、并发控制等。这些改进将帮助程序员编写出更简洁、更安全、更高效的代码。

这一章作为旅程的起点，为读者描绘了一个C++11新世界的概览。接下来的章节将逐步深入，详细探讨每一个新特性的细节和应用，使读者能够充分利用C++11的威力来解决实际问题。

# 2. C++11的核心语法改进

## 2.1 自动类型推导与类型别名

### 2.1.1 auto关键字的使用

在C++11之前，编程者需要显式指定变量的类型，这在某些情况下会增加代码的冗余性，比如迭代器的声明和初始化。C++11引入了`auto`关键字，它允许编译器自动推断变量的类型，从而简化了代码并提高了可读性。

#### 示例代码

std::vector<int> vec = {1, 2, 3, 4, 5};
for(auto iter = vec.begin(); iter != vec.end(); ++iter) {
    // 使用iter
}

在这个例子中，`iter`的类型会由编译器推导出是`std::vector<int>::iterator`。这样做的好处是减少了代码冗余，特别是当类型非常长或者复杂时，`auto`可以提高代码的可读性。

### 2.1.2 decltype的引入及其作用

`decltype`关键字用于查询表达式的类型，并用于类型推导。它特别有用于函数返回类型推导，或者在模板编程中推导出复杂表达式的类型。

#### 示例代码

template<typename Container, typename Index>
auto get_element(Container& c, Index i) -> decltype(c[i]) {
    return c[i];
}

在这个例子中，`decltype`用于推导`c[i]`表达式的类型，并将其作为函数的返回类型。这种用法特别在模板编程中，因为模板参数的类型可能未知，而`decltype`能够准确推导出复杂的表达式类型。

### 2.1.3 using和typedef的区别和使用场景

`using`关键字在C++11中被引入，用于替代`typedef`，提供了一种新的声明类型别名的方式。`using`相比`typedef`提供了更清晰和更强大的类型声明功能。

#### 示例代码

typedef int (*FunctionPointer)(int, int);
using FunctionPointer = int (*)(int, int);

在以上代码中，两种方式都声明了一个指向函数的指针类型，但`using`声明的语法更接近于变量声明，更容易阅读和理解。此外，`using`声明可以在模板中使用，为模板参数指定别名，而`typedef`则不支持模板。

## 2.2 引入的初始化器

### 2.2.1 列表初始化

列表初始化是C++11中引入的一种初始化方式，它允许使用花括号`{}`来初始化任何类型的对象。它不仅可以用于初始化数组和标准容器，还能用于初始化类的实例。

#### 示例代码

std::vector<int> vec{1, 2, 3, 4, 5};
std::map<std::string, int> map{{"one", 1}, {"two", 2}};

### 2.2.2 委托构造函数

C++11引入了委托构造函数的概念，允许一个构造函数将构造过程委托给另一个构造函数。这能够减少代码的重复，并且使得构造过程更加清晰。

#### 示例代码

class Rectangle {
public:
    int width, height;
    Rectangle() {}
    Rectangle(int width, int height) : width(width), height(height) {}
    Rectangle(int size) : Rectangle(size, size) {}
};

### 2.2.3 显式虚函数声明

在C++11中，显式地声明虚函数使得虚函数能够以`virtual`关键字作为修饰词出现在函数声明中。这使得代码意图更加明确，提高了代码的可读性。

#### 示例代码

class Base {
public:
    virtual ~Base() {}
    virtual void doSomething() = 0;
};

## 2.3 引用和指针的增强

### 2.3.1 左值引用和右值引用

C++11通过引入右值引用(`&&`)扩展了引用的概念。左值引用(`&`)用于绑定到左值，右值引用用于绑定到将亡值，这使得移动语义成为可能，允许对象在转移资源时避免不必要的复制。

#### 示例代码

std::string getTempString() {
    return std::string("temp");
}

std::string str = getTempString();

### 2.3.2 引用折叠规则和完美转发

引用折叠是C++11中引入的一个特性，它在模板编程中非常有用。它确保在模板实例化时，引用的引用能够正确折叠成左值或右值引用。完美转发允许函数模板将任何参数序列完美转发给另一个函数。

#### 示例代码

template <typename T>
void forwardRef(T&& t) {
    func(std::forward<T>(t));
}

### 2.3.3 智能指针的改进

智能指针在C++11中也得到了改进，`std::unique_ptr`和`std::shared_ptr`被引入作为管理动态分配内存的新方式。这些智能指针自动释放所管理的资源，减少内存泄漏的风险。

#### 示例代码

std::unique_ptr<int> p1(new int(42));
std::shared_ptr<int> p2 = std::make_shared<int>(42);

通过使用智能指针，我们确保了在异常安全性和多线程环境中更加安全地管理内存。智能指针的使用可以有效避免野指针、悬挂指针等问题。

# 3. C++11的并发编程特性

在现代编程中，能够有效利用多核处理器的能力至关重要。C++11引入了多个并发编程特性，极大地简化了多线程编程的复杂性。开发者可以借助C++11提供的线程库、基于任务的并行库、以及内存模型和原子操作来创建高效、可扩展的并行程序。

## 3.1 线程库的引入

C++11通过提供`<thread>`头文件引入了新的线程库，它使得创建和管理线程变得简单直接。新的线程库还提供了丰富的同步原语，帮助开发者处理线程间的协作问题。

### 3.1.1 std::thread的创建和管理

`std::thread`类是C++11并发库的核心组件之一，用于表示可执行的线程。与老版本的线程库相比，`std::thread`提供了一个类型安全和可移植的接口。

#include <thread>
#include <iostream>

void print_hello() {
    std::cout << "Hello, concurrency!" << std::endl;
}

int main() {
    std::thread t(print_hello);
    t.join(); // 等待线程t执行完毕
    return 0;
}

在这段代码中，我们定义了一个`print_hello`函数，并通过`std::thread`的构造函数创建了一个线程`t`。`t.join()`语句是用来等待`t`线程完成其任务的。

### 3.1.2 线程间同步的原子操作和互斥锁

为了保护共享资源，避免竞态条件，C++11提供了`<atomic>`和`<mutex>`头文件中的同步机制。原子操作是不可分割的一系列操作，保证了在多线程环境下操作的原子性。

#include <atomic>
#include <thread>

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

void increment_counter(int num_steps) {
    for (int i = 0; i < num_steps; ++i) {
        ++counter; // 原子自增操作
    }
}

int main() {
    std::thread t1(increment_counter, 1000);
    std::thread t2(increment_counter, 1000);
    t1.join();
    t2.join();
    std::cout << "Counter: " << counter << std::endl;
    return 0;
}

在这个例子中，我们使用了`std::atomic<int>`类型来保证`counter`变量在多个线程中自增操作的原子性。

### 3.1.3 条件变量的使用

当需要在线程间进行更复杂的同步时，C++11提供了`<condition_variable>`头文件中的条件变量。条件变量允许线程在某些条件尚未成立时阻塞，直到其他线程改变条件并通知它。

#include <mutex>
#include <condition_variable>
#include <thread>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void print_id(int id) {
    std::unique_lock<std::mutex> lck(mtx);
    while (!ready) {
        cv.wait(lck); // 等待，直到条件变量收到通知
    }
    // ...
}

void go() {
    std::unique_lock<std::mutex> lck(mtx);
    ready = true;
    cv.notify_all(); // 通知所有等待的线程
}

int main() {
    std::thread threads[10];
    for (int i = 0; i < 10; ++i) {
        threads[i] = std::thread(print_id, i);
    }
    go(); // 设置ready为true，并通知所有线程
    for (auto& th : threads) {
        th.join();
    }
    return 0;
}

这段代码中，`print_id`函数中的线程将等待一个共享变量`ready`变为`true`。`go`函数将改变`ready`的状态，并通知所有等待的线程。这样我们可以在所有线程准备好之后再继续执行。

在了解了C++11线程库的基础使用之后，让我们继续深入探讨基于任务的并行库，以及内存模型和原子操作这些高级特性。

# 4. C++11的泛型编程扩展

## 4.1 模板的增强

### 4.1.1 变参模板的应用

C++11中引入了变参模板（Variadic Templates），使得模板编程的能力得到了极大的提升。变参模板允许模板函数或者模板类接受任意数量和类型的参数。这种功能在编写泛型代码时提供了高度的灵活性和强大的表达能力。

变参模板通常与递归模板展开技术结合使用。通过递归的方式处理参数包，可以设计出可以处理任意数量参数的模板函数或类。例如，可以创建一个函数模板，它接受任意数量的参数，并将它们相加。

template<typename... Args>
auto sum(Args... args) -> decltype(args + ...)
{
    return (0 + ... + args);
}

在这个例子中，`Args... args`表示参数包，`decltype(args + ...)`使用了C++11引入的折叠表达式，能够对参数包中的所有参数执行加法操作。

### 4.1.2 折叠表达式和参数包操作

折叠表达式是C++17的新特性，但在这里我们先介绍它在模板编程中的应用。通过折叠表达式，我们可以简洁地实现参数包中元素的聚合操作。在C++11中，虽然没有直接的折叠表达式，但我们可以用递归模板的方式来实现相似的功能。

变参模板结合递归模板的一个经典例子是打印任意数量和类型的参数。下面是一个简单的实现：

#include <iostream>

template<typename T>
void print(T const& t)
{
    std::cout << t << '\n';
}

template<typename T, typename... Arg