【C++特殊工具与技术】优化内存分配(四)：定位new表达式、类特定的new、delete表达式

#include <new>  // 必须包含此头文件

// 在已分配的内存p上构造类型T的对象
T* obj = new (p) T(构造参数);

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

// 内存池类（简化版）
class MemoryPool {
private:
    char* pool;         // 内存池起始地址
    size_t block_size;  // 每个内存块的大小
    size_t block_num;   // 内存块数量
    bool* used;         // 记录内存块是否被使用

public:
    // 构造函数：初始化内存池
    MemoryPool(size_t block_size, size_t block_num)
        : block_size(block_size), block_num(block_num) {
        // 分配连续内存（对齐处理：简化示例，实际需考虑对齐）
        pool = new char[block_size * block_num];
        used = new bool[block_num]{false};  // 初始化为未使用
    }

    // 分配一个内存块（返回原始内存地址）
    void* allocate() {
        for (size_t i = 0; i < block_num; ++i) {
            if (!used[i]) {
                used[i] = true;
                return pool + i * block_size;
            }
        }
        return nullptr;  // 内存池已满
    }

    // 释放一个内存块
    void deallocate(void* p) {
        if (p < pool || p >= pool + block_size * block_num) return;
        size_t index = (static_cast<char*>(p) - pool) / block_size;
        used[index] = false;
    }

    // 析构函数：释放内存池
    ~MemoryPool() {
        delete[] pool;
        delete[] used;
    }
};

// 测试类：需要频繁创建的对象
class Particle {
private:
    int id;
public:
    Particle(int id) : id(id) {
        std::cout << "Particle " << id << " 构造完成" << std::endl;
    }

    ~Particle() {
        std::cout << "Particle " << id << " 析构完成" << std::endl;
    }

    void print() const {
        std::cout << "Particle " << id << " 正在运行" << std::endl;
    }
};

int main() {
    // 初始化内存池：每个块64字节（足够容纳Particle），共10个块
    MemoryPool pool(64, 10);

    // 使用定位new构造对象
    std::vector<Particle*> particles;
    for (int i = 0; i < 5; ++i) {
        void* mem = pool.allocate();
        if (!mem) {
            std::cerr << "内存池不足！" << std::endl;
            break;
        }
        // 在内存池的内存上构造Particle对象
        Particle* p = new (mem) Particle(i);
        particles.push_back(p);
    }

    // 调用对象方法
    for (auto p : particles) {
        p->print();
    }

    // 显式调用析构函数（定位new不会自动调用析构）
    for (auto p : particles) {
        p->~Particle();  // 必须手动调用析构！
        pool.deallocate(p);  // 释放内存块回内存池
    }

    return 0;
}

class MyClass {
public:
    // 普通版本：分配单个对象
    static void* operator new(size_t size);
    static void operator delete(void* p, size_t size);

    // 数组版本：分配对象数组
    static void* operator new[](size_t size);
    static void operator delete[](void* p, size_t size);

    // 可选：带额外参数的版本（如对齐）
    static void* operator new(size_t size, std::align_val_t align);
    static void operator delete(void* p, std::align_val_t align);
};

#include <iostream>
#include <new>
#include <vector>
#include <cstdalign>  // 对齐相关头文件

// 全局统计信息
struct AllocStats {
    size_t count = 0;       // 分配次数
    size_t total_bytes = 0; // 总分配字节数
};

// 内存池（支持对齐）
class AlignedMemoryPool {
private:
    char* pool;
    size_t block_size;
    size_t block_num;
    bool* used;
    std::align_val_t align;  // 对齐要求

public:
    AlignedMemoryPool(size_t block_size, size_t block_num, std::align_val_t align)
        : block_size(block_size), block_num(block_num), align(align) {
        // 分配对齐内存（使用std::aligned_alloc）
        pool = static_cast<char*>(std::aligned_alloc(static_cast<size_t>(align), block_size * block_num));
        used = new bool[block_num]{false};
    }

    void* allocate() {
        for (size_t i = 0; i < block_num; ++i) {
            if (!used[i]) {
                used[i] = true;
                return pool + i * block_size;
            }
        }
        return nullptr;
    }

    void deallocate(void* p) {
        if (p < pool || p >= pool + block_size * block_num) return;
        size_t index = (static_cast<char*>(p) - pool) / block_size;
        used[index] = false;
    }

    ~AlignedMemoryPool() {
        std::free(pool);  // 对齐内存用std::free释放
        delete[] used;
    }
};

