12-
判断题
1-1 T
pair类模板的作用是将两个数据组成一个数据，用来表示一个二元组或一个元素对，两个数据可以是同一个类型也可以是不同的类型。
选择题
1.关于函数模板，描述错误的是。 A
A. 函数模板必须由程序员实例化为可执行的函数模板
B. 函数模板的实例化由编译器实现
C. 一个类定义中，只要有一个函数模板，则这个类是类模板
D. 类模板的成员函数都是函数模板，类模板实例化后，成员函数也随之实例化
2.下列的模板说明中，正确的是。 C
A. template < typename T1, T2 >
B. template < class T1, T2 >
C. template < typename T1, typename T2 >
D. template ( typedef T1, typedef T2 )
3.假设有函数模板定义如下：
template Max( T a, T b ,T &c)
{ c = a + b ; }
下列选项正确的是( B )。
A. int x, y; char z ;Max( x, y, z ) ;
B. double x, y, z ;Max( x, y, z ) ;
C. int x, y; float z ;Max( x, y, z );
D. float x; double y, z;Max( x, y, z ) ;
4.建立类模板对象的实例化过程为。 C
A. 基类-派生类
B. 构造函数-对象
C. 模板类-对象
D. 模板类-模板函数
5.模板函数的真正代码是在哪个时期产生的____。C
A.源程序中声明函数时
B.源程序中定义函数时
C.源程序中调用函数时
D.运行执行函数时
2-6类模板的模板参数____。D
A.只可作为数据成员的类型
B.可作为成员函数的返回类型
C.可作为成员函数的参数类型
D.以上三者皆可
2-7下列关于pair<>类模板的描述中，错误的是。 C
A.pair<>类模板定义头文件utility中
B.pair<>类模板作用是将两个数据组成一个数据，两个数据可以是同一个类型也可以是不同的类型
C.创建pair<>对象只能调用其构造函数
D.pair<>类模拟提供了两个成员函数first与second来访问这的两个数据
函数题
6-1 一个简单的队列类模板
6-1 一个简单的队列类模板
请按照下列简单的整数队列类创建一个简单的队列类模板。
整数队列类如下：
const int SIZE=100;
//整数队列类
class Queue {
int q[SIZE];
int front; //队列头
int rear; //队列尾
public:
Queue( )
{ front = rear = 0; }
void put(int i); // 在队尾放置一个数据
int get( ); // 从队列头部取一个数据
};
裁判测试程序样例：
在这里给出函数被调用进行测试的例子。例如：
#include <iostream>
#include <string>
using namespace std;
// 你提交的代码将嵌入到这里
int main()
{
Queue<int> a; // 创建一个整数队列
int m,n;
cin>>m>>n;
a.put(m);
a.put(n);
cout << a.get() << " ";
cout << a.get() << endl;
Queue<double> d; // 创建一个双精度浮点数队列
double x,y;
cin>>x>>y;
d.put(x);
d.put(y);
cout << d.get() << " ";
cout << d.get() << endl;
Queue<string> qs;// 创建一个字符串队列
string s1,s2,s3;
cin>>s1>>s2>>s3;
qs.put(s1);
qs.put(s2);
qs.put(s3);
cout << qs.get() << " ";
cout << qs.get() << " ";
cout << qs.get() << endl;
return 0;
}
输入样例：
6 9
3.14159 2.781828
ShenZhen Beijing HangZhou
输出样例：
6 9
3.14159 2.78183
const int SIZE = 100;
template <typename T> class Queue {
private:
T q[SIZE];
int front;
int rear;
public:
Queue() {
front = rear = 0;
}
void put(T i);
T get();
};
template <class T> void Queue<T> :: put(T i) {
if (front == SIZE)
exit(0);
rear++;
q[rear] = i;
}
template <class T>T Queue<T> :: get() {
if (rear == front)
return 0;
front++;
return q[front];
}
6-2 Max函数模板
6-2 Max函数模板
创建一个函数模板Max( ),该模板返回两个参数中的最大值，例如：
Max(3,4)返回4
Max('c','a')返回'c'
裁判测试程序样例：
#include <iostream>
#include <string>
using namespace std;
//你提交的代码将被嵌入到这里
int main( )
{
int m,n;
char c,d;
string s1,s2;
cin>>m>>n;
cin>>c>>d;
cin>>s1>>s2;
cout<<Max(m,n)<<endl;
cout<<Max(c,d)<<endl;
cout<<Max(s1,s2)<<endl;
return 0 ;
}
/* 请在这里填写答案 */
输入样例：
在这里填写一组输入
-21252 3
输出样例：
在这里填写相应的输出
3
template<class T> T Max(T x, T y) {
return x > y ? x : y;
}
6-3 创建函数模板实现求数组中的最小元素
6-3 创建函数模板实现求数组中的最小元素
创建一个函数模板实现求数组中的最小元素，在主函数将分别使用该模板求整形数组和double型数组中的最小元素并输出。
输入：
6 （整型数组中的元素个数）
8 3 4 1 6 9 （整型数组中的元素）
5 （双精度浮点数数组中的元素个数）
2.7 3.1 9.8 5.3 7.6 （双精度浮点数数组中的元素）
输出：
1
2.7
函数模板接口定义：
T Min(T *p, int len)
其中 p 和 len 都是用户传入的参数。 p 是数组元素的起始地址； len 是数组的长度。
裁判测试程序样例：
#include <iostream>
using namespace std;
// 你提交的代码将嵌入到这里
int main( )
{
int n,m,*pn,i=0;
cin>>n;
pn=new int[n];
do{
cin>>pn[i];
i++;
}while(i<n);
double *pd;
i=0;
cin>>m;
pd=new double[m];
do{
cin>>pd[i];
i++;
}while(i<m);
cout<<Min(pn,n)<<endl;
cout<<Min(pd,m)<<endl;
delete [ ] pn;
delete [ ] pd;
return 0;
}
输入样例：
9
8 2 7 6 4 5 3 1 0
7
3.1 9.6 5.8 2.7 6.3 7.0 8.5
输出样例：
0
2.7
template<class T1, class T2> T1 Min(T1 *p, T2 len) {
int j;
T1 min = p[0];
for (j = 0; j < len; j++) {
if (p[j] < min)
min = p[j];
}
return min;
}
12+
单选题
2-1 C
在C++语言中设置虚基类的目的是（ ） 。
A.简化程序代码
B.提高程序的运行效率
C.解决多继承造成的二义性问题
D.缩短程序的目标代码
2-2 B
一个类的私有成员
A.只能被该类的成员函数访问
B.只能被该类的成员函数和友元函数访问
C.只能被该类的成员函数、友元函数和派生类访问
D.以上答案都不对
2-3 D
以下关于C++语言中继承的叙述中，错误的是（ ）。
A.继承是父类和子类之间共享数据和方法的机制
B.继承定义了一种类与类之间的关系
C.继承关系中的子类将拥有父类的全部属性和方法
D.继承仅仅允许单继承，即不允许一个子类有多个父类
2-4 D
下列关于类的继承描述中，( )是正确的。
A.派生类公有继承基类时，可以访问基类的所有数据成员，调用所有成员函数。
B.派生类也是基类，所以它们是等价的。
C.派生类对象不会建立基类的私有数据成员，所以不能访问基类的私有数据成员。
D.一个基类可以有多个派生类，一个派生类可以有多个基类。
2-5 A
关于类模板，描述错误的是。
A.一个普通基类不能派生类模板
B.类模板可以从普通类派生，也可以从类模板派生
C.根据建立对象时的实际数据类型，编译器把类模板实例化为模板类
D.函数的类模板参数需生成模板类并通过构造函数实例化
2-6 C
建立类模板对象的实例化过程为。
A.基类-派生类
B.构造函数-对象
C.模板类-对象
D.模板类-模板函数
2-7 D
下列有关模板的描述，错误的是____。
A.模板把数据类型作为一个设计参数，称为参数化程序设计
B.使用时，模板参数与函数参数相同，是按位置而不是名称对应的
C.模板参数表中可以有类型参数和非类型参数
D.类模板与模板类是同一个概念
2-8 B
假设有函数模板定义如下：
template
Max( T a, T b ,T &c)
{ c = a + b ; }
下列选项正确的是( )。
A.int x, y; char z ;Max( x, y, z ) ;
B.double x, y, z ;Max( x, y, z ) ;
C.int x, y; float z ;Max( x, y, z );
D.float x; double y, z;Max( x, y, z ) ;
函数题
6-1 编写一个函数模板Swap,实现两个变量交换。
6-1 编写一个函数模板Swap,实现两个变量交换。
编写一个函数模板Swap,实现两个变量交换。
函数模板实例化：
Swap( i, j );
：其中 i 和 j 都是用户传入的参数， i 和 j类型相同，但可以是任何数据类型。
裁判测试程序样例：
#include <iostream>
using namespace std;
//你提交的代码将被嵌入到这里
int main()
{
int i,j;
char m,n;
cin>>i>>j;
cin>>m>>n;
Swap(i,j);
Swap(m,n);
cout<<i<<' '<<j<<'\n';
cout<<m <<' '<<n<<endl;
return 0;
}
输入样例：
2 1
a c
输出样例：
1 2
template <typename T> void Swap(T &i,T &j){
T temp;
temp=i;
i=j;
j=temp;
}
6-2 编写一个函数模板 sort 实现选择法排序的功能
6-2 编写一个函数模板 sort 实现选择法排序的功能
编写一个函数模板 sort 实现选择法排序的功能。
函数模板实例化：
Mysort(a,m);
其中 a 和 n 都是用户传入的参数。 a 表示数组名； m 表示数组元素的个数。
裁判测试程序样例：
#include<iostream>
using namespace std;
//你提交的代码将被嵌入到这里
int main()
{
int m,n,a[20],i,j;
float b[20];
cin>>m;
for(i=0;i<m;i++)
cin>>a[i];
cin>>n;
for(j=0;j<n;j++)
cin>>b[j];
Mysort(a,m);
Mysort(b,n);
for(i=0;i<m;i++)
cout<<a[i]<<' ';
cout<<endl;
for(j=0;j<n;j++)
cout<<b[j]<<' ';
cout<<endl;
return 0;
}
输入样例：
在这里填写一组输入
6
1 4 2 6 3 5
5
1.5 1.2 1.1 1.3 1.4
输出样例：
在这里填写相应的输出
1 2 3 4 5 6
1.1 1.2 1.3 1.4 1.5
template <typename T>
void Mysort(T a[],int n){
int i=0,j;
for(i=0;i<n;i++){
int k=i;
for(j=i+1;j<n;j++){
if(a[k]>a[j]){
k=j;
}
}
if(i!=k){
T temp;
temp=a[i];
a[i]=a[k];
a[k]=temp;
}
}
}
6-3 一个简单的队列类模板
6-3 一个简单的队列类模板
请按照下列简单的整数队列类创建一个简单的队列类模板。
整数队列类如下：
const int SIZE=100;
//整数队列类
class Queue {
int q[SIZE];
int front; //队列头
int rear; //队列尾
public:
Queue( )
{ front = rear = 0; }
void put(int i); // 在队尾放置一个数据
int get( ); // 从队列头部取一个数据
};
裁判测试程序样例：
在这里给出函数被调用进行测试的例子。例如：
#include <iostream>
#include <string>
using namespace std;
// 你提交的代码将嵌入到这里
int main()
{
Queue<int> a; // 创建一个整数队列
int m,n;
cin>>m>>n;
a.put(m);
a.put(n);
cout << a.get() << " ";
cout << a.get() << endl;
Queue<double> d; // 创建一个双精度浮点数队列
double x,y;
cin>>x>>y;
d.put(x);
d.put(y);
cout << d.get() << " ";
cout << d.get() << endl;
Queue<string> qs;// 创建一个字符串队列
string s1,s2,s3;
cin>>s1>>s2>>s3;
qs.put(s1);
qs.put(s2);
qs.put(s3);
cout << qs.get() << " ";
cout << qs.get() << " ";
cout << qs.get() << endl;
return 0;
}
输入样例：
6 9
3.14159 2.781828
ShenZhen Beijing HangZhou
输出样例：
6 9
3.14159 2.78183
const int SIZE = 100;
template <typename T> class Queue {
private:
T q[SIZE];
int front;
int rear;
public:
Queue() {
front = rear = 0;
}
void put(T i);
T get();
};
template <class T> void Queue<T> :: put(T i) {
if (front == SIZE)
exit(0);
rear++;
q[rear] = i;
}
template <class T>T Queue<T> :: get() {
if (rear == front)
return 0;
front++;
return q[front];
}
6-4 数组排序输出（函数模板）
6-4 数组排序输出（函数模板）
对于输入的每一批数，按从小到大排序后输出。
一行输入为一批数，第一个输入为数据类型（1表示整数，2表示字符型数，3表示有一位小数的浮点数，4表示字符串，0表示输入结束），第二个输入为该批数的数量size（0<size<=10），接下来为size个指定类型的数据。
输出将从小到大顺序输出数据。
函数接口定义：sort函数将接受size个数据，将它们从小到大排序后存在a指向的一段连续空间中。
template <class T>
void sort(T *a, int size)；
裁判测试程序样例：
#include <iostream>
#include <string>
using namespace std;
/* 请在这里填写答案 */
template <class T>
void display(T* a, int size){
for(int i=0; i<size-1; i++) cout<<a[i]<<' ';
cout<<a[size-1]<<endl;
}
int main() {
const int SIZE=10;
int a[SIZE];
char b[SIZE];
double c[SIZE];
string d[SIZE];
int ty, size;
cin>>ty;
while(ty>0){
cin>>size;
switch(ty){
case 1:sort(a,size); display(a,size); break;
case 2:sort(b,size); display(b,size); break;
case 3:sort(c,size); display(c,size); break;
case 4:sort(d,size); display(d,size); break;
}
cin>>ty;
}
return 0;
}
输入样例：
1 3 3 2 1
2 2 a A
3 3 1.5 2.6 2.2
4 2 bca abc
0
输出样例：
1 2 3
A a
1.5 2.2 2.6
template <class T>
void sort(T *data,int size){
int i,j,min;
for(i=0;i<size;i++)
cin>>data[i];
for(i=0;i<size-1;i++){
min=i;
for(j=i+1;j<size;j++)
if(data[j]<data[min])
min=j;
if(min!=i){
T t=data[i];
data[i]=data[min];
data[min]=t;
}
}
}
