C++ PTA习题总结（一）

第一章 C++概述

1.The cin stream normally is connected to the display screen. F
（cin流通常连接到显示屏上。）

2.使用提取符(<<)可以输出各种基本数据类型的变量的值，也可以输出指针值。T

3.C++对C语言作了很多改进，下列描述中（D）使得C语言发生了质变，从面向过程变成了面向对象。
A.增加了一些新的运算符；
B.允许函数重载，并允许设置缺省参数；
C.规定函数说明必须用原型；
D.引进了类和对象的概念;

4.cout 是由I/O 流库预定义的（ B）。
A.类
B.对象
C.包含文件
D.常量
5.计算圆的面积

从键盘输入圆的半径，计算圆的面积并输出。圆周率PI=3.1415926。
输入格式: 在这里写输入圆的半径，例如：
3.6
输出格式: 在这里输出圆的面积，例如：
40.715

#include<iostream>
using namespace std;
const float PI = 3.1415926;
int main() { 
	float r; 
	cin >> r; 
	cout << PI * r * r; 
	return 0;
}

6.问候

输出问候：Hello!What’s your name?
从键盘输入名字，然后输出欢迎信息。
输入格式:
请在这里写输入姓名。例如：
GaiFuShuai
输出格式:
请在这里描述输出，例如：
Hello!What’s your name?
GaiFuShuai,Welcome to learn OOP using C++!

#include <iostream>
using namespace std;
int main() {    
	char r [50];    
	cin >> r;    
	cout << "Hello!What's your name?" << endl << r <<",Welcome to learn OOP using C++!";     	return 0;
}

7.重载函数在调用时选择的依据中，错误的是（D）。

A.函数的参数
B.参数的类型
C.函数的名字
D.函数的类型

8.对定义重载函数的下列要求中，（C）是错误的。

A.要求参数的个数不同
B.要求参数中至少有一个类型不同
C.要求函数的返回值不同
D.要求参数个数相同时，参数类型不同

9.最大值函数重载

裁判测试程序样例：

/* 请在这里填写答案 */

int main(){
cout<<myMax(3,4)<<endl;
cout<<myMax(3,4,5)<<endl;
cout<<myMax(4.3,3.4)<<endl;
}
输入样例： 无
输出样例：
在这里给出相应的输出。
例如：
4
5
4.3

#include<iostream>
using namespace std;
int myMax(int a, int b) {  
	return a > b ? a : b;
}
int myMax(int a, int b, int c) {  
	int t = a > b ? a : b; 
	return t > c ? t : c;
}
double myMax(double a, double b) {  
	return a > b ? a : b;
}

10.计算三角形面积

从键盘输入三个数，用来表示三角形的三条边长。如果能构成三角形就输出三角形的面积，否则就输出No。
输入格式:
请在这里写输入三角形的三条边长，
例如：
3.1 4.2 5.3
输出格式:
请在这里输出三角形的面积，
例如：
6.50661

输入样例:
3.0 4.0 5.0

输出样例:
6

#include<iostream>
#include<math.h>
using namespace std;

int main(){  
	float a, b, c, p, s;  
	cin >> a >> b >> c;  
	if ( (a + b > c) && (a + c > b) && (b + c > a) )  {  
		p = (a + b + c) / 2.0;  
		s = sqrt(p * (p - a) * (p - b) * (p - c));  
		cout << s;  
	}  
	else  
		cout << "No" << endl;  
		return 0;
}

11.计算正五边形的面积和周长

从键盘输入一个数作为正五边形的边长，计算并输出该正五边形的周长和面积。
计算正五边形的面积公式为：
S=a​2​​×√​25+10×√​5​​​​​​/4
输入格式:
输入正五边形的边长。例如：
5
输出格式:
输出正五边形的面积和周长。第一行输出面积，第二行输出周长。例如：
43.0119
25

输入样例:
16.8

输出样例:
485.5875
84

#include<iostream>
#include<math.h>
using namespace std;
int main() {  
	float a, c, s;  
	cin >> a;  
	c = 5 * a;  
	s = a * a * sqrt(25 + 10 * sqrt(5)) / 4.0;
	cout << s << endl;  
	cout << c << endl;  
	return 0;
}

12.函数的参数个数和类型都相同，只是返回值不同，这不是重载函数。 T

13.The types of arguments in a function call must match the types of the corresponding parameters in the function prototype’s parameter list. T
(函数调用中的参数类型必须匹配函数原型的参数列表中相应参数的类型。)

14.在C++语言中引入内联函数（inline function）的主要目的是降低空间复杂度，即缩短目标代码长度。 F

15.关于new运算符的下列描述中，（D）是错误的。

A.它可以用来动态创建对象和对象数组；
B.使用它创建的对象或对象数组可以使用运算符delete删除；
C.使用它创建对象时要调用构造函数；
D.使用它创建对象数组时必须指定初始值；

16.关于delete运算符的下列描述中，（C）是错误的。

A.它必须用于new返回的指针；
B.使用它删除对象时要调用析构函数；
C.对一个指针可以使用多次该运算符；
D.指针名前只有一对方括号符号，不管所删除数组的维数。

17.以下程序中，new语句干了什么。 C
int** num;
num = new int* [20];

A.分配了长度为20的整数数组空间，并将首元素的指针返回。
B.分配了一个整数变量的空间，并将其初始化为20。
C.分配了长度为20的整数指针数组空间，并将num[0]的指针返回。
D.存在错误，编译不能通过。

18.以下程序存在的问题是：C
void fun()
{
int *num1, *num2;
num1 = new int[10];
num2 = new int[20];
num1[0] = 100;
num2[0] = 300;
num1 = num2;
delete [] num1;
}
A.num2不能给num1赋值
B.num2最初指向的空间没有释放
C.num1最初指向的空间没有释放
D.程序没有问题

19.设void f1(int * m，long & n)；int a；long b；则以下调用合法的是（ B ）。

A.f1(a，b)；
B.f1(&a，b)；
C.f1(a，&b)；
D.f1(&a，&b)；

20.一个函数功能不太复杂，但要求被频繁调用，选用（ A ）。

A. 内联函数
B.重载函数
C.递归函数
D.嵌套函数

