一、C++11有什么新特性？⭐

1. 自动类型推导（Type Inference）：引入了 auto 关键字，允许编译器根据初始化表达式的类型自动推导变量的类型。
2. 统一的初始化语法（Uniform Initialization Syntax）：引入了用花括号 {} 进行初始化的统一语法，可以用于初始化各种类型的对象，包括基本类型、数组、结构体、类等。
3. 右值引用（Rvalue References）：引入了 && 符号，用于声明右值引用。右值引用具有区分左值和右值的能力，提供了移动语义和完美转发的基础。
4. 移动语义（Move Semantics）：通过右值引用和移动构造函数（Move Constructor）实现，用于高效地转移资源拥有权，避免不必要的复制和内存分配。
5. lambda 表达式（Lambda Expressions）：引入了类似于匿名函数的语法，允许在代码中创建匿名函数对象，方便地编写更简洁的、具有局部作用域的函数。
6. 并发支持（Concurrency Support）：引入了多线程和原子操作的支持，包括线程库、原子类型、互斥锁、条件变量等，使得并发编程更加方便和安全。
7. 新的智能指针（Smart Pointers）：引入了 std::shared_ptr、std::unique_ptr、std::weak_ptr 等智能指针类模板，提供了更安全、更方便的内存管理机制。
8. 静态断言（Static Assert）：引入了 static_assert 关键字，允许在编译时对表达式进行静态断言，用于自定义的编译时检查和错误提示。
9. 新的标准库组件：包括了正则表达式库、基于范围的循环（Range-based for loop）、哈希表（std::unordered_map、std::unordered_set）、随机数库、异步任务库（std::async）、类型特征工具（std::is_same、std::is_convertible 等）等。

二、auto关键字⭐

auto 是 C++ 中的关键字，用于自动推导变量的类型。它可以让编译器根据初始化表达式的类型自动推导变量的类型，从而简化类型的声明和定义过程。

优点：简化类型声明：

• 使用 auto 可以简化变量类型的声明，避免重复书写冗长的类型名。增强代码灵活性：
• 使用 auto 可以方便地适应不同的数据类型，使代码更具有通用性和灵活性。
• 减少代码依赖：使用 auto 可以减少对具体类型的依赖，使得代码的维护和修改更加灵活和容易。

缺点：降低可读性：

• 使用 auto 可能会降低代码的可读性，因为类型信息不再明显可见，需要根据上下文推测变量的真实类型。
• 可能引发隐式类型转换：使用 auto 会自动推导变量的类型，可能导致隐式类型转换和意外的行为，尤其是在复杂的表达式或函数中使用时需要特别注意。

使用场景：

• 简化类型声明：在变量的类型已经明确而且易于推导的情况下，可以使用 auto 以简化代码。
• 模板编程：在模板函数和模板类的定义中，通过 auto 结合类型推导，可以实现更通用、灵活的模板代码。
• 迭代器类型：对于容器和遍历器等情况，使用 auto 可以自动推导迭代器的类型，避免显式指定具体类型。

代码示例：

• 简化类型声明：

auto i = 10; // 推导为 int 类型
auto d = 3.14; // 推导为 double 类型
auto b = true; // 推导为 bool 类型

• 模板函数和模板类的定义：

template <typename T>
auto add(T a, T b) -> decltype(a + b) {
    return a + b;
}

• 迭代器类型推导：

std::vector<int> nums = {1, 2, 3, 4, 5};
for (auto it = nums.begin(); it != nums.end(); ++it) {
    std::cout << *it << " ";
}

三、Lambda表达式⭐⭐

在C++11中引入的lambda表达式是一种匿名函数，它允许你在需要时快速定义一个函数。Lambda表达式的符号不是一个单一的符号，而是一组语法结构，包括捕获子句、参数列表、箭头（->）和函数体。

[capture] (parameters) -> return_type { function_body }

其中：

