使用C++开发黑神话悟空类似3A如何避免内存泄漏

1. 智能指针：使用C++11或更高版本中的智能指针（如std::unique_ptr、std::shared_ptr和std::weak_ptr）来自动管理内存。这些智能指针在超出作用域时会自动释放它们所管理的内存。

2. RAII（Resource Acquisition Is Initialization）：采用RAII原则，确保资源在对象生命周期结束时被正确释放。这意味着资源的获取和释放与对象的创建和销毁同步。

3. 内存池：对于频繁分配和释放的小对象，使用内存池可以减少内存碎片并提高性能。内存池预先分配一块内存，并在其中分配对象，这样可以避免多次调用new和delete。

4. 定制分配器：为标准容器（如std::vector、std::map等）提供定制的内存分配器，以便更好地控制内存分配和释放的行为。

5. 避免野指针：确保不使用未初始化或已删除对象的指针，避免悬垂指针指向无效的内存地址。

6. 使用析构函数：确保每个拥有资源的类都有一个适当的析构函数来释放资源。当对象生命周期结束时，析构函数会被调用。

7. 定期审计和测试：定期进行代码审查和使用内存检测工具（如Valgrind、Visual Studio的诊断工具等）来检测内存泄漏和其他内存问题。

8. 避免内存泄漏的编程习惯：例如，使用delete释放单个对象时，将其指针设置为nullptr，避免重复删除。

9. 对象所有权明确：明确哪个对象或模块负责内存的分配和释放，避免多个所有者尝试释放同一块内存。

10. 日志记录：在内存分配和释放时添加日志记录，有助于跟踪内存使用情况和定位泄漏来源。

11. 避免使用全局变量：全局变量的生命周期与程序相同，可能导致难以追踪的内存泄漏。尽量使用局部变量和对象来管理资源。

12. 异常安全：确保代码在异常发生时不会泄漏资源。使用try、catch和finally块来保证资源在异常路径中也能被正确释放。

下面是一些常见代码示例：

使用智能指针：

#include 
#include 

class GameResource {
public:
    GameResource() { std::cout << "Resource created.\n"; }
    ~GameResource() { std::cout << "Resource destroyed.\n"; }
};

void useResource() {
    // 使用std::unique_ptr自动管理资源
    std::unique_ptr resource = std::make_unique();
    // 无需手动删除资源，unique_ptr在超出作用域时自动销毁
}

int main() {
    useResource();
    // main函数结束前，所有unique_ptr管理的资源都会被自动释放
    return 0;
}

简单的内存池实现:

#include 
#include 
#include 

class MemoryPool {
private:
    std::vector allocatedBlocks;
    size_t blockSize;
    char* pool;
    size_t poolSize;
    char* current;

public:
    MemoryPool(size_t size, size_t blockSize)
        : blockSize(blockSize), pool(new char[size * blockSize]), poolSize(size), current(pool) {}

    ~MemoryPool() {
        delete[] pool;
    }

    char* allocate() {
        if (current + blockSize > pool + poolSize * blockSize) {
            allocatedBlocks.push_back(new char[blockSize]);
            return allocatedBlocks.back();
        }
        char* temp = current;
        current += blockSize;
        return temp;
    }

    void deallocate(char* block) {
        // 内存池不负责释放个别内存块，使用完所有内存后统一释放
    }

    void clear() {
        for (auto block : allocatedBlocks) {
            delete[] block;
        }
        allocatedBlocks.clear();
        current = pool;
    }
};

int main() {
    MemoryPool pool(10, 1024); // 创建一个包含10个1024字节块的内存池
    char* block = pool.allocate();
    // 使用内存块...
    pool.deallocate(block); // 内存池不释放个别内存块
    pool.clear(); // 清理所有分配的内存块
    return 0;
}

遵循RAII原则的类定义：

#include 

class ManagedResource {
    int* data;
public:
    ManagedResource(size_t size) : data(new int[size]) {
        std::cout << "Resource allocated.\n";
    }
    ~ManagedResource() {
        delete[] data;
        std::cout << "Resource deallocated.\n";
    }

    // 禁止复制构造函数和赋值操作符，确保RAII
    ManagedResource(const ManagedResource&) = delete;
    ManagedResource& operator=(const ManagedResource&) = delete;

    // 移动构造函数和移动赋值操作符，支持资源的转移
    ManagedResource(ManagedResource&& other) noexcept : data(other.data) {
        other.data = nullptr;
    }
    ManagedResource& operator=(ManagedResource&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            other.data = nullptr;
        }
        return *this;
    }
};

int main() {
    // 正确管理资源的生命周期
    {
        ManagedResource resource(1024);
        // 使用resource...
    } // resource自动释放，无需手动delete
    return 0;
}