21.在（ C ）情况下适宜采用inline定义内联函数。

A.函数体含有循环语句
B.函数体含有递归语句
C.函数代码少、频繁调用
D.函数代码多、不常调用

22.下面说法正确的是（B）。

A.内联函数在运行时是将该函数的目标代码插入每个调用该函数的地方
B.内联函数在编译时是将该函数的目标代码插入每个调用该函数的地方
C.类的内联函数必须在类体内定义
D.类的内联函数必须在类体外通过加关键字inline定义

23.重载绝对值函数

将绝对值函数abs( )重载三次，以便在下列的主函数中调用。
在主函数中调用形式为：
abs(x1);

其中 x1 是用户传入的参数。

裁判测试程序样例：
#include"iostream"
using std::cin;
using std::cout;
using std::endl;
//你提交的代码将被嵌入到这里

int main()
{
int x1; long x2; double x3;
cin>>x1>>x2>>x3;
cout<<“x1=”<<abs(x1)<<endl;
cout<<“x2=”<<abs(x2)<<endl;
cout<<“x3=”<<abs(x3)<<endl;
return 0;
}

输入样例：
8 -9 -2.7818281828

输出样例：
x1=8
x2=9
x3=2.78183

int abs(int x) {  
	if(x < 0)  x = -x;  
	return x; 
}
long abs(long x) {  
	if(x < 0)   x = -x;  
	return x;
}
double abs(double x) {  
	if(x < 0)  x=-x;  
	return x;
}

24.重载函数可以带有默认值参数，但是要注意二义性。T
25.命名空间应用于：B

A.在类外定义类的成员函数
B.避免各个不同函数、变量等的名称冲突
C.提高代码的执行速度
D.以上答案都正确

26.如果在函数中定义的局部变量与命名空间中的变量同名时，（B）被隐藏。

A.函数中的变量
B.命名空间中的变量
C.两个变量都
D.两个变量都不

27.如果程序中使用了using命令同时引用了多个命名空间，并且命名空间中存在相同的函数，将出现： A

A.编译错误
B.语法错误
C.逻辑错误
D.无法判定错误类型

28.要说明标识符是属于哪个命名空间时，需要在标识符和命名空间名字之间加上： A

A. ::
B. ->
C. .
D. ( )

29.如果默认参数的函数声明为“ void fun(int a,int b=1,char c=‘a’,float d=3.2);”，
则下面调用写法正确的是（B）。

A.fun();
B.fun(2,3);
C.fun(2, ,‘c’,3.14)
D.fun(int a=1);

30.填空使下列程序完整并能正确运行。

#include <iostream>
using namespace std;

int main ( )
{
  double* pDouble  = NULL; // initialized with null
  pDouble  = new double(4分);   // Request memory for the variable
	
  char* pChar  = NULL(2分);   // initialized with null
  pChar  = new char[20];   // Request memory for the array
	
  cin>>*pDouble >>pChar;     // Store value at allocated address
  cout << *pDouble<<endl << pChar<<endl ;
	
  delete pDouble;         // free up the memory.
  delete pChar(4分);       // free the memory pointed to by pChar
	
  return 0;
}

31.面积计算器（函数重载）

实现一个面积计算器，它能够计算矩形或长方体的面积。
函数接口定义：
int area(int x, int y);
int area(int x, int y, int z);

第一个函数计算长方形的面积，其中x和y是长和宽。第二个函数计算长方体的表面积，x,y和z是长，宽和高。
裁判测试程序样例：
#include < iostream >
#include < string >
using namespace std;
int area(int,int);
int area(int,int,int);
int main() {
int i, repeat, c, x, y, z;
cin>>repeat;
for(i=0;i<repeat;i++){
cin>>c;
if(c == 2){
cin>>x>>y;
cout<<area(x,y)<<endl;
}
if(c==3){
cin>>x>>y>>z;
cout<<area(x,y,z)<<endl;
}
}
return 0;
}

/* 请在这里填写答案 */

输入样例：
2
2 1 2
3 2 3 4

输出样例：
2
52

int area(int x, int y) {  
	return(x * y);
}
int area(int x, int y, int z) {  
	return(2  * ( x * y + x * z + y * z ) );
}

32.求最大值和最小值

本题要求实现一个函数f，可找出10个整数中最大值max和最小值min。
函数接口定义：
在主函数中将以下列形式调用该函数
f(a,10,max,min);

例如：其中a是数组名，max用来保存最大值，min用来保存最小值。
裁判测试程序样例：
#include < iostream >
using namespace std;
/* 你提交的代码将被嵌入到这里 */

int main( ) {
int a[10];
int max,min,i;
for(i=0;i<10;i++){
cin>>a[i];
}
f(a,10,max,min);
cout<<"Max: "<<max<<endl;
cout<<"Min: "<<min<<endl;
return 0;
}

输入样例：
2 5 8 1 4 7 3 6 9 0

输出样例：
Max: 9
Min: 0

int f(int a[10], int n, int &max, int &min) {  
	int j;  
	max = a[0];  
	min = a[0];  
	for (j = 0; j < n; j++)  {    
		if(a[j] > max)  max = a[j];  
	}   
	for(j = 0; j < n; j++)  {    
		if(a[j] < min)  min = a[j];  
	}
}

第二章 类和对象

1.给定以下类声明，哪个成员函数可能改变成员变量data? D
class A {
public:
void f1 (int d);
void f2 (const int &d);
void f3 (int d) const; private:
int data;};

A.f1
B.f2
C.f3
D.f1和f2

2.在下列关键字中,用以说明类中公有成员的是（A）。

A.public
B.private
C.protected
D.friend

3.有关类和对象的说法下列不正确的有（C）。

A.对象是类的一个实例
B.任何一个对象只能属于一个具体的类
C.一个类只能有一个对象
D.类与对象和关系与数据类型和变量的关系相似

4.类成员的默认访问属性是：A

A.private
B.protected
C.public
D.以上答案都不对

5.在面向对象的软件系统中，不同类对象之间的通信的一种构造称为 D 。

A.属性
B.封装
C.类
D.消息

6.设计一个名为Rectangle的矩形类（C++ set函数）

