寻找std::function替代方案：适配拷贝运算符已删除的对象

当前代码中std::function<HeavyObject(int)>要求返回值可拷贝/移动，但你的HeavyObject禁用了这些操作，核心解决思路是让对象直接在目标内存构造，而非通过返回值传递。以下是几种可行方案：

方案1：堆分配+智能指针转移所有权 #

将Manager中的HeavyObject成员改为std::unique_ptr<HeavyObject>，生成器返回堆上构造的对象指针，通过智能指针的所有权转移避免拷贝/移动操作：

#include <memory>
#include <functional>

class HeavyObject {
    int x;
public:
    HeavyObject(int x) : x(x) {}

    HeavyObject &operator=(const HeavyObject &) = delete;
    HeavyObject &operator=(HeavyObject &&) = delete;
};

using HeavyObjectGenerator = std::function<std::unique_ptr<HeavyObject>(int)>;

class HeavyObjectManager {
    HeavyObjectGenerator heavyObjectGenerator;
    std::unique_ptr<HeavyObject> heavyObject;

public:
    HeavyObjectManager(HeavyObjectGenerator gen) 
        : heavyObjectGenerator(std::move(gen)),
          heavyObject(heavyObjectGenerator(0)) {}

    void updateHeavyObject(int x) {
        heavyObject = heavyObjectGenerator(x);
    }
};

// 使用示例
auto generator = [](int x) {
    return std::make_unique<HeavyObject>(x);
};
HeavyObjectManager manager(generator);

原理：std::unique_ptr本身支持移动操作（无需拷贝），生成器直接在堆上构造HeavyObject并返回智能指针，Manager仅转移指针的所有权，完全不涉及HeavyObject的拷贝或移动。

方案2：原位构造（内存存储区+placement new） #

通过预分配内存存储区，让生成器直接在Manager的成员内存位置构造HeavyObject，避免对象拷贝/移动：

#include <functional>
#include <type_traits>

class HeavyObject {
    int x;
public:
    HeavyObject(int x) : x(x) {}

    HeavyObject &operator=(const HeavyObject &) = delete;
    HeavyObject &operator=(HeavyObject &&) = delete;
};

using HeavyObjectGenerator = std::function<void(int, void*)>;

class HeavyObjectManager {
    HeavyObjectGenerator heavyObjectGenerator;
    std::aligned_storage_t<sizeof(HeavyObject), alignof(HeavyObject)> heavyObjectStorage;
    HeavyObject* heavyObject;

public:
    HeavyObjectManager(HeavyObjectGenerator gen) 
        : heavyObjectGenerator(std::move(gen)) {
        // 初始化构造第一个对象
        heavyObject = new (&heavyObjectStorage) HeavyObject(0);
    }

    ~HeavyObjectManager() {
        // 手动析构对象
        heavyObject->~HeavyObject();
    }

    // 禁用拷贝/移动，避免内存管理问题
    HeavyObjectManager(const HeavyObjectManager&) = delete;
    HeavyObjectManager& operator=(const HeavyObjectManager&) = delete;

    void updateHeavyObject(int x) {
        // 先析构旧对象
        heavyObject->~HeavyObject();
        // 调用生成器在原内存构造新对象
        heavyObjectGenerator(x, &heavyObjectStorage);
        heavyObject = reinterpret_cast<HeavyObject*>(&heavyObjectStorage);
    }
};

// 使用示例
auto generator = [](int x, void* storage) {
    new (storage) HeavyObject(x);
};
HeavyObjectManager manager(generator);

原理：提前分配与HeavyObject大小、对齐一致的内存块，每次更新时先析构旧对象，再通过placement new让生成器直接在该内存块构造新对象，全程没有对象的拷贝或移动操作。

方案3：模板化生成器（避免类型擦除开销） #

如果不需要类型擦除的灵活性，可以将HeavyObjectManager设计为模板类，直接接受生成器类型，让生成器负责原位构造：

#include <utility>

class HeavyObject {
    int x;
public:
    HeavyObject(int x) : x(x) {}

    HeavyObject &operator=(const HeavyObject &) = delete;
    HeavyObject &operator=(HeavyObject &&) = delete;
};

template<typename Generator>
class HeavyObjectManager {
    Generator heavyObjectGenerator;
    std::aligned_storage_t<sizeof(HeavyObject), alignof(HeavyObject)> heavyObjectStorage;
    HeavyObject* heavyObject;

public:
    explicit HeavyObjectManager(Generator gen) 
        : heavyObjectGenerator(std::move(gen)) {
        heavyObject = new (&heavyObjectStorage) HeavyObject(0);
    }

    ~HeavyObjectManager() {
        heavyObject->~HeavyObject();
    }

    HeavyObjectManager(const HeavyObjectManager&) = delete;
    HeavyObjectManager& operator=(const HeavyObjectManager&) = delete;

    void updateHeavyObject(int x) {
        heavyObject->~HeavyObject();
        // 调用生成器直接构造，生成器需负责placement new逻辑
        heavyObjectGenerator(x, &heavyObjectStorage);
        heavyObject = reinterpret_cast<HeavyObject*>(&heavyObjectStorage);
    }
};

// 使用示例
auto generator = [](int x, void* storage) {
    new (storage) HeavyObject(x);
};
HeavyObjectManager<decltype(generator)> manager(generator);

原理：模板化生成器避免了std::function的类型擦除开销，同时确保生成器的行为明确，直接在预分配内存上构造对象，无拷贝/移动操作。

方案4：扩展HeavyObject的原位重置接口（若允许修改对象） #

如果可以修改HeavyObject类，添加一个重置对象状态的成员函数，让生成器返回构造参数或直接执行重置逻辑：

#include <functional>

class HeavyObject {
    int x;
public:
    HeavyObject(int x) : x(x) {}

    HeavyObject &operator=(const HeavyObject &) = delete;
    HeavyObject &operator=(HeavyObject &&) = delete;

    // 添加重置接口，复用已有对象内存
    void reset(int new_x) {
        // 若对象持有其他资源，需先释放再重新初始化
        x = new_x;
    }
};

using HeavyObjectGenerator = std::function<int(int)>;

class HeavyObjectManager {
    HeavyObjectGenerator heavyObjectGenerator;
    HeavyObject heavyObject{0};

public:
    HeavyObjectManager(HeavyObjectGenerator gen) 
        : heavyObjectGenerator(std::move(gen)) {}

    void updateHeavyObject(int x) {
        int new_val = heavyObjectGenerator(x);
        heavyObject.reset(new_val);
    }
};

// 使用示例
auto generator = [](int x) {
    // 自定义生成逻辑，返回构造参数
    return x * 2;
};
HeavyObjectManager manager(generator);

原理：通过重置接口复用已有对象的内存，避免销毁和重建对象，生成器只需提供新的构造参数，无需涉及对象的拷贝/移动。

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