为C＋＋实现一个IDL　（三）-CSDN博客

一、修正错误。

首先修正第二篇中的一些错误，错误的内容可见第二篇的评论。

在Base类中，FUNC_TYPE需要所有的in/out类型，如果Method的模板参数——即函数类型参数——的返回值不是void，则把它装配成out参数，作为FUNC_TYPE函数类型的最后一个参数，这可以通过偏特化来实现。

修改Method模板类，把所有类型包装成一个Typelist，直接传递给Base模板类，由Base去推导出in类型的Typelist。Method模板类修改如下：

template < class T >
struct Method
{
Loki::CompileTimeError < false > Only_Define_With_A_Function_Type;
};

template < class Ret >
struct Method < Ret() > : public Base < typename Loki::TL::MakeTypelist < out < Ret > > ::Result >
{
};

template <>
struct Method < void () > : public Base < typename Loki::TL::MakeTypelist < > ::Result >
{
};

template < class Ret, class A >
struct Method < Ret(A) > : public Base < typename Loki::TL::MakeTypelist < A, out < Ret > > ::Result >
{
};

template < class A >
struct Method < void (A) > : public Base < typename Loki::TL::MakeTypelist < A > ::Result >
{
};

template < class Ret, class A, class B >
struct Method < Ret(A,B) > : public Base < typename Loki::TL::MakeTypelist < A,B, out < Ret > > ::Result >
{
};

template < class A, class B >
struct Method < void (A,B) > : public Base < typename Loki::TL::MakeTypelist < A,B > ::Result >
{
};

template < class Ret, class A, class B, class C >
struct Method < Ret(A,B,C) > : public Base < typename Loki::TL::MakeTypelist < A,B,C, out < Ret > > ::Result >
{
};

template < class A, class B, class C >
struct Method < void (A,B,C) > : public Base < typename Loki::TL::MakeTypelist < A,B,C > ::Result >
{
};

template < class Ret, class A, class B, class C, class D >
struct Method < Ret(A,B,C,D) > : public Base < typename Loki::TL::MakeTypelist < A,B,C,D, out < Ret > > ::Result >
{
};

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 >
{
};

template < class Ret, class A, class B, class C, class D, class E >
struct Method < Ret(A,B,C,D,E) > : public Base < typename Loki::TL::MakeTypelist < A,B,C,D,E, out < Ret > > ::Result >
{
};

template < class A, class B, class C, class D, class E >
struct Method < void (A,B,C,D,E) > : public Base < typename Loki::TL::MakeTypelist < A,B,C,D,E > ::Result >
{
};

实现了1－5个参数的版本，一般情况下足够用了，这里也只是用做解释。

Base类的修改为：

InList模板类修改为接受一个Typelist模板参数，它的Result是这个Typelist中的所有in类型构成的Typelist。OutList暂时用不到，不过由于它和InList很相似，一并甩卖出来。

template < class T, int T_COUNT = Loki::TL::Length < T > ::value >
struct InList
{
    typedef typename If <
        InOutTypeTraits < typename T::Head > ::isin,
        typename Loki::Typelist < typename T::Head, 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 < typename T::Head, 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模板类中，需要根据TYPES模板参数推导出FUNC＿TYPE类型，TYPES是个Typelist，我使用了一个FuncTypeTraits模板类来生成这个类型。

template < class T, int T_COUNT = Loki::TL::Length < T > ::value >
struct FuncTypeTraits
{
    Loki::CompileTimeError < false > Only_Use_Partial_Specialisation_Version;
};

template < class T >
struct FuncTypeTraits < T, 0 >
{
    typedef void ( * Result)();
};

template < class T >
struct FuncTypeTraits < T, 1 >
{
    typedef void ( * Result)(
        typename Loki::TL::TypeAt < T, 0 > ::Result::OriginalType);
};

template < class T >
struct FuncTypeTraits < T, 2 >
{
    typedef void ( * Result)(
        typename Loki::TL::TypeAt < T, 0 > ::Result::OriginalType,
        typename Loki::TL::TypeAt < T, 1 > ::Result::OriginalType);
};

template < class T >
struct FuncTypeTraits < T, 3 >
{
    typedef void ( * Result)(
        typename Loki::TL::TypeAt < T, 0 > ::Result::OriginalType,
        typename Loki::TL::TypeAt < T, 1 > ::Result::OriginalType,
        typename Loki::TL::TypeAt < T, 2 > ::Result::OriginalType);
};

template < class T >
struct FuncTypeTraits < T, 4 >
{
    typedef void ( * Result)(
        typename Loki::TL::TypeAt < T, 0 > ::Result::OriginalType,
        typename Loki::TL::TypeAt < T, 1 > ::Result::OriginalType,
        typename Loki::TL::TypeAt < T, 2 > ::Result::OriginalType,
        typename Loki::TL::TypeAt < T, 3 > ::Result::OriginalType);
};

template < class T >
struct FuncTypeTraits < T, 5 >
{
    typedef void ( * Result)(
        typename Loki::TL::TypeAt < T, 0 > ::Result::OriginalType,
        typename Loki::TL::TypeAt < T, 1 > ::Result::OriginalType,
        typename Loki::TL::TypeAt < T, 2 > ::Result::OriginalType,
        typename Loki::TL::TypeAt < T, 3 > ::Result::OriginalType,
        typename Loki::TL::TypeAt < T, 4 > ::Result::OriginalType);
};

现在Base类所需要的信息都齐备了，下面是Base模板类的定义：

template < class TYPES,
     class IN_TYPES = typename InList < TYPES > ::Result,
     int IN_COUNT = Loki::TL::Length < IN_TYPES > ::value
>
struct Base
{
    Loki::CompileTimeError < false > Only_Use_Partial_Specialisation_Version;
};

template < class TYPES, class IN_TYPES >
struct Base < TYPES, IN_TYPES, 0 >
{
    typedef typename FuncTypeTraits < TYPES > ::Result FUNC_TYPE;

