类模板成员函数
可以写在类模板定义中{}。那么这种写在类模板定义中的成员函数会被隐式声明为inline函数。
一个实例化模板,它的成员函数只有在使用时才会被实例化
注意,浮点型不能做非类型模板参数
template<class T>
class FVector
{
public:
FVector();
typedef T* FIterator;
FVector& operator=(const FVector&);
private:
FIterator FBegin();
FIterator FEnd();
};
template <class T>
FVector<T>& FVector<T>::operator=(const FVector&)
{
return *this;
}
template<class T>
FVector<T>::FVector()
{
}
template <class T>
typename FVector<T>::FIterator FVector<T>::FBegin()
{
}
int main()
{
FVector<int> myvector;
return 0;
}
typename 目的是为了显式告诉编译器 FVector 是一个类型
用法2
template<class T>
typename T::size_type getlegth(const T &cc)
{
if (!cc.empty())
{
return cc.size();
}
return 0;
}
//函数指针当做参数传递
using funInt = int(*)(int, int);
int mf(int a, int b)
{
return a+b;
}
int ref(int a,int b,funInt ff)
{
return ff(a, b);
}
main: cout<<ref(2, 5, mf)<<endl;
模板写法
template <typename T,typename F>
void ttt(const T& a,const T& b,F fun)
{
cout<< fun(a,b)<<endl;
}
同时给模板参数和函数参数提供缺省值
class Test;
template <typename T,typename F = Test>
int ttt(const T& a,const T& b,F fun = F())
{
return fun(a, b);
}
class Test
{
public:
Test() {};
int operator()(int a,int b)
{
if (a>b)
{
return a;
}
else
{
return b;
}
}
};
int main()
{
int er = ttt(49, 5);
return 0;
}
普通类的成员函数模板
成员函数模板不可以是虚函数,否则会报错
类模板的成员函数模板
template<class T>
class Test2
{
public:
template<class R>
Test2(R a1,R a2)
{
}
};
main:Test2<int> tttt(5,7);
模板显式实例化
template <typename T>
class Tta
{
public:
Tta() { }
};
template Tta<int>;//实例化定义
using定义模板别名
template <typename T>
struct mys
{
typedef map<string, T> type;
};
template <typename T>
using type = map<string, T>;
类模板特化
泛化模板,可以随便指定类型
特化,对特殊类型进行特殊对待,写适合他的专用代码
只要存在特化,就一定存在泛化
全特化就是指的所有类型模板参数
template<typename T,typename U>
struct ct
{
void funtest()
{
cout << "泛化版本" << endl;
}
};
template<>//全特化
struct ct<int,int>
{
void funtest()
{
cout << "int,int 全特化" << endl;
}
};
//偏特化
template<typename T,typename U,typename F>
struct ct
{
void funtest()
{
cout << "泛化版本" << endl;
}
};
template<typename U>
struct ct<int,U,int>
{
void funtest()
{
cout << "int,int 偏特化" << endl;
}
};
//可变参数模板
template<typename ... T>
void fun6(T ... args)
{
cout<< sizeof ...(args) <<endl;
}
T 后带了。。。 称呼T:可变参数类型
args 称为一包或者一堆参数,参数类型各不相同,可变形参
template<typename T,typename ...U>
void fun7(const T & d1,const U&...d3)
{
cout << sizeof ...(d3) << endl;
}
可变参数包展开
void fun7()
{
cout << "end" << endl;
}
template<typename T,typename ...U>
void fun7(const T & d1,const U&...d3)
{
cout << "参数值:"<<d1 << endl;
fun7(d3...);
}
int main()
{
fun7(12,"123",1,412,6436,123123,"cc");
return 0;
}
可变参类模板(递归继承展开)
template<typename ... B>
class Ta1{};//主模板
template<typename A,typename ... B>
class Ta1<A,B...>:private Ta1<B...>
{
public:
Ta1():m1(0)
{
printf("this:%p \n",this);
}
A m1;
};
void funcc()
{
Ta1<int, float, double, int>mm;
}
可变参类模板(递归组合展开)
template<typename ...B>
class funcdemo
{
};
template<>
class funcdemo<>
{
};
template<typename A, typename ...B>
class funcdemo<A,B...>
{
public:
funcdemo():a(0)
{
cout << "111" << endl;
}
funcdemo(A a_f,B...b_f):a(a_f),m_o(b_f)
{
}
A a;
funcdemo<B...> m_o;
};
void funcc()
{
funcdemo<int, float, double> mm;
}
模板模板参数
template<
typename T,
template<class>class U //模板 模板参数
//template<typename C>typename W //模板 模板参数,同上,仅写法不同 C只是占位
>
class myc
{
public:
myc()
{
for (int i=0;i<10;i++)
{
myc1.push_back(it+i);
}
}
public:
T it;
U<T> myc1;//U作为类模板使用
//W<T> myc2;
};
template<typename T>
using mvector = vector<T, allocator<T>>;
void fun111()
{
myc<int, mvector> myVector;
}
int main()
{
fun111();
return 0;
}