设计一个名为Rectangle的矩形类，这个类包括：两个名为width和height的double数据域，它们分别表示矩形的宽和高。一个为width和height设置初值的函数set()；一个名为getArea( )的函数返回矩形的面积；一个名为getPerimeter( )的函数返回矩形的周长。请实现这个类。

类名为：
Rectangle

裁判测试程序样例： 在这里给出函数被调用进行测试的例子。例如：
#include < iostream >
using namespace std;
//你提交的代码将嵌入到这里

int main() {
double m,n;
cin>>m;
cin>>n;
Rectangle a;
a.set(m,n);
cout<<a.getArea()<<endl;
cout<<a.getPerimeter()<<endl;
return 0;
}

输入样例：
3.5 35.9

输出样例：
125.65
78.8

class Rectangle  {
private:
    double width;
    double height;
public:
    int set(double m, double n) {
        width = m;
        height = n;
        return 0;
    }
    double getArea() {
        return width * height;
    }
    double getPerimeter() {
        return 2 * (width + height);
    }
};

7.Point类的声明和实现

定义一个Point类，代表平面上的一个点，其横坐标和纵坐标分别用x和y表示，设计Point类的成员函数，实现并测试这个类。主函数中输入两个点的坐标，计算并输出了两点间的距离。请根据主函数实现Point类。

裁判测试程序样例：
#include < iostream >
#include < iomanip >
#include < cmath >
using namespace std;

//你的代码将被嵌在这里

int main() {
Point p1, p2;
double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
p1.setX(x1);
p1.setY(y1);
p2.setX(x2);
p2.setY(y2);
double x = p1.getX() - p2.getX();
double y = p1.getY() - p2.getY();
double len = sqrt(x * x + y * y);
cout << fixed << setprecision(2) << len << endl;
return 0;
}

输入样例：
0 0 3 3

输出样例：
4.24

class Point {
private:
    double x;
    double y;
public:
    double getX() {
        return x;
    }
    double getY() {
        return y;
    }
    double setX(double X) {
        x = X;
        return 0;
    }
    double setY(double Y) {
        y = Y;
        return 0;
    }
};

8.有关类和对象的说法下列不正确的有（C）。

A.对象是类的一个实例
B.任何一个对象只能属于一个具体的类
C.一个类只能有一个对象
D.类与对象和关系与数据类型和变量的关系相似

9.类的实例化是指（ B ）。

A.定义类
B.定义对象
C.调用类的成员函数
D.访问对象的数据成员

10.关于成员函数特征的描述中，（ B ）是错误的。

A.成员函数可以重载
B.成员函数一定是内联函数
C.一个类可以没有成员函数
D.成员函数可以设置参数的默认值

11.如果类定义中没有使用 private、protected、或public 关键字，则所有成员（C）

A.都是 public 成员
B.都是 proctected 成员
C.都是 private 成员
D.不一定

12.在面向对象系统中，对象是基本的运行时实体，它 C 。

A.只能包括数据(属性)
B.只能包括操作(行为)
C.把属性和行为封装为一个整体
D.必须具有显式定义的对象名

13.在面向对象系统中，对象的属性是 C 。

A.对象的行为特性
B.和其他对象相关联的方式
C.和其他对象相互区分的特性
D.与其他对象交互的方式

14.类的声明和成员函数的实现

声明了一个Dog类，包含了age，weight等属性，以及对这些属性进行操作的方法。请实现该类的成员函数。
Dog类声明如下：
class Dog {
public:
void setAge(int a);
int getAge();
void setWeight(int w);
int getWeight();
private:
int age, weight;
};

请实现Dog类的成员函数。 裁判测试程序样例：
#include < iostream >
using namespace std;

class Dog {
public:
void setAge(int a);
int getAge();
void setWeight(int w);
int getWeight();
private:
int age, weight;
};

