Question

我正在用C ++开发一种脚本语言，它使用解释器中“内置”的函数。我使用以下构造将函数名称映射到它们各自的指针：

typedef void(*BuiltInFunction)(Context*);
typedef std::unordered_map<std::string, BuiltInFunction> BuiltinFunctionsMap;

其中Context是自定义类。

然后我有这样的函数声明：

namespace BuiltIns {
    void _f_print(Context* context);
    void _f_error(Context* context);
    void _f_readline(Context* context);
    void _f_read(Context* context);
    void _f_readchar(Context* context);
    void _f_eof(Context* context);
    ...
}

最后是一个用实际指针填充地图的例程：

BuiltinFunctionsMap BuiltIns::populateFunctions() {
    BuiltinFunctionsMap funcMap;
    // Standard I/0
    funcMap["print"] = &BuiltIns::_f_print;
    funcMap["error"] = &BuiltIns::_f_error;
    funcMap["readline"] = &BuiltIns::_f_readline;
    funcMap["read"] = &BuiltIns::_f_read;
    funcMap["readchar"] = &BuiltIns::_f_readchar;
    funcMap["eof"] = &BuiltIns::_f_eof;
    ...
    return funcMap;
}

我要问的是，是否有一种方法可以使用模板或类似方法从函数声明中自动生成填充函数。目前，我使用的是正则表达式，这很简单，但每当我添加新函数时我都必须这样做，而且很麻烦。

Answer 1

您可以使用模板元编程自动检测某些类型的函数 - 例如，给定类型T，您可以以编程方式回答“T是否有operator+？”的问题。但在一般情况下，你不能用语言自动完成上面的工作。

Answer 2

我不知道这是否真的是一个有用的答案，但你可以使用预处理器来做一些pretty squirrelly stuff：

#include <iostream>
#include <map>
#include <string>

class Context {}; 
typedef void (*BuiltInFunction)(Context*);

// a list of your function names
#define FN_NAMES \
X(foo)  \
X(bar)  \
X(baz)

// this declares your functions (you also have to define them 
// somewhere else, e.g. below or in another file)
#define X(a) void _f_ ## a ## _print(Context *context);
namespace BuiltIns {
  FN_NAMES
}
#undef X

// a global map initialized (using C++11's initializer syntax)
// to strings mapped to functions
#define X(a) {#a, &BuiltIns::_f_ ## a ## _print},
std::map<std::string, BuiltInFunction> g_fns = { 
  FN_NAMES
};
#undef X

int main() {
  g_fns["foo"](NULL);  // calls BuiltIns::_f_foo_print(NULL) 
}

// (these have to be defined somewhere)
namespace BuiltIns {
  void _f_foo_print(Context *context) {
    std::cout << "foo\n";
  }
  void _f_bar_print(Context *context) {
    std::cout << "bar\n";
  }
  void _f_baz_print(Context *context) {
    std::cout << "baz\n";
  }
}

这种方法具有自动生成例如字符串"foo"并将其绑定到_f_foo_print函数。缺点是可怕的预处理器技巧以及你仍然需要在两个地方处理foo的事实。

使用函数指针自动填充std :: map

2 个答案: