C++11、C++14、C++17、C++20常用新特性

C++11、C++14、C++17、C++20是近年来的几个重要版本，它们都带来了许多新的特性，让C++编程更加现代化和高效。下面，我们一一解析这些版本的常用新特性。

C++11新特性

auto类型推导

使用auto关键字可以让编译器自动推导变量类型，从而简化代码。例如，下面的代码中，变量i的类型会根据右值根据推导出来：

auto i = 42;

Lambda表达式

Lambda表达式是一种匿名函数，可以在函数内部定义函数，从而提升代码的可读性和可维护性。例如，下面的代码定义了一个Lambda表达式，用来排序一组整数：

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

// 使用Lambda表达式排序
std::sort(nums.begin(), nums.end(), [](int a, int b) { return a < b; });

空指针常量nullptr

空指针常量nullptr是一个类型安全的空指针字面量，可以代替NULL和0，从而减少程序出错的风险。例如，下面的代码中，我们使用nullptr来表示一个空指针：

int *p = nullptr;

智能指针

C++11引入了智能指针（smart pointer），可以自动管理动态分配的内存，从而避免内存泄漏和悬空指针的问题，同时也能够提升代码的可靠性和可读性。例如，下面的代码使用std::unique_ptr来创建和管理字符串的动态内存：

std::unique_ptr<std::string> p = std::make_unique<std::string>("hello world");
std::cout << *p << std::endl;

C++14新特性

泛型Lambda表达式

C++14扩展了Lambda表达式的语法，可以在Lambda表达式中使用auto关键字来定义参数类型，从而达到更好的泛型编程效果。例如，下面的代码定义了一个泛型Lambda表达式，用来实现两个变量求和的操作：

auto sum = [](auto a, auto b) { return a + b; };

二进制字面量和分隔符

C++14提供了二进制字面量的支持，可以使用0b前缀来表示二进制数。同时，C++14还支持数字的分隔符，可以使用单引号将数字按照一定的分隔符进行划分，从而使代码更加易读。例如，下面的代码中，使用二进制字面量和分隔符来定义一个整数：

int b = 0b1010'1010;

C++17新特性

结构化绑定

结构化绑定是一种新的语法，可以将一个结构体或元组中的多个成员一次性绑定到多个变量中，从而简化变量的声明和初始化过程。例如，下面的代码中，结构化绑定将点p的x和y坐标绑定到变量x和y中：

struct Point { int x; int y; };
Point p = {1, 2};
auto [x, y] = p;

if初始化语句

C++17允许在if语句中声明变量并进行初始化，使得代码的可读性和可维护性更好。例如，下面的代码中，使用if语句进行变量的初始化：

if (auto p = foo(); p != nullptr) {
  //...
}

C++20新特性

概念（Concept）

C++20引入了概念（Concept）的概念，可以在编译时对泛型代码进行类型检查，避免出现语法错误和类型错误。例如，下面的代码中，使用requires关键字来定义输出迭代器的概念：

template<typename T>
concept bool OutputIterator = requires(T it) {
    *it++ = typename std::iterator_traits<T>::value_type{};
};

template<OutputIterator It>
void foo(It begin, It end) {
    for (; begin != end; ++begin) {
        std::cout << *begin << std::endl;
    }
}

协程（Coroutine）

C++20引入了协程（Coroutine）的概念，可以让程序更加高效地处理异步操作和事件驱动的编程模式。例如，下面的代码中，使用协程来处理异步IO操作：

#include <coroutine>
#include <fstream>
#include <iostream>

struct AsyncFile {
    struct promise_type {
        AsyncFile get_return_object() {
            return AsyncFile{coroutine_handle<promise_type>::from_promise(*this)};
        }
        auto initial_suspend() { return std::suspend_always{}; }
        auto final_suspend() { return std::suspend_always{}; }
        void return_void() {}
        void unhandled_exception() {}
    };
    AsyncFile(coroutine_handle<promise_type> h) : _handle(h) {}
    ~AsyncFile() { _handle.destroy(); }
    bool await_ready() { return false; }
    void await_suspend(std::coroutine_handle<> h) {
        _handle.promise()._continuation = h;
        _handle.resume();
    }
    std::string await_resume() { return _result; }
    std::string read(const char* filename) {
        std::ifstream file(filename);
        getline(file, _result);
        return _result;
    }
    std::coroutine_handle<promise_type> _handle;
    std::coroutine_handle<> _continuation;
    std::string _result;
};

AsyncFile read_async(const char* filename) {
    co_await std::suspend_always{};
    co_return AsyncFile{}.read(filename);
}

int main() {
    std::cout << read_async("test.txt").await_resume() << std::endl;
    return 0;
}

以上就是C++11、C++14、C++17、C++20常用新特性的完整攻略。