1、背景

在 C++ 中，new 和 delete 是动态分配内存的核心操作符。然而，直接使用它们有时会增加程序的复杂性，甚至导致内存泄漏和其他问题。因此，了解何时替换 new 和 delete 并选择更适合的内存管理策略，是编写高效、健壮 C++ 程序的关键。直接使用 new 和 delete 存在以下潜在问题：

• 内存泄漏： 如果忘记调用 delete 释放内存，就会导致内存泄漏。
• 异常安全性： 在异常发生时，可能导致内存无法正确释放。
• 复杂性： 手动管理内存使代码变得更难维护和阅读。
• 性能问题： 默认的全局 new 和 delete 可能不适合特定场景，例如需要高效的内存池。
• 无法跟踪分配： 默认 new 和 delete 无法提供关于内存分配的额外信息（如分配大小或位置）。

2、替换 new 和 delete 的常用方法

2.1 、使用智能指针代替原始指针

现代 C++ 提供了智能指针（std::unique_ptr 和 std::shared_ptr），它们能够自动管理内存，避免手动调用 delete。

#include <memory>
#include <iostream>

class Widget {
public:
    Widget() { std::cout << "Widget constructed" << std::endl; }
    ~Widget() { std::cout << "Widget destroyed" << std::endl; }
};

int main() {
    std::unique_ptr<Widget> w = std::make_unique<Widget>();
    // 无需手动调用 delete
    return 0;
}

这样做可以避免内存泄漏，提供异常安全性

2.2、定制全局 new 和 delete

在某些场景中，需要替换全局 new 和 delete 以提供自定义的内存分配行为。

#include <cstdlib>
#include <iostream>

void* operator new(size_t size) {
    std::cout << "Custom new: Allocating " << size << " bytes" << std::endl;
    return std::malloc(size);
}

void operator delete(void* ptr) noexcept {
    std::cout << "Custom delete: Freeing memory" << std::endl;
    std::free(ptr);
}

int main() {
    int* p = new int;
    delete p;
    return 0;
}

• 优点，可以跟踪内存分配和释放，可优化内存分配以满足特定需求。

2.3、为特定类重载 new 和 delete

对于某些类，可以提供自定义的 new 和 delete，以优化其内存管理。

#include <iostream>
#include <cstdlib>

class Widget {
public:
    static void* operator new(size_t size) {
        std::cout << "Widget custom new: Allocating " << size << " bytes" << std::endl;
        return std::malloc(size);
    }

    static void operator delete(void* ptr) noexcept {
        std::cout << "Widget custom delete: Freeing memory" << std::endl;
        std::free(ptr);
    }
};

int main() {
    Widget* w = new Widget;
    delete w;
    return 0;
}

• 优点，针对特定类优化内存分配，可实现类级别的内存跟踪和调试。

2.4、使用内存池

在需要频繁分配和释放小对象的场景下，使用内存池可以显著提升性能。

#include <vector>
#include <iostream>

class MemoryPool {
public:
    MemoryPool(size_t objectSize, size_t poolSize)
        : m_objectSize(objectSize), m_poolSize(poolSize) {
        m_pool.reserve(m_poolSize);
        for (size_t i = 0; i < m_poolSize; ++i) {
            m_pool.push_back(std::malloc(m_objectSize));
        }
    }

    ~MemoryPool() {
        for (void* ptr : m_pool) {
            std::free(ptr);
        }
    }

    void* allocate() {
        if (m_pool.empty()) {
            return std::malloc(m_objectSize);
        } else {
            void* ptr = m_pool.back();
            m_pool.pop_back();
            return ptr;
        }
    }

    void deallocate(void* ptr) {
        m_pool.push_back(ptr);
    }

private:
    size_t m_objectSize;
    size_t m_poolSize;
    std::vector<void*> m_pool;
};

int main() {
    MemoryPool pool(sizeof(int), 10);
    int* p = static_cast<int*>(pool.allocate());
    pool.deallocate(p);
    return 0;
}

• 优点，显著降低小对象的分配和释放开销，避免频繁调用全局的 new 和 delete