int main() {
Dog d;
int a, w;
cin >> a >> w;
d.setAge(a);
d.setWeight(w);
cout << d.getAge() << endl;
cout << d.getWeight() << endl;
return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：
1 3

输出样例：
1
3

void Dog :: setAge(int a) {
    age = a;
}
void Dog :: setWeight(int w) {
    weight = w;
}
int Dog :: getAge() {
    return age;
}
int Dog :: getWeight() {
    return weight;
}

15.使用类计算矩形的面积
定义并实现一个矩形类，有长和宽两个属性，由成员函数计算矩形的面积。
矩形类Rectang接口定义如下：
class Rectangle {
public:
void setLength(int l);//设置矩形的长度
void setWidth(int w); //设置矩形的宽度
int getArea(); //计算并返回矩形的面积
private:
int length, width; //矩形的长度和宽度
};

请实现Rectangle类的成员函数。
裁判测试程序样例：
#include < iostream >
using namespace std;

class Rectangle {
public:
void setLength(int l);//设置矩形的长度
void setWidth(int w); //设置矩形的宽度
int getArea(); //计算并返回矩形的面积
private:
int length, width; //矩形的长度和宽度
};

int main()
{
Rectangle r;
int len, w;
cin >> len >> w;
r.setLength(len);
r.setWidth(w);
cout << r.getArea() << “\n”;
return 0;
}

/* 你的代码将嵌在这里 */

输入样例：
10 20

输出样例：
200

void Rectangle :: setLength(int l) {
    length = l;
}
void Rectangle :: setWidth(int w) {
    width = w;
}
int Rectangle :: getArea() {
    return length * width;
}

16.定义一个名为Stock的股票类
定义一个名为Stock的股票类，这个类包括：一个名为symbol的字符串表示股票代码。一个名为name的字符串数据成员表示股票名称。一个名为previousClosingPrice的double数据成员，它存储前一日的股票收盘价。一个名为currentPrice数据成员，它存储当前的股票成交价格。创建一个设置股票代码和股票名称的set( )函数。一个名为changePercent()函数返回股价涨跌幅度。（即从previousClosingPrice变化到currentPrice的百分比。）
类名为：
Stock

裁判测试程序样例：
#include
using namespace std;
/* 你提交的代码将被嵌入到这里 */

int main( ) {
char s1[10],n1[20];
cin>>s1>>n1;
Stock stock;
stock.set(s1, n1);
// 输入前一日收盘价
cin>>stock.previousClosingPrice;
// 输入当前成交价
cin>>stock.currentPrice;
// 显示股票信息
cout<<stock.name<<" price changed: " <<(stock.changePercent() * 100)<<"%";
return 0;
}

输入样例：
002594
比亚迪
56.98
55.40

输出样例：
比亚迪price changed: -2.7729%

在这里插入代码片

17.对于有返回值的return语句,用它可以返回一个表达式的值,从而实现函数之间的信息传递 T

18.析构函数可以返回： D

A.指向某个类的指针
B.某个类的对象
C.状态信息表明对象是否被正确地析构
D.不可返回任何值

19.下列函数中，（C）不能重载。

A.成员函数
B.非成员函数
C.析构函数
D.构造函数

20.下列属于类的析构函数特征的是 A

A.一个类中只能定义一个析构函数
B.析构函数名与类名不同
C.析构函数的定义只能在类体内
D.析构函数可以有一个或多个参数

21.基本概念*
类是对象的抽象，而一个对象则是其对应的一个 实例

22.阅读下列程序并填空：

#include <iostream>
#include <cstring>
using namespace std; 
class Book{
private:
  char *title; //书名
  char *author; //作者
  int sales;    //销售量
 public:
  Book();   //默认构造函数；
  Book(char *a,char *b,int c); //构造函数
   void print();         //输出函数
   ~Book();            //析构函数
};
Book::Book(char *a,char *b,int c)
{
  title=new char[strlen(a)+1];
  strcpy(title, a)      (2分);
  author=new char[strlen(b) + 1];       (3分)
  strcpy(author,b);
  sales=c;
}
void Book::print()
{
  cout<<title<<endl;
  cout<<author<<endl;
  cout<<sales<<endl;
}
Book::~Book( )
{
   delete []title      (3分);
  delete []author      (2分);
}
int main( )
{
  char title[80],author[80];
  int sales;
  cin.getline(title,79,'\n');
  cin.getline(author,79,'\n');
  cin>>sales;
  Book aBook(title,author,sales);
  aBook.print();	
}

23.定义一个矩形类（C++构造函数）
设计一个名为Rectangle的矩形类，这个类包括：两个名为width和height的double数据域，它们分别表示矩形的宽和高。width和height的默认值都为1.该类包括矩形类的无参构造函数（默认构造函数）；一个width和height为指定值的矩形构造函数；一个名为getArea( )的函数返回矩形的面积；一个名为getPerimeter( )的函数返回矩形的周长。请实现这个类。
类名为：
Rectangle

裁判测试程序样例：
在这里给出函数被调用进行测试的例子。例如：
#include
using namespace std;
//你提交的代码将嵌入到这里

int main()
{
double m,n;
cin>>m;
cin>>n;
Rectangle a(m,n);
cout<<a.getArea()<<endl;
cout<<a.getPerimeter()<<endl;
return 0;
}

输入样例：
3.5 35.9

输出样例：
125.65
78.8

class Rectangle {
private:
    double width =  1;
    double height = 1;
public:
    Rectangle();
    Rectangle(double h, double w);
    double getArea();
    double getPerimeter();
};
Rectangle :: Rectangle(double h, double w) {
    width = w;
    height = h;
}
double Rectangle :: getArea() {
    return width * height;
}
double Rectangle :: getPerimeter() {
    return 2 * (width + height);
}

24.C++程序中，类的构造函数名与类名相同。T

25.下列对重载函数的描述中，（A）是错误的。

A.重载函数中不允许使用默认参数
B.重载函数中编译根据参数表进行选择
C.不要使用重载函数来描述毫无相干的函数
D.构造函数重载将会给初始化带来多种方式

26.在下面类声明中，关于生成对象不正确的是（C）。
class point
{ public:
int x;
int y;
point(int a,int b) {x=a;y=b;}
}; (2分)

A.point p(10,2);
B.point *p=new point(1,2);
C.point *p=new point[2];
D.point *p[2]={new point(1,2), new point(3,4)};

27.Point类的声明和实现
定义一个Point类，代表平面上的一个点，其横坐标和纵坐标分别用x和y表示，设计Point类的成员函数，实现并测试这个类。
主函数中输入两个点的坐标，计算并输出了两点间的距离。请根据主函数实现Point类。
裁判测试程序样例：
#include
#include
#include
using namespace std;

//你的代码将被嵌在这里

int main()
{
Point p1, p2;
double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
p1.setX(x1);
p1.setY(y1);
p2.setX(x2);
p2.setY(y2);
double x = p1.getX() - p2.getX();
double y = p1.getY() - p2.getY();
double len = sqrt(x * x + y * y);
cout << fixed << setprecision(2) << len << endl;
return 0;
}

输入样例：
0 0 3 3

输出样例：
4.24

class Point{
 public:
  void setX(double X);
  void setY(double Y);
  double getX();
  double getY();
 private:
  double x;
  double y;
};
void Point :: setX(double X){
 x = X;
}
void Point :: setY(double Y){
 y = Y;
}
double Point :: getX(){
 return x;
}
double Point :: getY(){
 return y;
}

28.学生排名表（析构函数）
现在输入一批学生（人数大于0且不超过100）的名次和他们的姓名。要求按名次输出每个人的排名。
输入格式：每行为一个学生的信息，共两项，第一项为排名（为正整数，且任意两名学生的排名均不同），第二项为学生姓名。当输入－1时，表示输入结束。
输出格式：按名次输出学生姓名，每行一个。
函数接口定义：
main函数的一部分。

裁判测试程序样例：
#include < iostream >
#include < string >
using namespace std;
class Student{
int rank;
string name;
public:
int getRank(){return rank; }
Student(string name, int rank):name(name), rank(rank){ }
~Student(){ cout<<name<<endl;}
};
int main(){
int rank, count=0;
const int SIZE=100;
Student *pS[SIZE];
string name;
cin>>rank;
while(count<SIZE && rank>0){
cin>>name;
pS[count++]= new Student(name, rank);
cin>>rank;
}

/* 请在这里填写答案 */
return 0;
}

输入样例：
1 Jack
5 Peter
2 Alice
6 Kate
52 Mike
-1

输出样例：
Jack
Alice
Peter
Kate
Mike

int i = 0, j = 0;
    for ( i = 0; i < count - 1; i++) {
            int k = i;
        for ( j = i + 1; j < count; j++)
            if (ps[j] -> getRank() > ps[k] -> getRank())
                k = j;
        if (k != i) {
            Student *temp;
            temp = ps[i];
            ps[i] = ps[k];
            ps[k] = temp;
        }
    }
    for (int i = count - 1; i >= 0; i--) {
        ps[i] -> ~Student();
    }

29.体育俱乐部I（构造函数）
一个俱乐部需要保存它的简要信息，包括四项：名称（字符串），成立年份（整数），教练姓名（字符串）和教练胜率（0－100之间的整数）。用键盘输入这些信息后，把它们分两行输出：第一行输出名称和成立年份，第二行输出教练姓名和胜率。
裁判测试程序样例：
#include
#include
using namespace std;
class Coach{
string name;
int winRate;
public:
Coach(string n, int wr){
name=n; winRate=wr;
}
void show();
};
class Club{
string name;
Coach c;
int year;
public:
Club(string n1, int y, string n2, int wr);
void show();
};
int main(){
string n1, n2;
int year, winRate;
cin>>n1>>year>>n2>>winRate;
Club c(n1,year, n2, winRate);
c.show();
return 0;
}

/* 请在这里填写答案 */

输入样例：
Guanzhou 2006 Tom 92

输出样例：
Guanzhou 2006
Tom 92%

void Coach :: show() {
    cout << name << " " << winRate << "%" << endl;
}
Club :: Club(string n1, int y, string n2, int wr) : c(n2, wr) {
    name = n1;
    year = y;
}
void Club :: show() {
    cout << name << " " << year << endl;
    c.show();
}

第三章 进一步学习类和对象

1.Given the declaration Circle x[10], which of the following statements is Wrong? A

A.x contains an array of ten int values.
B.x contains an array of ten objects of the Circle type.
C.Each element in the array is a Circle object.
D.You can change the contents in each object element.

2.下列关于this指针的叙述中，正确的是 D

A.任何与类相关的函数都有this指针
B.类的成员函数都有this指针
C.类的友元函数都有this指针
D.类的非静态成员函数才有this指针

3.以下说法正确的是（C）。

A.在静态成员函数中可以调用同类的其他任何成员函数
B.const成员函数不能作用于非const对象
C.在静态成员函数中不能使用this指针
D.静态成员变量每个对象有各自的一份

4.对象指针与对象数组（拉丁舞）
怡山小学毕业文艺晚会上，拉丁舞是最受欢迎的节目。不过，每年为了排练这个节目，舞蹈组都会出现一些纠纷。有些同学特别受欢迎，有些却少人问津，因此安排舞伴成为舞蹈组陈老师最头疼的问题。
为了解决这一问题，今年陈老师决定让按先男生后女生，先低号后高号的顺序，每个人先报上自己期待的舞伴，每人报两位，先报最期待的舞伴。接下来按先男生后女生，先低号后高号的顺序，依次按以下规则匹配舞伴：
（１）每个人均按志愿顺序从前到后确定舞伴。如果第一志愿匹配不成功，则考虑第二志愿。
（２）如果Ａ的当前志愿为Ｂ，则如果Ｂ未匹配舞伴，且有以下情形之一者，Ａ和Ｂ匹配成功：
2a) B的期待名单中Ａ。
2b) Ｂ的期待名单中没有Ａ，但Ｂ期待的两位舞伴均已匹配成功，所以Ｂ只能与Ａ凑合。
输入时先输入男生数m, 接下来m行，第一项为学生的姓名，后两项为期待舞伴的编号，编号从０开始，最大为女生数减１。接下来输入女生数f，接下来f行，第一项为学生的姓名，后两项为期待舞伴的编号，编号从0开始，最大为男生数减１。
输出时按男生的编号顺序输出　　姓名:舞伴姓名
注意两个姓名间有冒号隔开
函数接口定义：
Student的两个成员函数：
void printPair();
void addPair();

