《Modern C++ Design》源码Loki库读解随感二：类型间耦合检测和去耦合

Loki库读解随感二：类型间耦合检测和去耦合

过了如许之久才有这随感二，实在不好意思。原因是我虽然读懂了Loki的每一行代码，却实在未能理解如何去使用这些代码，直到近来才渐渐有所悟的。

 

      数据类型之间的联系主要有两类：一，类型之间存在着自动转换关系；二，类型间存在着继承关系，虽然它其实也表明了某种转换（主要是对象切片和指针向上映射）。

      那么，如何判断类型间存在转换或继承呢？Loki库TypeManip提供了很精彩很完美的解决方法（注：《More Exceptional C++》Item 4也给出了讲解，可以参考。）：

 

//WQ注：和以前讨论过的TypeList一样，Conversion类也是供编译期使用

//的，所以靠提供萃取来解决问题的。

    template <class T, class U>

    struct Conversion

    {

        typedef Private::ConversionHelper<T, U> H;

#ifndef __MWERKS__

        //WQ注：这是精妙所在！讲解太长，放到后面进行。

        enum { exists = sizeof(typename H::Small) == sizeof(H::Test(H::MakeT())) };

#else

        enum { exists = false };

#endif

        enum { exists2Way = exists && Conversion<U, T>::exists };

        enum { sameType = false };

    };

    //WQ注：用偏特化解决相同类型

    template <class T>

    struct Conversion<T, T>   

    {

        enum { exists = 1, exists2Way = 1,sameType = 1 };

    };

    // WQ注：用偏特化和特化解决void

    template <class T>

    struct Conversion<void, T>   

    {

        enum { exists = 1, exists2Way = 0,sameType = 0 };

    };

   

    template <class T>

    struct Conversion<T, void>   

    {

        enum { exists = 1, exists2Way = 0,sameType = 0 };

    };

   

    template <>

    class Conversion<void, void>   

    {

    public:

        enum { exists = 1, exists2Way = 1,sameType = 1 };

    };   

}

 

先看辅助类ConversionHelper的定义：

        template <class T, class U>

        struct ConversionHelper

        {

            typedef char Small;

struct Big { char dummy[2]; };

//WQ注：注意，下面三个函数并没有实现体！

            static Big   Test(...);//WQ注：C++中，不定参数已不需要“至少一个定参”了。

            static Small Test(U);

            static T MakeT();

        };

看其中的Test函数，如果T到U之间存在转换关系的话，根据重载决策，肯定调Big Test(U)函数。依靠两个函数的返回类型并不相同，就可以判断出调了那个版本，于是也就推测出T到U之间是否存在转换关系了。

回过头来再看前面的使用：sizeof(typename H::Small) == sizeof(H::Test(H::MakeT()))；由于我们讲过，Conversion是编译期使用的类，不想采用对返回值采用运行期比较运算，恰好有sizeof()运算满足要求。所以，ConversionHelper将两个Test函数的返回类型实现得在大小上不等。

令人崩溃的事来了：由于我们只使用了Big和Small的大小而没有用它的值，所以，可以根本不用真的创建返回对象，Test函数也不必真的被调用，于是所有行为都是编译期的了。C++说，你可以不用创建并没有被真的使用的东西，所以，Test函数可以不用被定义，只要有这个申明就行了。是的，Loki库中确实没有定义这三个函数！崩溃啊，崩溃！在没搞懂这一点之前，我反复搜索了全部源码，并认为我下载了一个不完全的版本，然后四处搜索最新版本，着实乱了好一阵。虽然我不敢说所有C++编译器都能支持这一点，但我使用的VC、BCB、DevCPP三个主流编译器都正确支持了这一点，Loki的源码能够正确编译和使用。

     如何判断两个类型间存在继承关系？很简单：派生类指针类型可以自动向上映射为基类指针类型。当然还得排除“同类型指针间”和“非void *与void *间”这两种情况。Loki库源码如下：

// macro SUPERSUBCLASS

// Invocation: SUPERSUBCLASS(B, D) where B and D are types.

// Returns true if B is a public base of D, or if B and D are aliases of the

// same type.

//

// Caveat: might not work if T and U are in a private inheritance hierarchy.

 

#define SUPERSUBCLASS(T, U) /

    (::Loki::Conversion<const U*, const T*>::exists && /

    !::Loki::Conversion<const T*, const void*>::sameType)

 

// macro SUPERSUBCLASS_STRICT

// Invocation: SUPERSUBCLASS_STRICT(B, D) where B and D are types.

// Returns true if B is a public base of D.

//

// Caveat: might not work if T and U are in a private inheritance hierarchy.

 

#define SUPERSUBCLASS_STRICT(T, U) /

    (SUPERSUBCLASS(T, U) && /

!::Loki::Conversion<const T, const U>::sameType)//WQ注：有人指出此处最好使用const T *,const U *，但确实T和U就足够了，只是编译耗时可能要多一点点，反正运行期都是没有任何开销。

      故事还没有结束，提供的萃取值是int的0或1（当然也可以认为等价于bool的false或true），它们只能作运行期运算的，那么如何编译期使用这些结果？Loki库同样有精彩的解决方法：

// class template Int2Type

// Converts each integral constant into a unique type

// Invocation: Int2Type<v> where v is a compile-time constant integral

// Defines 'value', an enum that evaluates to v

 

    template <int v>

    struct Int2Type

    {

        enum { value = v };

};

// class template Select

// Selects one of two types based upon a boolean constant

// Invocation: Select<flag, T, U>::Result

// where:

// flag is a compile-time boolean constant

// T and U are types

// Result evaluates to T if flag is true, and to U otherwise.

 

    template <bool flag, typename T, typename U>

    struct Select  

    {

        typedef T Result;

    };

    template <typename T, typename U>

    struct Select<false, T, U>

    {

        typedef U Result;

};

    

Select，一个编译期的?:运算。编译期只能靠类型推导（模板），类型判决（重载）来选择不同的分支。Int的0和1自然不在这两种情况之列，但Int2Type<0>和Int2Type<1>当然是满足的。依靠偏特化，Select圆满完成了它的任务。

 

      类型之间有自动转换当然是极有用的，但很多时候却也造成麻烦：一，很容易产生转换多径，尤以多继承时最为麻烦；二，发生期望外的转换而得到期望外的行为，尤以重载时的情况最为混乱；三，转换不够精确，不能完全满足需要，问题发生在向下类型映射时。

      在适当的时候去除了类型间耦合就可以避免这三方面副作用。

      类型间去耦合有两种方法：一，用模板封装；二，指向指针的指针。

方法一的实现太简单了：

template<typename T>

struct Type2Type

{

    typedef  T  OriginalType;

}    

      多个T之间的转换和继承关系在Type2Type<T>之间再不存在了。更为神奇的是，向下类型映射将可以精确进行的，但这得结合其具体使用来讲，我把它留到下一篇《多继承的改良》中讲。