std::function能否容纳参数不同的多个方法？技术实现咨询

你的需求很明确：想让Foo类里的函数包装器能存储不同参数个数/类型的成员方法，并且调用时直接传递对应参数，而不是提前把参数绑定到lambda里。这确实是std::function的一个常见痛点——它是类型固定的包装器，必须明确签名，没法直接存储多种不同签名的可调用对象。下面给你几个可行的实现方案：

方案1：用std::variant存储多种std::function（C++17+） #

这是最直观且可靠的方案，利用C++17引入的std::variant来存储不同签名的std::function，然后通过重载call_func来匹配参数列表，再用std::visit分发到对应的函数。

修改后的完整代码：

#include <iostream>
#include <functional>
#include <variant>
#include <stdexcept>

class Foo {
private:
    // 用variant存储两种我们需要的函数签名
    std::variant<std::function<void(int)>, std::function<void(int, int)>> func_variant;
public:
    // 重载call_func，匹配单个int参数的情况
    void call_func(int num) {
        // 访问variant中存储的function并调用
        std::visit([num](auto&& stored_func) {
            // 编译期检查当前function是否能接受这个参数
            if constexpr (std::is_invocable_v<decltype(stored_func), int>) {
                stored_func(num);
            } else {
                throw std::runtime_error("参数个数不匹配：预期2个int，实际传入1个");
            }
        }, func_variant);
    }

    // 重载call_func，匹配两个int参数的情况
    void call_func(int num1, int num2) {
        std::visit([num1, num2](auto&& stored_func) {
            if constexpr (std::is_invocable_v<decltype(stored_func), int, int>) {
                stored_func(num1, num2);
            } else {
                throw std::runtime_error("参数个数不匹配：预期1个int，实际传入2个");
            }
        }, func_variant);
    }

    // 提供不同签名的set_func重载，方便赋值
    void set_func(std::function<void(int)> func) {
        func_variant = std::move(func);
    }

    void set_func(std::function<void(int, int)> func) {
        func_variant = std::move(func);
    }
};

class Bar {
public:
    Bar() {
        Foo foo;
        // 绑定单个参数的成员方法
        foo.set_func(std::bind(&Bar::func, this, std::placeholders::_1));
        foo.call_func(1); // 输出：1

        // 绑定两个参数的成员方法
        foo.set_func(std::bind(&Bar::func2, this, std::placeholders::_1, std::placeholders::_2));
        foo.call_func(1, 2); // 输出：1\n2
    }

    void func(int number) { std::cout << number << "\n"; }
    void func2(int number, int number2) { 
        std::cout << number << "\n"; 
        std::cout << number2 << "\n"; 
    }
};

int main() {
    Bar bar;
    return 0;
}

这个方案的优势是：

• 类型安全，编译期就能检查参数匹配性（配合std::is_invocable_v）
• 代码清晰，容易扩展（如果需要支持更多签名，只需要给variant添加新的std::function类型，再重载对应的call_func）

方案2：自定义类型擦除的可调用包装器（更灵活） #

如果需要支持任意数量/类型的参数签名，可以自己实现一个类型擦除的包装器，比std::variant更灵活，但实现复杂度稍高。核心思路是用基类+派生类的方式擦除具体可调用对象的类型，然后通过模板调用操作符来匹配参数。

简化版示例：

#include <iostream>
#include <functional>
#include <memory>
#include <type_traits>
#include <stdexcept>

class AnyCallable {
private:
    struct CallableBase {
        virtual ~CallableBase() = default;
    };

    template<typename F>
    struct CallableImpl : CallableBase {
        F func;
        CallableImpl(F&& f) : func(std::forward<F>(f)) {}
    };

    std::unique_ptr<CallableBase> impl;

public:
    template<typename F>
    AnyCallable(F&& f) 
        : impl(std::make_unique<CallableImpl<std::decay_t<F>>>(std::forward<F>(f))) {}

    // 模板调用操作符，支持任意参数
    template<typename... Args>
    void operator()(Args&&... args) const {
        using TargetFunc = std::function<void(Args...)>;
        // 尝试转换到对应类型的CallableImpl
        auto* casted = dynamic_cast<CallableImpl<TargetFunc>*>(impl.get());
        if (!casted) {
            throw std::runtime_error("调用的参数签名与存储的函数不匹配");
        }
        casted->func(std::forward<Args>(args)...);
    }
};

class Foo {
private:
    AnyCallable func;
public:
    template<typename... Args>
    void call_func(Args&&... args) {
        func(std::forward<Args>(args)...);
    }

    template<typename F>
    void set_func(F&& f) {
        func = AnyCallable(std::forward<F>(f));
    }
};

// Bar类和main函数和方案1一致，这里省略

这个方案的优势是可以支持任意签名的可调用对象，但缺点是dynamic_cast有一定运行时开销，且需要确保传入的可调用对象能被转换为对应的std::function类型（比如bind表达式需要显式转换，或者直接用lambda）。

为什么你之前的lambda方式不一样？ #

你之前用的[this]() { this->func(1); }这种写法，本质是把参数提前绑定到lambda中，让所有存储的可调用对象签名都是void()，所以call_func不需要传参数。这和你想要的“存储不同签名函数，调用时传递参数”是两种完全不同的思路：前者是“绑定参数后统一签名”，后者是“保留原签名，动态匹配调用”。

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