裁判测试程序样例：
#include < iostream >
#include < string >
using namespace std;
const int K=2;
const int N=20;
class Student{
string name;
Student *welcome[K];
Student *pair;
public:
void init(string &name, Student *a, Student *b) {
this->name=name;
welcome[0]=a;
welcome[1]=b;
pair=NULL;
}
void printPair();
void addPair();
};

/* 请在这里填写答案 */

int main(){
Student male[N], female[N];
int m, f, i, j, a, b;
string name;
cin>>m;
for(i=0;i<m;i++){
cin>>name>>a>>b;
male[i].init(name, &female[a], &female[b]);
}
cin>>f;
for(i=0;i<f;i++){
cin>>name>>a>>b;
female[i].init(name, &male[a], &male[b]);
}
for(i=0;i<m;i++) male[i].addPair();
for(i=0;i<f;i++) female[i].addPair();
for(i=0;i<m;i++) male[i].printPair();
return 0;
}

输入样例：
5
M0 3 1
M1 1 3
M2 1 4
M3 3 1
M4 0 3
5
F0 0 2
F1 2 0
F2 2 1
F3 2 4
F4 3 2

输出样例：
M0:F1
M2:F4
M4:F0

说明：匹配过程如下：
（１）M0先选择F3, 但F3并未期待M0；接下来M0选择F1, F1也期待M0，故匹配成功。
（２）Ｍ１选择F1, 但F1已匹配，故,不成功；Ｍ１选择Ｆ３，但Ｆ３未期待M1，仍然不成功。
（３）Ｍ２选择Ｆ１，Ｆ１已匹配；Ｍ２选择Ｆ４，　Ｆ４未匹配且也期待Ｍ２，故匹配成功。
（４）Ｍ３选择Ｆ３，但Ｆ３未期待他，不成功；Ｍ３选择Ｆ１，Ｆ１已匹配，不成功。
（５）Ｍ４选择Ｆ０，　Ｆ０不期待Ｍ４，但是Ｆ０期待的Ｍ０和Ｍ２已分配，所以凑合，匹配成功。
（６）Ｆ０已匹配，　Ｆ１已匹配。
（７）Ｆ２选择Ｍ２，　Ｍ２已匹配，不成功；　Ｆ２选择Ｍ１，　Ｍ１未匹配，但期待表中没有Ｆ２，且Ｆ３也未分配，故不成功。
（８）Ｆ３选择Ｍ２，　Ｍ２已匹配，不成功；Ｆ３选择Ｍ４，　Ｍ４已匹配，不成功。
（９）Ｆ４已匹配。