// 带内存池和统计的Widget类
class Widget {
private:
    int data;
    static AllocStats stats;        // 分配统计
    static AlignedMemoryPool pool;  // 类共享的内存池

public:
    // 构造函数
    Widget(int data) : data(data) {}

    // 析构函数
    ~Widget() {}

    // 重载operator new（普通版本）
    static void* operator new(size_t size) {
        void* mem = pool.allocate();
        if (!mem) {
            throw std::bad_alloc();  // 分配失败抛出异常
        }
        // 更新统计信息
        stats.count++;
        stats.total_bytes += size;
        return mem;
    }

    // 重载operator delete（普通版本）
    static void operator delete(void* p, size_t size) {
        pool.deallocate(p);
        // 更新统计信息
        stats.count--;
        stats.total_bytes -= size;
    }

    // 重载operator new（对齐版本，C++17+）
    static void* operator new(size_t size, std::align_val_t align) {
        // 这里简化处理：假设内存池已按align对齐
        void* mem = pool.allocate();
        if (!mem) {
            throw std::bad_alloc();
        }
        stats.count++;
        stats.total_bytes += size;
        return mem;
    }

    // 重载operator delete（对齐版本）
    static void operator delete(void* p, std::align_val_t align) {
        pool.deallocate(p);
        stats.count--;
        stats.total_bytes -= align;  // 简化处理，实际应使用size参数
    }

    // 打印统计信息
    static void printStats() {
        std::cout << "Widget分配统计：" << std::endl
                  << "  总分配次数: " << stats.count << std::endl
                  << "  总分配字节数: " << stats.total_bytes << std::endl;
    }
};

// 初始化静态成员
AllocStats Widget::stats;
AlignedMemoryPool Widget::pool(
    sizeof(Widget) + alignof(Widget),  // 内存块大小（考虑对齐填充）
    10,                                // 10个内存块
    std::align_val_t(32)               // 32字节对齐
);

int main() {
    std::vector<Widget*> widgets;

    // 创建5个Widget对象
    for (int i = 0; i < 5; ++i) {
        try {
            Widget* w = new Widget(i);
            widgets.push_back(w);
        } catch (const std::bad_alloc& e) {
            std::cerr << "分配失败: " << e.what() << std::endl;
            break;
        }
    }

    Widget::printStats();  // 打印分配统计

    // 释放对象
    for (auto w : widgets) {
        delete w;
    }

    Widget::printStats();  // 再次打印（应恢复为0）

    return 0;
}

Widget分配统计：
  总分配次数: 5
  总分配字节数: 400  // 假设每个Widget占80字节（含对齐填充），5*80=400
Widget分配统计：
  总分配次数: 0
  总分配字节数: 0

#include <iostream>
#include <new>

class HeavyObject {
private:
    int* data;  // 大数组模拟"重"资源

public:
    HeavyObject() {
        data = new int[1000000];  // 模拟大量内存分配
        std::cout << "HeavyObject 构造完成" << std::endl;
    }

    ~HeavyObject() {
        delete[] data;
        std::cout << "HeavyObject 析构完成" << std::endl;
    }

    void work() const {
        std::cout << "HeavyObject 工作中..." << std::endl;
    }

    // 类特定new：普通版本（分配内存）
    static void* operator new(size_t size) {
        std::cout << "类特定new：分配 " << size << " 字节" << std::endl;
        return ::operator new(size);  // 调用全局new分配内存
    }

    // 类特定delete：普通版本（释放内存）
    static void operator delete(void* p, size_t size) {
        std::cout << "类特定delete：释放 " << size << " 字节" << std::endl;
        ::operator delete(p);  // 调用全局delete释放内存
    }

    // 定位new专用重载：接受void*参数
    static void* operator new(size_t size, void* ptr) {
        std::cout << "定位new：在地址 " << ptr << " 构造对象" << std::endl;
        return ptr;  // 直接返回传入的内存地址
    }

    // 定位new配套的delete（用于构造失败时的回滚）
    static void operator delete(void* ptr, void*) noexcept {
        std::cout << "定位delete：无需释放内存（由用户管理）" << std::endl;
        // 定位new的delete不执行实际释放，因为内存由用户管理
    }
};

int main() {
    // 1. 分配原始内存（调用类特定new）
    void* mem = HeavyObject::operator new(sizeof(HeavyObject));

    // 2. 使用定位new构造对象
    HeavyObject* obj = new (mem) HeavyObject();

    // 3. 使用对象
    obj->work();

    // 4. 显式调用析构函数（定位new需要手动析构）
    obj->~HeavyObject();

    // 5. 释放原始内存（调用类特定delete）
    HeavyObject::operator delete(mem, sizeof(HeavyObject));

    return 0;
}