代码规范_4：c++ _模板

函数模板

基础

template <typename T>
T Add(T t1,T t2){
return t1+t2;
}

template <typename T1, typename T2>
T1 Add(T1 t1,T2 t2){
return t1+t2;
}

int main(int argc, char *argv[])
{
cout<< Add(1,3) <<endl;
cout<< Add(1.3,4) <<endl;
}

模板的重载

##include <iostream>
using namespace std;

template <typename Any> //原始模板函数
void Swap(Any &a, Any &b);

template <typename Any> //新模板函数
void Swap(Any *a, Any *b， int n);

void Show(int a[]);
const int Lim=8;

int main()
{
int i=10, j=20;
cout<<"i ,j=" << i << "," << j << ".\n";
cout<<"Using int swapper : \n";
Swap(i,j); //原始模板的匹配
cout<<"Now i, j= " << i<< "," << j <<".\n";

int d1[Lim]={0,7,0,4,1,7,7,6};
int d2[Lim]={0,6,0,4,1,7,7,6};
cout<<"Original arrays: \n";
Show(d1);
Show(d2);
Swap(d1,d2,Lim);
cout << "Swapper array: \n";
Show(d1);
Show(d2);

return 0;
}

显示具体化

struct job
{
char name[40];
double salary;
int floor;
};
// 非模板
void swap（job &， job &）
//模板
template <typename Any>
void Swap(Any &, Any &);
//显示模板
template <> void Swap<job>(job& ,job&)

template <> void Swap<job>(job& j1 ,job& j2)
{
double t1;
int t2;
t1=j1.salary;
j1.salary=j2.salary;
j2.salary=t1;
j1.floor=j2.floor;
j2.frool=t2;
}

实例化和具体化

template void Swap<int> (int ,int); //实例化

函数模板的补充

template<typename T> void f(T*) {...}
template<typename T> void g(void (*pf) (T*)){}
//
g<int>(&f<int>)

类模板

基础

template <typename T>
class Stack
{
private:
enum {MAX=10};
T items[MAX];
int top;

public:
Stack();
bool isempty();
bool isfull();
bool push (const T & item);
bool pop(T &item);

};

template <typename T>
Stack<T>::Satck()
{...}

template <typename T>
bool Stack<T>::push(const Type &item)
{...}

// 使用类模板

int  main()
{
Stack(std::string) st;
}

模板的参数

无类型模板参数

//指定一个无类型模板的参数为其基础数组的大小
template<class T, size_t N> class Stack{
T data
;
size_t count;
public:
void push(const T& t);
};

Stack<int, 100>myFixedStack;

//Stack<int, 100>和Stack<int, 99>是两个不同的类

默认模板参数

template<class T， size_t N=100 > class Stack{
T data
;
size_t count;
public:
void push(const T& t);
};

//默认
template<class T=int， size_t N=100 > class Stack{

//函数模板不可以使用默认的模板参数，可以用模板参数作为普通函数的默认参数

模板类型的模板参数

template<class T>
class Array
{.......};

template<class T,template<class> class Seq>
或者
template<class T,template<class U> class Seq>

tempalte<class T,size_t N> class Array{...}

template<class T, size_t N, template<class , size_t> class seq>

模板的特化

template<>
const char* const& min <const char*>
(const char* const&a, const char* const &b)

模板的半特化

[cpp] view plain copy
template<typename T1, typename T2>
class Test
{
public:
Test(T1 i,T2 j):a(i),b(j){cout<<"模板类"<<endl;}
private:
T1 a;
T2 b;
};

template<>
class Test<int , char>
{
public:
Test(int i, char j):a(i),b(j){cout<<"全特化"<<endl;}
private:
int a;
char b;
};

template <typename T2>
class Test<char, T2>
{
public:
Test(char i, T2 j):a(i),b(j){cout<<"偏特化"<<endl;}
private:
char a;
T2 b;
};

//main函数

Test<double , double> t1(0.1,0.2);
Test<int , char> t2(1,'A');
Test<char, bool> t3('A',true);

//模板函数只可以全特化
template<typename T1, typename T2>
void fun(T1 a , T2 b)
{
cout<<"模板函数"<<endl;
}

//全特化
template<>
void fun<int ,char >(int a, char b)
{
cout<<"全特化"<<endl;
}

//函数不存在偏特化：下面的代码是错误的
/*
template<typename T2>
void fun<char,T2>(char a, T2 b)
{
cout<<"偏特化"<<endl;
}

模板元