    template < class FUNC_TYPE >
     void async_call (FUNC_TYPE func = 0 )
    {
    }
};

template < class TYPES, class IN_TYPES >
struct Base < TYPES, IN_TYPES, 1 >
{
    typedef typename FuncTypeTraits < TYPES > ::Result FUNC_TYPE;

     void async_call (
        typename Loki::TL::TypeAt < IN_TYPES, 0 > ::Result::OriginalType v0,
        FUNC_TYPE func = 0 )
    {
    }
};

template < class TYPES, class IN_TYPES >
struct Base < TYPES, IN_TYPES, 2 >
{
    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,
        FUNC_TYPE func = 0 )
    {
    }
};

template < class TYPES, class IN_TYPES >
struct Base < TYPES, IN_TYPES, 3 >
{
    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 )
    {
    }
};

template < class TYPES, class IN_TYPES >
struct Base < TYPES, IN_TYPES, 4 >
{
    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,
        typename Loki::TL::TypeAt < IN_TYPES, 3 > ::Result::OriginalType v3,
        FUNC_TYPE func = 0 )
    {
    }
};

写一点代码来测试：

void test_func ( int v0, char v1, string v2, short v3)
{
}

int main ()
{
    Method < void ( in < int > , in < char > , inout < string > , out < short > ) > m;

    m.async_call( 3 , ' a ' , "test" );
    m.async_call( 3 , ' a ' , "test" , test_func);
     return 0 ;
}

OK，函数原形推导就写完了，以上代码都已经在VC2005 Beta2中测试过，由于VC2005对于typename的要求不是很严格，所以可能在G＋＋下会有些问题，暂时没有在G＋＋下测试。

接下来以上面的测试代码为例来简单说明一下。

定义一个Method < void < in<int>, in<char>, inout<string>, out<short> >类型的对象，它将从Base < typename MakeTypelist < in<int>, in<char>, inout<string>, out<short> >::Result >派生。

根据Base类的声明，后2个模板参数将被推导出来，Method对象实际上是从Base < typename MakeTypelist < in<int>, in<char>, inout<string>, out<short> >::Result, typename MakeTypelist < in<int>, in<char>, inout<string> >::Result, 3>派生。

于是，Base类中的FUNC＿TYPE可通过FuncTypeTraits模板类推导，得到void (int, char, string, short)类型。

async_call函数的原型也推导出来：

void async_call (int, char, string, short, FUNC_TYPE = 0);

当然这里是简单的演示，实际上async_call为了支持兼容类型，除最后一个函数指针参数以外，其它每个参数都是in或inout模板类型，

二、完善动态与静态结构之间的耦合。

解决了函数原形推导问题，不过忽略了另一个重要的问题。

Method的定义最终要生成一个动态结构，要能够得到它的参数个数、各个参数的类型，这个在上一篇已经解决了。现在稍稍完整的部分写下来：

struct IMethod
{
vector < IParameter *> parameters;
//

其它操作省略
};

IMethod是Method动态实现的基础，它里面包含各个参数的指针，in/out模板类从IParameter派生，相信从这个形式就能明白整个动态部分如何组织的，也就是实现一个简单的自省。

in/inout/out这3个模板类实际是是从IParameter派生的，直接定义于Method模板类中：

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_baqck ( & a);
        parameters.push_baqck ( & b);
        parameters.push_baqck ( & c);
        parameters.push_baqck ( & d);
    }
};

动态结构就完成了，各个偏特化版本都是这样来实现。

上面说到出现了一个重要的新问题，在上面的测试代码中，async_call函数接受3个参数（最后一个函数指针参数暂不考虑），而这里有4个变量，3个参数对应4个变量的位置只有到实例化的时候才能知道。

所以async_call还有另一个任务，就是把函数的参数值赋值给成员变量。

这个问题留到下一篇解决吧，这是最后一个问题了。