C++11特性

引用折叠### 简述C++11有什么新特性？⭐

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

auto关键字⭐

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

优点：简化类型声明

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

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

缺点：降低可读性

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

使用场景

简化类型声明：在变量的类型已经明确而且易于推导的情况下，可以使用 auto 以简化代码。
模板编程：在模板函数和模板类的定义中，通过 auto 结合类型推导，可以实现更通用、灵活的模板代码。

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

迭代器类型：对于容器和遍历器等情况，使用 auto 可以自动推导迭代器的类型，避免显式指定具体类型。

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

Lambda表达式⭐⭐

`lambda` 表达式的基本语法

[capture](parameters) -> return_type { 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 表达式可以提供一种简洁的实现方式。

// 定义一个函数doSomething，它接受三个参数：
// 第一个参数a是int类型，
// 第二个参数b也是int类型，
// 第三个参数callback是一个函数，它接受两个int类型的参数并返回一个int类型的结果。
void doSomething(int a, int b, std::function<int(int, int)> callback) {
    // 在函数内部，调用传入的callback函数，将a和b作为参数传递。
    // callback函数的返回值被赋值给局部变量result。
    int result = callback(a, b);
    
    // 使用std::cout输出result变量的值，后面跟着文本"Result: "。
    std::cout << "Result: " << result << std::endl;
}
 
// 调用doSomething函数，传入两个整数5和3作为前两个参数。
// 第三个参数是一个匿名的lambda表达式，它接受两个int类型的参数x和y，
// 并返回它们的和。这个lambda表达式被用作callback函数。
doSomething(5, 3, [](int x, int y) {
    // 这个lambda表达式的函数体只包含一个返回语句，返回参数x和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];
}

理解左值和右值？⭐⭐⭐

左值（L-value）：左值表示一个内存位置的标识符，可以出现在赋值语句的左边或右边。左值在表达式中是持久的，具有地址，并且可以被修改。可以将其简单理解为可以取址的表达式。一般来说，变量、函数或内存中的对象都可以是左值。

右值（R-value）：右值表示暂时的、临时的值，不能出现在赋值语句的左边。右值在表达式中是短暂的，不具有地址，不能被修改。可以将其简单理解为没有地址的表达式。一般来说，常量、字面量、临时对象、表达式的结果等都可以被视为右值。

int x = 10; // x 是一个左值，可以取址和修改
int y = x; // x 是一个右值，不可以取址，只是一个临时值
int z = x + y; // x + y 是一个右值，表达式计算结果是一个临时值

右值引用

什么是右值引用？⭐⭐

右值引用（R-value reference）是 C++11 引入的一种新的引用类型，用于标识和操作右值。

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

右值引用它的作用？⭐⭐

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

void processValue(int&& value) {
    // 对右值进行操作
    // ...
}
 
int main() {
    int x = 10;
 
    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++ 中用来保持传递参数的值类别的技术，它使得函数模板在接受参数时能够保持传递参数的原始值类别，无论是左值还是右值。

实现所需特性

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

原理⭐

基于引用折叠（Reference collapsing）和函数重载解析。

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

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(已弃用）。

unique_ptr

unique_ptr是独占所有权的智能指针，用于管理动态分配的对象。
它禁止多个unique_ptr指向同一对象，可以通过std::move转移所有权。
适用于需要独占所有权的场景，能够避免内存泄漏。
std::unique_ptr 智能指针设计用于独占地管理一块内存资源。为了确保这一点，它的拷贝构造函数和拷贝赋值运算符都被显式删除（deleted），从而禁止任何拷贝行为。这样就确保了一个 std::unique_ptr 实例不会与其他实例共享同一块内存资源。

#include <iostream>
#include <memory>
 
// 自定义删除器
struct UniqueDeleter {
    void operator()(int* p) { delete p; }
};
 
int main() {
    // 创建一个带有自定义删除器的 std::unique_ptr
    std::unique_ptr<int, UniqueDeleter> uptr(new int(10), UniqueDeleter());
 
    // 检查 unique_ptr 是否有效（即不为空）
    if (uptr) {
        std::cout << *uptr << std::endl; // 输出10
    }
 
    // 调用 reset() 方法手动释放内存
    uptr.reset(); // 释放内存后，uptr 成为一个空指针
 
    // 下面的声明是无效的，因为拷贝构造函数和赋值运算符都被删除了
    // std::unique_ptr<int, UniqueDeleter> uptr2 = uptr; // error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>::unique_ptr(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = int; _Dp = UniqueDeleter]’
 
    // 同样，赋值也是不允许的
    // std::unique_ptr<int, UniqueDeleter> uptr3;
    // uptr3 = uptr; // error: use of deleted function ‘std::unique_ptr<_Tp, _Dp>& std::unique_ptr<_Tp, _Dp>::operator=(const std::unique_ptr<_Tp, _Dp>&) [with _Tp = int; _Dp = UniqueDeleter]’
 
    return 0;
}

shared_ptr

shared_ptr允许多个指针共享对同一对象的所有权，通过引用计数来追踪当前有多少个指针共享一个对象。
当最后一个shared_ptr超出作用域或被重置时，才会释放所管理的对象。
它可以通过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;
}

weak_ptr

weak_ptr是一种不共享所有权的智能指针，用于解决shared_ptr的循环引用问题。
weak_ptr可以从shared_ptr创建，但不能直接访问所管理的对象。
它可以使用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。

static_cast

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

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);

dynamic_cast

向上转换：将派生类指针或引用转换为基类指针或引用。
安全向下转换：将基类指针或引用转换为派生类指针或引用，仅当基类指针或引用实际指向派生类对象时才有效。
运行时类型检查：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) {
    // 转换成功
}

const_cast

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

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

reinterpret_cast

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

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

🪴 Quartz 4.0

Explorer

C++11特性

auto关键字⭐

优点：简化类型声明

缺点：降低可读性

使用场景

Lambda表达式⭐⭐

`lambda` 表达式的基本语法

lambda优点

lambda缺点

使用场景

理解左值和右值？⭐⭐⭐

右值引用

什么是右值引用？⭐⭐

右值引用它的作用？⭐⭐

说说移动语义的原理⭐

完美转发

定义

实现所需特性

原理⭐

函数模板与模板函数？⭐

函数模板

模板函数

区别

智能指针⭐⭐⭐⭐⭐

unique_ptr

shared_ptr

shared_ptr出现内存泄露怎么办？

weak_ptr

四种cast转换⭐⭐

static_cast

dynamic_cast

const_cast

reinterpret_cast

Graph View

Table of Contents

🪴 Quartz 4.0

Explorer

C++11特性

auto关键字⭐

优点：简化类型声明

缺点：降低可读性

使用场景

Lambda表达式⭐⭐

lambda 表达式的基本语法

lambda优点

lambda缺点

使用场景

理解左值和右值？⭐⭐⭐

右值引用

什么是右值引用？⭐⭐

右值引用它的作用？⭐⭐

说说移动语义的原理⭐

完美转发

定义

实现所需特性

原理⭐

函数模板与模板函数？⭐

函数模板

模板函数

区别

智能指针⭐⭐⭐⭐⭐

unique_ptr

shared_ptr

shared_ptr出现内存泄露怎么办？

weak_ptr

四种cast转换⭐⭐

static_cast

dynamic_cast

const_cast

reinterpret_cast

Graph View

Table of Contents

`lambda` 表达式的基本语法