C++函数模板&类模板
文章目录
一、函数模板
1.函数模板的定义
template <class 类型参数1，class 类型参数2,……>
返回值类型 模板名 (形参表) {
函数体
};
2.函数模板的实例化
-
通过参数实例化：
-
交换两个变量函数模板：
template <class T> void Swap(T &x, T &y) { T tmp = x; x = y; y = tmp; } int main() { int n = 1, m = 2; Swap(n, m); //编译器自动生成 void Swap(int & ,int & )函数 double f = 1.2, g = 2.3; Swap(f, g); //编译器自动生成 void Swap(int & ,int & )函数 return 0; } -
编译器自动生成 void Swap(int & ,int & )函数
void Swap(int &x, int &y) { int tmp = x; x = y; y = tmp; } -
编译器自动生成 void Swap(int & ,int & )函数
void Swap(double &x, double &y) { double tmp = x; x = y; y = tmp; }
-
-
不通过参数实例化：
直接调用函数名<类型参数列表>(参数列表)#include <iostream> using namespace std; template <class T> T Inc(T n) { return 1 + n; } int main() { cout << Inc<double>(4) / 2; //输出 2.5 return 0; }
3.函数模板的重载
函数模板可以重载，只要它们的形参表或类型参数表不同即可。
template <class T1, class T2>
void print(T1 arg1, T2 arg2)
{
cout << arg1 << " " << arg2 << endl;
}
template <class T>
void print(T arg1, T arg2)
{
cout << arg1 << " " << arg2 << endl;
}
template <class T, class T2>
void print(T arg1, T arg2)
{
cout << arg1 << " " << arg2 << endl;
}
4.函数模板和函数的次序
在有多个函数和函数模板名字相同的情况下，编译器如下处理一条函数调用语句：（匹配模板函数时，不进行类型自动转换）
-
- 先找参数完全匹配的普通函数(非由模板实例化而得的函数)。
-
- 再找参数完全匹配的模板函数。
-
- 再找实参数经过自动类型转换后能够匹配的普通函数。
-
- 上面的都找不到，则报错。
5.函数模板示例：Map
-
代码：
#include <iostream> using namespace std; template <class T, class Pred> void Map(T s, T e, T x, Pred op) { for (; s != e; ++s, ++x) { *x = op(*s); } } int Cube(int x) { return x * x * x; } double Square(double x) { return x * x; } int a[5] = { 1, 2, 3, 4, 5}, b[5]; double d[5] = { 1.1, 2.1, 3.1, 4.1, 5.1}, c[5]; int main() { Map(a, a + 5, b, Square); for (int i = 0; i < 5; ++i) cout << b[i] << ","; cout << endl; Map(a, a + 5, b, Cube); for (int i = 0; i < 5; ++i) cout << b[i] << ","; cout << endl; Map(d, d + 5, c, Square); for (int i = 0; i < 5; ++i) cout << c[i] << ","; cout << endl; return 0; } -
输出：
1,4,9,16,25,
1,8,27,64,125,
1.21,4.41,9.61,16.81,26.01, -
实例化：
Map(a, a + 5, b, Square); //实例化出以下函数: void Map(int *s, int *e, int *x, double (*op)(double)) { for (; s != e; ++s, ++x) { *x = op(*s); } }
二、类模板
1.类模板的定义
-
类模板：
在定义类的时候，加上一个/多个类型参数。在使用类模板时，指定类型参数应该如何替换成具体类型，编译器据此生成相应的模板类。
-
模板类的写法：
template <class 类型参数1，class 类型参数2，……> //类型参数表 class 类模板名 { 成员函数和成员变量 }; -
类模板里成员函数的写法：
template <class 类型参数1，class 类型参数2，……> //类型参数表 返回值类型 类模板名<类型参数名列表>::成员函数名（参数表） { …… } -
用类模板定义对象的写法：
编译器由类模板生成类的过程叫类模板的实例化。由类模板实例化得到的类，叫模板类。类模板名 <真实类型参数表> 对象名(构造函数实参表);-
同一个类模板的两个模板类是不兼容的：
Pair<string,int> * p; Pair<string,double> a; p = & a; //wrong
-
-
类模板示例： Pair类模板：
template <class T1, class T2> class Pair { public: T1 key; //关键字 T2 value; //值 Pair(T1 k, T2 v) : key(k), value(v){ }; bool operator<(const Pair<T1, T2> &p) const; }; template <class T1, class T2> bool Pair<T1, T2>::operator<(const Pair<T1, T2> &p) const //Pair的成员函数 operator < { return key < p.key; } int main() { Pair<string, int> student("Tom", 19); //实例化出一个类 Pair<string,int> cout << student.key << " " << student.value; return 0; }输出：
Tom 19
2.函数模版作为类模板成员
#include <iostream>
using namespace std;
template <class T>
class A
{
public:
template <class T2>
void Func(T2 t) {
cout << t; } //成员函数模板
};
int main()
{
A<int> a;
a.Func('K'); //成员函数模板 Func被实例化
a.Func("hello"); //成员函数模板 Func再次被实例化
return 0;
}
输出：KHello
3.类模板与非类型参数
-
类模板的“<类型参数表>”中可以出现非类型参数：
template <class T, int size> class CArray { T array[size]; public: void Print() { for (int i = 0; i < size; ++i) cout << array[i] << endl; } }; CArray<double, 40> a2; CArray<int, 50> a3; //a2和a3属于不同的类
4.类模板与派生
-
类模板从类模板派生
-
基类A：
template <class T1, class T2> class A { T1 v1; T2 v2; }; -
派生类B：
template <class T1, class T2> class B : public A<T2, T1> { T1 v3; T2 v4; }; -
B<int,double> obj1;的实例化class B<int,double>: public A<double,int> { int v3; double v4; };class A<double, int> { double v1; int v2; };
-
-
类模板从模板类派生
template <class T1, class T2> class A { T1 v1; T2 v2; }; template <class T> class B : public A<int, double> { T v; }; int main() { B<char> obj1; //自动生成两个模板类：A<int,double> 和 B<char> return 0; } -
类模板从普通类派生
class A { int v1; }; template <class T> class B : public A { //所有从B实例化得到的类，都以A为基类 T v; }; int main() { B<char> obj1; return 0; } -
普通类从模板类派生
template <class T> class A { T v1; int n; }; class B : public A<int> { double v; }; int main() { B obj1; return 0; }
5.类模板与友元
-
函数、类、类的成员函数作为类模板的友元
void Func1() { } class A { }; class B { public: void Func() { } }; template <class T> class Tmpl { friend void Func1(); friend class A; friend void B::Func(); }; //任何从Tmp1实例化来的类，都有以上三个友元 -
函数模板作为类模板的友元
任意从
template <class T1,class T2>
ostream & operator<< (ostream & o,const Pair<T1,T2> & p)
生成的函数，都是任意Pair摸板类的友元#include <iostream> #include <string> using namespace std; template <class T1, class T2> class Pair { private: T1 key; //关键字 T2 value; //值 public: Pair(T1 k, T2 v) : key(k), value(v){ }; bool operator<(const Pair<T1, T2> &p) const; template <class T3, class T4> friend ostream &operator<<(ostream &o, const Pair<T3, T4> &p); }; template <class T1, class T2> bool Pair<T1, T2>::operator<(const Pair<T1, T2> &p) const { //"小"的意思就是关键字小 return key < p.key; } template <class T1, class T2> ostream &operator<<(ostream &o, const Pair<T1, T2> &p) { o << "(" << p.key << "," << p.value << ")"; return o; } int main() { Pair<string, int> student("Tom", 29); Pair<int, double> obj(12, 3.14); cout << student << " " << obj; return 0; }输出：
(Tom,29) (12,3.14) -
函数模板作为类的友元
所有从template <class T>
void Print(const T & p)
生成的函数，都成为 A 的友元
但是自己写的函数
void Print(int a) { }
不会成为A的友元#include <iostream> using namespace std; class A { int v; public: A(int n) : v(n) { } template <class T> friend void Print(const T &p); }; template <class T> void Print(const T &p) { cout << p.v; } int main() { A a(4); Print(a); return 0; }
输出：
4
-
类模板作为类模板的友元
A< double>类，成了B<int>类的友元。
任何从A模版实例化出来的类，都是任何B实例化出来的类的友元#include <iostream> using namespace std; template <class T> class B { T v; public: B(T n) : v(n) { } template <class T2> friend class A; }; template <class T> class A { public: void Func() { B<int> o(10); cout << o.v << endl; } }; int main() { A<double> a; a.Func(); return 0; }输出：
10
6.类模板与静态成员变量
类模板中可以定义静态成员，那么从该类模板实例化得到的所有类，都包含同样的静态成员。
#include <iostream>
using namespace std;
template <class T>
class A
{
private:
static int count;
public:
A() {
count++; }
~A() {
count--; };
A(A &) {
count++; }
static void PrintCount() {
cout << count << endl; }
};
template <>
int A<int>::count = 0;
template <>
int A<double>::count = 0;
int main()
{
A<int> ia;
A<double> da;
ia.PrintCount();
da.PrintCount();
return 0;
}
输出：
1
1