c++模板及应用习题答案

1.概念填空题

1.1 C++最重要的特性之一就是代码重用，为了实现代码重用，代码必须具有 通用性 。通用代码需要不受数据 类型 的影响，并且可以自动适应数据类型的变化。这种程序设计类型称为 参数化 程序设计。模板是C++支持参数化程序设计的工具，通过它可以实现参数化 多态性 性。

1.2函数模板的定义形式是template <模板参数表> 返回类型 函数名(形式参数表){…}。其中，<模板参数表>中参数可以有 多 个，用逗号分开。模板参数主要是 模板类型 参数。它代表一种类型，由关键字 typename 或 class 后加一个标识符构成，标识符代表一个潜在的内置或用户定义的类型参数。类型参数由可以是任意合法标识符。C++规定参数名必须在函数定义中至少出现一次。

1.3编译器通过如下匹配规则确定调用那一个函数：首先，寻找最符合 函数名 和 参数类型 的一般函数，若找到则调用该函数；否则寻找一个 函数模板 ，将其实例化成一个 模板函数 ，看是否匹配，如果匹配，就调用该 模板函数 ；再则，通过 类型转换 规则进行参数的匹配。如果还没有找到匹配的函数则调用错误。如果有多于一个函数匹配，则调用产生 二义性 ，也将产生错误。

1.4类模板使用户可以为类声明一种模式，使得类中的某些数据成员、某些成员函数的参数、某些成员函数的返回值能取 任意类型 （包括 系统预定类型 和 用户自定义的类型）。类是对一组对象的公共性质的抽象，而类模板则是对不同类的 数据类型？ 的抽象，因此类模板是属于更高层次的抽象。由于类模板需要一种或多种 类型 参数，所以类模板也常常称为 参数化类 。

2. 简答题

2.1简述函数模板生成函数的过程。 2.2 简述类模板生成对象的过程。

2.3 简述函数模板与模板函数、类模板与模板类的区别。

3. 选择题

3.1关于函数模板,描述错误的是（A ）。

A.函数模板必须由程序员实例化为可执行的函数模板 B.函数模板的实例化由编译器实现

C.一个类定义中,只要有一个函数模板,则这个类是类模板

D.类模板的成员函数都是函数模板,类模板实例化后,成员函数也随之实例化 3.2下列的模板说明中,正确的是（D ）。 A.template B.template

C.template D.template 3.3 函数模板定义如下:

template Max( T a, T b ,T &c){c=a+b;}

下列选项正确的是（B ）。

A. int x, y; char z; B.double x, y, z; Max(x, y, z); Max( x, y, z);

C.int x, y; float z; D.float x; double y, z；

Max( x, y, z); Max( x,y, z);

3.4 下列有关模板的描述错误的是(D)。

A． 模板把数据类型作为一个设计参数，称为参数化程序设计。

B． 使用时，模板参数与函数参数相同，是按位置而不是名称对应的。 C． 模板参数表中可以有类型参数和非类型参数。 D． 类模板与模板类是同一个概念。

3.5类模板的使用实际上是将类模板实例化成一个（C）。 A．函数 B．对象 C．类 D．抽象类 3.6类模板的模板参数（D）。

A．只能作为数据成员的类型 B．只可作为成员函数的返回类型

C．只可作为成员函数的参数类型 D．以上三种均可 3.7类模板的实例化（A）。

A．在编译时进行 B．属于动态联编

C．在运行时进行 D．在连接时进行 3.8以下类模板定义正确的为（A）。

A．template

4．编程题

4.1设计一个函数模板，其中包括数据成员T a[n]以及对其进行排序的成员函数 sort( )，模板参数T可实例化成字符串。

#include #include using namespace std;

templatevoid Sort(T* a,int n){

int i,j; T t;

for(i=0;i

for(j=0;ja[j+1])

B．template D．template

C．template

{ t=a[j];

a[j]=a[j+1]; a[j+1]=t; }

}

templatevoid Print(T* a,int n){ }

int i;

for(i=0;i

int main(){ string

Str[10]={\ }

4.2设计一个类模板，其中包括数据成员T a[n]以及在其中进行查找数据元素的函数int search(T)模板参数 T可实例化成字符串。 #include

using namespace std;

templateclass A{ int size; T* element; public: A(); ~A();

int Search(T);

void SetElement(int index,const T& value); };

templateA::A(){ size=n>1? n:1; element=new T[size]; }

templateA::~A(){ delete [] element; }

templateint A::Search(T t){ int i; }

for(i=0;i

return i;

return -1;

int Int[8]={20,12,0,-5,9,-18,6,11};

double Dou[7]={3.07,8.12,-0.45,6,10,-9,7.29}; Sort(Str,10); Sort(Int,8); Sort(Dou,7); Print(Str,10); Print(Int,8); Print(Dou,7); return 0;

templatevoid A::SetElement(int index,const T& value){ element[index]=value; }

int main(){ A intAry;

//用int实例化，建立模板类对象

}

A douAry;//用double实例化，建立模板类对象 int i;

for(i=0;i<5;i++)

intAry.SetElement(i,i+3); for(i=0;i<10;i++)

douAry.SetElement(i,(i+i)*0.35); i=intAry.Search(7); if(i>=0)cout<=0)cout<

4.3设计一个单向链表类模板，节点数据域中数据从小到大排列，并设计插入、删除节点的成员函数。

#include using namespace std;

templateclass List; templateclass Node{ T info; //数据域 Node *link; //指针域 public:

Node(); //生成头结点的构造函数 Node(const T & data);//生成一般结点的构造函数 friend class List; };

template Node::Node(){link=NULL;} template Node::Node(const T & data){ }

info=data; link=NULL;

//定义链表类

templateclass List{

Node *head; //链表头指针和尾指针 public:

List(); //构造函数，生成头结点(空链表) ~List(); //析构函数

void MakeEmpty(); //清空一个链表，只余表头结点

Node* Find(T data); //搜索数据域与data相同的结点，返回该结点的地址 void PrintList(); //打印链表的数据域 void InsertOrder(Node *p); //按升序生成链表

Node* CreatNode(T data); //创建一个结点(孤立结点)

Node* DeleteNode(Node* p); //删除指定结点 };

templateList::List(){

head=new Node(-9999);//头结点，最小的数据从小到大插入

}

templateList::~List(){ MakeEmpty(); delete head;

}

templatevoid List::MakeEmpty(){ }

Node *tempP;

while(head->link!=NULL){ }

tempP=head->link;

head->link=tempP->link; //把头结点后的第一个节点从链中脱离 delete tempP; //删除(释放)脱离下来的结点

template Node* List::Find(T data){ Node *tempP=head->link; }

while(tempP!=NULL && tempP->info!=data) tempP=tempP->link; return tempP; //搜索成功返回该结点地址，不成功返回NULL

templatevoid List::PrintList(){ Node* tempP=head->link; }

while(tempP!=NULL){ cout<info<<'\\t'; tempP=tempP->link; }

cout<

templatevoid List::InsertOrder(Node *p){ Node *tempP=head,*tempQ=head; //tempQ指向tempP前面的一个节点 while(tempP!=NULL){ }

templateNode* List::CreatNode(T data){//建立新节点 Node*tempP=new Node(data); }

return tempP; }

if(p->infoinfo)break; //找第一个比插入结点大的结点，由tempP指向 tempQ=tempP; tempP=tempP->link;

p->link=tempP; tempQ->link=p;

templateNode* List::DeleteNode(Node* p){ Node* tempP=head->link,*tempQ=head,*tempC; while(tempP!=NULL && tempP!=p){