设计模式－－－－ 泛型traits技术

#include  < iostream >
using   namespace  std;

struct  __xtrue_type  ... { } ;  //  define two mark-type
struct  __xfalse_type  ... { } ;

class  CComplexObject  //  a demo class
... {
public:
    virtual void clone() ...{ cout << "in clone" << endl; }
} ;

class  CDerivedComplexObject :  public  CComplexObject  //  a demo derived class
... {
public:
    virtual void clone() ...{ cout << "in derived clone" << endl; }
} ;

//  A general edtion of Traits
template  < typename T >
struct  Traits
... {
    typedef __xfalse_type has_clone_method; // trait 1: has clone method or not? All types defaultly has no clone method.
} ;

//  Specialized edtion for ComplexObject
template  <>
struct  Traits < CComplexObject >
... {
    typedef __xtrue_type has_clone_method;
} ;

template  < typename T >
class  XContainer
... {
    template <typename flag>
        class Impl
    ...{
    };
    template <>
        class Impl <__xtrue_type>
    ...{
    public:
        void clone(T* pObj)
        ...{
            pObj->clone();
        }
    };
    template <>
        class Impl <__xfalse_type>
    ...{
    public:
        void clone(T* pObj)
        ...{
        }
    };
public:
    void clone(T* pObj)
    ...{
        Impl<Traits<T>::has_clone_method>().clone(pObj);
    }
} ;

void  main()
... {
    int* p1 = 0;
    CComplexObject c2;
    CComplexObject* p2 = &c2;
    CDerivedComplexObject c3;
    CComplexObject* p3 = &c3; // you must point to a derived object by a base-class pointer,
                            //it's a little problem

    XContainer<int> n1;
    XContainer<CComplexObject> n2;
    XContainer<CComplexObject> n3;

    n1.clone(p1);
    n2.clone(p2);
    n3.clone(p3);
}

traits是一种特性萃取技术 ,它在Generic Programming中被广泛运用 ,常常被用于使不同的类型可以用于相同的操作 ,或者针对不同类型提供不同的实现 .traits在实现过程中往往需要用到以下三种C ++的基本特性 :
enum
typedef
template  (partial ) specialization
其中 :
enum用于将在不同类型间变化的标示统一成一个 ,它在C ++中常常被用于在类中替代define ,你可以称 enum为类中的define ;
typedef则用于定义你的模板类支持特性的形式 ,你的模板类必须以某种形式支持某一特性 ,否则类型萃取器traits将无法正常工作 .看到这里你可能会想 ,太苛刻了吧 ?其实不然 ,不支持某种特性本身也是一种支持的方式 (见示例 2 ,我们定义了两种标示 ,__xtrue_type和__xfalse_type ,分别表示对某特性支持和不支持 ).
template  (partial ) specialization被用于提供针对特定类型的正确的或更合适的版本 .
借助以上几种简单技术 ,我们可以利用traits提取类中定义的特性 ,并根据不同的特性提供不同的实现 .你可以将从特性的定义到萃取 ,再到traits的实际使用统称为traits技术 ,但这种定义使得traits显得过于复杂 ,我更愿意将traits的定义限于特性萃取 ,因为这种定义使得traits显得更简单 ,更易于理解 ,^_ ^.

举例 :
上面提到过 ,traits可被用于针对不同类型提供不同的实现 ,那么下面就举两个例子来说明如何实现这一点 .
Example  1 :
假定我们需要为某个类设计一个可以对所有类型 (包括普通的 int / long ...,提供了clone方法的复杂类型CComplexObject ,及由该类派生的类 )进行操作的函数clone ,下面 ,先用OO的方法来考虑一下解决方案 .看到前面的条件 ,最先跳进你脑子里的肯定是Interface ,pure  virtual function等等 .对于我们自己设计的类CComplexObject而言 ,这不是问题 ,但是 ,对于基本数据类型呢 ?还有那些没有提供clone方法的复杂类型呢 ?(这时候你可能会想 ,要是Java该多easy ,所有类都默认从Object派生 ,而Object已提供了一个默认的clone方法 ,但是 ,要使类真正支持clone ,还必须implements Cloneable ,所以 ,同样也不能避免这里遇到的麻烦 ).
下面是一个可能的解决方案 :

template  < typename T,  bool  isClonable >
class  XContainer
... {
    ...
    void clone(T* pObj)
    ...{
        if (isClonable)
        ...{
            pObj->clone();
        }
        else
        ...{
            //... non-Clonable algorithm ...
        }
    }
} ;

但是只要你测试一下 ,这段代码不能通过编译 .为什么会这样呢 ?原因很简单 :对于没有实现clone方法的非Clonable类或基本类型 ,pObj ->clone这一句是非法的 .
那么怎样解决上面的这个难题呢 ?上面不能通过编译的代码告诉我们 ,要使我们的代码通过编译 ,就不能使非Clonable类或基本类型的代码中出现pObj ->clone ,即我们需要针对不同类型提供不同的实现 .为了实现这一点 ,我们可以在我们的模板类中用 enum定义一个trait ,以标示类是否为Clonable类 ,然后在原模板类内部引入一个traits提取类Traits ,通过对该类进行specilizing ,以根据不同的trait提供不同的实现 .具体实现如下 :

#include  < iostream >
using   namespace  std;

class  CComplexObject  //  a demo class
... {
public:
    void clone() ...{ cout << "in clone" << endl; }
} ;

//  Solving the problem of choosing method to call by inner traits class
template  < typename T,  bool  isClonable >
class  XContainer
... {
public:
    enum ...{Clonable = isClonable};

    void clone(T* pObj)
    ...{
        Traits<isClonable>().clone(pObj);
    }

    template <bool flag>
        class Traits
    ...{
    };

    template <>
        class Traits<true>
    ...{
    public:
        void clone(T* pObj)
        ...{
            cout << "before cloning Clonable type" << endl;
            pObj->clone();
            cout << "after cloning Clonable type" << endl;
        }
    };

    template <>
        class Traits<false>
    ...{
    public:
        void clone(T* pObj)
        ...{
            cout << "cloning non Clonable type" << endl;
        }
    };
} ;

void  main()
... {
    int* p1 = 0;
    CComplexObject* p2 = 0;

    XContainer<int, false> n1;
    XContainer<CComplexObject, true> n2;

    n1.clone(p1);
    n2.clone(p2);
}

编译运行一下 ,上面的程序输出如下的结果 :
doing something non Clonable
before doing something Clonable
in clone
after doing something Clonable
这说明 ,我们成功地根据传入的isClonable模板参数为模板实例选择了不同的操作 ,在保证接口相同的情况下 ,为不同类型提供了不同的实现 .

Example  2 :
我们再对上面的例子进行一些限制 ,假设我们的clone操作只涉及基本类型和CComplexObject及其派生类 ,那么我们可以进一步给出下面的解法 :

现在 ,所有基本类型以及CComplexObject类系都可以用于XContainer了 .

结语 :
看到这里 ,你或许会说 ,traits不过如此 ,还以为是什么高深的玩意呢 !其实技术就是这样 ,说白了都很Easy ,关键是怎么将他们用于实际 ,为实际的Designing /Development服务 .毕竟 ,在IT领域 ,不能应用于实际的技术是没有价值的 .