左值和右值：

移动语义与完美转发：

移动语义和完美转发是C++11引入的两个重要特性，目的是提高性能，减少不必要的对象复制和临时对象的创建。

移动语义允许你从一个函数返回一个大对象时不进行复制，而是移动它转移所有权，是一种优化资源管理机制。这是通过使用std::move函数来告诉编译器你希望对象被移动而不是复制节省时间和内存。std::move 是一个标准库函数，其定义在 <utility> 头文件中。它的作用是将一个左值转换为一个右值。为了支持移动语义，通常需要定义 移动构造函数 和 移动赋值运算符。默认原对象不在使用，原对象到底能不能用取决于你的移动构造函数和移动赋值函数如何实现（如果还是拷贝则原对象还可以使用，如果原对象内存里废弃掉新对象使用原对象内存，那原对象不可以用）

#include <iostream>
#include <utility> // for std::move
class MyClass {
public:
    MyClass(int size) : data(new int[size]), size(size) {
        std::cout << "Resource acquired\n";
    }
    // 移动构造函数
    MyClass(MyClass&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr; // 置空其他对象的资源，以避免双重释放
        other.size = 0;
        std::cout << "Resource moved\n";
    }

    ~MyClass() {
        delete[] data; // 释放资源
        std::cout << "Resource released\n";
    }

public:
    int* data;
    int size;
};

int main() {
    MyClass obj1(10); // 创建一个对象
    MyClass obj2 = std::move(obj1); // 移动 obj1 的资源到 obj2
    // 在此之后，obj1 的资源已被转移，制造新的内容不能再使用 obj1
    return 0;
}

完美转发允许你在模板函数中完全保留函数参数的左值和右值属性。这是通过模板中的forward函数来实现的，主要用于在模板中转发函数参数。它的主要目的是实现高效的参数传递，以保持参数的值类别（左值或右值），并避免不必要的拷贝。

#include <iostream>
#include <vector>
#include <utility> // for std::move
std::vector<int> returnByValue(std::vector<int> vec) {
    return vec; // 按值返回，可能会发生复制
}
std::vector<int> returnByMove(std::vector<int> vec) {
    return std::move(vec); // 使用移动语义返回
}
int main() {
    std::vector<int> largeVector;
    // 填充大对象
    for (int i = 0; i < 1000000; ++i) {
        largeVector.push_back(i);
    }
    // 按值返回，可能会发生复制
    std::vector<int> copied = returnByValue(largeVector);
    // 使用移动语义返回，避免了复制
    std::vector<int> moved = returnByMove(std::move(largeVector));
    return 0;
}

#include <iostream>
#include <utility> 
// 包含 std::forward

// 一个示例函数，接受一个整数参数
void process(int& i) {
    std::cout << "Lvalue: " << i << std::endl;
}
void process(int&& i) {
    std::cout << "Rvalue: " << i << std::endl;
}
// 完美转发的模板函数
template<typename T>
void forwardToProcess(T&& arg) {
    // 使用 std::forward 将参数转发
    process(std::forward<T>(arg)); 
}
int main() {
    int x = 10;
    // 使用左值调用
    forwardToProcess(x);   // Lvalue: 10
    // 使用右值调用
    forwardToProcess(20);  // Rvalue: 20
    return 0;
}

列表初始化：

列表初始化是C++11引入的一种新的初始化方式，它允许使用大括号 {} 来初始化各种类型的对象包括基本数据类型、类对象、数组、标准库容器等。列表初始化的好处：简洁性，类型安全：可以防止窄化转换（narrowing conversion），即不会自动转换数据类型，减少错误。统一性：可以用于各种数据结构，使得初始化方式统一。
 

智能指针：

智能指针（包括std::unique_ptr、std::shared_ptr和std::weak_ptr）

1. std::unique_ptr
原理：std::unique_ptr 是一个独占所有权的智能指针，利用RAII模式，自动管理动态分配的资源，意味着同一时间只能有一个 unique_ptr 指向某个对象。当 unique_ptr 被销毁时，它所管理的内存会自动释放，避免内存泄漏。不允许被复制因为他的拷贝构造被声明为delete，可以进行所以权转移，可以避免双重释放问题。
当你需要唯一拥有一个对象的所有权，且不需要共享它时，可以使用 unique_ptr。常用于动态分配的对象，确保它们会在不再需要时被清理。

