青少年编程能力等级测评CPA C++ 四级试卷（2）
一、单项选择题（共15题，每题3分，共45分）
CP4_2_1. 下列有关面向对象程序设计的叙述中，不正确的是（ ）。
A．面向对象程序设计中的类，是具有相同属性和行为的对象的抽象
B．封装、继承、多态是面向对象程序设计的基本特点
C．在面向对象程序设计中，程序的模块是由类组成的
D．在面向对象程序设计中，将属性和方法封装起来，使外界无法访问
CP4_2_2．若有如下类A的定义，则下列有关类成员访问权限的叙述中，正确的是（ ）。
class A
{
int a;
private：
int b;
public:
int c;
};
A．在类A的成员函数成员中才能访数据成员b，可以在任何地方访问数据成员a
B．在类A的成员函数成员中才能访数据成员a，可以在任何地方访问数据成员b
C．在类A的成员函数成员中才能访数据成员a，可以在任何地方访问数据成员c
D．在类A的成员函数成员中才能访数据成员c，可以在任何地方访问数据成员a
CP4_2_3．下列有关类与对象的关系叙述中，不正确的是（ ）。
A．同一个类的不同对象，具有相同的数据成员和成员函数
B．同一个类的不同对象，它们的属性值可以是不同的
C．同一个类的不同对象，它们的属性值必须是相同的
D．在创建对象时，可以通过构造函数为对象的属性初始化
CP4_2_4．下列有关构造函数与析构函数的叙述中，不正确的是（ ）。
A．创建对象时，会自动调用构造函数
B．创建对象时，如果没有提供实参，则不会调用构造函数
C．对象删除时，会自动调用析构函数
D．析构函数不能重载
CP4_2_5．下列有关复制构造函数的叙述中，不正确的是（ ）。。
A．如果一个类没有定义复制构造函数时，系统将自动提供一个默认的复制构造函数
B．一个类只能有一个复制构造函数
C．复制构造函数的参数是该类对象的引用
D．复制构造函数的名字不能用类名
CP4_2_6．执行下列代码，运行结果是（ ）。
#include <iostream>
#include <cmath>
using namespace std;
class Point
{
private:
int x;
int y;
public:
Point(int x, int y){
this->x=x;
this->y=y;
}
int getX(){
return x;
}
int getY(){
return y;
}
};
double dist(Point start, Point end){
int x = end.getX()-start.getX();
int y = end.getY()-start.getY();
return sqrt(x*x+y*y);
}
int main(){
Point p1(1,2),p2(4,6);
cout << dist(p1,p2) << endl;
return 0;
}
A．3
B．4
C．5
D．6
CP4_2_7．执行下列代码，运行结果是（ ）。
#include <iostream>
using namespace std;
class Point
{
private:
int x;
int y;
public:
Point(int x=0, int y=0){
this->x=x;
this->y=y;
}
void output(){
cout << "(" << x << "," << y << ") ";
}
};
int main(){
Point p[] = {Point(),Point(1),Point(2,3)};
p[0].output();
p[1].output();
p[2].output();
cout << endl;
return 0;
}
A．(0,0) (1,0) (2,3)
B．(0,0) (0,1) (2,3)
C．(0,0) (1,0) (0,3)
D．(0,0) (1,0) (2,0)
CP4_2_8．执行下列代码，运行结果是（ ）
#include <iostream>
using namespace std;
class Point
{
private:
int x;
int y;
public:
Point(int x=0, int y=0){
this->x=x;
this->y=y;
}
void output(){
cout << "(" << x << "," << y << ") ";
}
};
class Circle
{
private:
int radius;
Point center;
public:
Circle(int x=0, int y=0, int radius=10):center(x,y){
this->radius = radius;
}
void output(){
center.output();
cout << radius << " ";
}
};
int main(){
Circle c1;
Circle c2(5,6,20);
c1.output();
c2.output();
cout << endl;
return 0;
}
A．(0,0) 0 (0,0) 0
B．(0,0) 10 (0,0) 20
C．(0,0) 10 (5,6) 0
D．(0,0) 10 (5,6) 20
CP4_2_9．下列有关struct和class的叙述中，正确的是（ ）。
A．struct和class完全相同
B．struct只能有数据成员，class既可以有数据成员，也可以有函数成员
C．struct的默认访问权限是public，class的默认访问权限是private
D．struct的默认访问权限是private，class的默认访问权限是public
CP4_2_10．下列有关对静态数据成员的叙述中，正确的是（ ）。
A．静态数据成员应该在构造函数中初始化
B．无论创建多少个对象，静态数据成员只有一个副本
C．公有的静态数据成员可以用类名调用，不能用对象调用
D．公有的静态数据成员可以用对象调用，不能用类名调用
CP4_2_11. 执行下列代码，运行结果是（ ）。
#include <iostream>
using namespace std;
class A
{
private:
static int count;
public:
A(){
++count;
}
~A(){
--count;
}
static int getCount(){
return count;
}
};
int A::count = 0;
int main(){
A s1;
A *p;
cout << A::getCount() << " ";
p = new A();
cout << A::getCount() << " " << p->getCount()<<" ";
delete p;
cout << A::getCount() << endl;
return 0;
}
A．1 2 2 1
B．1 2 1 1
C．1 2 2 2
D．1 2 1 2
CP4_2_12．下列代码要输出圆的面积314，则****//(1)****处需要填写的语句是（ ）
#include <iostream>
using namespace std;
class Circle
{
private:
int radius;
public:
Circle(int radius=10){
this->radius = radius;
}
/ /(1);
};
double getArea(Circle c){
return 3.14 * c.radius * c.radius;
}
int main(){
Circle c(10);
cout << getArea(c)<< endl;
return 0;
}
A．double getArea(Circle c);
B．friend double getArea(Circle c);
C．double getArea();
D．friend double getArea();
CP4_2_13．将A类的成员函数fun()声明为B类的友元函数，则以下叙述中，正确的是（ ）。
A．A类的成员函数fun()可以访问B类的私有成员
B．A类的所有成员函数都可以访问B类的私有成员
C．B类的所有成员函数都可以访问A类的成员函数fun()
D．A类的成员函数fun()只能访问B类的同名成员函数fun()
CP4_2_14．将A类声明为B类的友元类，则以下叙述中，正确的是（ ）。
A．B类的成员函数可以访问A类的私有成员
B．A类的成员函数可以访问B类的私有成员
C．A类的成员函数可以访问B类的私有成员，B类的成员函数也可以访问A类的私有成员
D．B类也是A类的友元类
CP4_2_15．下列对语句"vector<int> v(5); "的叙述中，正确的是（ ）
A．向量v有1个元素，值是5
B．向量v有5个元素，每个元素的值都是5
C．向量v有5个元素，每个元素的值都是0
D．向量v有5个元素，每个元素的值是不确定的
二、多项选择题（共5题，每题2分，共10分）
CP4_2_16．下列有关构造函数和虚构函数的叙述中，正确的有（ ）。
A．类可以有多个构造函数，但只能有一个析构函数
B．构造函数必须与类同名
C．析构函数不能有参数
D．析构函数可以重载
CP4_2_17．以下代码定义了类A和类B，在创建B类的对象时，下列叙述不正确的有（ ）。
class A
{
private:
int i;
public:
A(int i=10) { this->i = i; }
};
class B
{
private:
int j;
A a1;
A a2;
public:
B(int j=0){ this->j= j; }
};
A．创建类B的对象时，先构造内嵌对象a1，后构造内嵌对象a2
B．创建类B的对象时，先执行类B的构造函数，后构造内嵌对象
C．创建类B的对象时，先构造内嵌对象，后执行类B的构造函数
D．创建类B的对象时，不构造内嵌对象，只执行类B的构造函数
CP4_2_18．下列有关类的静态成员的叙述中，正确的有（ ）。
A．类的静态成员函数没有this指针
B．类的静态成员函数只能调用类的静态成员函数及访问类的静态数据成员
C．类的静态数据成员只能被类的静态成员函数访问
D．类的静态数据成员可以被类的普通成员函数访问
CP4_2_19．下列有关友元的叙述中，正确的有（ ）。
A．友元函数不是类的成员函数，但可以访问该类的私有成员
B．如果类A是类B的友元类，类B是类C的友元类，则类A也是类C的友元类
C．友元关系是不能继承的
D．如果类A是类B的友元类，则类A的所有成员函数都是B类的友元函数
CP4_2_20．下列有关运算符重载的叙述中，不正确的有（ ）。
A．运算符可以重载为类的成员函数或重载为类的友元函数
B．运算符重载为类的成员函数，函数的参数个数与运算符的操作数个数相同
C．C++中的所有运算符都是可以重载的
D．运算符重载，不能改变运算符的操作数的个数
三、编程题（共3题，每题15分，共45分）
CP4_2_21．编写程序实现如下功能：
用户输入线段的起点和终点坐标，通过类的定义和计算，求线段的长度。如（x1,y1），(x2,y2)分别是线段的起点和终点，则计算线段的长度公式是：
。
说明：
编程过程中对于程序给定的部分不允许修改，考生仅允许在/****code****/提示行区间内作答。
#include <iostream>
#include <cmath>
using namespace std;
class Line
{
/*****************code***********/
/*****************code***********/
private:
int startx,starty,endx, endy;
};
int main(){
int startx,starty,endx, endy; //线段的起点和终点坐标
double length; //线段的长度
cin >> startx >> starty >> endx >> endy; //输入起点和终点坐标
Line l(startx, starty, endx, endy);
length = l.getLength();
cout << length << endl;
return 0;
}
样例1：
输入：10 20 7 16
输出：5
样例2：
输入：0 0 10 10
输出：14.1421
CP4_2_22．编写程序实现如下功能：
通过类的静态成员实现计数统计。用户输入学生人数n(n≤10)以及n个学生的学号和性别。输出男生总数和女生总数。
说明：
（1）本程序中，学号为正整数，性别为字符,'m'表示男，'f'表示女；
（2）假设输入的数据（学生人数，学号，性别）都在规定的范围内，不要求程序对输入的数据进行合法性检查。
（3）编程过程中对于程序给定的部分不允许修改，考生仅允许在/****code****/提示行区间内作答。
#include <iostream>
using namespace std;
class Student
{
/******************************code*****************/
/******************************code*****************/
};
int Student::boyStudentCount=0; //初始化类 Student 的静态成员
int Student::girlStudentCount=0; //初始化类 Student 的静态成员
int main(){
Student *s[10];
int n, num; // n表示学生的数量，num表示学生的学号
char gender; // gender表示学生的性别
cin >> n; // 输入学生数量, 小于等于10
for(int i=0;i<n;i++){
cin>>num>>gender;
s[i]=new Student(num,gender);
}
cout << Student::getBoyStudentCount() << " "; //男生总数
cout << Student::getGirlStudentCount() << endl; //女生总数
return 0;
}
样例1：
输入：3
101 m
102 f
103 m
输出：2 1
样例2：
输入：2
101 f
102 f
输出：0 2
CP4_2_23．编写程序实现如下功能：
定义矩形Rect类，通过重载运算符"<"和">"，使之能实现两个矩形大小的比较。用户输入两个矩形的宽和高，输出两个矩形的面积以及两个矩形比较的结果（比较结果为真输出1，比较结果为假输出0）。
说明：
（1）本程序中，矩形的宽和高均为实数；
（2）两个矩形大小的比较规则是：面积大的矩形为大，面积小的矩形为小；
（3）编程过程中对于程序给定的部分不允许修改，考生仅允许在/****code****/提示行区间内作答。
#include <iostream>
using namespace std;
class Rect
{
private:
double width;
double height;
public:
Rect(double width=0, double height=0)
{
this->width = width;
this->height = height;
}
double area() const {
return width * height;
}
/*************************code***********************/
//运算符重载函数的声明
/*************************code***********************/
};
/*************************code***********************/
//运算符重载函数的定义
/*************************code***********************/
int main()
{
double w1,h1,w2,h2; //分别表示两个矩形的宽和高
cin>>w1>>h1; //输入第一个矩形的宽和高
cin>>w2>>h2; //输入第二个矩形的宽和高
Rect r1(w1,h1); //创建矩形对象r1
Rect r2(w2,h2); //创建矩形对象r2
cout << r1.area() << " "; //显示矩形r1的面积
cout << r2.area() << endl; //显示矩形r2的面积
cout << (r1<r2) << " "; // 输出两个矩形的比较结果
cout << (r1>r2) << endl; // 输出两个矩形的比较结果
return 0;
}
样例1：
输入：10 20 30 40
输出：200 1200
1 0
样例2：
输入：10.5 8.2 6.5 4.4
输出：86.1 28.6
0 1