【Deepseek C++】std:function 内部实现

可以以lambda 表达式的形式给出嘛



l详ambda的类型是唯一的，每个lambda表达式都有不同的类型，所以必须通过decltype来获取类型，并在构造时传入该lambda的实例。，因为如果lambda有捕获，它的类型将包含捕获的内容，这可能导致无法作为模板参数使用。因此，在示例中应该使用无捕获的lambda

详细解释std::function 内部实现的多态机制

template <typename Result, typename... Args>
class function<Result(Args...)> {
private:
    // 基类：定义统一接口
    struct CallableBase {
        virtual ~CallableBase() = default;
        virtual Result invoke(Args... args) = 0;
        virtual CallableBase* clone() const = 0;
    };

    // 派生类：存储具体可调用对象 F
    template <typename F>
    struct CallableImpl : CallableBase {
        F f; // 存储 Lambda、函数指针等
        CallableImpl(F f) : f(f) {}

        Result invoke(Args... args) override {
            return f(std::forward<Args>(args)...); // 调用实际对象
        }

        CallableBase* clone() const override {
            return new CallableImpl<F>(f); // 深拷贝
        }
    };

    CallableBase* callable; // 指向派生类对象的基类指针

public:
    // 构造函数：接受任意可调用对象 F
    template <typename F>
    function(F f) : callable(new CallableImpl<F>(f)) {}

    // 调用运算符重载
    Result operator()(Args... args) const {
        return callable->invoke(std::forward<Args>(args)...);
    }

    // 析构函数、拷贝构造函数、移动构造函数等需要处理 callable
    ~function() { delete callable; }
};

5. 实现深拷贝的核心代码

// std::function 的拷贝构造函数
template <typename Result, typename... Args>
class function<Result(Args...)> {
public:
    // 拷贝构造函数
    function(const function& other) {
        if (other.callable) {
            // 调用 clone() 生成新对象
            callable = other.callable->clone();
        } else {
            callable = nullptr;
        }
    }

private:
    struct CallableBase {
        virtual CallableBase* clone() const = 0;
    };

    template <typename F>
    struct CallableImpl : CallableBase {
        F f;
        CallableImpl(F f) : f(f) {}

        CallableBase* clone() const override {
            // 调用 F 的拷贝构造函数
            return new CallableImpl<F>(f);
        }
    };

    CallableBase* callable;
};

lambda 表达式底层实现

初始化捕获， 引用捕获，值捕获区