第四节 · 意念造山河 · lambda表达式

有时候，标准的内存分配方式不能满足特殊需求，比如需要更高的性能或特定的内存布局。C++ 允许我们自定义内存管理。

---

operator new 和 operator delete

#include <iostream>
#include <cstdlib>
using namespace std;

class MyClass
{
public:
    int data;
    
    // 自定义 new
    void* operator new(size_t size)
    {
        cout << "Custom new, size: " << size << endl;
        void* p = malloc(size);
        if (!p) throw bad_alloc();
        return p;
    }
    
    // 自定义 delete
    void operator delete(void* p) noexcept
    {
        cout << "Custom delete" << endl;
        free(p);
    }
};

int main()
{
    MyClass* obj = new MyClass();
    obj->data = 42;
    delete obj;
    
    return 0;
}

---

placement new

在已分配的内存上构造对象。

#include <new>  // placement new 需要此头文件

class Widget
{
public:
    int value;
    Widget(int v) : value(v)
    {
        cout << "Widget created: " << value << endl;
    }
    ~Widget()
    {
        cout << "Widget destroyed: " << value << endl;
    }
};

int main()
{
    // 预先分配内存
    char buffer[sizeof(Widget)];
    
    // 在指定位置构造对象
    Widget* w = new (buffer) Widget(42);
    
    cout << "Value: " << w->value << endl;
    
    // 必须手动调用析构函数
    w->~Widget();
    
    // 不需要 delete，因为内存是 buffer
    
    return 0;
}

---

内存池

#include <vector>
#include <memory>

template<typename T>
class MemoryPool
{
private:
    struct Block
    {
        char data[sizeof(T)];
        bool used = false;
    };
    
    vector<Block> pool;
    
public:
    MemoryPool(size_t size) : pool(size) {}
    
    T* allocate()
    {
        for (auto& block : pool)
        {
            if (!block.used)
            {
                block.used = true;
                return reinterpret_cast<T*>(block.data);
            }
        }
        throw bad_alloc();
    }
    
    void deallocate(T* ptr)
    {
        for (auto& block : pool)
        {
            if (reinterpret_cast<T*>(block.data) == ptr)
            {
                block.used = false;
                return;
            }
        }
    }
};

int main()
{
    MemoryPool<int> pool(10);
    
    int* p1 = pool.allocate();
    int* p2 = pool.allocate();
    
    *p1 = 100;
    *p2 = 200;
    
    cout << *p1 << ", " << *p2 << endl;
    
    pool.deallocate(p1);
    pool.deallocate(p2);
    
    return 0;
}

---

allocator - 标准分配器

#include <memory>
#include <vector>

int main()
{
    allocator<int> alloc;
    
    // 分配内存（不构造对象）
    int* p = alloc.allocate(5);
    
    // 构造对象
    for (int i = 0; i < 5; ++i)
    {
        construct_at(p + i, i * 10);  // C++20
        // 或 alloc.construct(p + i, i * 10);  // C++17 前
    }
    
    for (int i = 0; i < 5; ++i)
    {
        cout << p[i] << " ";
    }
    cout << endl;
    
    // 析构对象
    for (int i = 0; i < 5; ++i)
    {
        destroy_at(p + i);  // C++17
    }
    
    // 释放内存
    alloc.deallocate(p, 5);
    
    return 0;
}

---

自定义分配器

template<typename T>
class LoggingAllocator
{
public:
    using value_type = T;
    
    LoggingAllocator() = default;
    
    template<typename U>
    LoggingAllocator(const LoggingAllocator<U>&) {}
    
    T* allocate(size_t n)
    {
        cout << "Allocating " << n << " objects of size " 
             << sizeof(T) << endl;
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }
    
    void deallocate(T* p, size_t n)
    {
        cout << "Deallocating " << n << " objects" << endl;
        ::operator delete(p);
    }
};

int main()
{
    vector<int, LoggingAllocator<int>> vec;
    
    vec.push_back(1);
    vec.push_back(2);
    vec.push_back(3);
    
    return 0;
}

---

RAII - 资源获取即初始化

这是 C++ 最重要的内存管理模式。

// 管理文件资源
class FileHandle
{
private:
    FILE* file;
    
public:
    FileHandle(const char* name, const char* mode)
        : file(fopen(name, mode))
    {
        if (!file) throw runtime_error("Cannot open file");
    }
    
    ~FileHandle()
    {
        if (file) fclose(file);
    }
    
    // 禁止复制
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    // 允许移动
    FileHandle(FileHandle&& other) noexcept
        : file(other.file)
    {
        other.file = nullptr;
    }
    
    FILE* get() { return file; }
};

void writeToFile()
{
    FileHandle f("test.txt", "w");
    fprintf(f.get(), "Hello, RAII!");
}  // 文件自动关闭

---

内存对齐

#include <cstddef>

// 手动对齐
struct alignas(16) AlignedData
{
    double values[2];
};

int main()
{
    cout << "Alignment: " << alignof(AlignedData) << endl;  // 16
    cout << "Size: " << sizeof(AlignedData) << endl;
    
    // C++17 对齐分配
    AlignedData* p = new AlignedData();
    delete p;
    
    return 0;
}

---

避免内存碎片

// 策略 1：对象池
// 预分配一批相同大小的对象，重复使用

// 策略 2：使用 vector 代替单独分配
vector<Widget> widgets;  // 连续内存
widgets.reserve(1000);   // 预分配

// 策略 3：使用自定义分配器
// 针对特定大小优化分配

---

习题

• 实现一个简单的对象池，支持分配和回收。

• 解释 RAII 模式的优点。

• 什么情况下需要使用 placement new？