qiezi的学习园地

AS/C/C++/D/Java/JS/Python/Ruby

  C++博客 :: 首页 :: 新随笔 ::  ::  :: 管理 ::
一、修正错误。

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

在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类的修改为:

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

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还有另一个任务,就是把函数的参数值赋值给成员变量。

这个问题留到下一篇解决吧,这是最后一个问题了。
posted on 2005-09-21 20:34 qiezi 阅读(430) 评论(6)  编辑 收藏 引用 所属分类: C++asgard项目