void Student::addPair(){
    if(pair == NULL &&
    (this == welcome[0]->welcome[0] || this == welcome[0]->welcome[1] )
    && welcome[0]->pair == NULL)
    {
        pair = welcome[0];
        welcome[0]->pair = this;
        return ;
    }
    if(pair == NULL && welcome[0]->pair == NULL &&
      (welcome[0]->welcome[0]->pair != NULL && welcome[0]->welcome[1]->pair != NULL))
    {
        pair = welcome[0];
        welcome[0]->pair = this;
        return ;
    }
    if(pair == NULL &&
    (this == welcome[1]->welcome[0] || this == welcome[1]->welcome[1] )
    && welcome[1]->pair == NULL)
    {
        pair = welcome[1];
        welcome[1]->pair = this;
        return ;
    }
    if(pair == NULL && welcome[1]->pair == NULL &&
      (welcome[1]->welcome[0]->pair != NULL && welcome[1]->welcome[1]->pair != NULL))
    {
        pair = welcome[1];
        welcome[1]->pair = this;
        return ;
    }
}
void Student::printPair(){
  //只输出配对成功的名单
    if(this->pair)
  cout << this->name << ":" << this->pair->name << endl;
}

5.类的声明和成员函数的实现–this指针
本题要求声明和实现一个Car类，包括实现其成员函数。

要求如下：

类和函数接口定义：

1. 声明一个Car类;
2. 三个public成员函数:
   (1) disp_welcomemsg()，无返回类型;
   (2) get_wheels()，返回一个Car类的数据成员m_nWheels的值；
   (3) set_wheels(int)，用指定的形参初始化数据成员m_nWheels的值；
3. 一个私有数据成员m_nWheels，整数类型，代表汽车的车轮数量。

其中，成员函数disp_welcomemsg()显示一条欢迎信息“Welcome to the car world!”。
成员函数get_wheels()返回Car类的私有数据成员m_nWheels。
成员函数set_wheels(int)用指定的形参初始化数据成员m_nWheels。
裁判测试程序样例：
#include
using namespace std;

/* 请在这里填写答案 */

int main()
{
int n;
cin >> n;
Car myfstcar, myseccar; //定义类对象
myfstcar.disp_welcomemsg();//访问成员函数，显示欢迎信息
myfstcar.set_wheels(n); //访问成员函数，设置车轮数量
myseccar.set_wheels(n+4); //访问成员函数，设置车轮数量
//访问成员函数，显示车轮数量
cout << "my first car wheels num = " << myfstcar.get_wheels() << endl;
cout << "my second car wheels num = " << myseccar.get_wheels() << endl;
return 0;
}

输入样例：
4

输出样例：
Welcome to the car world!
my first car wheels num = 4
my second car wheels num = 8

class Car {
private:
    int m_nWheels;
public:
    void disp_welcomemsg();
    int get_wheels();
    void set_wheels(int);
};
void Car :: disp_welcomemsg() {
    cout << "Welcome to the car world!" << endl;
}
int Car :: get_wheels() {
    return m_nWheels;
}
void Car :: set_wheels(int n) {
    m_nWheels = n;
}

6.Variables that are shared by every instances of a class are D.

A. public variables
B. private variables
C. instance variables
D. static variables

7.A function that is associated with an individual object is called C.

A. a static function
B. a class function
C. an instance function
D. an object function

8.静态成员函数没有： B

A. 返回值
B. this指针
C. 指针参数
D. 返回类型

9.下面对静态数据成员的描述中，正确的是A

A. 静态数据成员是类的所有对象共享的数据
B. 类的每个对象都有自己的静态数据成员
C. 类的不同对象有不同的静态数据成员
D. 静态数据成员不能通过类的对象调用，只能通过“类名::标识符”调用

10.对于以下关于友元的说法 D

A. 如果函数fun被声明为类A的友元函数，则该函数成为A的成员函数
B. 如果函数fun被声明为类A的友元函数，则该函数能访问A的保护成员，但不能访问私有成员
C. 如果函数fun被声明为类A的友元函数，则fun的形参类型不能是A。
D. 以上答案都不对

11.友元的作用是 A

A. 提高程序的运用效率
B. 加强类的封装性
C. 实现数据的隐藏性
D. 增加成员函数的种类

12.下面关于友元的描述中，错误的是： D

A. 友元函数可以访问该类的私有数据成员
B. 一个类的友元类中的成员函数都是这个类的友元函数
C. 友元可以提高程序的运行效率
D. 类与类之间的友元关系可以继承

13.定义有静态成员的C++学生类Student
本程序中学生Student类中有学号 number，姓名 name，成绩 score 等数据成员，另外有静态变量：学生对象个数 count 和总分sum。静态成员函数average( )用来计算学生的平均分。
Student类构造函数的原型如下：
Student(int number1, String name1, float score1);

裁判测试程序样例：
/* 请在这里填写答案 */

int main( )
{
// Student::init( );
Student stu1(1,“Bill”,87);
stu1.print( );
Student stu2(2,“Adam”,91);
stu2.print( );
Student stu3(3,“David”,96);
stu3.print( );
Student::average( ); //静态成员函数的调用
return 0;
}

输出样例：
在这里给出相应的输出。例如：
number: 1 name: Bill score: 87 count: 1
number: 2 name: Adam score: 91 count: 2
number: 3 name: David score: 96 count: 3
sum is 274
count is 3
average is 91.3333

#include <iostream>
#include <cstring>
using namespace std;
class Student {
private:
    int number;
    char *name;
    float score;
    static int count;
    static float sum;
public:
    Student(int n, char *na, float s);
    ~Student();
    static void init() {
        Student :: count = 0;
        Student :: sum = 0;
    }
    void print();
    static float average();
};
int Student :: count;
float Student :: sum;
Student :: Student(int n, char *na, float s) {
    number = n;
    name = new char[strlen(na) + 1];
    strcpy(name, na);
    score = s;
    count++;
    sum = sum + score;
}
Student :: ~Student() {
    delete [] name;
    count--;
}
void Student :: print() {
    cout <<  "number: " << number << " name: " <<
    name << " score: " << score << " count: " << count
    << endl;
}
float Student :: average() {
    cout << "sum is " << sum << endl;
    cout << "count is " << count << endl;
    cout << "average is " << sum / count << endl;
    return sum / count;
}