class A {
public:
    A() { std::cout << "A Constructor\n"; }
    ~A() { std::cout << "A Destructor\n"; }
};

int main() {
    std::unique_ptr<A> ptr1(new A()); // 创建 unique_ptr
    // std::unique_ptr<A> ptr2 = ptr1; // 错误：不能拷贝
    std::unique_ptr<A> ptr2 = std::move(ptr1); // 转移所有权
    return 0;
}

2. std::shared_ptr
原理：std::shared_ptr 允许多个指针共享同一个对象的所有权。它使用引用计数来追踪有多少个 shared_ptr 指向同一个对象。只有当最后一个 shared_ptr 被销毁后，所管理的对象才会被释放。
使用场景：适用于需要多个对象共享同一个资源的情况，比如在多个地方需要引用同一个对象，但不希望它立即被销毁。

class A {
public:
    A() { std::cout << "A Constructor\n"; }
    ~A() { std::cout << "A Destructor\n"; }
};
int main() {
    std::shared_ptr<A> ptr1(new A()); // 创建 shared_ptr
    {
        std::shared_ptr<A> ptr2 = ptr1; // 共用同一个对象
        std::cout << "Usage Count: " << ptr1.use_count() << '\n'; //2 输出使用计数
    } // ptr2 超出作用域，使用计数减少
    std::cout << "Usage Count: " << ptr1.use_count() << '\n'; //1 仍然可用
    return 0;
}

shared_ptr 本身是线程安全的，具体来说，它的引用计数操作是线程安全的因为对于引用计数做了原子级操作。这意味着你可以在多个线程中安全地读取和复制同一个 shared_ptr。然而，shared_ptr 对所指向的对象的访问并不是线程安全的。如果多个线程同时访问和修改同一个对象，你仍然需要使用其他同步机制（如互斥锁）来保证线程安全。

3. std::weak_ptr
原理：std::weak_ptr 是一种不控制所有权的智能指针，主要用于解决 shared_ptr 之间的循环引用问题。通过 weak_ptr 可以观察到 shared_ptr 指向的对象，但不增加引用计数，当 shared_ptr 被销毁时，weak_ptr 不会影响其生命周期。
使用场景：当你需要引用一个 shared_ptr 指向的对象，但不希望阻止它被销毁，例如在缓存或观察者模式中使用。

class A {
public:
    A() { std::cout << "A Constructor\n"; }
    ~A() { std::cout << "A Destructor\n"; }
};

int main() {
    std::shared_ptr<A> ptr1(new A()); // 创建 shared_ptr
    std::weak_ptr<A> weakPtr = ptr1; // 创建 weak_ptr

    std::cout << "Use Count: " << ptr1.use_count() << '\n'; //1 输出使用计数
    if (auto sharedPtr = weakPtr.lock()) { // 检查对象是否仍然存在
        std::cout << "Object is alive\n"; //Y
    } else {
        std::cout << "Object is no longer alive\n";
    }

    ptr1.reset(); // 释放 shared_ptr 指向的对象
    if (auto sharedPtr = weakPtr.lock()) {
        std::cout << "Object is alive\n";
    } else {
        std::cout << "Object is no longer alive\n"; //Y
    }
    return 0;
}

static

1. 静态变量（局部静态变量）
定义：在函数内部定义的变量，可以使用static修饰。
特点：该变量在函数调用之间保持其值，不会在每次调用时重新初始化。只在第一次调用函数时初始化一次。
使用场景：当需要在函数中记住某个状态，且不想每次调用时都初始化时。

void countCalls() {
    static int callCount = 0; // 只初始化一次
    callCount++;
    std::cout << "function called " << callCount << " times." << std::endl;
}

int main() {
    countCalls(); // 输出 1
    countCalls(); // 输出 2
    countCalls(); // 输出 3
    return 0;
}

2. 静态全局变量或函数
定义：在文件顶部声明的变量，使用static修饰。
特点：该变量只能在声明它的文件内访问，其他文件无法访问。
使用场景：有助于限制变量的作用域，使其只在当前文件中可见，从而避免与其他文件中的同名变量冲突。

3. 静态成员变量、函数
定义：在类中声明的变量、函数，使用static修饰。
特点：属于类而非类的实例，所有实例共享同一个静态变量。而函数不能访问类的非静态成员，只能访问静态成员。必须在类外进行初始化。
使用场景：当你希望跟踪与类相关的状态，而与特定实例无关时。

