C++11 特性

总结

• 语法糖：
  • 关键字：
    • auto、decltype。
    • nullptr。
    • override、final。
    • constexpr。
    • using。
    • explicit、default。
  • 语法：
    • 基于范围的 for 循环。
    • function 函数对象。
      • lambda 产生函数对象。
      • bind 产生函数对象。
  • 目的：写代码更便捷、更严谨，让编译器做更多的事情。
• STL 容器：
  • array。
  • forward_list。
  • unordered_map、unordered_set。
• 智能指针：shared_ptr、weak_ptr、unique_ptr。
• 多线程：thread、mutex、lock_guard、condition_variable、atomic。
• 右值引用：
  • T &&。
  • 将亡值 → 会触发移动构造或移动赋值构造。
  • 实现移动语义 → std::move。
  • 实现完美转发 → 万能引用 T && 用来接收参数 + std::forward。

---

C++ 类型推导用法

• 类型推导的场景：
  • 模板参数类型的推导（和 auto 类型推导的规则是一致的）。
  • C++11 引入了 auto、decltype（在编译期进行类型推导）。
• 为什么要引入类型推导 ?
  • C++ 是强类型语言，用编译器来处理类型推导，可以提升语言的编码效率。
• 类型推导的关键字：
  • auto：
    • 原理：用于推导变量的类型，通过强制声明一个变量的初始值，编译器会通过初始值进行类型推导。
    • 规则：
      • auto 变量必须在定义时进行初始化。
      • 如果用 auto 定义多个变量，那么这些变量必须为同一类型。
      • auto 不能推导数组类型，会推导出指针类型。
      • C++14 auto 可以推导函数的返回值类型。
      • 类型推导时会丢失引用或 const、volatile 语义 → 使用 auto & 解决。
        • volatile 定义的变量不会被编译器优化，每次访问这样的变量时都需要直接从内存中读取其值。volatile 并不意味着线程安全，它仅仅保证对变量的直接访问。
      • 万能引用 auto && → 根据初始值的属性来判断是左值引用还是右值引用。

        const int &i = 5; // i 是左值引用
        
        auto &&m = i;  // m 是左值引用
        auto &&n = 10; // n 是右值引用
        
        template <typename T>
        void func(T &&t) {
                    // 万能引用，既可以传左值，也可以传右值
            当你传递一个左值给 func 时，模板参数 T 会被推导为左值引用类型 T&。
            因此 T && 实际上变成了 T& &&。
            根据引用折叠规则（Reference Collapsing Rules），T& && 折叠为 T&。
            当你传递一个右值给 func 时，T 会被推导为该值的类型，所以 T && 直接就是一个右值引用。
        }
        

    • 应用：
      • 尽量使用 auto 声明变量（因为 auto 变量必须在定义时进行初始化），除非影响可读性。
      • 使用容器时，迭代器类型名很长。
      • 匿名函数的返回值。

        auto lambda = [](auto x, auto y) -> auto {
                    return x + y; };
        cout << lambda(5, 3) << endl;     // 8
        cout << lambda(2.3, 1.7) << endl; // 4
        

      • 模板函数中，可以节约一个模板参数类型。

        template <typename T>
        void print(T value) {
                   
            std::cout << value << std::endl;
        }
        

        void print(auto value) {
                   
            std::cout << value << std::endl;
        }
        

  • decltype：
    • 原理：用于推导表达式的类型，编译器只分析表达式类型而不实际运算。
    • 规则：
      • exp 是一个普通的表达式，推导表达式类型。
      • exp 是函数调用，推导函数返回值类型。
      • exp 是左值，推导出左值引用。
    • 应用：用于泛型编程。

    int a = 1;
    float b = 2.0;
    decltype(a + b) c = a + b;
    cout << "a + b = " << c << typeid(c).name() << endl; // a + b = 3f
        
    auto f = [](int a, double b) {
           
    	return a + b;
    };
    decltype(f(a, b)) d = b;
    cout << "d = " << d << typeid(d).name() << endl; // d = 2d
    
    decltype(a += b) e = a;
    e = 18;
    cout << "a = " << a << endl; // a = 18
    /*
    	对于表达式 a += b，这是一个复合赋值表达式，它的结果是 a 本身的左值。
    	在 C++ 中，复合赋值表达式（如 +=、-=、*= 等）是左值表达式，它们返回对象的左值引用。
    */
    

---

nullptr 和 NULL 的区别

• nullptr 专门用来表示空指针。它的类型是 nullptr_t，可以自动转换成任何指针类型，但不能转换成整数类型，这提供了更高的类型安全性。
• NULL 被定义为整数 0。可能会在重载函数中引发歧义。例如，如果有两个重载函数，一个接受整型参数，另一个接受指针参数，使用 NULL 可能导致调用接受整型的版本，而不是预期的指针版本。

void func(int) {
   
    std::cout << "Integer version called." << std::endl;
}

void func(int*) {
   
    std::cout << "Pointer version called." << std::endl;
}

int main() {
   
	// 可能调用 func(int), 也可能调用 func(int*), 因为 NULL 被视为 0
	// 所以编译器无法确定调用哪个版本，导致编译报错
    func(NULL);     
    
    func(nullptr);  // 明确调用 func(int*)
}

---

关键字 override、final 的作用

• C++11 引入了这两个关键字。
• 为什么要引入这两个关键字 ?
  • 虚函数重写。
    • 不能阻止某个虚函数进一步被重写。
    • 本意是写一个新函数，但是由于子类中 virtual 关键字可省略，导致重写了基类的虚函数。
    • 本意是重写基类的虚函数，但是由于函数签名不一致，导致在子类中构建了新的虚函数。
  • 类继承：不能阻止某个类进一步派生。
• override：
  • 指定子类的一个虚函数重写基类的一个虚函数。
  • 保证该重写的虚函数与基类的虚函数具有相同的函数签名。

    class A {
           
    public:
        virtual void Func() {
           }
    }; 
    class B : public A {
           
    public:
        void Func() override {
           }
    };
    

• final：
  • 指定某个虚函数不能在派生类中被重写，或者某个类不能被派生。
  • 阻止类进一步派生。
  • 阻止虚函数进一步被重写。

    class A {
           
    public:
        virtual void Func() {
           }
    }; 
    class B : public A {
           
    public: