如何调用存储在map中的仿函数？代码调用报错原因解析

这个问题我之前也碰到过，核心原因其实是C++的静态类型检查在起作用——咱们一步步拆解来看：

问题根源 #

你定义的基类BFunctor里没有声明operator()，虽然子类Add重载了这个运算符，但当你把Add*存入map<string, BFunctor*>后，取出的指针类型是BFunctor*。编译器只会根据静态类型（也就是BFunctor）来做语法检查，而BFunctor本身没有可调用的operator()，自然会报错说“无法将表达式作为函数调用”。

简单说就是：编译器不知道这个基类指针指向的子类对象有operator()，所以不允许你这么调用。

两种可行的解决方案 #

方案一：用多态基类（传统面向对象方式） #

给基类添加一个纯虚的operator()，让所有子类去重写它，这样通过基类指针就能触发多态调用子类的实现：

#include <map>
#include <string>

// 修改基类，添加纯虚operator()和虚析构
class BFunctor {
public:
    // 声明纯虚函数，规定子类必须实现这个签名的operator()
    virtual int operator()(int x, int y) const = 0;
    // 必须加虚析构，否则销毁子类对象时会内存泄漏
    virtual ~BFunctor() = default;
};

class Add : public BFunctor {
public:
    // 重写基类的纯虚函数，override关键字可以帮你检查签名是否匹配
    int operator()(int x, int y) const override {
        return x + y;
    }
};

class Multiply : public BFunctor {
public:
    int operator()(int x, int y) const override {
        return x * y;
    }
};

int main() {
    std::map<std::string, BFunctor*> ops;
    Add add;
    Multiply multiply;
    
    ops["sum"] = &add;
    ops["product"] = &multiply;
    
    // 注意要先解引用指针，再调用operator()
    int sum_result = (*ops["sum"])(3, 5);
    // 或者用箭头语法直接调用成员函数：ops["sum"]->operator()(3,5);
    int product_result = (*ops["product"])(2, 4);
    
    return 0;
}

这里要注意两个关键点：

• 必须给基类加虚析构函数：如果没有，当map销毁时只会调用基类的析构函数，子类的资源（如果有的话）不会被释放，导致内存泄漏。
• 调用时要解引用指针：因为ops["sum"]返回的是指针，直接写ops["sum"](3,5)会被当成“调用指针指向的函数”，而不是调用对象的operator()。

方案二：用std::function（更灵活的现代C++方式） #

如果你不想维护基类和虚函数，推荐用标准库的std::function，它可以直接存储任何符合签名的可调用对象（仿函数、lambda、普通函数都可以）：

#include <map>
#include <string>
#include <functional>

// 不需要基类了，直接写子类
class Add {
public:
    int operator()(int x, int y) {
        return x + y;
    }
};

class Multiply {
public:
    int operator()(int x, int y) {
        return x * y;
    }
};

int main() {
    // 定义map的value类型为std::function<int(int, int)>，对应"两个int入参，返回int"的签名
    std::map<std::string, std::function<int(int, int)>> ops;
    
    Add add;
    Multiply multiply;
    
    ops["sum"] = add; // 直接存入仿函数对象
    ops["product"] = multiply;
    // 甚至可以直接存lambda表达式，非常灵活
    ops["difference"] = [](int x, int y){ return x - y; };
    
    // 直接调用就行，不需要解引用，和你最初想写的代码几乎一样！
    int sum_result = ops["sum"](3, 5);
    int product_result = ops["product"](2, 4);
    int diff_result = ops["difference"](10, 3);
    
    return 0;
}

这种方式的优势是灵活性极高，不需要维护继承关系，还能混合存储不同类型的可调用对象，只要它们的签名一致就行。

额外提示 #

如果用方案一的指针存储，一定要注意对象的生命周期：比如你不能把局部对象的指针存入map后，在局部对象销毁后再调用，否则会触发未定义行为。如果需要动态创建对象，建议用智能指针（比如std::unique_ptr<BFunctor>）来管理内存，比如std::map<std::string, std::unique_ptr<BFunctor>> ops;，这样能自动释放资源，避免内存泄漏。

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