class A {
public:
    static int instanceCount; // 声明静态成员变量
    A() {
        instanceCount++; // 每次创建实例时增加计数
    }
    static void displayMessage() {
        std::cout << "Hello from static function!" << std::endl;
    }
};
int A::instanceCount = 0; // 定义并初始化静态成员变量
int main() {
    A obj1;
    A obj2;
    A::displayMessage(); // 调用静态成员函数
    std::cout << "Number of instances: " << A::instanceCount << std::endl; // 输出 2
    return 0;
}

STL

std::array

std::array 是 C++ 标准库中的一个容器，它封装了一个固定大小的数组。

int main() {
    // 创建一个 std::array，大小为 5(模板需要大小参数)，元素类型为 int
    std::array<int, 5> arr = {1, 2, 3, 4, 5};

    // 访问元素
    std::cout << "第一元素: " << arr.at(0) << std::endl; // 使用 at() 访问或进行越界检查
    std::cout << "数组大小: " << arr.size() << std::endl; // 输出数组大小

    // 遍历数组，也可以使用迭代器
    for (const auto& element : arr) {
        std::cout << element << " "; // 输出每个元素
    }
    std::cout << std::endl;
    return 0;
}

vector:

vector 是一个动态数组类。实现了自动增长、随机访问等功能。提供了一些方便的成员函数来管理元素，如 push_back、pop_back、erase 等。vector一些方法的区别

1、 size 和 capacity 的区别
size: 指当前 vector 中实际存储的元素数量，通过 vector.size() 方法。
capacity: 指 vector 在不需要重新分配内存的情况下可以容纳的最大元素数量，vector.capacity() 方法。如果一个 vector 的 capacity 是 10，则在添加更多元素之前，它可以存储最多 10 个元素。超过这个数量时，vector 会自动扩展。
2、resize 和 reserve 的区别
resize: 改变 vector 的 size，使其包含指定数量的元素。如果新 size 比当前 size 大，vector 将添加新元素（如果没有指定值，则新元素默认初始化为0）如果新 size 比当前 size 小，vector 将删除多余的元素。

3 、push_back 和 emplace_back

std::vector<std::string> vec;
std::string str = "Hello, World!";
vec.push_back(str); // 复制操作
// 或者
vec.push_back("Hello, World!"); // 临时对象的复制
vec.emplace_back("Hello, World!"); // 直接在 vector 内部构造

map 和 unordered_map

在C++中，map 和 unordered_map 都是用于存储键值对数据结构的容器，主要区别如下

迭代器与指针：

在 C++ 中，迭代器和指针都是用于访问和遍历数据结构（如数组、链表、容器等）的工具

 指针使用不好会产生野指针和悬挂指针：

多态：

多态是一种面向对象编程中的基本概念，它允许不同的对象以相同的方式响应相同的消息或方法调用。在C++中，多态使得一个接口可以被不同的类实现，从而提高代码的灵活性和可扩展性。多态其实分为两种类型：编译时多态（静态多态）主要通过函数重载和运算符重载实现。在编译阶段，编译器决定调用哪个函数或操作符。运行时多态（动态多态）：主要通过虚函数和继承实现，通过基类指针或引用来调用子类的重写函数实现。在运行时，根据对象的实际类型决定调用哪个函数。

虚函数：

虚函数是C++中实现多态的一种方式。虚函数是在基类中使用关键字 virtual 声明的成员函数。派生类重写虚函数，通过虚函数，基类指针或引用可以调用派生类中的重写函数。程序在运行时根据对象的实际类型选择调用哪个函数。

实现虚函数的关键在于虚函数表（vtable）和虚函数表指针（vptr）：每个包含虚函数的类都有一个虚函数表（Vtable），这是一个指针数组，存放该类的虚函数地址。对于每个对象实例，会有一个指向所在类的虚函数表的指针（内存中除了成员变量外额外一个虚指针）称为虚指针（Vptr）。

构造函数不可以是虚函数：构造函数主要用于初始化对象的状态。当一个类的对象被创建时，构造函数会被调用。编译器首先分配内存，然后调用构造函数来初始化对象。虚函数的机制依赖于虚函数表，而虚函数表的建立需要在调用构造函数之后才能完成，如果为虚函数会导致对象初始化（明确对象的类型）和多态机制矛盾（对象类型在构造时尚未确定。）。

析构函数需要是虚函数（继承体系）：目的确保在删除对象时，通过将基类的析构函数声明为虚函数，基类指向派生类调用时，派生类的析构函数先被调用，然后再析构父类，确保所有资源都被正确释放，防止资源泄漏。

explicit、delete、default

explicit是一个关键字，它主要用于构造函数的声明。使用explicit可以避免某些不必要的类型转换，确保代码更加安全和可读。
隐式转换：在C++中，如果构造函数只有一个参数，编译器可以自动将该参数的类型转换为对象类型。这种行为有时会导致意想不到的错误。
 

class A
{
public:
    explicit A(int value)
    { // 加上explicit
        // 构造函数代码
    }
};
void function(A obj)
{
    // 函数代码
}
int main()
{
    A obj1(10); // 合法的构造
    // A obj2 = 20; // 不合法，编译错误
    function(A(30)); // 合法
    // function(40); // 不合法，编译错误
    return 0;
}

使用explicit可以使代码意图更加明确。程序员在创建对象时需要清楚地指定要创建的对象类型，而不是依赖于编译器的隐式转换。（适用于单个参数的构造函数）对于多个参数的构造函数，通常不需要使用explicit，因为它们不支持隐式转换。

delete和default关键词，用于管理类的构造函数、析构函数和拷贝/移动操作。delete 用于删除对象的某个特殊成员函数的默认实现，表示这个特定操作不能被使。（目地控制资源管理：如果一个类管理动态分配的资源（如内存），复制对象可能会导致资源重复释放的潜在问题。
举例单例模式：通常需要防止对象被复制以保证单例的唯一性。）

default 用于显式地请求编译器生成某些特殊成员函数的默认实现。自定义类：当你创建一个自定义类并希望使用编译器生成的成员函数时，可以明确地使用 default。

final：

final关键字主要用于控制类和虚函数的继承行为，确保某些类或函数不能被继承或重写。它通常和override关键字一起使用，可以显示指出该函数时覆盖基类的某个虚函数且不允许再被派生类覆盖

类型转换

volatile

volatile 关键字是一个用于类型修饰的关键字，主要用于告诉编译器特定的变量可能会被异步地改变。1）当一个变量被声明为 volatile，编译器在访问该变量时不会进行优化。这意味着每次读取该变量的值时，编译器都会从其实际内存位置重新读取，而不是使用缓存的值。2）用于多线程编程：在多线程程序中，一个线程可能会修改某个变量，而另一个线程需要读取这个变量。将该变量声明为 volatile 可以确保一个线程读取的值是最新的，防止因编译器优化导致读取到过期值。
3）与硬件寄存器交互：在嵌入式系统中，某些变量可能与硬件寄存器直接关联。使用 volatile 可以确保程序不会因为优化而漏掉对这些寄存器的读写操作。

volatile 关键字并不能替代线程同步机制（如锁），它只保证了变量的可见性，并不保证操作的原子性。在多线程程序中，除了使用 volatile，还应该考虑使用其他同步手段，如互斥锁（mutex）等，以确保程序的正确性和安全性。

RAII

RAII（Resource Acquisition Is Initialization）是一种在 C++ 中管理资源（如内存、文件句柄、线程等）的技术。这种设计模式确保了资源能够在对象的生命周期内被有效管理，并在对象被销毁时自动释放资源。

RAII 的基本原则： 资源获取: 当对象被创建时，它负责获取和管理所需的资源。
资源释放: 当对象的生命周期结束（即对象被销毁）时，它的析构函数会自动释放那些资源。
异常安全: RAII 确保即使在异常发生的情况下，资源也会被正确释放。
RAII 的实现步骤：定义类: 创建一个类，该类负责管理特定的资源。
构造函数: 在构造函数中获取和分配资源。析构函数: 在析构函数中释放资源。

class Resource {
public:
    // 构造函数：分配资源
    Resource() {
        data = new int[10];  // 动态分配内存
        std::cout << "Resource acquired.\n";
    }

    // 析构函数：释放资源
    ~Resource() {
        delete[] data;  // 释放内存
        std::cout << "Resource released.\n";
    }

private:
    int* data;  // 资源指针
};

int main() {
    {
        Resource res;  // 创建 Resource 对象，获取资源
        // 在这里可以使用资源（例如，填充数据等）
    }  // 资源对象的生命周期结束，自动释放资源

    // 这里，Resource 对象已经被销毁，资源也被释放
    return 0;
}

简化资源管理: 不必手动释放资源，降低内存泄漏的风险。
异常安全: 任何时候只要对象被销毁，资源就会被释放，避免了异常情况带来的资源泄露。
清晰的语义: 对象的生命周期与资源的管理相结合，使得代码更加清晰易懂。
两种RAII形式的锁管理类lock_guard和unique_lock

#include <iostream>
#include <mutex>
#include <thread>

std::mutex mtx;

void printMessage() {
    std::lock_guard<std::mutex> lock(mtx); // 自动锁定
    std::cout << "Hello from thread!" << std::endl;
} // 自动解锁

int main() {
    std::thread t1(printMessage);
    std::thread t2(printMessage);
    t1.join();
    t2.join();
    return 0;
}

std::mutex mtx;
void printMessage() {
    std::unique_lock<std::mutex> lock(mtx); // 锁定
    std::cout << "Hello from thread!" << std::endl;
    lock.unlock(); // 手动解锁
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 做一些事情
    lock.lock(); // 重新锁定
    std::cout << "Thread finished work!" << std::endl;
} 

int main() {
    std::thread t1(printMessage);
    std::thread t2(printMessage);
    t1.join();
    t2.join();
    return 0;
}

thread：

thread 是用于创建和管理线程的一个类。在使用 std::thread 时，通常会用到 join 和 detach 函数来处理线程的生命周期。

#include <iostream>
#include <thread>
#include <chrono>
void task() {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟工作
    std::cout << "Task completed!" << std::endl;
}
int main() {
    // 使用 join
    std::thread t1(task);
    t1.join(); // 等待线程 t1 完成
    std::cout << "Thread t1 has joined." << std::endl;

    // 使用 detach
    std::thread t2(task);
    t2.detach(); // 线程 t2 在后台运行
    std::cout << "Thread t2 has detached." << std::endl;
    // 等待一段时间，让 t2 有机会完成
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout << "Main thread ended." << std::endl;
    return 0;
}

那如何设计一个线程安全的类：涉及到多线程编程的几个核心概念，包括互斥量、条件变量和原子操作等。

#include <iostream>
#include <mutex>
#include <thread>
//引入标准库
class ThreadSafeCounter {
public:
    ThreadSafeCounter() : count(0) {}
    // 增加计数
    void increment() {
        std::lock_guard<std::mutex> lock(mutex_); // 加锁
        ++count; // 修改共享数据
    }
    // 获取计数
    int getCount() {
        std::lock_guard<std::mutex> lock(mutex_); // 加锁
        return count; // 返回共享数据
    }
private:
    int count; // 共享数据
    std::mutex mutex_; // 互斥量
};
void incrementCounter(ThreadSafeCounter& counter) {
    for (int i = 0; i < 1000; ++i) {
        counter.increment();
    }
}

int main() {
    ThreadSafeCounter counter;

    std::thread t1(incrementCounter, std::ref(counter));
    std::thread t2(incrementCounter, std::ref(counter));
    
    t1.join(); // 等待线程t1完成
    t2.join(); // 等待线程t2完成

    std::cout << "Final count: " << counter.getCount() << std::endl; // 输出最终计数
    return 0;
}

原子操作代替互斥锁

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>

std::atomic<int> counter(0); // 声明一个原子变量
void increment() {
    for (int i = 0; i < 1000; ++i) {
        counter++; // 原子加法
    }
}
int main() {
    const int num_threads = 2;
    std::vector<std::thread> threads;

    // 创建多个线程
    for (int i = 0; i < num_threads; ++i) {
        threads.emplace_back(increment);
    }

    // 等待所有线程完成
    for (auto& t : threads) {
        t.join();
    }

    std::cout << "Final counter value: " << counter.load() << std::endl; // 输出结果
    return 0;
}

 原子操作：一个操作是原子的，即它要么完全执行，要么完全不执行，不会受到其他线程的干扰。可以使用std::atomic修饰基本类型，它通过CPU提供的原子指令来实现这些不可分割的操作，现在CPU会提供一组指令，比如CMPXCHG,XADD等原子操作的读或写，虽然在某些场景下可以替代锁，比如一些基本的计算器或标志位，但复杂场景下锁还是较优选择。

memcpy 和 memmove  

memcpy 和 memmove 都是 C 和 C++ 中用于内存拷贝的函数