• capture：用于从外部作用域捕获变量，可以是值捕获或引用捕获。
• parameters：函数参数列表。
• return_type：函数返回类型。可以省略，会根据返回表达式自动推导。
• body：函数体，可以包含任意合法的代码。

lambda优点：

• 简洁性：lambda 表达式可以在需要时直接在代码中定义，避免了显式地编写独立的函数。
• 局部性：lambda 表达式在定义它的作用域内有效，对于一些只在某个特定场景下使用的函数，使用 lambda 表达式更加合适。
• 便捷性：lambda 表达式可以捕获外部作用域的变量，方便实现闭包效果，减少了函数参数的传递复杂性。

lambda缺点：

• 可读性：lambda 表达式的语法相对复杂，对于不熟悉 lambda 表达式的人来说，可读性可能会有一定的挑战。
• 滥用问题：在不需要捕获外部变量或需要较长代码块的场景下，过度使用 lambda 表达式可能会导致代码的可读性和可维护性下降。

使用场景：

• 算法函数对象：作为 STL 的算法函数对象，lambda 表达式可以方便地用于操作容器中的元素。

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

• 回调函数：作为回调函数传递给其他函数，lambda 表达式可以提供一种简洁的实现方式。

void doSomething(int a, int b, std::function<int(int, int)> callback) {
    int result = callback(a, b);
    std::cout << "Result: " << result << std::endl;
}

doSomething(5, 3, [](int x, int y) {
    return x + y;
});

• 并行编程：在并行编程的场景下，lambda 表达式可以用于定义线程函数或并行执行的任务。

std::vector<int> nums = {1, 2, 3, 4, 5};
std::vector<int> squares(nums.size());

#pragma omp parallel for
for (size_t i = 0; i < nums.size(); ++i) {
    squares[i] = nums[i] * nums[i];
}

四、左值和右值⭐⭐⭐

在C++中，左值（Lvalue）和右值（Rvalue）是根据表达式在赋值操作中的作用来分类的：

左值（Lvalue）

• 定义：左值是指那些可以出现在赋值表达式左边的表达式，即可以被赋值的目标。
• 特点：左值代表内存位置，具有地址。可以进行取地址操作（&）。可以被赋值。通常用于变量的命名或引用。

右值（Rvalue）

• 定义：右值是指那些不能出现在赋值表达式左边的表达式，通常作为赋值操作的源。
• 特点：右值不指向持久存储的位置，通常是临时的或不可访问的。不能进行取地址操作（&）。不能被赋值，因为它们没有持久的内存地址。

一些具体的例子：

• 变量是左值：例如，a 在 a = 10; 中是左值，因为它出现在赋值的左侧。
• 字面量是右值：例如，10 在 a = 10; 中是右值，因为它出现在赋值的右侧。
• 返回临时对象的函数调用是右值：例如，func() 如果返回一个对象，那么在 auto val = func(); 中 func() 的结果是一个右值。
• 对象的解引用是左值：如果 p 是一个指针，*p 是左值。
• 数组的元素是左值：array[0] 是左值，因为它可以被赋值。

C++11中的左值和右值的新特性：

C++11引入了右值引用（使用 && 声明），以及移动语义和完美转发，这些特性使得对右值的处理更加灵活和高效。

• 右值引用：允许程序员直接操作即将被销毁的右值，例如，通过移动语义转移资源的所有权，而不是进行复制。
• 移动语义：使用 std::move 将左值转换为右值引用，从而允许使用移动构造函数或移动赋值运算符来接受对象。
• 完美转发：在模板编程中，能够保持被转发参数的左值/右值属性。

示例：

int a = 5; // a是左值
int b = a; // a是左值，5是右值

int* p = &a; // p是指针，&a是取a的地址，a是左值
int c = *p;  // p是左值（指针可以被赋值），*p是左值（解引用）

std::vector<int> v1;
std::vector<int> v2 = std::move(v1); // v1变为右值引用，移动v1的资源给v2

理解左值和右值的区别对于深入掌握C++的赋值、拷贝、移动语义等概念至关重要。

