C++ 11 新特性

• 变量类型推导 auto
• 表达式类型推导 decltype
• 初始化列表
• 基于范围的for循环
• Lambda 表达式
• 智能指针
• 空指针nullptr
• 左值右值
• 移动语义和完美转发
• 常量表达式 constexpr
• 委托构造函数
• 继承构造函数
• override
• final
• 并发编程
• 正则表达式

C++ 11 新特性

以下内容给出C++11部分新特性的使用示例。

变量类型推导 auto

C++11引入了auto关键字，可以用于自动推导变量的类型，使得代码更加简洁和灵活。下面是一个简单的示例：

#include <iostream>
#include <vector>

int main() {
    // 使用auto推导变量类型
    auto x = 5; // x被初始化为整数，因此其类型被推导为int。
    auto y = 3.14; // y被初始化为浮点数，因此其类型被推导为double。
    auto str = "Hello"; // str被初始化为字符串字面量，因此其类型被推导为const char*。

    // 使用了`auto`来声明循环迭代器`it`
    std::vector<int> numbers = {1, 2, 3, 4, 5};  // 初始化列表,见下文
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

表达式类型推导 decltype

decltype用于推导表达式的类型。它可以用于推导变量的类型，也可以用于函数返回类型的推导：

推导变量类型

int x = 5;
decltype(x) y = x; // y的类型为int，与x相同

函数返回类型推导

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

decltype(add(1, 2)) result; // result的类型为int，与add函数的返回类型相同

初始化列表

初始化列表特性它允许使用一种更简洁的语法来初始化容器、数组和类对象的成员。

在C++11之前，要初始化一个容器，需要使用一系列push_back()或insert()调用，比较繁琐。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers;
    numbers.push_back(1);
    numbers.push_back(2);
    numbers.push_back(3);
    numbers.push_back(4);
    numbers.push_back(5);

    for (auto num : numbers) {
        std::cout << num << " ";
    }

    return 0;
}

使用初始化列表可以更加简洁地实现初始化。

#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5}; // 使用初始化列表初始化vector

    for (autonum : numbers) {
        std::cout << num << " ";
    }

    return 0;
}

这里，{1, 2, 3, 4, 5}就是一个初始化列表，用来初始化std::vector<int>容器。

基于范围的for循环

基于范围的for循环（range-based for loop）可以让遍历容器的操作更加简洁和直观。它使得循环体内可以直接访问容器中的元素，而不需要通过迭代器或者下标。

下面是一个使用基于范围的for循环遍历vector的例子：

#include <iostream>
#include <vector>

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

    // 使用基于范围的for循环遍历vector
    for (int num : numbers) {
        std::cout << num << " ";
    }

    return 0;
}

另外，如果要修改vector中的元素，可以将num声明为引用类型：

#include <iostream>
#include <vector>

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

    // 使用基于范围的for循环遍历并修改vector
    for (int& num : numbers) {
        num *= 2;
    }

    // 输出修改后的vector
    for (int num : numbers) {
        std::cout << num << " ";
    }

    return 0;
}

这段代码会输出每个元素的两倍：

2 4 6 8 10

Lambda 表达式

Lambda表达式允许在代码中创建匿名函数，使得代码更加简洁和灵活。Lambda表达式的基本语法如下：

[捕获列表](参数列表) -> 返回类型 { 函数体 }

其中，[捕获列表]用于捕获外部变量，参数列表,返回类型和函数体与普通函数相似。

下面以求两个整数之和为例，演示Lambda表达式的使用：

#include <iostream>

int main() {
    // Lambda表达式，用于求两个整数a和b的和
    auto add = [](int a, int b) { return a + b; };

    // 调用Lambda表达式
    std::cout << "Result: " << add(5, 3) << std::endl;

    return 0;
}

Lambda表达式还支持捕获外部变量。例如:

#include <iostream>

int main() {
    int x = 10;

    // Lambda表达式，捕获外部变量x，并与另一个参数y相加
    auto add_with_x = [x](int y) { return x + y; };

    // 调用Lambda表达式
    std::cout << "Result: " << add_with_x(5) << std::endl;

    return 0;
}

智能指针

智能指针用于管理动态分配的内存的智能对象，可以在对象不再被使用时自动释放内存，避免了内存泄漏和悬空指针的问题。

C++11中最常用的智能指针包括std::shared_ptr、std::unique_ptr和std::weak_ptr。

std::shared_ptr

