初步C++类模板学习笔记

类模板

实现：在上课时间的定义给它的一个或多个参数，这些参数代表了不同的数据类型。 -->抽象的类。

在调用类模板时, 指定參数, 由编译系统依据參数提供的数据类型自己主动产生对应的模板类 -->详细的类。

类模板的定义

C++的类模板的写法例如以下:

template <类型參数表>        //类型參数表的写法就是:class 类型參数1, class 类型參数2, …
class 类模板名
{
成员函数和成员变量
};

类模板里的成员函数, 如在类模板外面定义时,

template <型參数表>
返回值类型 类模板名<类型參数名列表>::成员函数名(參数表)
{
……
}

用类模板定义对象的写法例如以下:

类模板名 <真实类型參数表> 对象名(构造函数实际參数表);

假设类模板有无參构造函数, 那么也能够仅仅写:

类模板名 <真实类型參数表> 对象名;

举例：

template <class T1, class T2>
class Pair{
public:
T1 key;  //keyword
T2 value;  //值
Pair(T1 k,T2 v):key(k),value(v) { };
bool operator < (const Pair<T1,T2> & p) const;
};

template<class T1,class T2>    //在类外定义 Pair的成员函数 operator <
bool Pair<T1,T2>::operator<( const Pair<T1, T2> & p) const
{ return key < p.key; }

Pair类模板的使用:

int main()
{
Pair<string, int> student("Tom",19);
//实例化出一个类 Pair<string, int>
cout << student.key << " " << student.value;
return 0;

｝

函数模版作为类模板成员

#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被实例化
return 0;
}

类模板与非类型參数

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;

注意:

CArray<int,40>和CArray<int,50>全然是两个类

这两个类的对象之间不能互相赋值

类模板与继承

普通类从模板类派生

template <class T>
class A { T v1;  int n; };
class B:public A<int> { double v;  };// 类A是个类模板。A<int>是模板类
int main() {
B obj1;
return 0;
}

类模板从模板类派生

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; return 0;

}

类模板A ->实例化 模板类A<int,double> ->派生 类模板B ->实例化 模板类B<char>

此时B中有成员

｛

int v1;

double v2;

T v;

｝

类模板从普通类派生

class A {  int v1; };

template <class T>
class B:public A  { T v; };
int main() {
B<char> obj1;
return 0;
}

没什么可说的。在继承A的基础上添加了T类型的成员。

类模板从类模板派生

#include <iostream>
using namespace std;
template <class T1, class T2>
class A
{
public:
T1 v1; T2 v2;
};

template <class T1, class T2>
class B:public A<T1,T2>
{
public:
T1 v3; T2 v4;
};

int main()
{
B<int,double> b;
B<int,double> *pb = &b;
b.v1 = 1;
b.v3 = 3;
b.v2 = 2.2;
b.v4 = 4.4;
cout << pb->v1<<endl;
cout << pb->v2<<endl;
cout << pb->v3<<endl;
cout << pb->v4<<endl;

return 0;
}

要保证当给类模板B实例化的时候。类模板A也随之完毕类型T的实例化。

B<int,double> b 时，B有自身的成员int v3 、double v4 也有继承A<int，double>的成员int v1 和 double v2