C++指针、智能指针（std::unique_ptr，std::shared_ptr）和内存池的使用。

C++中的指针、智能指针和内存池是管理动态内存的关键工具。理解并正确使用这些工具，可以有效地避免内存泄漏，提升程序的性能和可靠性。

一、指针

1. 原生指针

原生指针是C++中的基本指针类型，用于存储内存地址。它们非常灵活，但也容易导致内存泄漏和悬空指针等问题。

使用示例

#include <iostream>

int main() {
    // 动态分配一个整数
    int* ptr = new int(10);
    std::cout << "Value: " << *ptr << std::endl;

    // 手动释放内存
    delete ptr;

    // 指针置空，防止悬空指针
    ptr = nullptr;

    return 0;
}

2. 原生指针的优缺点

优点：

• 灵活性高，可以指向任何内存地址。
• 适合低级别的内存管理操作。

缺点：

• 需要手动管理内存，容易发生内存泄漏。
• 容易产生悬空指针和未初始化指针等问题。

二、智能指针

智能指针是C++11引入的模板类，用于自动管理动态内存，避免手动释放内存带来的问题。

1. std::unique_ptr

std::unique_ptr是独占所有权的智能指针。一个unique_ptr对象拥有其指向的内存，不允许其他指针共享该内存。

使用示例

#include <iostream>
#include <memory> // 需要包含 <memory> 头文件

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
    void sayHello() const { std::cout << "Hello from MyClass" << std::endl; }
};

int main() {
    // 创建一个 unique_ptr，自动管理 MyClass 对象的生命周期
    std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>();
    ptr->sayHello();

    // unique_ptr 自动释放内存，无需手动 delete

    // 释放所有权
    std::unique_ptr<MyClass> ptr2 = std::move(ptr);

    if (ptr == nullptr) {
        std::cout << "ptr is null after move" << std::endl;
    }

    return 0;
}

优点：

• 自动管理内存，防止内存泄漏。
• 支持转移所有权。

缺点：

• 不支持共享所有权。

2. std::shared_ptr

std::shared_ptr是共享所有权的智能指针。多个shared_ptr可以指向同一个对象，并通过引用计数来管理对象的生命周期。

使用示例

#include <iostream>
#include <memory> // 需要包含 <memory> 头文件

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
    void sayHello() const { std::cout << "Hello from MyClass" << std::endl; }
};

int main() {
    // 创建一个 shared_ptr
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>();
    ptr1->sayHello();

    // 共享所有权
    std::shared_ptr<MyClass> ptr2 = ptr1;

    std::cout << "Reference Count: " << ptr1.use_count() << std::endl;

    return 0;
}

优点：

• 允许多个指针共享同一个对象。
• 自动管理对象的生命周期。

缺点：

• 引用计数会带来一定的性能开销。
• 需要避免循环引用问题（可以使用std::weak_ptr来解决）。

三、内存池

内存池（Memory Pool）是一种预分配内存块的技术，用于高效管理和复用内存，特别是在频繁分配和释放小块内存的场景下。

内存池的实现

内存池通过预先分配一大块内存，将其划分为多个小块。当需要内存时，从池中分配一个小块；当不再需要时，将小块归还到池中，而不是立即释放。

简单的内存池示例

#include <iostream>
#include <vector>

// 简单的内存池类
class MemoryPool {
public:
    MemoryPool(size_t blockSize, size_t blockCount)
        : blockSize_(blockSize), blockCount_(blockCount) {
        // 预分配内存
        pool_.resize(blockSize_ * blockCount_);
        freeBlocks_.reserve(blockCount_);

        // 将每个块的地址添加到空闲列表
        for (size_t i = 0; i < blockCount_; ++i) {
            freeBlocks_.push_back(&pool_[i * blockSize_]);
        }
    }

    void* allocate() {
        if (freeBlocks_.empty()) {
            throw std::bad_alloc();
        }
        // 从空闲列表中获取一个块
        void* ptr = freeBlocks_.back();
        freeBlocks_.pop_back();
        return ptr;
    }

    void deallocate(void* ptr) {
        // 将块归还到空闲列表
        freeBlocks_.push_back(ptr);
    }

private:
    size_t blockSize_;
    size_t blockCount_;
    std::vector<char> pool_;
    std::vector<void*> freeBlocks_;
};

int main() {
    const size_t blockSize = 32; // 每块32字节
    const size_t blockCount = 10; // 总共10块

    MemoryPool pool(blockSize, blockCount);

    // 分配一个块
    void* ptr = pool.allocate();
    std::cout << "Allocated memory at: " << ptr << std::endl;

    // 释放一个块
    pool.deallocate(ptr);

    std::cout << "Memory deallocated" << std::endl;

    return 0;
}

内存池的优缺点

优点：

• 提高了内存分配和释放的效率。
• 避免了频繁的小块内存分配和释放带来的碎片化问题。

缺点：

• 实现和管理相对复杂。
• 不适用于所有类型的内存分配需求。

总结

在C++编程中，选择适当的内存管理方式非常重要。对于需要直接控制内存的低级操作，原生指针是不可替代的；对于更高层次的内存管理，智能指针可以有效地减少内存泄漏的风险；而在需要频繁分配和释放小块内存的场景下，内存池可以显著提高性能。