C++ 表成员函数

Question

我需要一个将代码映射到 C++ 成员函数的表。假设我们有这个类：

class foo
{
  bool one() const;
  bool two() const;
  bool call(char*) const;
};

我想要的是一个像这样的表：

{
  { “somestring”,  one },
  { ”otherstring”, two }
};

所以如果我有一个 foo 对象 f, f.call(”somestring”) 将在表中查找“somestring”，调用 one() 成员函数，并返回结果。

所有被调用的函数都具有相同的原型，即它们是 const、不带参数并返回 bool。

这可能吗？如何？

Answer 1

是的，这是可能的，使用指向成员的指针语法。

使用您提供的原型，地图将是。

std::map< std::string, bool( foo::*)() const>

它将用这种语法来调用

this->*my_map["somestring"]();

看起来很奇怪的 ->* 运算符用于指向成员函数的指针，由于继承的原因，它可能有一些奇怪的考虑因素。 （它不仅仅是一个原始地址，正如 -> 所期望的那样）

Answer 2

由于您只需要存储具有相同参数和返回类型的同一类的成员，因此您可以使用指向成员函数的指针：

bool foo::call(char const * name) const {
    static std::map<std::string, bool (foo::*)() const> table 
    {
        {"one", &foo::one}, 
        {"two", &foo::two}
    };

    auto entry = table.find(name);
    if (entry != table.end()) {
        return (this->*(entry->second))();
    } else {
        return false;
    }
}

它使用 C++11 的新初始化语法。如果您的编译器不支持它，还有各种其他选项。您可以使用静态函数初始化地图：

typedef std::map<std::string, bool (foo::*)() const> table_type;
static table_type table = make_table();

static table_type make_table() {
    table_type table;
    table["one"] = &foo::one;
    table["two"] = &foo::two;
    return table;
}

或者您可以使用 Boost.Assignment：

static std::map<std::string, bool (foo::*)() const> table = 
    boost::assign::map_list_of
        ("one", &foo::one)
        ("two", &foo::two);

或者您可以使用数组，并使用 std::find_if 查找条目（如果您的库没有，则使用简单的 for 循环）还没有），或 std::binary_search 如果您确保数组已排序。

Answer 3

是的。

struct foo_method
{
   std::string name;
   bool (foo::*pfun)() const;
};

foo_method methodTable[] = 
{
  { “somestring”,  &foo::one },
  { ”otherstring”, &foo::one }
};

void foo::call(const char* name) const
{
   size_t size = sizeof(methodTable)/sizeof(*methodTable);
   for(size_t i = 0 ; i < size ; ++i)
   {
       if ( methodTable[i].name == name )
       {
           bool (foo::*pfun)() const = methodTable[i].pfun;
           (this->*pfun)(); //invoke
       }
   }
}

Answer 4

我会使用 boost::function 和 std::map。具体来说，是这样的：

typedef boost::function<bool()> MyFunc;
typedef std::map<std::string, MyFunc> MyFuncMap;

然后，给定一个 MyFuncMap 实例，您可以执行 map["something"]() 操作。然后您可以将其包装在一个重载 operator() 的类中。您可以使用函数指针/引用，但我更喜欢使用 boost::function ，因为它允许我将指针绑定到成员函数（使用 boost::bind ）或使用其他函数对象。您还可以像使用常规函数指针一样在条件中测试 boost::function。

这是相关文档：

• Boost.Function
• Boost.Bind

祝你好运！

编辑：关于您关于 const 成员和 boost::function 的问题，这里有一个示例：

#include <boost/function.hpp>
#include <boost/bind.hpp>

typedef boost::function<bool ()> FuncPtr;

struct Test
{
    bool test() const
    {
        std::cout << "yay" << std::endl;
    }
};

int main(int argc, char **argv)
{
    Test t;
    FuncPtr ptr = boost::bind(&Test::test, &t);
    ptr();
}

Answer 5

我想补充一点，如果没有类的实例来调用它，则指向成员函数的指针是没有意义的。您所描述的情况说明了这一点（我想您知道这一点），但是在其他情况下，可能需要用指针或对它对应于某种 函子构造。