std::shared_ptr是一种共享所有权的智能指针，多个std::shared_ptr对象可以共享同一个资源。当所有指向资源的std::shared_ptr都销毁时，资源才会被释放。 std::shared_ptr是一个引用计数智能指针，它在构造时会将引用计数初始化为 1，每当有新的 std::shared_ptr 指向相同的对象时，引用计数加 1，当有 std::shared_ptr 超出作用域或被显式置为 nullptr 时，引用计数减 1。当引用计数为 0 时，对象被销毁，释放内存。

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> sharedPtr1 = std::make_shared<int>(42);
    std::cout << sharedPtr1.use_count() << std::endl; // 引用计数：1
    std::shared_ptr<int> sharedPtr2 = sharedPtr1;
    std::cout << sharedPtr1.use_count() << std::endl; // 引用计数：2

    std::cout << *sharedPtr1 << std::endl; // 输出 42
    std::cout << *sharedPtr2 << std::endl; // 输出 42

    // 通过reset释放资源
    sharedPtr1.reset();
    std::cout << "sharedPtr1 is " << (sharedPtr1 ? "not null" : "null") << std::endl; // 输出 null
    std::cout << *sharedPtr2 << std::endl; // 输出 42，sharedPtr2仍然有效

    return 0;
}

std::unique_ptr

std::unique_ptr是一种独占所有权的智能指针，同一时间只能有一个std::unique_ptr指向资源。当std::unique_ptr被销毁时，它所拥有的资源也会被释放。

#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> uniquePtr1 = std::make_unique<int>(42);
    // std::unique_ptr<int> uniquePtr2 = uniquePtr1; // 错误！资源不可共享
    std::cout << *uniquePtr1 << std::endl; // 输出 42

    // 通过reset释放资源
    uniquePtr1.reset();
    std::cout << "uniquePtr1 is " << (uniquePtr1 ? "not null" : "null") << std::endl; // 输出 null

    return 0;
}

std::weak_ptr

std::weak_ptr是一种弱引用智能指针，它不增加资源的引用计数。std::weak_ptr可以观察由std::shared_ptr管理的资源，但不会增加资源的引用计数，避免了循环引用的问题。

weak_ptr.lock() 方法用于获得对所指向对象的访问权。如果原来的 shared_ptr 对象还存在，则 lock() 方法返回一个有效的 shared_ptr 对象，如果原来的 shared_ptr 对象已经被销毁了（或者被置为 nullptr），则 lock() 方法返回一个空的 shared_ptr。

#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    std::weak_ptr<int> weakPtr = sharedPtr;
 
 std::cout << sharedPtr.use_count() << std::endl; // 引用计数：1
 
    if (auto ptr = weakPtr.lock()) {
        std::cout << *ptr << std::endl; // 输出 42
    } else {
        std::cout << "sharedPtr is expired" << std::endl;
    }

    // 释放sharedPtr
    sharedPtr.reset();

    if (auto ptr = weakPtr.lock()) {
        std::cout << *ptr << std::endl; // 不会执行到这里，因为sharedPtr已经被释放
    } else {
        std::cout << "sharedPtr is expired" << std::endl; // 输出 sharedPtr is expired
    }

    return 0;
}

空指针nullptr

nullptr表示空指针常量。它的引入解决了传统的空指针表示方法NULL的一些问题，使代码更加清晰和安全。

在C++11之前，通常使用NULL来表示空指针。然而，NULL实际上是一个宏定义，其值通常是0或者(void*)0，这可能导致一些潜在的类型转换和歧义。例如：

void foo(int);
void foo(char*);

foo(NULL);  // 调用foo(int)，

NULL会被视为int类型，而不是char*类型，这可能导致程序出错。

使用nullptr可以解决这个问题。nullptr的类型是std::nullptr_t，它只能隐式转换为任意指针类型，而不能转换为整数类型。因此，上面的例子可以这样改写：

void foo(int);
void foo(char*);

foo(nullptr);  // 调用foo(char*)

现在，nullptr明确表示一个空指针，不会引起类型转换的问题。

左值右值

左值和右值

• 左值（lvalue）：指向内存位置的表达式，可以出现在赋值号的左边或右边。
• 右值（rvalue）：临时值，它可以是字面量、临时对象或表达式求值的结果。

int x = 5;   // x是左值
int y = x + 3; // x + 3是右值

左值引用（&）和右值引用（&&）

• 左值引用（&）：绑定到左值的引用。
• 右值引用（&&）：绑定到右值的引用。

int x = 5;
int& lref = x;  // lref是左值引用
int&& rref = 10; // rref是右值引用

