STl-traits编程技巧

STl-traits编程技巧

无论是泛型思想或者是STL（标准库）的实际运用，迭代器(iterators)都扮演着重要的作用。STL的中心思想是：将容器和算法分开，彼此独立设计，最后再讲他们融合在一起。

容器和算法的泛型设计并不难，使用C++的类模板(class tempalte)和成员模板(function template)就能完成。

但要是将两者融合在一起，你还需要掌握一些其他的技巧，比如成员模板的参数推导，声明内置类型，还有最重要的偏特化技巧。

要提取变量的类型，我们先使用函数模板的参数推导

template< class T, class U>
void func_impl(T t, U u) {
   U temp;
}

template< class T>
void func(T t) {
	func_impl(t, *t);

}

这里是以func为对外的接口，实际操作在func_impl里面,这样的话可以由一个类型推导出多个相关的类型，还实现了较好的封装性。

因为模板(class template)只能推导参数，不能推导函数的返回类型，我们需要其他的技巧，声明内置类型就是一种不错的方法。

#include<iostream>
using namespace std;

template<class T>
class MyIter
{
public:
	typedef T value_type;//声明内嵌类型
	T *ptr;

	MyIter(T *p=0):ptr(p)
	{
	}

	T& operator*()const
	{
		return *ptr;
	}
};

template<class I>
typename I::value_type func(I ite)//这里I是MyIter, 返回类型是MyIter<T>里面T的类型，也就是int,有了typename和value_type，我们可以让返回值是任何类型都可以
{
	return *ite; //*ite指向的是int类型，根据T& operator*()const决定返回的类型
}



void main()
{
	MyIter<int> ite(new int(8));
	cout<<func(ite)<<endl;
}

typename的意思是告诉编译器这是一个类型，这样才能顺利通过编译

但是这样只能接受类，不能接受内置的类型，举个例子

//===============不支持原生指针的版本===
#include<iostream>
using namespace std;

template<class T>
class MyIter
{
public:
	typedef T value_type;//声明内嵌类型
	T *ptr;

	MyIter(T *p=0):ptr(p)
	{
	}

	T& operator*()const
	{
		return *ptr;
	}
};

template<class I>
typename I::value_type func(I ite)//这里I是MyIter, 返回类型是MyIter<T>里面T的类型，也就是int,有了typename和value_type，我们可以让返回值是任何类型都可以
{
	return *ite; //*ite指向的是int类型，根据T& operator*()const决定返回的类型
}



void main()
{
	int *p=new int(5);
	MyIter<int> ite(p);
	cout<<func(p)<<endl;//错误,因为p没有value_type类型，在func的返回处typename I::value_type出错,因为不存在
}

使用原生的指针就会出错。

这个时候我们需要偏特化技术

//=============================偏特化和traits提取特性

#include<iostream>
using namespace std;

template<class T>
class MyIter
{
public:
	typedef T value_type;//声明内嵌类型
	T *ptr;

	MyIter(T *p=0):ptr(p)
	{
	}

	T& operator*()const
	{
		return *ptr;
	}
};

template<class I>
struct iterator_trait{
	typedef typename I::value_type value_type;//提取出内嵌类型
};

//偏特化版本
template<class T>
struct iterator_trait<T*>
{
	typedef T value_type;//为了支持原生指针,即int等
};


template<class I>
typename iterator_trait<I>::value_type 
func(I ite)
{
	return *ite;
}


void main()
{
	int *p=new int(8);
	MyIter<int> ite(p);
	cout<<func(ite)<<endl;
}

这里的traits指的是就是提取去类里面的内置类型或者偏特化版本的内置类型

最后还是一个问题，还要设计一个指向常数对象的指针版本

//=======================带指向常对象的指针
#include<iostream>
using namespace std;

template<class T>
class MyIter
{
public:
	typedef T value_type;//声明内嵌类型
	T *ptr;

	MyIter(T *p=0):ptr(p)
	{
	}

	T& operator*()const
	{
		return *ptr;
	}
};

template<class I>
struct iterator_trait{
	typedef typename I::value_type value_type;//提取出内嵌类型
};

//偏特化版本
template<class T>
struct iterator_trait<T*>
{
	typedef T value_type;//为了支持原生指针,即int等
};

//针对指向常数对象的指针的偏特化版本
template<class T>
struct iterator_trait<const T*>
{
	typedef T value_type;
};



template<class I>
typename iterator_trait<I>::value_type 
func(I ite)
{
	return *ite;
}


void main()
{
	int *p=new int(8);
	const int c=7;
	const int*r=&c;
	MyIter<int> ite(p);
	cout<<func(r)<<endl;
}