C++中如何用单个实例实现支持任意参数的成员函数指针映射类

我实现了一个名为MethodMap的模板类，用于存储类的成员函数指针，并通过字符串键在运行时调用这些函数，支持带任意参数或无参的成员函数。代码如下：

template <typename T, typename... Args>
class MethodMap {
private:
    std::unordered_map<std::string, std::function<void(T*, Args...)>> method_map;
public:
    void Insert(const std::string& key, void (T::* method)(Args...)) {
        method_map[key] = [method](T* obj, Args... args) { (obj->*method)(args...); };
    }

    void Call(const std::string& key, T* instance, Args&&... methodArgs) const {
        auto it = method_map.find(key);
        if (it != method_map.end()) {
            auto& func = it->second;
            // use tuple to store and forward the arguments
            std::tuple<Args...> arg_tuple(std::forward<Args>(methodArgs)...);
            std::apply(func, std::tuple_cat(std::make_tuple(instance), arg_tuple));
            return;
        }
        std::cerr << "Error: method '" << key << "' not found" << std::endl;
    }
};

Insert方法用于向映射中插入成员函数指针，Call方法则通过指定键和参数调用对应函数。

该类运行正常，但不同参数列表的成员函数需要创建不同的MethodMap实例。例如，若MyClass包含以下成员函数：

class MyClass {
public:
    void Method1(int x);
    void Method2(double d);
    void Method3(int x, const std::string& s);
    void Method4();
};

则需为每个成员函数创建不同的MethodMap实例：

MethodMap<MyClass> methodmap;
MyClass myClass;
methodmap.Insert("key", &MyClass::Method4); 
methodmap.Call("key", &myClass); 
MethodMap<MyClass, int> methodmapWithParameters; 
methodmapWithParameters.Insert("key", &MyClass::Method1);
methodmapWithParameters.Call("key", &myClass, 1);

请问是否存在方法可通过单个MethodMap实例处理这类任意参数的成员函数指针？我曾查阅过类似问题，但这些问题中的成员函数参数列表均一致，自行泛化实现存在困难。

要实现单个实例处理任意参数的成员函数，核心是类型擦除——将不同参数签名的成员函数包装成统一的可调用类型，存储在同一个映射中，调用时再根据参数类型匹配并执行。

下面是基于std::any和模板推导的实现方案：

#include <unordered_map>
#include <any>
#include <functional>
#include <tuple>
#include <stdexcept>
#include <iostream>

template <typename T>
class UnifiedMethodMap {
private:
    std::unordered_map<std::string, std::any> method_map;

    // 辅助模板：从std::any中取出对应类型的function并调用
    template <typename... Args>
    void call_impl(const std::any& func_any, T* instance, Args&&... args) const {
        try {
            auto func = std::any_cast<std::function<void(T*, Args...)>>(&func_any);
            if (!func) {
                throw std::bad_any_cast();
            }
            (*func)(instance, std::forward<Args>(args)...);
        } catch (const std::bad_any_cast&) {
            std::cerr << "Error: argument types do not match method signature" << std::endl;
        }
    }

public:
    // 插入任意参数的成员函数，自动推导参数类型
    template <typename... Args>
    void Insert(const std::string& key, void (T::*method)(Args...)) {
        method_map[key] = std::function<void(T*, Args...)>(
            [method](T* obj, Args... args) {
                (obj->*method)(std::forward<Args>(args)...);
            }
        );
    }

    // 调用函数，需传入匹配的参数类型
    template <typename... Args>
    void Call(const std::string& key, T* instance, Args&&... args) const {
        auto it = method_map.find(key);
        if (it == method_map.end()) {
            std::cerr << "Error: method '" << key << "' not found" << std::endl;
            return;
        }
        call_impl(it->second, instance, std::forward<Args>(args)...);
    }
};

使用示例 #

对于之前的MyClass，现在只需要一个UnifiedMethodMap实例即可处理所有成员函数：

class MyClass {
public:
    void Method1(int x) { std::cout << "Method1 called with " << x << std::endl; }
    void Method2(double d) { std::cout << "Method2 called with " << d << std::endl; }
    void Method3(int x, const std::string& s) { std::cout << "Method3 called with " << x << ", " << s << std::endl; }
    void Method4() { std::cout << "Method4 called" << std::endl; }
};

int main() {
    UnifiedMethodMap<MyClass> method_map;
    MyClass obj;

    // 插入所有不同参数的成员函数
    method_map.Insert("m1", &MyClass::Method1);
    method_map.Insert("m2", &MyClass::Method2);
    method_map.Insert("m3", &MyClass::Method3);
    method_map.Insert("m4", &MyClass::Method4);

    // 调用测试
    method_map.Call("m1", &obj, 10);
    method_map.Call("m2", &obj, 3.14);
    method_map.Call("m3", &obj, 20, "hello");
    method_map.Call("m4", &obj);

    // 错误测试：参数不匹配
    method_map.Call("m1", &obj, "wrong type"); // 输出参数类型不匹配错误
    method_map.Call("non_exist", &obj); // 输出方法未找到错误

    return 0;
}

原理说明 #

1. 类型擦除：用std::any存储不同签名的std::function对象，擦除参数类型差异，让它们能共存于同一个unordered_map中。
2. 自动推导：Insert方法利用模板参数推导，自动识别成员函数的参数列表，将其包装为对应的std::function。
3. 安全调用：Call方法通过std::any_cast尝试取出对应参数类型的std::function，若参数类型不匹配，会捕获bad_any_cast异常并输出错误信息。

这种方案的优势是无需为不同参数列表创建多个实例，使用更简洁；缺点是参数类型检查只能在运行时进行，编译期无法提前发现参数不匹配的问题。

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