如《为C＋＋实现一个IDL（三）》一文中所说，还剩最后一个问题，还是使用前面的测试代码说明。
async_call函数的原型是：
typedef void(*FUNC_TYPE)(int, char, string, short);
void async_call (int v0, char v1, string v2, FUNC_TYPE func);
这是模板类根据in/out来产生的。
在异步调用中，参数是和操作保存在一起的，因为要交给线程处理。前面已经说过，Method模板类中将保有这些参数，Method的定义如下（以例子中4个参数的特化版本来说明）：
template <class A, class B, class C, class D>
struct Method <void(A,B,C,D)> : public Base < typename Loki::TL::MakeTypelist< A,B,C,D >::Result >
{
A a;
B b;
C c;
D d;
Method ()
{
parameters.push_back (&a);
parameters.push_back (&b);
parameters.push_back (&c);
parameters.push_back (&d);
}
};
相应地，Base类使用这个特化版本：
template <class TYPES, class IN_TYPES>
struct Base <TYPES, IN_TYPES, 3> : public IMethod
{
typedef typename FuncTypeTraits <TYPES>::Result FUNC_TYPE;
void async_call (
typename Loki::TL::TypeAt <IN_TYPES, 0>::Result::OriginalType v0,
typename Loki::TL::TypeAt <IN_TYPES, 1>::Result::OriginalType v1,
typename Loki::TL::TypeAt <IN_TYPES, 2>::Result::OriginalType v2,
FUNC_TYPE func = 0)
{
}
};
TYPES模板参数中保存了所有的参数类型，IN_TYPES模板参数中保存了所有的in参数类型，但它们不知道如何来对应起来，async_call也不知道如何把几个参数值交给parameters（在IMethod中定义，见上一篇）。
如果我们在生成IN_TYPES的时候，把它在TYPES中的位置（索引）也一起交给它，就能解决这个问题。
InList第二个模板参数是一个常量，当我们把TYPES交给它时，以上面的代码为例，将会使用T_COUNT值为4的偏特化版本。这时候，将会首先推导出IN_TYPES中的第一个类型int，它在IN_TYPES中的索引是0，并接着调用T_COUNT值是3的偏特化版本，这样递归推导，直到调用T_COUNT值为0的偏特化版本，这个过程就结束了。在这个递归过程中，能够得到各个类型以及对应的“索引”值：int: 4, char: 3, string: 2。
注意这个索引值和实际的索引值是有差别的，实际的索引值应该是4-T_COUNT，所以上面的对应关系应该是：int: 0, char: 1, string: 2。
最初传递给InList的TYPES有4个元素，当它递归调用时，这个值就会依次递减，后面的递归调用并不知道应该用4去减掉T_COUNT作为索引，因为4并没有传递过来。简单的解决办法是再加上一个模板参数，让它往下传递，当然这种方式并不好看，好在我们不是真的必须这么做。
注意，在Base类中，它是知道TYPES的个数的，那么只要用这个数减去前面生成的IN_TYPE的“索引”，就能得到这个类型在TYPES中的真正索引。（这部分真是有点罗嗦）
修改InList模板类，让它生成由
[ in类型以及in类型在TYPES中的“索引”] 构成的新Typelist。
首先要增加一个辅助模板类：
template <class T, int INDEX>
struct TypeReversedIndex
{
typedef T type;
enum {value = INDEX};
};
它能够保存一个类型，以及一个整数。取名为TypeReversedIndex，意思是说它要保存一个Type和一个ReversedIndex（反的索引）。
InList模板类也要修改，OutList依旧是免费赠送：
template < class T, int T_COUNT = Loki::TL::Length <T>::value >
struct InList
{
typedef typename If <
InOutTypeTraits <typename T::Head>::isin,
typename Loki::Typelist < TypeReversedIndex <typename T::Head, T_COUNT>, typename InList <typename T::Tail>::Result >,
typename InList <typename T::Tail>::Result
>::Result Result;
};
template <class T>
struct InList < T, 0 >
{
typedef typename Loki::TL::MakeTypelist <>::Result Result;
};
template < class T, int T_COUNT = Loki::TL::Length <T>::value >
struct OutList
{
typedef typename If <
InOutTypeTraits <typename T::Head>::isout,
typename Loki::Typelist < TypeReversedIndex <typename T::Head, T_COUNT>, typename OutList <typename T::Tail>::Result >,
typename OutList <typename T::Tail>::Result
>::Result Result;
};
template <class T>
struct OutList < T, 0 >
{
typedef typename Loki::TL::MakeTypelist <>::Result Result;
};
Base类就可以写出来了：
template <class TYPES, class IN_TYPES>
struct Base <TYPES, IN_TYPES, 3> : public IMethod
{
typedef typename FuncTypeTraits <TYPES>::Result FUNC_TYPE;
typedef IN_TYPES type;
enum {TYPES_COUNT = typename Loki::TL::Length<TYPES>::value};
void async_call (
typename Loki::TL::TypeAt <IN_TYPES, 0>::Result::type::OriginalType v0,
typename Loki::TL::TypeAt <IN_TYPES, 1>::Result::type::OriginalType v1,
typename Loki::TL::TypeAt <IN_TYPES, 2>::Result::type::OriginalType v2,
FUNC_TYPE func = 0)
{
((typename Loki::TL::TypeAt <IN_TYPES, 0>::Result::type*)
parameters[TYPES_COUNT - typename Loki::TL::TypeAt <IN_TYPES, 0>::Result::value])->setValue (v0);
((typename Loki::TL::TypeAt <IN_TYPES, 1>::Result::type*)
parameters[TYPES_COUNT - typename Loki::TL::TypeAt <IN_TYPES, 1>::Result::value])->setValue (v1);
((typename Loki::TL::TypeAt <IN_TYPES, 2>::Result::type*)
parameters[TYPES_COUNT - typename Loki::TL::TypeAt <IN_TYPES, 2>::Result::value])->setValue (v2);
}
};
parameters中存放的是IParameter*类型，这里使用了强制转型，并调用in/inout模板类的setValue方法给它赋值。
为了测试结果，我为IParameter加上了void print () const虚函数，并在in/inout/out模板类中实现它，打印出类型，in/inout类中还将打印出参数值。
class IParameter
{
public:
virtual void print () const = 0;
};
template <class T>
struct in : public IParameter
{
typedef T OriginalType;
T value;
void setValue (T v){
value = v;
}
void print () const {
cout << typeid(*this).name() << ": " << value << endl;
}
};
template <class T>
struct out : public IParameter
{
typedef T OriginalType;
virtual void print () const {
cout << typeid(*this).name() << endl;
}
};
template <class T>
struct inout : public IParameter
{
typedef T OriginalType;
T value;
void setValue (T v){
value = v;
}
virtual void print () const {
cout << typeid(*this).name() << ": " << value << endl;
}
};
并在Base::async_call中调用parameters中所有对象的print函数来输出一些调试信息：
for (size_t i = 0; i < parameters.size(); i ++)
parameters[i]->print ();
简单测试了2种类型，不能保证所有代码都是正确的，毕竟是手工写出来的也没经过检查，模板类在没有实例化的时候某些错误是不会报告的。
测试代码如下：
void test_func (int v0, char v1, string v2, short v3)
{
cout << "===========================================" << endl;
cout << "test_func(" << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ")" << endl;
}
void test_func1 (int v0, char v1, short v2, string v3)
{
cout << "===========================================" << endl;
cout << "test_func1(" << v0 << ", " << v1 << ", " << v2 << ", " << v3 << ")" << endl;
}
int main()
{
{
Method < void(in<int>, in<char>, inout<string>, out<short>) > m;
m.async_call(3, 'a', "test");
cout << "===========================================" << endl;
m.async_call(3, 'a', "test", test_func);
cout << "===========================================" << endl;
}
{
Method <string(in<int>, out<char>, inout<short>)> m;
m.async_call(3, 4);
cout << "===========================================" << endl;
m.async_call(3, 4, test_func1);
cout << "===========================================" << endl;
}
return 0;
}
全部代码太长，就不一一罗列于此了，可以点击
这里下载。