五、什么是右值引用？它的作用？⭐⭐

在C++11中，右值引用是一种特殊类型的引用，使用两个和号（&&）来声明。与常规引用（左值引用）不同，右值引用专门用来绑定到右值上，即那些不是持久存储对象的表达式。

1. 标识右值：右值引用主要用于标识和操作右值（临时值、表达式结果、将被销毁的值等）。右值引用只能绑定到右值，不能绑定到左值。
2. 移动语义：右值引用支持移动语义，通过对临时对象的资源所有权进行移动而不是复制，提高了操作的效率。例如，在对象的拷贝构造函数和拷贝赋值运算符中，可以通过移动构造函数和移动赋值运算符来实现对资源的转移。
3. 完美转发：右值引用也用于实现完美转发，即在函数模板中保持参数的值类别。通过使用右值引用参数，可以将传递给函数的右值或左值转发到其他函数，保持传递参数的原始值类别。

右值引用的作用主要体现在以下几个方面：

• 避免不必要的拷贝：通过标识和操作右值，可以避免在操作临时对象时进行不必要的拷贝操作，提高程序的性能。
• 实现移动语义：通过右值引用和移动操作，可以在对象的资源拷贝过程中，将资源所有权从一个对象转移给另一个对象，避免了不必要的资源拷贝。
• 支持完美转发：通过右值引用，可以保持传递参数的值类别，实现参数的完美转发，避免了临时对象的额外拷贝操作。

void processValue(int&& value) {
    // 对右值进行操作
    // ...
}

int main() {
    int x = 10;  // x 是一个左值

    processValue(5); // 临时值 5 是一个右值
    processValue(x); // x 是一个左值，无法绑定到右值引用

    return 0;
}

在这个示例中，processValue() 函数接受一个右值引用参数，可以绑定到临时值 5，但无法绑定到变量 x。右值引用可以用于对右值进行特定的操作，提高代码的效率和灵活性。

六、移动语义 ⭐

移动语义：移动语义为了避免临时对象的拷贝，将内存的所有权从一个对象转移到另外一个对象，高效的移动用来替换效率低下的复制，为类增加移动构造函数。移动构造函数与拷贝构造不同，它并不是重新分配一块新的空间同时将要拷贝的对象复制过来，而是"拿"了过来，将自己的指针指向别人的资源，然后将别人的指针修改为nullptr。

   class MyObject {
public:
    // 移动构造函数
    MyObject(MyObject&& other) noexcept {
        // 将资源从 other 移动到当前对象
        data_ = other.data_;
        other.data_ = nullptr;
    }
    
    // 移动赋值运算符
    MyObject& operator=(MyObject&& other) noexcept {
        // 检查自我赋值
        if (this == &other) {
            return *this;
        }
        
        // 释放当前对象的资源
        delete data_;
        
        // 将资源从 other 移动到当前对象
        data_ = other.data_;
        other.data_ = nullptr;
        
        return *this;
    }
    
private:
    int* data_;  // 动态分配的内存资源
};

当需要移动一个 MyObject 对象时，移动构造函数将获取 other 对象的资源，并将 other 的指针置为 nullptr。移动赋值运算符也类似，先释放当前对象的资源，再将 other 的资源移动到当前对象。

七、说说完美转发的原理⭐

完美转发（Perfect Forwarding）是C++模板编程中的一个概念，它允许我们将函数的参数以它们的原始值类别（左值或右值）转发给其他函数。这是通过使用模板和右值引用来实现的，确保参数的类型特性（如左值/右值属性）在转发过程中得以保留。

完美转发的原理是基于引用折叠（Reference collapsing）和函数重载解析。引用折叠是一种规则，用于在特定情况下将引用类型折叠为一个类型。在函数重载解析过程中，编译器会根据参数的值类别和函数模板的特化匹配最佳的函数。

为了实现完美转发，通常要使用两个重要的特性：

1. 模板类型推导：函数模板使用模板参数来承载传递的参数，通过类型推导来确定参数的类型。
2. 转发引用：转发引用是指使用 std::forward 函数来将参数转发给其他函数。std::forward 的原理是根据参数的值类别和是否为左值引用来决定将参数转发为左值引用或右值引用。

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

void otherFunction(int& arg) {
    std::cout << "L-value reference: " << arg << std::endl;
}

void otherFunction(int&& arg) {
    std::cout << "R-value reference: " << arg << std::endl;
}

int main() {
    int x = 10;

    process(x); // 传递左值，调用 L-value 引用版本
    process(5); // 传递右值，调用 R-value 引用版本

    return 0;
}

在上面的示例中，process 函数是一个模板，并使用转发引用将参数 arg 转发给 otherFunction 函数。由于完美转发的存在，模板类型推导保持了参数的原始值类别，通过重载解析选取对应的函数版本进行调用。

八、请你说说函数模板与模板函数？⭐

函数模板是一种通用的函数模板声明，其中函数的参数和返回类型可以使用通用的模板参数来表示。函数模板的定义通常以 template<typename T> 或 template<class T> 开始，后跟函数的声明或定义。

template<typename T>
T add(T a, T b) {
    return a + b;
}

int intResult = add(5, 10);         // 实例化为 add<int>(5, 10)，返回 15
double doubleResult = add(3.14, 2.71);  // 实例化为 add<double>(3.14, 2.71)，返回 5.85


在这个例子中，add 是一个函数模板，它可以接受相同类型的参数 a 和 b，并返回它们的和。
模板参数 T 是一个占位符，表示函数中的类型。在函数调用时，编译器会根据实际的参数类型来实例化函数模板。

模板函数（Template function specialization）是对特定模板参数进行特化的函数定义。特化是指针对特定的模板参数类型编写的特殊版本。特化函数可以提供对特定数据类型的定制化行为。

template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

template<>
const char* max<const char*>(const char* a, const char* b) {
    return strcmp(a, b) > 0 ? a : b;
}
在这个例子中，max 是一个函数模板，用于比较两个值并返回较大的值。
然后，通过模板特化 template<> 来定义 max 函数针对 const char* 类型的特殊版本。
这个特殊版本使用了 strcmp 函数来比较两个 C 字符串并返回较大的字符串。

• 函数模板是一个通用的模板声明，可以用于多种数据类型，根据实际参数类型来实例化。
• 模板函数是对特定模板参数进行特化的函数定义，提供了对特定数据类型的定制化行为。

九、智能指针⭐⭐⭐⭐⭐

智能指针是C++中用于管理动态分配对象的一种特殊指针类型，它能够自动地分配和释放内存，避免内存泄漏和悬挂指针的问题。常用的智能指针有unique_ptr、shared_ptr和weak_ptr 和auto_ptr(已弃用）。智能指针的主要优点是它们在对象不再需要时自动释放资源，这使得资源管理更加安全和方便。

1、unique_ptr

1. unique_ptr是独占所有权的智能指针，用于管理动态分配的对象。
2. 它禁止多个unique_ptr指向同一对象，可以通过std::move转移所有权。
3. 适用于需要独占所有权的场景，能够避免内存泄漏。
4. unique指针规定一个智能指针独占一块内存资源。当两个智能指针同时指向一块内存，编译报错。我们只需要将拷贝构造函数和赋值拷贝构造函数申明为private或delete。不允许拷贝构造函数和赋值操作符。

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> uniquePtr(new int(10));
    if (uniquePtr) {
        std::cout << *uniquePtr << std::endl; // 输出10
    }
    uniquePtr.reset(); // 手动释放内存
    return 0;
}

2、shared_ptr：

1. shared_ptr允许多个指针共享对同一对象的所有权，通过引用计数来追踪当前有多少个指针共享一个对象。
2. 当最后一个shared_ptr超出作用域或被重置时，才会释放所管理的对象。
3. 它可以通过std::make_shared来创建，并且允许拷贝和移动。

相关问题:shared_ptr出现内存泄露怎么办？

