萃取（traits）

#include<iostream>
using namespace std;

template<class T>
struct MyIter
{
	typedef T value_type;//先声明一个内嵌类型
	T* ptr;
	MyIter(T *p):ptr(p)
	{}
	T& operator*()const
	{return *ptr;}
};
template<class I>
typename I::value_type func(I ite)//typename告诉编译器这是一个类型
{
	return *ite;	
}	
void main()
{
	MyIter<int> ite(new int(10));//ite是迭代器类型，T为int类型
	cout<<func(ite)<<endl;//可得I为迭代器类型，调用value_type（为int类型）则可返回int值
}

//并不是所有迭代器都是class type,struct type(自定义的类)这种类型，如果是int类型就不能为它定义一个内嵌类型
//但是STL绝对必须接受原生指针作为一个迭代器，因此上述这种做法是不够的，必须得对原生指针做出特殊化处理即模板的偏特化

class CInt
{
public:
	CInt()
	{
		for(int i = 0;i<10;i++)
		{
			value[i]=i+1;
		}
	}
	int GetSum()const
	{
		int sum = 0;
		for(int i=0;i<10;i++)
		{
			sum += value[i];
		}
		return sum;
	}
private:
	int value[10];
};

class CFloat
{
public:
	CFloat()
	{
		for(int i = 0;i<10;i++)
		{
			value[i]=i+1.01;
		}
	}
	float GetSum()const
	{
		float sum = 0.0f;
		for(int i=0;i<10;i++)
		{
			sum += value[i];
		}
		return sum;
	}
private:
	float value[10];
};

//萃取 （模板的特化）
template<class T>
struct NumTraits
{};

template<>
struct NumTraits<CInt>//对上面模板进行特化
{
	typedef int return_type;//return_type返回值类型名字必须一致
};
template<>
struct NumTraits<CFloat>//对上面模板进行特化
{
	typedef float return_type;//return_type返回值类型名字必须一致
};

///
template<class T>
class CApply
{
	//typename typedef NumTraits<T>::return_type return_type;
public:
	CApply(T &r):ref(r)
	{}
	/*
	int GetSum()const//结果只能返回整型，除非改变返回类型
	{
		return ref.GetSum();
	}*/
	typename NumTraits<T>::return_type GetSum()const//根据T来萃取return_type
	{return ref.GetSum();}
private:
	T &ref;
};
void main()
{
	CInt ci;
	CFloat cf;
	//cout<<ci.GetSum()<<endl;
	//cout<<cf.GetSum()<<endl;
	CApply<CFloat> ca(cf);
	cout<<ca.GetSum()<<endl;//结果返回整型?
}