地心探索 · 内存分配控制

在 C++ 的世界里，内存管理是一门深奥的艺术。大多数时候，我们使用 new 和 delete，或者更好的智能指针。但当你需要极致的性能，或者需要控制内存的每一个字节时，就需要深入到内存分配的底层。

让我们开始这场地心探索之旅。

---

new 和 delete 的本质

当你写 new int(42) 时，实际发生了两件事：

1. 调用 operator new 分配内存

2. 在分配的内存上调用构造函数

#include <iostream>
#include <new>

class Widget
{
public:
    int value;
    Widget(int v) : value(v) { std::cout << "Constructed: " << value << std::endl; }
    ~Widget() { std::cout << "Destructed: " << value << std::endl; }
};

int main()
{
    // 这两种写法是等价的：
    Widget* w1 = new Widget(42);
    
    // 等价于：
    void* memory = operator new(sizeof(Widget));  // 分配内存
    Widget* w2 = new (memory) Widget(42);         // 原位构造
    
    // 销毁时
    delete w1;
    
    // 等价于：
    w2->~Widget();              // 调用析构函数
    operator delete(memory);    // 释放内存
    
    return 0;
}

---

重载 operator new 和 operator delete

你可以为类或全局重载这些运算符：

#include <iostream>
#include <cstdlib>
#include <new>

class TrackedObject
{
public:
    int data;
    
    // 类特定的 operator new
    static void* operator new(size_t size)
    {
        std::cout << "Allocating " << size << " bytes for TrackedObject" << std::endl;
        void* p = std::malloc(size);
        if (!p) throw std::bad_alloc();
        return p;
    }
    
    // 类特定的 operator delete
    static void operator delete(void* p) noexcept
    {
        std::cout << "Deallocating TrackedObject" << std::endl;
        std::free(p);
    }
    
    // 数组版本
    static void* operator new[](size_t size)
    {
        std::cout << "Allocating array: " << size << " bytes" << std::endl;
        void* p = std::malloc(size);
        if (!p) throw std::bad_alloc();
        return p;
    }
    
    static void operator delete[](void* p) noexcept
    {
        std::cout << "Deallocating array" << std::endl;
        std::free(p);
    }
};

int main()
{
    TrackedObject* obj = new TrackedObject();
    delete obj;
    
    TrackedObject* arr = new TrackedObject[5];
    delete[] arr;
    
    return 0;
}

---

placement new：在指定位置构造对象

有时候你想在已分配的内存上构造对象：

#include <iostream>
#include <new>

class Widget
{
public:
    int value;
    Widget(int v) : value(v) { std::cout << "Constructed: " << value << std::endl; }
    ~Widget() { std::cout << "Destructed: " << value << std::endl; }
};

int main()
{
    // 预分配缓冲区
    alignas(Widget) char buffer[sizeof(Widget)];
    
    // 在缓冲区中构造对象
    Widget* w = new (buffer) Widget(42);
    
    std::cout << "Value: " << w->value << std::endl;
    
    // 必须显式调用析构函数！
    w->~Widget();
    
    // 不需要 delete，因为内存不是 new 分配的
    
    return 0;
}

placement new 的常见用途

#include <iostream>
#include <new>
#include <vector>

// 1. 对象池
template<typename T, size_t PoolSize>
class ObjectPool
{
private:
    alignas(T) char storage[PoolSize * sizeof(T)];
    bool used[PoolSize] = {false};
    
public:
    T* allocate()
    {
        for (size_t i = 0; i < PoolSize; ++i)
        {
            if (!used[i])
            {
                used[i] = true;
                return reinterpret_cast<T*>(storage + i * sizeof(T));
            }
        }
        throw std::bad_alloc();
    }
    
    template<typename... Args>
    T* construct(Args&&... args)
    {
        T* ptr = allocate();
        return new (ptr) T(std::forward<Args>(args)...);
    }
    
    void destroy(T* ptr)
    {
        ptr->~T();
        size_t index = (reinterpret_cast<char*>(ptr) - storage) / sizeof(T);
        used[index] = false;
    }
};

int main()
{
    ObjectPool<int, 10> pool;
    
    int* p1 = pool.construct(42);
    int* p2 = pool.construct(100);
    
    std::cout << *p1 << ", " << *p2 << std::endl;
    
    pool.destroy(p1);
    pool.destroy(p2);
    
    return 0;
}

---

allocator：标准分配器

C++ 标准库提供了 std::allocator，它是容器默认使用的分配器：

#include <iostream>
#include <memory>
#include <vector>

int main()
{
    std::allocator<int> alloc;
    
    // 分配内存（不构造对象）
    int* p = alloc.allocate(5);
    
    // 构造对象
    for (int i = 0; i < 5; ++i)
    {
        std::allocator_traits<std::allocator<int>>::construct(alloc, p + i, i * 10);
    }
    
    // 使用
    for (int i = 0; i < 5; ++i)
    {
        std::cout << p[i] << " ";
    }
    std::cout << std::endl;
    
    // 析构对象
    for (int i = 0; i < 5; ++i)
    {
        std::allocator_traits<std::allocator<int>>::destroy(alloc, p + i);
    }
    
    // 释放内存
    alloc.deallocate(p, 5);
    
    return 0;
}