共享指针的循环引用计数问题：当两个类中相互定义shared_ptr成员变量，同时对象相互赋值时，就会产生循环引用计数问题，最后引用计数无法清零，资源得不到释放。

可以使用weak_ptr，weak_ptr是弱引用，weak_ptr的构造和析构不会引起引用计数的增加或减少。我们可以将其中一个改为weak_ptr指针就可以了。

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sharedPtr1 = std::make_shared<int>(10);
    std::shared_ptr<int> sharedPtr2 = sharedPtr1;

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

    sharedPtr1.reset(); // 释放sharedPtr1所指向的对象

    if (sharedPtr2) {
        std::cout << *sharedPtr2 << std::endl; // 输出10
    }

    return 0;
}

3、weak_ptr：

1. weak_ptr是一种不共享所有权的智能指针，用于解决shared_ptr的循环引用问题。
2. weak_ptr可以从shared_ptr创建，但不能直接访问所管理的对象。
3. 它可以使用lock()方法来获取一个有效的shared_ptr，用于访问所管理的对象。

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(10);
    std::weak_ptr<int> weakPtr(sharedPtr);

    if (auto lockedPtr = weakPtr.lock()) {
        std::cout << *lockedPtr << std::endl; // 输出10
    }

    sharedPtr.reset(); // 释放sharedPtr，引用计数为0

    if (weakPtr.expired()) {
        std::cout << "Weak pointer expired" << std::endl;
    }

    return 0;
}

十、四种cast转换⭐⭐

C++中有四种类型转换符可用于在不同类型之间进行类型转换。static_cast、dynamic_cast、const_cast和reinterpret_cast。

1、static_cast：

1. 基本类型之间的转换，例如将int转换为double等。
2. 向上或向下进行继承关系的指针或引用转换。
3. 显式调用转换构造函数或转换操作符。
4. 进行其他合法的转换，例如指针与整数类型之间的转换。

int num = 10;
double convertedNum = static_cast<double>(num);

class Base {};
class Derived : public Base {};
Base* basePtr = new Derived();
Derived* derivedPtr = static_cast<Derived*>(basePtr);

2、dynamic_cast：

1. 向上转换：将派生类指针或引用转换为基类指针或引用。
2. 安全向下转换：将基类指针或引用转换为派生类指针或引用，仅当基类指针或引用实际指向派生类对象时才有效。
3. 运行时类型检查：dynamic_cast会在运行时检查转换的安全性，如果转换失败，返回空指针（对于指针转换）或抛出std::bad_cast异常（对于引用转换）

class Base { virtual void foo() {} };
class Derived : public Base {};

Base* basePtr = new Derived();
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
if (derivedPtr) {
    // 转换成功
}

3、const_cast：

1. const_cast用于去除指针或引用的const属性。
2. 可以修改被const修饰的对象。
3. 仅能去除直接指针或引用的const属性。
4. 使用const_cast需谨慎，因为修改被const修饰的对象会导致未定义行为。仅在确保安全性的前提下使用。

const int num = 10;
int* nonConstPtr = const_cast<int*>(&num);
*nonConstPtr = 20; // 合法：修改nonConstPtr的值

4、reinterpret_cast：

1. reinterpret_cast是C++中用于执行低级别的类型转换的关键字（使用reinterpret_cast需要格外谨慎）。
2. 它可以将一个指针或引用转换为不同类型的指针或引用，甚至是完全无关的类型。
3. reinterpret_cast在类型转换时只进行位模式的重新解释，不执行任何类型检查或转换操作。
4. 错误的使用reinterpret_cast可能导致程序行为不确定或非法。
5. 因此，除非绝对必要，否则应避免使用reinterpret_cast，并且使用前需要确保类型转换的合法性。

int num = 10;
double* doublePtr = reinterpret_cast<double*>(&num);  // 不安全，可能导致未定义行为

int* intPtr = reinterpret_cast<int*>(doublePtr);  // 转回原始类型