14.2017final友元函数之全班同学的平均绩点
一个学生类，有三个私有成员：名字name、课程学分指针score、课程成绩指针grade。定义一个友元函数，求全班同学的平均绩点。单门课程的学分绩点=学分绩点=学分(成绩/10-5) ; 全班同学的平均绩点是 所有同学的全部课程的学分绩点之和/所有同学学分数之和。单个同学的课程数不超过100门。全班同学人数不超过100名。
输入说明：
输入若干行。
每行一个学生的信息：第一个输入是学生的名字，第二个输入是第一门课程的学分，第三个输入是第一门课程的成绩，第四个输入是第二门课程的学分，第五个输入是第二门课程的成绩，以此类推，最后以-1表示该行输入结束。每个学生的课程数不超过100门。
最后以 no 表示输入结束。
输出一行，即该全班同学的平均绩点。
函数接口定义：
这是求全部同学平均绩点的友元函数的声明：
friend double averagegrade(student *stu, int count)

其中 *stu 和 count 都是用户传入的参数。 *stu 是传入的学生对象数组的首指针，count是全班学生数量。
裁判测试程序样例：

#include
#include
using namespace std;
class student{
private:
double *grade;
double *score;
string name;
public:
student( )
{
grade=NULL;
score=NULL;
}
student(string n, double *g, double *s)
{
name=n;
grade=g;
score=s;
}
friend double averagegrade(student stu, int count);
};
/ 请在这里填写答案 */

int main()
{
student stu[100];
double s[100][100], g[100][100];
int count=0;
string n;
for(int i=0;i<100;i++)
{
cin>>n;
if(n==“no”) break;
count++;
for(int j=0;j<100;j++)
{
cin>>s[i][j];
if(s[i][j]==-1) break;
cin>>g[i][j];
}
stu[i]=student(n, g[i], s[i]);
}
cout<<averagegrade(stu, count);
return 0;
}

输入样例：
bob 3 90 2 68.5 2.5 50 -1
andy 3 80 2 77 -1
no

输出样例：
2.408

double averagegrade(student *stu, int count) {
    int i, j;
    double sum1 = 0, sum2 = 0;
    for (i = 0; i < count; i++) {
        for (j = 0; stu[i].score[j] != -1; j++) {
            sum1 += stu[i].score[j] * (stu[i].grade[j] / 10 - 5);
            sum2 += stu[i].score[j];
        }
    }
    if (sum2 == 0 || sum1 == 0)
        return 0;
    return sum1 / sum2;
}

四、堆与构造函数

1.在类的定义中，用于为对象分配内存空间，对类的数据成员进行初始化并执行其他内部管理操作的函数是 C

A. 友元函数
B. 虚函数
C. 构造函数
D. 析构函数

2.类的析构函数的作用是 D

A. 一般成员函数的初始化
B. 类的初始化
C. 对象的初始化
D. 删除类创建的对象

3.下列函数中，（C）不能重载。

A. 成员函数
B. 非成员函数
C. 析构函数
D. 构造函数

4.下列关于类定义的说法中，正确的是 A

A. 类定义中包括数据成员和函数成员的声明
B. 类成员的缺省访问权限是保护的
C. 数据成员必须被声明为私有的
D. 成员函数只能在类体外进行定义

5.假设MyClass是一个类，则该类的拷贝初始化构造函数的声明语句为（C）

A. MyClass&(MyClass x);
B. MyClass(MyClass x);
C. MyClass(MyClass &x);
D. MyClass(MyClass *x);

6.下列关于类的构造函数的描述中，错误的是 B

A. 类的构造函数可以重载
B. 类可以没有构造函数
C. 类的构造函数可以缺省
D. 类的构造函数可以作为其它类型向本类类型进行转换的函数

7.下列对重载函数的描述中，（A ）是错误的。

A. 重载函数中不允许使用默认参数
B. 重载函数中编译根据参数表进行选择
C. 不要使用重载函数来描述毫无相干的函数
D. 构造函数重载将会给初始化带来多种方式

8.建立一个类对象时，系统自动调用 A

A. 构造函数
B. 析构函数
C. 友元函数
D. 成员函数

9.对于任意一个类，析构函数的个数最多为（ B）

A. 0
B. 1
C. 2
D. 3

10.实现数组类（C++ 拷贝构造函数、拷贝函数）
裁判测试程序样例中展示的是一段实现“数组类”的代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行。
函数接口定义：
提示：要想程序正确运行，至少需要补充以下函数（可能还需要补充其他函数）：

1. 带参构造函数
2. 拷贝构造函数
3. 拷贝函数（赋值运算符重载）

裁判测试程序样例：
#include
using namespace std;
class ArrayIndexOutOfBoundsException{ // 异常类
public:
int index;
ArrayIndexOutOfBoundsException(int k){
index = k;
}
};
class Array{
private:
int data;
int size;
static const int dSize = 10; // 数组默认大小
public:
Array( ){ // 无参构造
size = dSize;
data = new intsize;
}
/* 你提交的代码将被嵌在这里（替换本行内容） **/
int& operator [] (int k){ // 运算符 [ ] 重载，以方便数组的使用
if(k<0 || k>=size) throw ArrayIndexOutOfBoundsException(k);
return data[k];
}
friend ostream& operator << (ostream& o, const Array& a); // 运算符 << 重载，以方便输出
};
ostream& operator << (ostream& o, const Array& a){
o << ‘[’ ;
for(int i=0; i<a.size-1; i++)
o << a.data[i] << ‘,’ ;
o << a.data[a.size-1] << ‘]’;
return o;
}
// 注意：实际测试程序中，在此处之前的代码与样例中相同
// 注意：实际测试程序中，在此处之后的代码（即main函数）可能与样例中不同
int main(){
int n, k;
cin >> n >> k;
Array a(n); // 构造数组，大小为 n
for(int i=0; i<n; i++) a[i] = i;
Array b = a; // 拷贝构造数组
b[n/2] = k;
cout << a << endl;
cout << b << endl;
Array c; // 构造数组，默认大小
c = a; // 拷贝数组
c[n/2] = k;
cout << a << endl;
cout << c << endl;
a = a;
a[n/2] = 2223;
cout << a << endl;
return 0;
}