---

自定义分配器

你可以为标准容器提供自定义分配器：

#include <iostream>
#include <vector>
#include <list>

template<typename T>
class DebugAllocator
{
public:
    using value_type = T;
    
    DebugAllocator() = default;
    
    template<typename U>
    DebugAllocator(const DebugAllocator<U>&) noexcept {}
    
    T* allocate(size_t n)
    {
        std::cout << "[Alloc] " << n << " x " << sizeof(T) 
                  << " = " << n * sizeof(T) << " bytes" << std::endl;
        
        T* p = static_cast<T*>(::operator new(n * sizeof(T)));
        std::cout << "[Alloc] Address: " << p << std::endl;
        return p;
    }
    
    void deallocate(T* p, size_t n) noexcept
    {
        std::cout << "[Dealloc] " << n << " x " << sizeof(T) 
                  << " = " << n * sizeof(T) << " bytes at " << p << std::endl;
        ::operator delete(p);
    }
};

template<typename T, typename U>
bool operator==(const DebugAllocator<T>&, const DebugAllocator<U>&) { return true; }

template<typename T, typename U>
bool operator!=(const DebugAllocator<T>&, const DebugAllocator<U>&) { return false; }

int main()
{
    std::cout << "=== vector ===" << std::endl;
    std::vector<int, DebugAllocator<int>> v;
    
    for (int i = 0; i < 10; ++i)
    {
        v.push_back(i);
    }
    
    std::cout << "\n=== list ===" << std::endl;
    std::list<int, DebugAllocator<int>> lst;
    
    for (int i = 0; i < 5; ++i)
    {
        lst.push_back(i);
    }
    
    return 0;
}

---

内存池实现

高性能应用常用内存池来避免频繁的堆分配：

#include <iostream>
#include <vector>
#include <cstddef>

class MemoryPool
{
private:
    struct Block
    {
        Block* next;
    };
    
    size_t blockSize;
    size_t blockCount;
    std::vector<char*> chunks;
    Block* freeList = nullptr;
    
    void allocateChunk()
    {
        // 分配一大块内存
        char* chunk = new char[blockSize * blockCount];
        chunks.push_back(chunk);
        
        // 将其分割成小块，链接到空闲列表
        for (size_t i = 0; i < blockCount; ++i)
        {
            Block* block = reinterpret_cast<Block*>(chunk + i * blockSize);
            block->next = freeList;
            freeList = block;
        }
    }
    
public:
    MemoryPool(size_t blockSize, size_t blockCount = 1024)
        : blockSize(std::max(blockSize, sizeof(Block)))
        , blockCount(blockCount)
    {
        allocateChunk();
    }
    
    ~MemoryPool()
    {
        for (char* chunk : chunks)
        {
            delete[] chunk;
        }
    }
    
    void* allocate()
    {
        if (!freeList)
        {
            allocateChunk();
        }
        
        Block* block = freeList;
        freeList = block->next;
        return block;
    }
    
    void deallocate(void* p)
    {
        Block* block = static_cast<Block*>(p);
        block->next = freeList;
        freeList = block;
    }
};

// 为特定类使用内存池
class PooledWidget
{
private:
    static MemoryPool pool;
    
public:
    int data;
    
    PooledWidget(int d) : data(d) {}
    
    static void* operator new(size_t size)
    {
        return pool.allocate();
    }
    
    static void operator delete(void* p)
    {
        pool.deallocate(p);
    }
};

MemoryPool PooledWidget::pool(sizeof(PooledWidget), 100);

int main()
{
    std::vector<PooledWidget*> widgets;
    
    // 分配
    for (int i = 0; i < 1000; ++i)
    {
        widgets.push_back(new PooledWidget(i));
    }
    
    // 释放
    for (auto* w : widgets)
    {
        delete w;
    }
    
    return 0;
}

---

内存对齐

现代 CPU 对内存对齐有要求，访问对齐的内存更快：

#include <iostream>
#include <cstddef>
#include <new>

// 使用 alignas 指定对齐
struct alignas(16) AlignedData
{
    double x, y;
};

// 使用 alignas 指定更大的对齐
struct alignas(64) CacheLineAligned  // 缓存行对齐
{
    int data;
};

int main()
{
    std::cout << "alignof(AlignedData): " << alignof(AlignedData) << std::endl;
    std::cout << "sizeof(AlignedData): " << sizeof(AlignedData) << std::endl;
    
    std::cout << "alignof(CacheLineAligned): " << alignof(CacheLineAligned) << std::endl;
    std::cout << "sizeof(CacheLineAligned): " << sizeof(CacheLineAligned) << std::endl;
    
    // 对齐的动态分配 (C++17)
    AlignedData* p = new AlignedData();
    std::cout << "Address: " << p << std::endl;
    std::cout << "Aligned: " << (reinterpret_cast<uintptr_t>(p) % 16 == 0) << std::endl;
    delete p;
    
    // 手动对齐分配
    void* raw = operator new(sizeof(AlignedData) + 15);
    void* aligned = reinterpret_cast<void*>(
        (reinterpret_cast<uintptr_t>(raw) + 15) & ~15
    );
    AlignedData* p2 = new (aligned) AlignedData();
    // ... 使用 p2 ...
    p2->~AlignedData();
    operator delete(raw);
    
    return 0;
}

---

std::aligned_storage 和 std::aligned_union

用于创建正确对齐的存储：

#include <iostream>
#include <type_traits>
#include <new>
#include <string>

// 延迟初始化的容器
template<typename T>
class Optional
{
private:
    std::aligned_storage_t<sizeof(T), alignof(T)> storage;
    bool hasValue = false;
    
public:
    Optional() = default;
    
    template<typename... Args>
    void emplace(Args&&... args)
    {
        if (hasValue)
            reinterpret_cast<T*>(&storage)->~T();
        
        new (&storage) T(std::forward<Args>(args)...);
        hasValue = true;
    }
    
    T& value()
    {
        return *reinterpret_cast<T*>(&storage);
    }
    
    bool has_value() const { return hasValue; }
    
    ~Optional()
    {
        if (hasValue)
            reinterpret_cast<T*>(&storage)->~T();
    }
};

int main()
{
    Optional<std::string> opt;
    
    std::cout << "Has value: " << opt.has_value() << std::endl;
    
    opt.emplace("Hello, World!");
    
    std::cout << "Has value: " << opt.has_value() << std::endl;
    std::cout << "Value: " << opt.value() << std::endl;
    
    return 0;
}

---

pmr：多态内存资源（C++17）

C++17 引入了多态内存资源，可以在运行时切换分配策略：

#include <iostream>
#include <memory_resource>
#include <vector>
#include <array>

int main()
{
    // 使用栈上的缓冲区
    std::array<std::byte, 1024> buffer;
    std::pmr::monotonic_buffer_resource pool(buffer.data(), buffer.size());
    
    // 使用池的 vector
    std::pmr::vector<int> vec(&pool);
    
    for (int i = 0; i < 100; ++i)
    {
        vec.push_back(i);
    }
    
    std::cout << "Size: " << vec.size() << std::endl;
    
    // 同步内存资源（线程安全）
    std::pmr::synchronized_pool_resource syncPool;
    std::pmr::vector<int> syncVec(&syncPool);
    
    // 无同步内存资源（单线程，更快）
    std::pmr::unsynchronized_pool_resource unsyncPool;
    std::pmr::vector<int> unsyncVec(&unsyncPool);
    
    return 0;
}

---

内存泄漏检测

简单的内存泄漏追踪器：

#include <iostream>
#include <map>
#include <cstdlib>

#ifdef DEBUG_MEMORY

std::map<void*, size_t>& getAllocations()
{
    static std::map<void*, size_t> allocations;
    return allocations;
}

void* operator new(size_t size)
{
    void* p = std::malloc(size);
    if (!p) throw std::bad_alloc();
    
    getAllocations()[p] = size;
    std::cout << "[NEW] " << size << " bytes at " << p << std::endl;
    
    return p;
}

void operator delete(void* p) noexcept
{
    if (p)
    {
        auto& allocs = getAllocations();
        auto it = allocs.find(p);
        if (it != allocs.end())
        {
            std::cout << "[DELETE] " << it->second << " bytes at " << p << std::endl;
            allocs.erase(it);
        }
        std::free(p);
    }
}

void checkLeaks()
{
    auto& allocs = getAllocations();
    if (allocs.empty())
    {
        std::cout << "\n[OK] No memory leaks detected!" << std::endl;
    }
    else
    {
        std::cout << "\n[LEAK] " << allocs.size() << " allocations not freed:" << std::endl;
        for (const auto& [ptr, size] : allocs)
        {
            std::cout << "  - " << size << " bytes at " << ptr << std::endl;
        }
    }
}

#else

void checkLeaks() {}

#endif

int main()
{
    int* p1 = new int(42);
    int* p2 = new int[10];
    
    delete p1;
    // 故意忘记 delete[] p2;
    
    checkLeaks();
    
    delete[] p2;  // 补上
    
    checkLeaks();
    
    return 0;
}

---

总结

技术	用途
operator new/delete 重载	自定义分配策略
placement new	在指定位置构造对象
std::allocator	标准分配器接口
自定义分配器	为容器提供特殊分配策略
内存池	减少分配开销
alignas	控制内存对齐
std::pmr	多态内存资源

掌握这些技术，你就能像探索地心一样，深入到 C++ 内存管理的最底层，实现真正的性能优化。