#include <cstring>
#include <iostream>
int main() {
    char src[] = "Hello, World!";
    char dest[20];

    // 使用 memcpy
    std::memcpy(dest, src, 13);
    std::cout << "Using memcpy: " << dest << std::endl;

    // 创建一个重叠的情况
    char overlap[] = "Hello, World!";
    std::memmove(overlap + 7, overlap, 6); // 把"Hello,"移动到"World!"前面
    std::cout << "Using memmove with overlap: " << overlap << std::endl;
    return 0;
}

还有一个专门针对字符串赋值的函数strcpy: 用于复制一个字符串（包括结束的空字符 \0）。   char* strcpy(char* dest, const char* src);  它会将 src 指向的字符串复制到 dest 中，并在最后添加一个空字符来标识字符串的结束。它适用于处理以空字符结尾的字符串，否则可能导致缓冲区溢出，如果 src 的长度超过了 dest 的分配空间。为了安全起见，可以使用 strncpy，指定最大拷贝长度。 

function、bind和lambda

function、bind和lambda都是处理函数和可调用对象的重要工具。

1、std::function：是C++标准库中的一个类模板，用于封装任何可调用对象（如普通函数、函数指针、成员函数、Lambda 表达式等）。
适用场景：1) 存储函数指针：当你需要将不同的函数存储在同一个容器中时，可以使用std::function。 2)  回调机制：可以用于实现回调函数，提供灵活性。3)多态性：允许将不同类型的可调用对象统一处理。

void sayHello() {
    std::cout << "Hello, World!" << std::endl;
}

int main() {
    std::function<void()> func = sayHello; // 使用std::function
    func(); // 调用
    return 0;
}

2、std::bind： 允许你绑定（或固定）函数的参数，生成新的可调用对象。
适用场景：1）参数绑定：当你想提前固定某些参数，或改变参数的顺序时。
2）适配器模式：将一个函数转变为另一个可以接受不同参数的形式。
3）简化代码：在需要传递函数作为参数时，可以减少需要传递的参数数量。

void printSum(int a, int b) {
    std::cout << "Sum: " << a + b << std::endl;
}

int main() {
    auto boundFunc = std::bind(printSum, std::placeholders::_1, 10); // 绑定第二个参数
    boundFunc(5); // 只需提供一个参数
    return 0;
}

 3、 Lambda 表达式：是一种在C++11引入的方式，用于定义匿名函数。
适用场景：1）简洁性：在需要快速定义小函数时，使用Lambda更加简洁。
2）临时用途：适用于临时计算，避免创建单独的函数。
3）捕获上下文：可以捕获周围的变量，可以在函数体内直接使用这些变量。

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    // 使用Lambda表达式打印每个数字
    std::for_each(numbers.begin(), numbers.end(), [](int n) {
        std::cout << n << std::endl;
    });
    return 0;
}

回调函数

回调函数是指作为参数传递给另一个函数的函数。实际上是把函数的调用权从一个地方转移到另一个地方，可以在某些事件发生或特定条件满足时调用这个回调函数。回调函数在C++中非常有用，主要用于处理异步操作、事件通知和自定义行为。

异步编程：回调函数允许程序在等待某些操作（如文件读取、网络请求等）完成时继续执行其他操作。当操作完成时，程序会调用回调函数来处理结果。

事件驱动编程：在图形用户界面（GUI）中，程序通过事件（如按钮点击）驱动，而回调函数可以定义对这些事件的响应。

解耦合：回调函数使程序的不同部分之间的耦合度降低。可以在不修改主逻辑的情况下，轻松更改或添加功能。

代码复用：通过使用回调函数，可以将通用逻辑与具体实现分离，从而更好地复用代码。

// 定义一个函数类型的别名
using Callback = std::function<void(int)>;
// 一个接受回调函数的函数
void performOperation(int value, Callback callback) {
    // 执行某些操作
    value *= 2; // 将值乘以2
    // 调用回调函数
    callback(value);
}

// 一个简单的回调函数
void myCallback(int result) {
    std::cout << "Callback called with result: " << result << std::endl;
}

int main() {
    // 调用performOperation，并传入myCallback作为回调
    performOperation(5, myCallback);
    return 0;
}

模板

C++模板是C++中的一种强大特性，它允许编写与类型无关的代码，使得同一段代码可以处理不同类型的数据。模板分为函数模板和类模板

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

template <typename T>
class Box {
private:
    T item;
public:
    void setItem(T item) {
        this->item = item;
    }
    T getItem() {
        return item;
    }
};

栈与堆内存