C++中函数表与函数容器

待我称王封你为后i 2022-06-11 00:52 224阅读 0赞

函数表(function table),是函数映射的表, 最简单的方法是使用”map<>”容器, 映射”std::string”和”function<>”容器;  
函数容器的类型是 调用签名(call signature), 如 “std::function

#include<iostream>
    #include<map>
    #include<string>
    #include <functional> 
    using namespace std;
    struct absInt
    {
        int operator()(int val)const
        {
            return val < 0 ? -val : val;
        }
    };
    //普通函数
    int add(int i, int j) {
        return i + j;
    }
    //lambda表达式，产生一个未命名的函数对象类
    auto mod = [](int i, int j) {
       return i%j; };
    //函数对象类,相当于类重载了函数调用运算符，则可以像使用函数一样使用该类的对象
    struct divide
    {
        int operator()(int denominator, int divisor) {
            return denominator / divisor;
        }
    };
    int main() {
        int i = -42;
        absInt absObj;
        int ui = absObj(i);//操作符重载，重载函数调用运算符()
        cout << ui << endl;
        //函数表function table,用于存储指向这些可调用对象的“指针”，当程序要执行某个特定操作时，从表中查找该调用的函数,索引是字符串，值是一个函数指针
        map<string, int(*)(int, int)> binops;
        binops.insert({ "+",add });//{ "+",add }是一个pair
        int rs = binops["+"](10, 5);
        cout << rs << endl;
        //函数容器function类型,function是一个模板，当创建一个具体的function类型时我们必须提供额外的信息
        map<string, function<int(int, int)>> binops2 = {
            {
       "+",add}, //函数指针
            {
       "-",std::minus<int>()}, //标准函数库对象
            {
       "/",divide()}, //用户定义的函数对象
            {
       "*",[](int i,int j) {
       return i*j; }}, //未命名的lambda表达式
            {
       "%",mod}                           //命名的lambda表达式
        };
        std::cout << "10 + 5 = " << binops["+"](10, 5) << std::endl;//调用add(10,5)
        std::cout << "10 - 5 = " << binops["-"](10, 5) << std::endl;//使用minus<int>对象的调用运算符
        std::cout << "10 / 5 = " << binops["/"](10, 5) << std::endl;//使用divide对象的调用运算符
        std::cout << "10 * 5 = " << binops["*"](10, 5) << std::endl;//调用lambda表达式
        std::cout << "10 % 5 = " << binops["%"](10, 5) << std::endl;//调用lambda表达式
        return 0;
    }

例如binops\[“+”\](10, 5)实际上是使用该指针调用add，并传入10和5。

**重载的函数与function**

不能直接将**重载**函数的名字存入function类型的对象中：

int add(int i, int j) { return i + j; }
        Sales_data add(const Sales_data&, const Sales_data&);
        map < string, function<int(int, int)> > binops;
        binops.insert({
       "+",add});//哪个add？

解决上面二义性的一个办法是存储函数指针而不是函数的名字：

int(*fp) (int, int) = add;//指针fp所指向的add是接受两个int的版本
        binops.insert({
       "+",fp});

同样，也可以使用lambda来消除二义性：

binops.insert({ "+",[](int a,intb) {return add(a,b); } });

lambda内部的函数调用传入了两个int，因此该调用只能匹配接受两个int的add版本，而这也是执行lambda时真正调用的函数。

具体细节可以参考C++ primer 第五版的第14章的内容。