输入样例：
15 666

输出样例：
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
[0,1,2,3,4,5,6,666,8,9,10,11,12,13,14]
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
[0,1,2,3,4,5,6,666,8,9,10,11,12,13,14]
[0,1,2,3,4,5,6,2223,8,9,10,11,12,13,14]

 Array(int n) {
        size = n;
        data = new int[size]();
    }
    Array(const Array &a) {
        size = a.size;
        data = new int[size];
        for (int i = 0; i < size; i++) {
            data[i] = a.data[i];
        }
    }
    ~Array() {
        delete [] data;
    }
    Array & operator=(const Array & a) {
        if (a.size != size) {
            delete [] data;
            size = a.size;
            data = new int[size];
        }
        for (int i = 0; i < size; i++) {
            data[i] = a.data[i];
        }
        return *this;
}

11.将构造函数说明为纯虚函数是没有意义的。 T
12.设A为自定义类，现有普通函数int fun(A& x)。则在该函数被调用]时： C

A. 将执行复制构造函数来初始化形参x
B. 仅在实参为常量时，才会执行复制构造函数以初始化形参x
C. 无需初始化形参x
D. 仅在该函数为A类的友元函数时，无需初始化形参x

13.在以下哪种情形，复制构造函数会被调用。 B

A. 当一个对象采用引用方式，作为参数传递给一个函数
B. 当一个函数采用值方式，返回一个对象
C. 当一个对象赋值给另一个对象
D. 以上答案都不对

14.学生成绩的快速录入（构造函数）
现在需要录入一批学生的成绩（学号，成绩）。其中学号是正整数，并且录入时，后录入学生的学号会比前面的学号大；成绩分两等，通过(Pass,录入时用1代表),不通过(Fail,录入时用0代表）。
由于很多学号都是相邻的，并且学号相邻的学生成绩常常相同。所以在录入时，适当地加了速。如果当前学生的学号比前面的学号大1，且成绩与前面的成绩相同，则只输入0即可。
类定义：
完成Student类

裁判测试程序样例：
#include
using namespace std;

/* 请在这里填写答案 */

int main(){
const int size=100;
int i, N, no, score;
Student *st[size];
cin>>N;
for(i=0; i<N; i++){
cin>>no;
if(no>0){
cin>>score;
st[i]=new Student(no, score);
}
else
st[i]=new Student(*st[i-1]);
}
cout<<Student::count<<" Students"<<endl;
for(i=0;i<N;i++) st[i]->display();
for(i=0;i<N;i++) delete st[i];
return 0;
}

输入样例：
5
3 0
0
7 1
0
12 1

输出样例：
5 Students
3 Fail
4 Fail
7 Pass
8 Pass
12 Pass

class Student {
private:
    int no;
    int score;
public:
    static int count;
    Student(int n, int s) {
        no = n;
        score = s;
        count++;
    }
    Student(const Student &p) {
        no = p.no + 1;
        score = p.score;
        count++;
    }
    void display() {
        cout << no << " ";
        if (score)
            cout << "Pass" << endl;
        else
            cout << "Fail" << endl;
    }
};
int Student :: count = 0;

15.解决内存泄漏问题
编译、运行下列程序后。从输出结果发现没有调用 class Y 的析构函数，出现了内存泄漏。请尝试修改class X类的定义解决这个内存泄露问题。并提交定义class X类的代码。
class X类的定义如下：
class X{
public:
X() { p = new int[2]; cout << "X(). "; }
~X() { delete [] p; cout << “~X().\n”; }
private:
int* p;
};

#include < iostream >
using namespace std;
// 你提交的代码将嵌入到这里

class Y : public X
{
public:
Y( ) { q = new int[1023]; cout << "Y( ) "; }
~Y( ) { delete [] q; cout << "~Y(). "; }
private:
int* q;
};
int main()
{
int n;
cin>>n;
for (int i = 0; i < n; i++)
{
X* r = new Y;
delete r;
}
return 0;
}
从输出结果发现没有调用 class Y 的析构函数，出现了内存泄漏。
3
X(). Y( ) ~X().
X(). Y( ) ~X().
X(). Y( ) ~X().

输入样例：
3

输出样例：（输出显示调用了Y类的析构函数）
X(). Y( ) ~Y(). ~X().
X(). Y( ) ~Y(). ~X().
X(). Y( ) ~Y(). ~X().

class X {
private:
    int* p;
public:
    X() {
        p = new int[2];
        cout << "X().      ";
    }
    virtual ~X() {
        delete [] p;
        cout << "~X.\n";
    }
};

16.为my_string类创建复制构造函数copy constructor
为下面的my_string类创建一个复制构造函数，并将定义该类的代码提交。
my_string类的定义：
class my_string {
char *s;
public:
my_string(char *str) {
s = new char[strlen(str)+1];
strcpy(s, str);
}
~my_string() {
if(s) delete [] s;
cout << “Freeing s\n”;
}
void show() { cout << s << “\n”; }
};

裁判测试程序样例：
#include
#include
using namespace std;
// 你提交的代码将被嵌入到这里

int main()
{
char str[80];
cin>>str;
my_string obj(str);

my_string ob1(obj);
my_string ob2=ob1;

ob1.show();
ob2.show();

return 0;
}

输入样例：
ByeBye

输出样例：
ByeBye
ByeBye
Freeing s
Freeing s
Freeing s

class my_string {
private:
    char *s;
public:
    my_string(char *str) {
        s = new char[strlen(str) + 1];
        strcpy(s, str);
    }
    my_string(const my_string &obj) {
        s = new char[strlen(obj.s) + 1];
        strcpy(s, obj.s);
    }
    ~my_string() {
        delete [] s;
        cout << "Freeing s\n";
    }
    void show() {
        cout << s << "\n";
    }
};