#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;//结果返回整型?
}
萃取(traits)
最新推荐文章于 2022-12-03 20:06:53 发布