移动语义和完美转发

移动语义（std::move()）

移动语义允许在不进行深拷贝的情况下，将资源（例如堆上分配的内存）从一个对象转移到另一个对象。

std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2 = std::move(v1); // 移动v1的资源到v2

在这里，std::move()将v1的资源移动（类似电脑的ctrl+x）到v2中，而不是复制，从而提高了效率。

完美转发（std::forward()）

完美转发可以让左右值参数传递给重载函数的时候，保持原来的参数类型。

template<typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg));
}

void process(int& x) {
    std::cout << "Processing lvalue\n";
}

void process(int&& x) {
    std::cout << "Processing rvalue\n";
}

int main() {
    int x = 5;
    wrapper(x);     // 输出 "Processing lvalue" 左值
    wrapper(10);    // 输出 "Processing rvalue" 右值
}

wrapper()函数使用了完美转发，它接受一个通用引用参数arg，然后使用std::forward()将arg转发给process()函数，保持了参数的值类别。

常量表达式 constexpr

constexpr 用于声明常量表达式。它允许在编译时计算表达式的值，并在编译期间执行函数。

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

int main() {
    constexpr int result = square(5); // 在编译时计算
    static_assert(result == 25, "Incorrect square calculation");
    return 0;
}

委托构造函数

C++11引入了委托构造函数的概念，允许一个构造函数调用同一个类中的另一个构造函数，从而减少代码冗余。下面是一个简单的例子：

#include <iostream>

class MyClass {
public:
    MyClass() : MyClass(0) { // 委托给带参数的构造函数
        std::cout << "Default constructor" << std::endl;
    }

    MyClass(int value) : m_value(value) {  // 带参数的构造函数
        std::cout << "Constructor with value " << m_value << std::endl;
    }

private:
    int m_value;
};

int main() {
    MyClass obj1; // 调用无参构造函数的同时也调用带参构造函数
    MyClass obj2(42); // 只是调用带参构造函数

    return 0;
}

输出结果为：

Constructor with value 0
Default constructor
Constructor with value 42

继承构造函数

继承构造函数的特性允许子类从基类中继承其所有构造函数。这使得代码更加简洁，避免了在子类中重新定义相同的构造函数。

以下是一个示例：

#include <iostream>

class Base {
public:
    Base(int x) : value(x) {
        std::cout << "Base constructor" << std::endl;
    }
    
    void print() {
        std::cout << "Value: " << value << std::endl;
    }

private:
    int value;
};

class Derived : public Base {
public:
    using Base::Base; // 继承基类的构造函数

    void foo() {
        std::cout << "Derived function" << std::endl;
    }
};

int main() {
    Derived d(10); // 使用继承的构造函数
    d.print(); // 调用基类的成员函数
    d.foo();   // 调用派生类的成员函数
    return 0;
}

override

override 关键字用于显式指示一个成员函数覆盖了基类中的虚函数，它可以帮助检测错误，如果子类中的函数并没有正确地覆盖基类中的虚函数，编译器将产生错误。

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

class Derived : public Base {
public:
    void foo() const override { // 使用override关键字
        std::cout << "Derived::foo()" << std::endl;
    }
};

int main() {
    Derived d;
    Base* ptr = &d;
    ptr->foo(); // 输出 Derived::foo()
    return 0;
}

如果在 Derived 类中的 foo() 函数没有正确地覆盖基类中的虚函数，例如拼写错误或者参数不匹配，编译器将会提示错误。

final

final 关键字用于标记一个虚函数不能被子类再次覆盖，或者一个类不能被继承。这有助于防止意外的覆盖或继承。

class Base {
public:
    virtual void foo() const final { // 使用final关键字
        std::cout << "Base::foo()" << std::endl;
    }
};

class Derived : public Base {
public:
    //void foo() const override; // 试图覆盖基类中的foo()函数，会导致编译错误
};

class Derived2 final : public Base { // 使用final关键字，Derived2类不能再被继承
};

// class Derived3 : public Derived2 {}; // 试图继承Derived2类，会导致编译错误

int main() {
    Derived d;
    Base* ptr = &d;
    ptr->foo(); // 输出 Base::foo()
    return 0;
}

并发编程

推荐阅读：C++ 并发编程（从C++11到C++17）

正则表达式

推荐阅读：https://www.cnblogs.com/coolcpp/p/cpp-regex.html

参考：c++11新特性，所有知识点都在这了！ - 知乎 (zhihu.com)

现代 C++ 教程：高速上手 C++11/14/17/20 欧长坤