【C++特殊工具与技术】优化内存分配(五)：显式析构函数的调用

对象实例.~类名();

#include <iostream>
#include <new> 

// 模拟需要管理资源的类
class ResourceHolder {
private:
    int* data;  // 模拟堆内存资源

public:
    ResourceHolder(int size) {
        data = new int[size];
        std::cout << "ResourceHolder 构造：分配 " << size << " 个int的内存" << std::endl;
    }

    ~ResourceHolder() {
        delete[] data;
        std::cout << "ResourceHolder 析构：释放堆内存" << std::endl;
    }

    void print() const {
        std::cout << "资源地址：" << data << std::endl;
    }
};

int main() {
    // 1. 分配原始内存（64字节足够容纳ResourceHolder）
    alignas(ResourceHolder) char raw_memory[sizeof(ResourceHolder)];

    // 2. 使用定位new构造对象（在raw_memory上构造）
    ResourceHolder* obj = new (raw_memory) ResourceHolder(100);

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

    // 4. 显式调用析构函数（释放资源）
    obj->~ResourceHolder();

    // 5. 手动释放原始内存（此处raw_memory是栈内存，无需释放；若是堆内存需用delete[]）
    // 注意：若raw_memory是堆分配的（如new char[...]），需在此处调用delete[] raw_memory;

    return 0;
}

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

// 内存池类（简化版）
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 PooledObject {
private:
    int id;

public:
    PooledObject(int id) : id(id) {
        std::cout << "PooledObject " << id << " 构造" << std::endl;
    }

    ~PooledObject() {
        std::cout << "PooledObject " << id << " 析构" << std::endl;
    }

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

int main() {
    MemoryPool pool(sizeof(PooledObject), 5);  // 内存池：5个块，每个块容纳PooledObject

    // 从内存池分配内存并构造对象
    std::vector<PooledObject*> objects;
    for (int i = 0; i < 3; ++i) {
        void* mem = pool.allocate();
        if (!mem) break;
        PooledObject* obj = new (mem) PooledObject(i);  // 定位new构造
        objects.push_back(obj);
    }

    // 使用对象
    for (auto obj : objects) {
        obj->print();
    }

    // 显式析构并归还内存池
    for (auto obj : objects) {
        obj->~PooledObject();  // 显式调用析构函数
        pool.deallocate(obj);   // 归还内存块
    }

    return 0;
}

#include <iostream>
#include <new>
#include <fstream>

// 模拟文件管理类
class FileHandler {
private:
    std::fstream file;  // 文件流

public:
    FileHandler(const std::string& filename) {
        file.open(filename, std::ios::out | std::ios::in);
        if (file.is_open()) {
            std::cout << "文件 " << filename << " 打开成功" << std::endl;
        } else {
            std::cerr << "文件 " << filename << " 打开失败" << std::endl;
        }
    }

    ~FileHandler() {
        if (file.is_open()) {
            file.close();
            std::cout << "文件关闭" << std::endl;
        }
    }

    void write(const std::string& content) {
        if (file.is_open()) {
            file << content;
        }
    }
};

int main() {
    // 分配原始内存（足够容纳FileHandler）
    alignas(FileHandler) char mem[sizeof(FileHandler)];

    // 第一次构造：打开文件
    FileHandler* fh1 = new (mem) FileHandler("test.txt");
    fh1->write("第一次写入");
    fh1->~FileHandler();  // 显式关闭文件（释放资源）

    // 第二次构造：重用内存，重新打开文件
    FileHandler* fh2 = new (mem) FileHandler("test.txt");
    fh2->write("第二次写入");
    fh2->~FileHandler();  // 显式关闭文件

    return 0;
}

#include <iostream>
#include <new>
#include <stdexcept>

class ComplexObject {
private:
    int* data;
    int size;

public:
    ComplexObject(int size) : size(size) {
        data = new int[size];
        std::cout << "分配 " << size << " 个int的内存" << std::endl;

        // 模拟构造过程中抛出异常（如参数非法）
        if (size <= 0) {
            delete[] data;  // 提前释放已分配的内存
            throw std::invalid_argument("size必须大于0");
        }
    }

    ~ComplexObject() {
        delete[] data;
        std::cout << "释放 " << size << " 个int的内存" << std::endl;
    }

    void print() const {
        std::cout << "数据地址：" << data << std::endl;
    }
};

int main() {
    // 分配原始内存
    alignas(ComplexObject) char mem[sizeof(ComplexObject)];

    try {
        // 构造对象（size=0，触发异常）
        ComplexObject* obj = new (mem) ComplexObject(0);
        obj->print();  // 不会执行
    } catch (const std::invalid_argument& e) {
        std::cerr << "构造异常：" << e.what() << std::endl;
        // 显式调用析构函数（即使构造未完成，仍需释放已分配的资源）
        // 注意：此处obj可能未完全构造，需通过placement new的指针手动析构
        // 实际中需确保obj指针有效（如构造函数在抛出前已初始化成员）
        reinterpret_cast<ComplexObject*>(mem)->~ComplexObject();
    }

    return 0;
}

#include <iostream>

class Test {
public:
    ~Test() {
        std::cout << "Test 析构" << std::endl;
    }
};

int main() {
    Test obj;  // 栈对象
    obj.~Test();  // 显式调用析构函数
    // 栈对象离开作用域时，编译器会再次调用析构函数
    return 0;
}

#include <iostream>

class HeapObject {
private:
    int* data;

public:
    HeapObject() {
        data = new int[100];
        std::cout << "构造：分配堆内存" << std::endl;
    }

    ~HeapObject() {
        delete[] data;
        std::cout << "析构：释放堆内存" << std::endl;
    }
};

int main() {
    HeapObject* obj = new HeapObject();  // 堆对象
    obj->~HeapObject();  // 显式析构（释放data）
    // 未调用delete obj; 导致内存泄漏
    return 0;
}

#include <iostream>
#include <memory>

class SmartObj {
public:
    ~SmartObj() {
        std::cout << "SmartObj 析构" << std::endl;
    }
};

int main() {
    auto ptr = std::unique_ptr<SmartObj>(new SmartObj());

    // 无需显式调用析构函数（智能指针自动管理）
    ptr->~SmartObj();  // 危险！重复析构

    return 0;  // ptr离开作用域时自动析构并释放内存
}