qiezi的学习园地

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

  C++博客 :: 首页 :: 新随笔 ::  ::  :: 管理 ::

说明:
要看懂后面那部分代码,即使用Typelist的部分,最好预先看过《C++设计新思维》,英文版名为《Modern C++ Design》。
If模板类在写完后想起来好像在哪见过,早晨去公司查阅了一下,在《产生式编程——方法、工具与应用》一书中有讲,英文名为《Generative Programming -- Methods, Tools, and Applications》基本和本篇中一个样。


前2篇乱七八糟地讲了一些,有一个遗留问题,函数原型的推导。

简要描述如下:

Method < void(in<int>in<char>, inout<string>out<short>> method;

// 同步调用
string str = "hello";
short value = 2;
method (
3'a', str, value);

// 异步调用1
method.async_call (3'a'"hello");

// 异步调用2
void test_func (intcharstringshort);
method.async_call (
3'a'"hello", test_func);


要产生这3种函数形式。参数类型如何转换,是以后的话题,本篇主要解决异步调用的函数原形推导问题。本篇也不讨论Method的模板参数(即那个函数类型)返回类型不为void的情况。

第一种形式,同步调用,比较好处理,参数个数和模板参数的数量相同。

后2种形式,如何让编译器根据in/out来推导出函数原型?

我们需要编译器做这样的处理,async_call的参数类型中,in类型的参数将保留,out类型的参数不需要,inout类型也需要保留。

要用到的Loki头文件:

#include <static_check.h>
#include 
<Typelist.h>

using namespace Loki;
using namespace Loki::TL;


首先看看in/inout/out的声明。为了简化,这里去掉了跟类型推导无关的部分。

class NullType
{
    NullType ();
};

template 
<class T>
struct in
{
    typedef T OriginalType;
};

template 
<class T>
struct out
{
    typedef T OriginalType;
};

template 
<class T>
struct inout
{
    typedef T OriginalType;
};

下面Method模板类的声明,使用偏特化来产生代码。为了简化,我只取函数参数个数为4个参数的版本,比照着上面的代码来解释,只解释method.async_call (3, 'a', "hello", test_func);这个版本,因为另一个比它简单。

template <class T>
struct Method
{
};

template 
<class Ret, class A, class B, class C, class D>
struct Method <Ret(A,B,C,D)> 
{
};


根据上面Method的定义,Method < void(in, in, inout, out) > ,async_call函数的类型将是:

typedef void (*FUNC_TYPE)(intcharstringshort);
void async_call (intcharstring, FUNC_TYPE func);

实际上FUNC_TYPE应该能够接受更广泛的类型,比如void(int, char, char*, short),这可以在内部做一些转换,不过本篇的重点不在这里,所以只讲上面的那种形式。

直接在Method类中实现有些麻烦,所以我把这个函数放在一个基类中实现,只要编译器能帮我们推导出下面这种形式就行了:

template <class Ret, class A, class B, class C, class D>
struct Method <Ret(A,B,C,D)> : public Base < A, B, C >
{
};


注意,这里是以Method < void(in, in, inout, out) >这种形式来讲的,才会有上面那种继承关系。而实际上,由于in/out在参数中的位置、数量都是未知的,要到定义时才能确定,所以使用模板来推导。(入正题了)

也就是说,只要我们能使用静态推导方式,获得A,B,C,D这四个参数中所有的in类型,把它交给Base作为模板参数就成了。

这里需要一个辅助的模板类,用来在编译时帮助推导:

template <class T>
class InOutTypeTraits
{
    Loki::CompileTimeError 
<false> Not_Supported_Type;
};

template 
<class T>
struct InOutTypeTraits < in<T> >
{
    
enum {isin=1, isout=0};
};

template 
<class T>
struct InOutTypeTraits < out<T> >
{
    
enum {isin=0, isout=1};
};

template 
<class T>
struct InOutTypeTraits < inout<T> >
{
    
enum {isin=1, isout=1};
};

template 
<>
struct InOutTypeTraits < NullType >
{
    
enum {isin=0, isout=0};
};

通过另一个模板类InList来帮我们产生所有的in类型,它的结果是一个Typelist。为了方便以后使用,我把out类型产生器也做了一个OutList。

template <int CONDITION, class _IF, class _ELSE>
struct If
{
    typedef _IF Result;
};

template 
<class _IF, class _ELSE>
struct If <0, _IF, _ELSE>
{
    typedef _ELSE Result;
};

template 
<class A = NullType, class B = NullType, class C = NullType, class D = NullType, 
    
class E = NullType, class F = NullType, class G = NullType, class H = NullType
>
struct InList
{
    typedef typename If 
< 
        InOutTypeTraits 
<A>::isin,
        typename Typelist 
< A, typename InList<B,C,D,E,F,G>::Result >
        typename InList
<B,C,D,E,F,G,H>::Result 
    
>::Result Result;
};

template 
<class A>
struct InList <A, NullType, NullType, NullType, NullType, NullType, NullType, NullType>
{
    typedef typename If 
<
        InOutTypeTraits 
<A>::isin,
        typename MakeTypelist 
<A>::Result,
        typename MakeTypelist 
<>::Result
    
>::Result Result;
};

template 
<class A = NullType, class B = NullType, class C = NullType, class D = NullType, 
    
class E = NullType, class F = NullType, class G = NullType, class H = NullType
>
struct OutList
{
    typedef typename If 
< 
        InOutTypeTraits
<A>::isout,
        typename Typelist 
< A, typename OutList<B,C,D,E,F,G>::Result >
        typename OutList
<B,C,D,E,F,G,H>::Result 
    
>::Result Result;
};

template 
<class A>
struct OutList <A, NullType, NullType, NullType, NullType, NullType, NullType, NullType>
{
    typedef typename MakeTypelist 
<A>::Result Result;
};

它的原理是,根据If模板类来判断一个类型是不是in类型,是的话就把它加入到Typelist中,不是就排除它。

InList , in, inout, out::Result是一个Typelist , Typelist, Typelist, NullType> > >类型,说简单点,它和MakeTypelist < in, in, inout >::Result是等价的。

现在Base模板类将接受一个模板参数,它是一个Typelist类型,这个不详细讲了,把它的定义写出来:

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

template 
<class T>
struct Base <T, 0>
{
    typedef 
void(*FUNC_TYPE)();

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

template 
<class T>
struct Base <T, 1>
{
    typedef 
void(*FUNC_TYPE)(
        typename TypeAt 
<T, 0>::Result::OriginalType);

    
void async_call (
        typename TypeAt 
<T, 0>::Result::OriginalType v0,
        FUNC_TYPE func)
    {
    }
    
void async_call (typename TypeAt <T, 0>::Result::OriginalType v0)
    {
    }
};

template 
<class T>
struct Base <T, 2>
{
    typedef 
void(*FUNC_TYPE)(
        typename TypeAt 
<T, 0>::Result::OriginalType,
        typename TypeAt 
<T, 1>::Result::OriginalType);

    
void async_call (
        typename TypeAt 
<T, 0>::Result::OriginalType v0, 
        typename TypeAt 
<T, 1>::Result::OriginalType v1, 
        FUNC_TYPE func)
    {
    }
    
void async_call (
        typename TypeAt 
<T, 0>::Result::OriginalType v0, 
        typename TypeAt 
<T, 1>::Result::OriginalType v1)
    {
    }
};

template 
<class T>
struct Base <T, 3>
{
    typedef 
void(*FUNC_TYPE)(
        typename TypeAt 
<T, 0>::Result::OriginalType, 
        typename TypeAt 
<T, 1>::Result::OriginalType,
        typename TypeAt 
<T, 2>::Result::OriginalType);

    
void async_call (
        typename TypeAt 
<T, 0>::Result::OriginalType v0, 
        typename TypeAt 
<T, 1>::Result::OriginalType v1, 
        typename TypeAt 
<T, 2>::Result::OriginalType v2, 
        FUNC_TYPE func)
    {
    }
    
void async_call (
        typename TypeAt 
<T, 0>::Result::OriginalType v0,
        typename TypeAt 
<T, 1>::Result::OriginalType v1,
        typename TypeAt 
<T, 2>::Result::OriginalType v2)
    {
    }
};

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

    
void async_call (
        typename TypeAt 
<T, 0>::Result::OriginalType v0, 
        typename TypeAt 
<T, 1>::Result::OriginalType v1, 
        typename TypeAt 
<T, 2>::Result::OriginalType v2, 
        typename TypeAt 
<T, 3>::Result::OriginalType v3,
        FUNC_TYPE func)
    {
    }
    
void async_call (
        typename TypeAt 
<T, 0>::Result::OriginalType v0,
        typename TypeAt 
<T, 1>::Result::OriginalType v1,
        typename TypeAt 
<T, 2>::Result::OriginalType v2,
        typename TypeAt 
<T, 3>::Result::OriginalType v3)
    {
    }
};

这部分有点多,其实还是比较清晰的。注意这个Base的版本已经不是上面所讲的那个了。

函数原形推导问题就讲完了。上面的代码不一定还能编译,昨天是能编译的,被我修改了一些,为了解释,又改成昨天那样子。
posted on 2005-09-20 22:34 qiezi 阅读(538) 评论(6)  编辑 收藏 引用 所属分类: 自家破烂C++asgard项目