c++ - 可变参数模板的模拟

Question

我正在为我们的 API 编写一个小的包装器，但我遇到了一个问题。来自外部客户端(JavaScript 引擎)的每个调用都是从名为 execute 的 ApiBase 调用函数，所有参数都作为 std::string 传递，不管在 api 调用中传递了什么，每个值都转换为字符串。

我的想法是使用指向成员函数的指针，并尝试将那些传递的字符串转换为编写特定函数的程序员需要拥有的 C++ 类型。

例如:

struct MyApiForVeryImportantDevice{
void Init(int, int);
};

MyApiForVeryImportantDevice api_entry;
ApiBase* api = make_api(&api_entry, &MyApiForVeryImportantDevice::Init);

//serve api

代码中的某处 api->execute("1", "2", "", "") 被调用 4 或 10 个字符串参数(总是 4 或 10)，不管怎样在 api 调用中传递的许多参数(不要问我为什么...)。

我知道这可以用可变模板来完成，但不幸的是我不能在这个项目中使用它。我的解决方案基于“模拟可变参数模板”，但它很难看。为了支持 10 个参数，我需要编写 10 个 ApiCall 类和 10 个 make_api 函数，这很容易出错，您有其他想法吗？某种 mpl(也许是类型列表？)？下面给出的代码只是 2 和 10 个参数的示例，我需要类似这样的 0-10 个参数。

问候。

template<class T>
T convert(const string& v){
    return T();
}

template<>
int convert(const string& v)
{
    return boost::lexical_cast<int>(v);
}


template<class T, class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
class ApiCall : public ApiBase
{
    typedef T result_type;
    typedef R class_type;
    typedef boost::function<result_type(class_type*,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9)> functor_type;

    ApiCall(T* obj, functor_type f)
    {
        func = boost::bind(f, _1, obj);
    }

    virtual void execute(const string& param1, const string& param2, const string& param3, const string& param4)
    {   
        func(convert<A0>(param0), convert<A1>(param1), convert<A2>(param2), convert<A3>(param3), convert<A4>(param4));
    }

    virtual void execute(const string& param0, const string& param1, const string& param2, const string& param3,
                         const string& param4, const string& param5, const string& param6, const string& param7
                         const string& param8, const string& param9)
    {       
        func(convert<A0>(param0), convert<A1>(param1), convert<A2>(param2), convert<A3>(param3), convert<A4>(param4), convert<A5>(param5), 
                     convert<A6>(param6),convert<A7>(param7), convert<A8>(param8), convert<A9>(param9));
    }

private:
    functor_type func;
};

template<class T, class R, class A0, class A1>
class ApiCall : public ApiBase
{
    typedef R result_type;
    typedef T class_type;
    typedef boost::function<result_type(class_type*,A0, A1)> functor_type;

    ApiCall(T* obj, functor_type f)
    {
        func = boost::bind(f, _1, obj);
    }

    virtual void execute(const string& param1, const string& param2, const string& param3, const string& param4)
    {   
        func(convert<A0>(param0), convert<A1>(param1));
    }

    virtual void execute(const string& param0, const string& param1, const string& param2, const string& param3,
                         const string& param4, const string& param5, const string& param6, const string& param7
                         const string& param8, const string& param9)
    {       
        func(convert<A0>(param0), convert<A1>(param1));
    }

private:
    functor_type func;
};

template<class T, class R, class A0, class A1>
ApiCall<T, R, A0, A1>* make_api(T obj, R(T::*fun)(A0, A1))
{
    return new ApiCall<T,R,A0,A!>(obj, fun);
}

template<class T, class R, class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
ApiCall<T,R,A0,A1,A2,A3,A4,A5,A6,A7,A8, A9>* make_api(T obj, R(T::*fun)(A0))
{
    return new ApiCall<T,R,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9>(obj, fun);
}

Answer 1

我认为 typelists 可以在这里用来模拟可变参数模板。

类型列表是一种模板元编程构造，充当类型的链接列表。由 Andrei Alexandrescu 在他的书中介绍 "Modern C++ design" .
基本上，类型列表是这样的一个类:

template<typename HEAD , typename TAIL>
struct type_list
{
    typedef HEAD head;
    typedef TAIL tail;
};

并且可以如下使用:

//A typelist wich stores int, bool, and char:
typedef type_list<int,type_list<bool,type_list<char, nil>>> list;  

nil 是一种用作标记列表末尾的标记的类型。我们可以使用 C 宏来定义快捷方式以简化类型列表定义:

#define MAKE_TYPELIST_1( type_1 ) type_list<type_1,nil>
#define MAKE_TYPELIST_2( type_1 , type_2 ) type_list<type_1,MAKE_TYPELIST_1( type_2 )>
#define MAKE_TYPELIST_3( type_1 , type_2 , type_3 ) type_list<type_1,MAKE_TYPELIST_2( type_2 , type_3 )>

...等等。

您可以使用此构造来传递参数类型而无需可变参数模板:

template<typename T , typename R , typename ARGS_LIST>
class APICall ...

typedef APICall<...,MAKE_TYPELIST_3(std::string,std::string,std::string)> tree_strings_call;

我建议您查看现代 C++ 设计的第三章。有类型列表的完整解释、它的操作(index_of、type_at 等)，以及它的使用的好例子。