含std::shared_ptr的ClassX类内存对齐后释放不匹配问题求解

方案1：封装静态辅助函数 #

在ClassX内部定义一个静态成员函数，把对齐内存分配、删除器绑定的逻辑封装起来，所有构造函数直接调用这个函数初始化sharedPTR，避免重复编写相同代码：

class ClassX {
private:
    std::size_t size;
    std::shared_ptr<T> sharedPTR;

    // 静态辅助函数，统一处理对齐内存的shared_ptr创建逻辑
    static std::shared_ptr<T> create_aligned_shared(std::size_t alloc_size) {
        void* raw_ptr = _mm_malloc(alloc_size, 64);
        if (!raw_ptr) {
            throw std::bad_alloc(); // 可选：处理内存分配失败的情况
        }
        return std::shared_ptr<T>(static_cast<T*>(raw_ptr), [](T* ptr) {
            _mm_free(ptr);
        });
    }

public:
    // 构造函数1
    ClassX(std::size_t s) : size(s) {
        sharedPTR = create_aligned_shared(size);
    }

    // 构造函数2
    ClassX(int element_count) : size(element_count * sizeof(T)) {
        sharedPTR = create_aligned_shared(size);
    }

    // 其他构造函数同理，只需调用create_aligned_shared即可
};

核心逻辑只需要维护一次，所有构造函数通过调用辅助函数完成初始化，代码简洁且易维护。

方案2：自定义删除器类型 #

如果觉得lambda不够直观，可以定义一个专门的对齐删除器结构体，替代匿名lambda，让代码逻辑更清晰：

// 自定义对齐内存删除器
struct AlignedDeleter {
    void operator()(T* ptr) const {
        _mm_free(ptr);
    }
};

class ClassX {
private:
    std::size_t size;
    std::shared_ptr<T> sharedPTR;

    static std::shared_ptr<T> create_aligned_shared(std::size_t alloc_size) {
        void* raw_ptr = _mm_malloc(alloc_size, 64);
        if (!raw_ptr) {
            throw std::bad_alloc();
        }
        return std::shared_ptr<T>(static_cast<T*>(raw_ptr), AlignedDeleter{});
    }

public:
    // 各构造函数调用create_aligned_shared即可，同方案1
};

自定义删除器的好处是可以在其他场景复用，且类型明确，便于调试和扩展。

方案3：委托构造函数 #

如果ClassX的多个构造函数可以通过参数转换统一逻辑，利用C++11的委托构造特性，只在核心构造函数中处理sharedPTR的初始化：

class ClassX {
private:
    std::size_t size;
    std::shared_ptr<T> sharedPTR;

    // 核心构造函数，负责初始化sharedPTR
    explicit ClassX(std::size_t alloc_size) : size(alloc_size) {
        void* raw_ptr = _mm_malloc(alloc_size, 64);
        if (!raw_ptr) {
            throw std::bad_alloc();
        }
        sharedPTR = std::shared_ptr<T>(static_cast<T*>(raw_ptr), [](T* ptr) {
            _mm_free(ptr);
        });
    }

public:
    // 构造函数1：直接委托核心构造
    ClassX(std::size_t s) : ClassX(static_cast<std::size_t>(s)) {}

    // 构造函数2：转换参数后委托核心构造
    ClassX(int element_count) : ClassX(element_count * sizeof(T)) {}

    // 构造函数3：处理复杂参数逻辑后委托核心构造
    ClassX(double scale, std::size_t base_size) : ClassX(static_cast<std::size_t>(scale * base_size)) {}
};

这种方式适合构造函数逻辑可以统一的场景，进一步减少重复代码。

额外注意事项 #

如果T不是平凡类型（比如有自定义构造/析构函数），直接将_mm_malloc分配的内存转为T*会导致对象未初始化，此时需要用placement new在分配的内存上构造对象，同时在删除器中先析构对象再释放内存：

static std::shared_ptr<T> create_aligned_shared(std::size_t element_count) {
    void* raw_ptr = _mm_malloc(element_count * sizeof(T), 64);
    if (!raw_ptr) {
        throw std::bad_alloc();
    }
    // 用placement new构造对象（假设T支持默认构造）
    T* obj_ptr = new (raw_ptr) T[element_count];
    return std::shared_ptr<T>(obj_ptr, [element_count](T* ptr) {
        // 先逐个析构对象
        for (std::size_t i = 0; i < element_count; ++i) {
            ptr[i].~T();
        }
        // 再释放内存
        _mm_free(ptr);
    });
}

这样才能保证对象的构造和析构流程完全正确。

内容的提问来源于stack exchange，提问作者heyloo