C++模板编程中的Traits技术
2015-09-08 11:05
721 查看
http://blog.csdn.net/buleriver/article/details/5711076
http://www.cppblog.com/woaidongmao/archive/2008/11/09/66387.html
由于C++不支持type_of,所以Traits技术,实际上就是通过通过模板中的类型推导机制,获取到变量的类型,以其在编译器确定函数的调用。STL中的迭代器就广泛的运用到该技术。下面是一个简单的例子:
凡是一个迭代器,我们总是希望能够知道它所指的数据的数据类型,我们可以这样做:
[c-sharp]
view plaincopy
template <class T>
class Iterator
{
public:
typedef typename T::value_type value_type;
// ...
};
当然,这需要我们用到迭代器的类,定义一个value_type,否则会编译不过。
然后,无论我们在什么地方用到迭代器,我们总是可以知道它所指的数据类型:
[c-sharp]
view plaincopy
Iterator::value_type value;
但是这样的写法有一个缺陷,就是:指针也是一种迭代器,但是却不是类,因此我们便无法得知指针指向的是什么元素。为此引入Traits技术,在原来的迭代器类上面再加一层:
[c-sharp]
view plaincopy
template <class Iter>
class Iterator_Traits
{
public:
typedef typename Iter::value_type value_type;
};
这样,我们就可以得知一个迭代器所指的类型:
[c-sharp]
view plaincopy
Iterator_Traits<Iterator>::value_type value;
而对于指针,可以使用模板中的偏特化技术:
[c-sharp]
view plaincopy
template <class T>
class Iterator_Traits<T *>
{
public:
typedef T value_type;
};
template <class T>
class Iterator_Traits<const T *>
{
public:
typedef T value_type;
};
因此,模板编程中的Traits技术,其实就是“萃取”出变量类型。
还可以写一个辅助函数:
[c-sharp]
view plaincopy
template <class Iter>
Iterator_Traits<Iter> value_type(Iter iter)
{
return static<Iterator_Traits<Iter>::value_type*>(0);
}
这样,我们在写程序的时候,可以把程序写成两层:
[c-sharp]
view plaincopy
// 第一层
template <class Iter>
void Function(Iter I)
{
_Function(I, value_type(I));
}
// 第二层: 根据不同的数据类型,做不同的处理
template <class Iter>
void _Function(Iter I, int)
{
// ....
}
template <class Iter>
void _Function(Iter I, char)
{
// ....
}
概述:
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
[b]{
...[/b]
void clone(T* pObj)
[b] {[/b]
if (isClonable)
[b] {[/b]
pObj->clone();
[b] }[/b]
else
[b] {[/b]
//... non-Clonable algorithm ...
}
[b] }
};[/b]
但是只要你测试一下,这段代码不能通过编译.为什么会这样呢?原因很简单:对于没有实现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; }
[b]};[/b]
// Solving the problem of choosing method to call by inner traits class
template <typename T,
bool isClonable>
class XContainer
[b]{[/b]
public:
enum {Clonable = isClonable};
void clone(T* pObj)
[b] {[/b]
Traits<isClonable>().clone(pObj);
[b] }[/b]
template <bool flag>
class Traits
[b] {
};[/b]
template <>
class Traits<true>
[b] {[/b]
public:
void clone(T* pObj)
[b] {[/b]
cout << "before cloning Clonable type" << endl;
pObj->clone();
cout << "after cloning Clonable type" << endl;
[b] }
};[/b]
template <>
class Traits<false>
[b] {[/b]
public:
void clone(T* pObj)
[b] {[/b]
cout << "cloning non Clonable type" << endl;
[b] }
};
};[/b]
void main()
[b]{[/b]
int* p1 = 0;
CComplexObject* p2 = 0;
XContainer<int, false>
n1;
XContainer<CComplexObject, true>
n2;
n1.clone(p1);
n2.clone(p2);
[b]}[/b]
编译运行一下,上面的程序输出如下的结果:
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; }
[b]};[/b]
class CDerivedComplexObject : public CComplexObject // a demo derived class
{
public:
virtual void clone() { cout << "in derived clone"
<< endl; }
[b]};[/b]
// A general edtion of Traits
template <typename T>
struct Traits
[b]{[/b]
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>
[b]{[/b]
typedef __xtrue_type has_clone_method;
[b]};[/b]
template <typename T>
class XContainer
[b]{[/b]
template <typename flag>
class Impl
[b] {
};[/b]
template <>
class Impl <__xtrue_type>
[b] {[/b]
public:
void clone(T* pObj)
[b] {[/b]
pObj->clone();
[b] }
};[/b]
template <>
class Impl <__xfalse_type>
[b] {[/b]
public:
void clone(T* pObj)
[b] {
}
};[/b]
public:
void clone(T* pObj)
[b] {[/b]
Impl<Traits<T>::has_clone_method>().clone(pObj);
[b] }
};[/b]
void main()
[b]{[/b]
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);
[b]}[/b]
现在,所有基本类型以及CComplexObject类系都可以用于XContainer了.
结语:
看到这里,你或许会说,traits不过如此,还以为是什么高深的玩意呢!其实技术就是这样,说白了都很Easy,关键是怎么将他们用于实际,为实际的Designing/Development服务.毕竟,在IT领域,不能应用于实际的技术是没有价值的.
http://www.cppblog.com/woaidongmao/archive/2008/11/09/66387.html
由于C++不支持type_of,所以Traits技术,实际上就是通过通过模板中的类型推导机制,获取到变量的类型,以其在编译器确定函数的调用。STL中的迭代器就广泛的运用到该技术。下面是一个简单的例子:
凡是一个迭代器,我们总是希望能够知道它所指的数据的数据类型,我们可以这样做:
[c-sharp]
view plaincopy
template <class T>
class Iterator
{
public:
typedef typename T::value_type value_type;
// ...
};
当然,这需要我们用到迭代器的类,定义一个value_type,否则会编译不过。
然后,无论我们在什么地方用到迭代器,我们总是可以知道它所指的数据类型:
[c-sharp]
view plaincopy
Iterator::value_type value;
但是这样的写法有一个缺陷,就是:指针也是一种迭代器,但是却不是类,因此我们便无法得知指针指向的是什么元素。为此引入Traits技术,在原来的迭代器类上面再加一层:
[c-sharp]
view plaincopy
template <class Iter>
class Iterator_Traits
{
public:
typedef typename Iter::value_type value_type;
};
这样,我们就可以得知一个迭代器所指的类型:
[c-sharp]
view plaincopy
Iterator_Traits<Iterator>::value_type value;
而对于指针,可以使用模板中的偏特化技术:
[c-sharp]
view plaincopy
template <class T>
class Iterator_Traits<T *>
{
public:
typedef T value_type;
};
template <class T>
class Iterator_Traits<const T *>
{
public:
typedef T value_type;
};
因此,模板编程中的Traits技术,其实就是“萃取”出变量类型。
还可以写一个辅助函数:
[c-sharp]
view plaincopy
template <class Iter>
Iterator_Traits<Iter> value_type(Iter iter)
{
return static<Iterator_Traits<Iter>::value_type*>(0);
}
这样,我们在写程序的时候,可以把程序写成两层:
[c-sharp]
view plaincopy
// 第一层
template <class Iter>
void Function(Iter I)
{
_Function(I, value_type(I));
}
// 第二层: 根据不同的数据类型,做不同的处理
template <class Iter>
void _Function(Iter I, int)
{
// ....
}
template <class Iter>
void _Function(Iter I, char)
{
// ....
}
概述:
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
[b]{
...[/b]
void clone(T* pObj)
[b] {[/b]
if (isClonable)
[b] {[/b]
pObj->clone();
[b] }[/b]
else
[b] {[/b]
//... non-Clonable algorithm ...
}
[b] }
};[/b]
但是只要你测试一下,这段代码不能通过编译.为什么会这样呢?原因很简单:对于没有实现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; }
[b]};[/b]
// Solving the problem of choosing method to call by inner traits class
template <typename T,
bool isClonable>
class XContainer
[b]{[/b]
public:
enum {Clonable = isClonable};
void clone(T* pObj)
[b] {[/b]
Traits<isClonable>().clone(pObj);
[b] }[/b]
template <bool flag>
class Traits
[b] {
};[/b]
template <>
class Traits<true>
[b] {[/b]
public:
void clone(T* pObj)
[b] {[/b]
cout << "before cloning Clonable type" << endl;
pObj->clone();
cout << "after cloning Clonable type" << endl;
[b] }
};[/b]
template <>
class Traits<false>
[b] {[/b]
public:
void clone(T* pObj)
[b] {[/b]
cout << "cloning non Clonable type" << endl;
[b] }
};
};[/b]
void main()
[b]{[/b]
int* p1 = 0;
CComplexObject* p2 = 0;
XContainer<int, false>
n1;
XContainer<CComplexObject, true>
n2;
n1.clone(p1);
n2.clone(p2);
[b]}[/b]
编译运行一下,上面的程序输出如下的结果:
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; }
[b]};[/b]
class CDerivedComplexObject : public CComplexObject // a demo derived class
{
public:
virtual void clone() { cout << "in derived clone"
<< endl; }
[b]};[/b]
// A general edtion of Traits
template <typename T>
struct Traits
[b]{[/b]
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>
[b]{[/b]
typedef __xtrue_type has_clone_method;
[b]};[/b]
template <typename T>
class XContainer
[b]{[/b]
template <typename flag>
class Impl
[b] {
};[/b]
template <>
class Impl <__xtrue_type>
[b] {[/b]
public:
void clone(T* pObj)
[b] {[/b]
pObj->clone();
[b] }
};[/b]
template <>
class Impl <__xfalse_type>
[b] {[/b]
public:
void clone(T* pObj)
[b] {
}
};[/b]
public:
void clone(T* pObj)
[b] {[/b]
Impl<Traits<T>::has_clone_method>().clone(pObj);
[b] }
};[/b]
void main()
[b]{[/b]
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);
[b]}[/b]
现在,所有基本类型以及CComplexObject类系都可以用于XContainer了.
结语:
看到这里,你或许会说,traits不过如此,还以为是什么高深的玩意呢!其实技术就是这样,说白了都很Easy,关键是怎么将他们用于实际,为实际的Designing/Development服务.毕竟,在IT领域,不能应用于实际的技术是没有价值的.
相关文章推荐
- C++ operator关键字(重载操作符)
- Java JNI调用c/c++程序
- c语言实现快速排序
- 减少C++代码编译时间的方法
- C语言函数调用模型[调用过程中在堆栈中的出栈、进栈顺序]
- C/C++快速入门图形化教学法简介(目录)
- libcurl在vs2013下C++项目中的编译连接
- C语言---函数返回局部变量
- C++获取系统时间
- VS工程中添加c/c++工程中外部头文件及库的基本步骤
- 《C++入门经典(第4版)》之C++编程总结
- POJ C++程序设计 编程题#1 编程作业—STL2
- 通过指针引用字符串
- c++学习笔记
- C++站点
- 【华为上机试题C++】老师想知道从某某同学当中,分数最高的是多少,现在请你编程模拟老师的询问。当然,老师有时候需要更新某位同学的成绩.
- 【转】c++编译原理
- c++对txt文件的读取与写入
- C++中的内联函数inline总结
- 讲解C++的do while循环和循环语句的嵌套使用方法