概述
:
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及其派生类 , 那么我们可以进一步给出下面的解法 :
#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 );
}
现在 , 所有基本类型以及CComplexObject类系都可以用于XContainer了 .
结语 :
看到这里 , 你或许会说 , traits不过如此 , 还以为是什么高深的玩意呢 ! 其实技术就是这样 , 说白了都很Easy , 关键是怎么将他们用于实际 , 为实际的Designing / Development服务 . 毕竟 , 在IT领域 , 不能应用于实际的技术是没有价值的 .
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及其派生类 , 那么我们可以进一步给出下面的解法 :
#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 );
}
现在 , 所有基本类型以及CComplexObject类系都可以用于XContainer了 .
结语 :
看到这里 , 你或许会说 , traits不过如此 , 还以为是什么高深的玩意呢 ! 其实技术就是这样 , 说白了都很Easy , 关键是怎么将他们用于实际 , 为实际的Designing / Development服务 . 毕竟 , 在IT领域 , 不能应用于实际的技术是没有价值的 .