类模板成员函数
可以写在类模板定义中{}。那么这种写在类模板定义中的成员函数会被隐式声明为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;
}
|