c++补考题目（附答案）

选择题

若定义：string str; 当语句cin>>str; 执行时，从键盘输入：Microsoft Visual Studio 6.0!所得的结果是str=（ B ）。

A、Microsoft Visual Studio 6.0 B、Microsoft Visual Studio 6.0! C、MicrosoftD、Microsoft Visual

关于纯虚函数和抽象类的描述中，错误的是（ D ）。 A、纯虚函数是一种特殊的虚函数，它没有具体的实现

B、抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出 C、抽象类是指具有纯虚函数的类

D、一个基类中说明有纯虚函数，该基类的派生类一定不再是抽象类 先加一然后再使用的++运算符的重载形式是（ D ）。 A、operator ()++ B、operator ++() int C、operator ++() charD、operator ++() 派生类的对象可访问：( A ) A、公有继承的基类公有成员 B、私有继承的基类保护成员 C、私有继承的基类公有成员 D、公有继承的基类私有成员

若派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类（D） A、保护成员或私有成员 B、保护成员 C、公有成员D、私有成员

下列对基类和派生类关系的描述中，错误的是（ D ）。 A、派生类是基类定义的延续 B、派生类是基类的组合 C、派生类是基类的具体化 D、派生类是基类的子集

下面关于类的成员访问属性的说法中，正确的说法是( A ) A、在类中，未设置访问属性的成员均为私有类型 B、在类中，未设置访问属性的成员均为公有类型 C、在类中，未设置访问属性的成员均为保护类型

D、在类中，未设置访问属性的成员均为不可访问类型 类的析构函数的作用通常是 ( D ) A、一般成员函数 B、对象的初始化

C、类的初始化 D、释放对象占用的资源（空间） 在下列关键字中, 用以说明类中公有成员的是( A )。 A、publicB、protected C、privateD、friend

对于在类中定义的静态数据成员，下面正确的说法是（ C ）。 A、该类的每个对象中都有一个静态数据成员 B、既可以在类外初始化，也可以在类内初始化 C、在类外进行初始化 D、对象创建时产生

设有基类定义： class Cbase

{ private: int a; protected: int b; public: int c; };

派生类采用何种继承方式可以使成员变量b成为自己的私有成员( A ) A、私有继承 B、保护继承

C、私有、保护、公有均可 D、公有继承

试题2：派生类的对象对它的哪一类基类成员是可以访问的？（ A、保护继承的基类的公有成员 B、公有继承的基类的保护成员 C、公有继承的基类的公有成员 D、公有继承的基类的私有成员 有如下程序：

#include using namespace std; class Base{ private:

void fun1( ) const {cout<<”fun1”;} protected:

void fun2( ) const {cout<<”fun2”;} public:

void fun3( ) const {cout<<”fun3”;} };

class Derived : protected Base{ public:

void fun4( ) const {cout<<”fun4”;} };

int main(){ Derived obj;

obj.fun1( ); //① obj.fun2( ); //② obj.fun3( ); //③ obj.fun4( ); //④ }

其中没有语法错误的语句是（ D）。

A、④ B、① C、③ D、②

C ） 试题4：有如下类定义： class XA{ int x; public:

XA(int n) {x=n;} };

class XB: public XA{ int y; public:

XB(int a,int b); };

在构造函数XB的下列定义中，正确的是（ D）。 A、XB::XB（int a，int b）：XA(a)，XB(b){ } B、XB::XB（int a，int b）：x(a)，XB(b){ } C、XB::XB（int a，int b）：x(a)，y(b){ } D、XB::XB（int a，int b）：XA(a)，y(b) { } 类O定义了私有函数F1。P和Q为O的派生类，定义为class P: protected O{…}； class Q: public O{…}。( A )可以访问Fl。 A、O类内 B、Q类内 C、O的对象 D、P类内 程序如下：

#include using namespace std; class A { public:

A( ) {cout<<”A”;} };

class B {public:B( ) {cout<<”B”;} }; class C: public A{ B b; public:

C( ) {cout<<”C”;} };

int main( ) {C obj; return 0;} 执行后的输出结果是（ A）。

A、ABC B、ACBC、CBA D、BAC

在公有派生情况下，有关派生类对象和基类对象的关系，不正确的叙述是（ B ） A、派生类的对象可以初始化基类的引用 B、派生类的对象可以直接访问基类中的成员 C、派生类的对象的地址可以赋给指向基类的指针 D、派生类的对象可以赋给基类的对象

当保护继承时，基类的（ B ）在派生类中成为保护成员，不能通过派生类的对象来直接访问。

A、任何成员 B、公有成员和保护成员 C、私有成员 D、公有成员和私有成员 下面对派生类的描述中，错误的是（ C ） A、派生类至少有一个基类

B、派生类的成员除了它自己的成员外，还包含了它的基类的成员 C、派生类中继承的基类成员的访问权限到派生类中保持不变 D、一个派生类可以作为另外一个派生类的基类 下述静态数据成员的特性中，错误的是( A )。 A、静态数据成员不是所有对象所共用的

B、说明静态数据成员时前边要加修饰符static

C、引用静态数据成员时，要在静态数据成员名前加上<类名>和作用域运算符 D、静态数据成员要在类体外进行初始化

派生类的对象对它的基类成员中( C )是可以访问的 A、公有继承的私有成员B、公有继承的保护成员 C、公有继承的公有成员 D、私有继承的公有成员 C++语言建立类层次结构是通过（ D ）。

A、抽象类B、类的嵌套 C、虚函数D、类的继承

print函数是一个类的常成员函数，它无返回值，下列表示中正确的是（B ）。 A、void const print()B、void print()const C、void print(const) D、const void print() 若类Ａ和类Ｂ的定义如下： class A {

int i,j; public:

void get(); //... };

class B: A {

int k; public:

void make(int ); //... };

void B::make(int j) {

k = i*j; }

则上述定义中，非法的表达式是( A )。

A、k=i*j; B、void get();C、int k; D、void make(int )

在多基继承的构造函数定义中，几个基类的构造函数之间用( A )分隔。 A、, B、; C、: D、::

在下列各函数中, 不是类的成员函数的是（ D ）。

A、拷贝构造函数B、析构函数 C、构造函数D、友元函数 对于任意一个类，析构函数的个数有( D )。 A、不确定B、2C、0D、1

在C++程序中，对象之间的相互通信通过( A )。

A、调用成员函数实现 B、函数重载实现 C、继承实现D、封装实现 下列有关类的说法不正确的是( C )。 A、类是一种用户自定义的数据类型

B、只有类中的成员函数才能存取类中的私有数据

C、在类中，如果不作特别说明，所有的成员函数均为公有类型 D、在类中，如果不作特别说明，所有的数据均为私有类型

类中定义的各个成员需要设置被访问的权限，以下给出的关键字中，( D )不能用于限定成员的访问权限。

A、publicB、protected C、privateD、extern 在下列函数中，（ B ）不能重载。

A、非成员函数 B、析构函数 C、构造函数 D、成员函数 构造函数的功能是（ B ）

A、建立对象并初始化成员函数B、建立对象并初始化数据成员 C、为类的实例分配存储空间 D、为类名分配存储空间 下列关于对象的描述不正确的是( A )。

A、现实世界中的一切事物都可以看作对象,但只有在具体的系统中加以论述才有实际的意义

B、对象可以描述任何东西 C、对象的属性是对象的静态特征,服务是动态特征,并且对象的属性只能由本对象的服务来操作

D、对象具有属性和服务两个主要因素 对于一个C++的类（ D ）

A、可有一个构造函数和多个析构函数 B、只能有一个构造函数和一个析构函数 C、可有多个构造函数和多个析构函数 D、可有多个构造函数和一个析构函数 关于析构函数，以下说法正确的是( D )

A、当对象调用了构造函数之后，立即调用析构函数

B、析构函数与构造函数的唯一区别是函数名前加波浪线~，因此，析构函数也可以重载 C、类中定义了构造函数，就必须定义析构函数，否则程序不完整，系统无法撤消对象 D、定义类时可以不说明析构函数，此时系统会自动产生一个缺省的析构函数 关于构造函数，以下正确的说法是( C )

A、构造函数没有返回值，因为系统隐含指定它的返回值类型为void

B、无参构造函数和参数为缺省值的构造函数符合重载规则，因此这个类中可以含有这两种构造函数

C、对象一经说明，首先调用构造函数，如果类中没有定义构造函数，系统会自动产生一个不做任何操作的缺省构造函数

D、定义类的成员时，必须定义构造函数，因为创建对象时，系统必定要调用构造函数 执行以下程序后，输出结果依次是( C )

class test { int x; public:

test(int a ),x=a;cout<

void main()

{ test x(1);x=5;}

A、1 构造函数 1 构造函数 5 析构函数 5析构函数 B、1 构造函数 5 析构函数 5 构造函数 5析构函数 C、1 构造函数 5 构造函数 5析构函数 5析构函数 D、1 构造函数 1 析构函数 5 构造函数 5析构函数 下列叙述中，不正确的是：( A )

A、类的析构函数可以重载 B、类的构造函数可以重载

C、一个类可以不定义析构函数 D、一个类可以不定义构造函数 关于成员函数特征的下述描述中，（ D ）是错误的。 A、成员函数可以是静态的B、成员函数可以重载

C、成员函数可以设置参数的默认值 D、成员函数一定是内联函数 在下列函数原型中，可以作为类AA构造函数的是（ A ）。 A、AA(int) const B、AA(int) const C、int AA( ) D、void AA(int) （ B ）是析构函数的特征。

A、析构函数的定义只能在类体内 B、一个类中只能定义一个析构函数 C、析构函数名与类名不同D、析构函数可以有一个或多个参数 类的构造函数被自动调用执行的情况是在创建该类的（ D ）。 A、数据成员时 B、友元函数时C、成员函数时D、对象时 在下面的类定义中，错误的语句是（ C ）。 class sample{ public:

sample(int val); //① ~sample( ); //② private:

int a=2.5; //③ public: sample( ); //④ A、③ B、④C、② D、① 下列说法中正确的是（ D ）。

A、类中的函数成员在类体之外定义时必须要与类声明在同一文件中 B、类定义中只能说明函数成员的函数头，不能定义函数体 C、在类体之外定义的函数成员不能操作该类的私有数据成员 D、类中的函数成员可以在类体中定义，也可以在类体之外定义 类的实例化是指（D ）。 A、定义类 B、指明具体类

C、调用类的成员 D、创建类的对象

数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是

( A )

A、类 B、对象 C、函数体 D、数据块

A、int &xx=x; B、int xx; C、int &xx; D、int xx=&x; 以下关于枚举的叙述不正确的是（ D ）

A、枚举变量只能取对应枚举类型的枚举元素表中元素 B、可以在定义枚举类型时对枚举元素进行初始化 C、枚举元素表中的元素有先后次序，可以进行比较 D、枚举元素的值可以是整数或字符串 以下对枚举类型名的定义中正确的是( C )

A、enum a={one,two,three}; B、enum a {\

C、enum a {one=9,two=1,three}; D、enum a={\设有如下枚举类型定义:

enum language { Basic=3,Assembly,Ada=100,COBOL,Fortran}; 枚举量Fortran的值为( A ) A、102 B、4 C、7 D、103

已知有职工情况结构变量emp定义为： struct Date { int year; int month; int day; };

strnct Employee { char name[20] ; long code ; Date birth };

Employee emp ;

下列对emp的birth的正确赋值方法是( B )。 A、year=1980; month=5; day=1;

B、emp.birth.year=1980; emp.birth.month=5; emp.birth.day=1; C、emp.year=1980; emp.month=5; emp.day=1; D、birth.year=1980; birth.month=5; birth.day=1; 枚举类型中的每个枚举常量的值都是一个（ D ） A、逻辑B、浮点数C、字符D、整数 以下程序的运行结果是（ C） typedef union{long a[2]; int b[4]; char c[8]; }TY; TY our;

main(){ cout<

使用typedef定义一个新类型的正确步骤是（C ） 1.把变量名换成新类型名。

2.按定义变量的方法写出定义体。 3.用新类型名定义变量。

4.在最前面加上关键字typedef。 A、2，4，1，3B、4，2，3，1 C、2，1，4，3 D、1，3，2，4 以下程序的运行结果是（ ） main()

{ union{ long a; int b; char c; }m;

cout<

A、2 B、6 C、8 D、4

若有以下定义，则以下叙述不正确的是（ ）： union data { int i; char c; float f; } un;

A、un可以作为函数参数

B、不能对un赋值，但可以在定义un时对它初始化 C、un的地址和它的各成员地址都是同一地址 D、un所占的内存长等于成员f的长度 若有以下定义和语句： union data { int i; char c; float f; } a; int n;

则以下语句正确的是（ D）。

A、cout《a; B、n=a; C、a={2,'a',1.2};D、a=5; 以下对共用体类型数据的叙述正确的是（ C ）。

A、共用体类型定义中不能出现结构体类型的成员 B、一个共用体变量中可以同时存放其所有成员 C、一个共用体变量中不能同时存放其所有成员 D、可以对共用体变量名直接赋值

当说明一个共用体变量时系统分配它的内存是（ D ）

A、结构中第一个成员所需内存量B、结构中最后一个成员所需内存量 C、成员中占内存量最大者所需的容量D、各成员所需内存量的总和

若有以下说明和语句： struct student

{int age; int num; }std,*p; p=&std;

则以下对结构体变量std中成员age的引用方式不正确的是（ C）。 A、(*p).ageB、p->age C、*p.ageD、std.age 下面程序的运行结果是（ A ） main() {

struct cmplx{int x; int y;

} cnum[2]={1,3,2,7};

cout<

A、6B、3C、 D、1

根据下面的定义，能打印出字母M的语句是（ C ） struct person{char name[9]; int age; };

struct person class[10]={\

A、cout《class[3].name; B、cout《class[3].name[1]; C、cout《class[2].name[0]; D、cout《class[2].name[1]; 以下程序的运行结果是（ C ） #include int main() {

struct date

{int year,month,day;} today; cout<

A、10B、8C、12 D、6

结构体类型变量在程序执行期间（ A ）

A、所有成员一直驻留在内存中B、没有成员驻留在内存中 C、只有一个成员驻留在内存中 D、部分成员驻留在内存中 设有以下说明语句 struct stu {int a; float b;

} stutype;则下面的叙述不正确的是（ C）。

A、stutype是用户定义的结构体类型名B、a和b都是结构体成员名 C、struct stu是用户定义的结构体类型D、struct是结构体类型的关键字 当说明一个结构体变量时系统分配给它的内存是（ D ）。

A、结构中最后一个成员所需内存量B、成员中占内存最最大者所需的容量

C、结构中第一个成员所需内存量D、各成员所需内存量的总和 已有定义int (*p)()；指针p可以（ A ）

A、指向函数的入口地址 B、代表函数的返回值 C、表示函数的类型 D、表示函数返回值的类型

若有函数max(a,b)，并且已使函数指针变量p指向函数max，当调用该函数时，正确的调用方法是（ A ）。

A、(*p)(a,b); B、(*p)max(a,b); C、*pmax(a,b); D、*p(a,b); 语句int (*ptr)()；含义是（ C）。

A、ptr是指向int型数据的指针变量 B、ptr是指向一维数组的指针变量 C、ptr是一个函数名，该函数的返回值是指向int型数据 D、ptr是指向函数的指针，该函数返回一个int型数据

若有说明：char *language[]={\则language[2]的值是（ A ）。

A、一个字符串 B、一个不定值 C、一个地址 D、一个字符

若以下main函数经过编译、连接后得到的可执行文件名为echo.exe，若希望在系统的命令状态下输入某一命令行后得到输出是china tianjin，则命令行的内容应是（ B）。 main(int argc, char *argv[]) {

int i;

for(i=1; i

cout<

A、echo chinatianjinB、echo china TianjinC、echo D、china tianjin 若有以下定义，则*(p+5)表示（ B ）。

A、元素a[6]的值 B、元素a[5]的地址C、元素a[6]的地址D、元素a[5]的值 若有定义：int *p[4]；则标识符p( C )。

A、说明不合法 B、是一个指针，它指向一个含有四个整型元素的一维数组 C、是一个指针数组名D、是一个指向整型变量的指针 以下与int *q[5]；等价的定义语句是（ A ）。

A、int *(q[5]); B、int (*q)[5]; C、int *q; D、int q[5]; 若有定义：int (*p)[4]；则标识符p（ D ）。

A、是一个指针数组名B、是一个指向整型变量的指针

C、定义不合法 D、是一个指针，它指向一个含有四个整型元素的一维数组 若有定义：int a[5]; 则a数组中首元素的地址可以表示为（ B）。 A、&aB、a C、a+1 D、&a[1]

填空题：

使程序的输出结果为： the worker is Zhang San the manager is Liu Ping #include

//删除【】左边的下划线并填入适当的语句，使它能调试并得到正确的结果。 //注意：不要改动main函数，不得增行或删行，也不得更改程序的结构 class manager; class worker {

char *name; public:

worker(char *str) {

name=str; }

friend void print(worker &, manager &); };

class manager {

char *name; public:

manager(char *str) {

name=_str_;//【1】 }

friend void print(worker &, manager &); };

void print(worker _&a_, manager _&b_) //【2】 {

cout<<\cout<<\}

void main() {

worker w(\manager m(\print(_w,m_); //【3】 }

题目描述：仔细阅读下列求两个点之间距离的程序，程序的输出结果是50，根据程序的输出结果在划线处填入正确语句。 #include #include using namespace std; class point

{

public:

point(float a,float b) { x=a; y=b; } float Distance(point &p) {

float dx=p.x-x; float dy=p.y-y;

return (float)sqrt(dx*dx+dy*dy); }

private: float x,y; };

int main() {

point p1(2,3),p2(32,43);

cout<

下列程序中声明了类girl，其中函数“display”是类girl的友元函数，请在（1）、（2）和（3）处各填入正确的内容，使程序能正常运行。 #include using namespace std; class girl {

private:

char name; int age; public:

girl(char n, int d) //构造函数 {

name= n; age=d; }

friendvoid display(girl &x); //声明友元函数 };

void display(girl &x) //类外定义友元函数 {

cout<<\ //girl类的友元函数能访问girl类对象的私有成员 }

int main( ) {

girl e('z',18);

display(e); //调用友元函数

return 0; }

后置自增运算符“++”重载为类的成员函数（设类名为A）的形式为 A operator++(int) 。

假定AB为一个类，则语句AB(AB&x)；为该类 拷贝构造 函数的原型说明。

定义类时，在类头中将使用关键字 class 来表示类定义的开始。

C++中，友元 不是 （是、不是）该类的成员函数

C++类的组成包括数据成员和 成员函数 。

new的功能是分配内存空间,delete的功能是 释放内存空间 。

无论是什么继承方式，派生类的成员不能访问基类 私有 属性的成员。

如果一个类包含一个或多个纯虚函数，则该类称为 抽象类 。

从实现的角度来讲，多态性可以划分为两类：静态多态性和 动态多态性

如果只想保留公共基类的一个复制，就必须使用关键字 virtual 把这个公共基类声明为虚基类。

C++中两种用户自定义的数据类型有结构体和 结构体类型变量 。

通过关键字 template 可以声明模板，通过关键字class(或typename)指定函数模板的类型参数，有几个类型参数就有几个类型关键字。

运算符重载要求保持其原来的操作数个数、结合性、 优先级 和语法结构。

类的静态成员分为静态数据成员和 静态函数成员 。

如果只想保留公共基类的一个复制，就必须使用关键字 virtual 把这个公共基类声明为虚基类。

在C++中，三种继承方式的说明符号为public、private和protected，如果不加说明，则默认的继承方式为 private 。

类和对象的关系可表述为：类是对象的抽象，而对象则是类的 实例 。

含有纯虚函数的类称为 抽象 类。

下列程序的功能是通过重载运算符“+=”，实现复数的相加赋值操作，请完善程序。 class Complex

{ double real,imag; public:

Complex( ) { real=0; imag=0; }

Complex( double r, double i) { real=r; imag=i; } Complex operator+=( Complex&x) { real +=x.real; imag +=x.imag;

returnComplex(real,imag); } };

下列程序第一行输出结果为8，第二行输出结果为9，请完善程序。 class B { int a,b; public:

B(int aa=0,int bb=0) { a=aa; b=bb; } B operator+( B b,int x);

void show( ) , cout<

B operator+( B b, int x) { B r;

r.a=_b.a+x_; r.b=_b.b+x-1_; return r; }

void main( )

{ B x(3,5), y(8,4),z1; z1=x+5; z1.show( ); }

以下程序实现动态数组类的功能，通过重载“＝”实现动态数组对象的赋值，add函数实现元素的追加，试完成该程序。 class array { int num; float *p; public:

array( ) { num=0; p=0; } array (int n, float *a) { num=n;

if(num= =0) p=0;

else { p=new float[num]; for(int i=0; i

~array( ) { if(p) delete []p; } array& operator=(array &arr) { if(num= =arr.num)

{ for(int i=0; i

else { if(p) delete []p; p=new float[arr.num]; num=arr.num;

for(int i=0; i

returnthis; }

void add(float x) { num++;

float *pt=new float[num];

for(int i=0; i

void show( )

{ for(int i=0; i

void main( )

{ float x[4]={10,11,12,13}; array a1(2,x), a2;

a2=a1; a1.show( ); a2.show( );

a2.add(14); a2.add(35); a2.show( ); }

下列程序的功能是通过重载运算符“＝＝”，实现字符串的比较运算，请完善程序。 class String { char *st; public:

int operator= =(String &); String( );

String(char *); ~String( );

void show( ) { cout<

String ::String( )

{ st=’\\0’; }

String ::String(char *s)

{ st=new char[_strlen(s)+1_ ]; strcpy(st,s); }

String ::~String( ) { delete _[]st_; }

int String ::operator= =(_String_ &tar) { return strcmp(_st_, tar.st) = =0; } void main( )

{ String youname(“zhang”); String myname(“Lou”);

cout<<(myname= = youname); }

运算符重载有两种实现方法，一种是通过友元函数来实现，另一种通过（成员）函数来实现。 运算符重载有两种实现方法，一种是通过成员函数来实现，另一种则通过_友元函数_ 来实现。

为了满足运算符“+”的可交换性，必须将其重载为_友元函数_。 运算符重载仍然保持其原来的优先级、操作个数和结合性。 利用成员函数对双目运算符重载，其左操作数为_this指针_，右操作数为__成员函数参数_。 类的构造函数__不可以_(可以/不可以)是虚函数，类的析构函数_可以_ (可以/不可以)是虚函数。当类中存在动态内存分配时经常将类的__析构函数_函数声明成虚函数。 纯虚函数是一种特别的虚函数，它没有函数的_函数体_部分，也没有为函数的功能提供实现的代码，它的实现版本必须由_派生类_给出，因此纯虚函数不能是友元函数。拥有纯虚函数的类就是_抽象类_类，这种类不能实例化。如果纯虚函数没有被重载，则派生类将继承此纯虚函数，即该派生类也是_抽象_类。

虚函数的声明方法是在函数原型前加上关键字_virtual_。在基类中含有虚函数，在派生类中的函数没有显式写出virtual关键字，系统依据以下规则判断派生类的这个函数是否是虚函数：该函数是否和基类的_虚函数_同名；是否与基类的虚函数_参数个数相同、类型_ ；是否与基类的虚函数_相同返回类型_ 。如果满足上述3个条件，派生类的函数就是虚函数。并且该函数覆盖基类的虚函数。

C++支持两种多态性,分别是 编译时 和 运行时 。 C++将类继承分为_单继承__和_多继承_两种。

派生类的构造函数一般有3项工作要完成：首先 基类初始化 ，其次 成员 对象初始化 ，最后执行派生类构造函数体。

当公有派生时，基类的公有成员成为派生类的 公有成员 ；保护成员成为派生类的 保护成员 ；私有成员成为派生类的 不能直接访问成员 。

当保护派生时，基类的公有成员成为派生类的 保护成员 ；保护成员成为派生类的 保护成员 ；私有成员成为派生类的 不能直接访问成员 。

在C++中，三种派生方式的说明符号为 public 、 private 、 protected 不加说明，则默认的派生方式为 private 。

补充以下程序，使其输出结果为20，40。

#include class A {

__public:___ int x; public:

A(int x=20){___A::x=x ___;} };

class B:public A {

int y; public:

B(int i=30,intj=40) ___{A::X=20;y=j}_____ void print()

{_cout<

void main() { B b;

b.print(); }

补充以下类，使其能正确运行。 #include class P {

private: int x1,x2; static int y; public:

P(_int i=0,int j=0_){x1 = i; x2 = j; } };

_int P::y _=0; //对静态成员y赋值 void main() {

P data[20]; }

类CPoint中的成员函数Init的功能是用已知对象给另一对象赋值，请将其补充完整。 class CPoint {

int x,y; public:

CPoint(int i,intj){ x = i; y = j; } void Init(CPoint& k) {

if(_this==&k_) return; //防止自身赋值 _*this _=k; } };

如果在定义类时没有定义构造函数，则编译系统会 默认构造函数 。如果用一个已经定义的对象去初始化另一个对象，则系统会调用 拷贝构造函数 。

类具有 继承、封装 、多态 的性质,所以所编出的程序安全性好，重用性好。 对象是类的实例。

类的成员的访问属性有三种，分别是 公共成员 、 私有成员 、 保护成员 。

类是 对象 的集合,分类的依据是 具有相同的结构和特性 。

构成对象的两个主要因素是 属性 和 行为 ,其中 行为 属于动态属性, 属性 属于静态属性, 成员数据只能由成员函数来操作。

写出程序程序执行结果( 5 10 3): #include using namespace std; class MyClass { public:

int number; void set(int i); };

int number=3;

void MyClass::set (int i){ number=i; }

void main( ){ MyClass my1; int number=10; my1.set(5);

cout<

cout<

写出程序程序执行结果( 5,7 ): #include using namespace std; class AA{ int n; public:

AA(int k):n(k){} int get( ) {return n;}

int get( ) const{ return n+1;} };

int main( ) {

AA a(5);

const AA b(6);

cout<

写出程序程序执行结果( n=0): #include using namespace std; class Test { public:

Test( ) { n+=2; } ~Test( ) { n-=3;}

static int getNum( ) { return n;} private: static int n; };

int Test::n=1; int main( ){

Test* p = new Test; delete p;

cout<<”n=”<

类的访问限定符包括public、 private 和(potected) 。类成员默认的访问方式是(private) 。访问限定符在类中无 先后次序，各限定符(允许)(允许/不允许)多次出现。 类定义的关键字是（class），类的数据成员通常指定为（ 私有），类的函数成员通常指定为（公有），指定为（公有）的类成员可以在类对象所在域中的任何位置访问它们。

定义语句int *f()；和int (*f)()；的含义分别为_f表示一个函数名，其返回值类型为int *_和_表示f是函数指针，它可以指向一个返回值为int类型。

设main函数的说明为： main( int argc, char *argv[])，且有命令行为：FILE1 1 2 3(代表回车)，则argc的值是_4_，argv[1]的值是_1_。

判断题

试题1： 运算符重载是通过函数来实现的，定义运算符重载函数时，函数名中要使用关键字

operator。（ T ）

试题2： 在c++中，只能重载已有的运算符。（ T ）

试题3： 私有继承中，基类中所有成员对派生类的对象都是不可见的。（ F ）

试题4： 类成员的默认访问模式是private。（ T ） 试题5： 一个类只能拥有一个对象。（ F ） 试题6： 友元是可以继承的。（ F ）

试题7： 对象是类的模板，类是对象的实例化。（ F ）

试题8： 构造函数名字和类名相同，构造函数可以带默认参数，可以重载，在创建对象时自

动执行。（ T ）

试题9： 结构体变量能整体进行输入输出。（ F ）

试题10： C++语言结构体类型变量在程序执行期间，所有成员驻留在内存中。（ T ） 试题1： 使用关键字class定义的类中默认的访问权限是私有的（private）。（ T ） 试题2： 静态类标识符在它的作用域之外是不存在的。（ F） 试题3： 函数形参的作用域是该函数的函数体。（ T ）

试题4： 在设置了参数默认值后，调用函数的对应实参就必须省略。（ F） 试题5： 使用内置函数是以增大空间开销为代价的。(T）

试题6： 基类中被说明为protected和private的成员只能被其派生类的成员函数访问，不能

被其他的函数访问。( F )

试题7： 说明函数原型时不需要指明每个函数参数的名字，只需说明每个参数的类型和返回

值类型就可以了。( T )

试题8： 函数重载既要求两函数参数对应的类型不同又要求参数个数不同。( F ) 试题9： 程序的编译是以文件为单位的，因此将程序分到多个文件中可以减少每次对程序修

改所带来的编译工作量。( T )

试题10： 派生类的成员函数可以直接访问基类的所有成员。( F ) 试题1： 在类Time中的析构函数可以声明为：void ~Time(int); （ F ） 试题2： 一个派生类不能作为基类被别的派生类继承。（F ） 试题3： 类中所提供的成员函数可以直接访问私有成员。（ T ）

试题4： 如果在一个类的对象之间要进行数据交换，可以使用该类的静态数据成员来完成。

（ T ）

试题5： 友元关系是单向的，不可交换的。（ T ） 试题6： 每个类都必须自己定义构造函数和析构函数。（ F ） 试题7： 析构函数没有形参，没有返回值，不能重载。（ T ）

试题8： 内联函数中不可以包括复杂语句，如switch及循环语句等。（ T ） 试题9： 结构体中的成员(域)，不可以单独使用。（ T ） 试题10： 结构体的定义不为它分配具体的内存空间。（ T ）

试题1： 用new动态申请的内存空间，必须用delete来释放。( T ) 试题2： 说明函数原型时不需要指明每个函数参数的名字，只需说明每个参数的类型和返回

值类型就可以了。( T )

试题3： 无论什么方式的继承，基类的私有成员都不能被派生类访问。（ T ） 试题4： 类的私有成员只能被类中的成员函数访问，任何以外的函数对它们的访问都是非法

的。（ F ）

试题5： 派生类的成员除了它自己的成员外，还包含了它的基类的所有成员。（ T） 试题6： 用new运算符来创建对象时不会调用构造函数。（ F ） 试题7： 构造函数的名字不一定要和类的名字一样。（ F ） 试题8： 任何一个对象只能属于一个具体的类。（ T ） 试题9： 对抽象类不能定义对象。（ T）

试题10： 使用关键字class定义的类中默认的访问权限是私有(private)的。（ T ）

void show( ) , cout<

void operator++(B &b) { b.a+=2; b.b+=5; }

void main( ) { B x(3,5); ++x;

x.show( ); }

下列程序的运行结果是（10 7）。 class S { int n; public:

S(int i) {n=i; }

operator ++( ) { n+=5; } operator++(int) { n+=2; }

void show( ) , cout<

void main( ) { S A(5), B(5); ++A; B++; A.show( ); B.show( ); }

下列程序的运行结果是（11 9）。 class point { int a,b; public:

point( int aa, int bb ) { a=aa; b=bb; } void operator +=(point &p) { a+=p.a; b+=p.b; } void show( )

{ cout<

void main( )

{ point p1(3,5), p2(8,4); p1+=p2; p1.show( ); }

本程序调用构造函数实现字符串对象的初始化。调用重载运算符”+”把两个字符串拼接，并

通过重载运算符“>”来实现字符串的比较运算。 #include #include class string { char *str; public:

string(char *s=0) {

if(_(1)_){str=new char[strlen(s)+1]; strcpy(__(2)__);} else str=0; }

friend string operator+(string &,string &); int operator>(string &);

void show(){ if(str)cout<

string operator+(string &s1,string &s2) {

string t;

t.str=____(3)_____; strcat(t.str,s2.str); ______(4)_______; }

int string::operator>(string &s) {

if(strcmp(____(5)_____)>0)return 1; else return 0; }

void main(void) {

string s1(\ string s3; s3=s1+s2;

s1.show(); s2.show(); s3.show(); cout<<(s1>s2)<<'\\n'; }

说明以下类Words的功能，并给出程序执行结果。 #include #include class Words {

char *str； public：

Words(char *s) {

str=new char[strlen(s)+1]；

strcpy(str，s)； }

void disp(){cout<

if(str*i+>=’A’&& str*i+<='Z') // 大写字母 return char(str[i]+32)；

else if(str[i]>='a'&&str[i]<='z') // 4'写字母 return char(str[i]-32)； else // 其他字符 return str[i]； } }

void main() {

int i；

char *s=”Hello”； Words word(s)； word．disp()；

for(i=0；i

解：Words类含有一个私有数据，其成员函数有：一个构造函数，disp()函数用于输出str，下标运算符重载函数用于将指定下标的字母大小写互换，其他字符时不变。本程序的输出结果如下：

Hell() heLL()

写出下列程序的运行结果： #include

static int dys[]={31，28，31，30，31，30，31，31，30，31，30，31}； c1ass date {

int mo ,da, yr； public：

date(int m，int d，int y){mo=m；da=d；yr=y；} date(){}

void disp(),cout<

friend date operator+(date &d，int day) // 运算符重载友元函数 {

date dt；

dt．mo=d．mo； dt．yr=d．yr； day+=d.da；

while(day>dys[dt．mo-1]) {

day-=dys[dt．mo-1]； if(++dt．mo==13) {

dt．mo=1； dt．yr++； } }

dt.da=day； return dt； } }

void main() {

date dl(2，10，2003)，d2； d2=dl+365;

d2．disp()； }

结果为：2／10／2004

以下程序的执行结果是（ ）。 #include class Sample {

private： int x； public：

Sample(){x=0；}

void disp(),cout<<”x=”<

void main() {

Sample obj； obj．disp()； obj++；

cout<<“执行bj++之后”<

结果为：x=0 执行bj++之后 x=10

以下程序的执行结果是（ ）。

#include class Sample {

int n； public：

Sample(){｝

Sample(int m){n=m；｝ int &operator--(int) { n--；

return n； }

void disp() { cout<<”n=”<

void main() {

Sample s(10)； (S--)++； S．disp()； }

结果为：n=10

以下程序的执行结果是（ ）。 #include class Tc { private:int A;

static int B;//静态数据成员 public:Tc(int a){A=a; B+=a;}

static void display(Tc c)//Tc的对象为形参 {

cout<<\ } };

int Tc::B=2; int main( ) { Tc a(2),b(4); Tc::display (a); Tc::display (b); }

结果为：A=2,B=8 A=4,b=8

分析输出结果：

{ int length,width; public:

Rectangle(int x,int y,int l,int w):Point(x,y) { length=l;width=w;}

int getlength(){return length;} int getwidth(){return width;} };

void main()

{ Rectangle r(0,0,8,4); r.move(23,56);

cout<

定义一个Point类，派生出Rectangle类和Circle类，计算各派生类对象的面积Area（）。将下列程序未完成的部分按要求完成之。 #include using namespace std; const double PI=3.14159; class Point { public:

Point(double x=0, double y=0) {X=x;Y=y;}

void ShowPoint() {cout<<\ private: double X,Y; };

class Rectangle: public Point { public:

Rectangle(double w,double h,double x,double y):Point(x,y) {width=w,height=h;Area();}

void Area() {area= width*height;} void ShowArea(){

cout<<\ }

private:

double width,height,area; };

class Circle: public Point { //**填入适当的语句 };

int main(){

Rectangle r(10,8,0,0); Circle c(4,3,5); r.ShowArea(); c.ShowArea(); return 0;

}

写出程序运行结果: #include using namespace std; class B{ public:

void f1(){cout<<\};

class D:public B{ public:

void f1(){cout<<\};

void f(B& rb){ rb.f1(); }

int main( ){ D d;

B b,&rb1=b,&rb2=d; f(rb1); f(rb2); return 0; }

结果为： B::f1 B::f1

试题6：写出下列程序的运行结果： #include class A{ public:

A(){ fvd(); }

virtual void fvd(){cout<<\基类中的成员函数\};

class B:public A{ public:

void fvd() { cout<<\派生类中的成员函数\};

void bar(){ A * a=new B; delete a;} void main(){ bar(); A a; B b; }

结果为：

基类中的成员函数 基类中的成员函数 基类中的成员函数

写出下列程序的运行结果： #include class A{ public:

A(int i = 3){ x = i; } virtual void at(){

cout<<\ }

void at2(){ at();} protected: int x; };

class B: public A{ public:

B(int m){ y = m; }

void at(){cout<<\ private : int y; };

void main(){ A k(5),* p; p = &k; p->at2(); B s(8); p = &s; p->at2(); }

结果为： x=5 y=8

试题8：

#include class A{ public:

A(){cout<<\ voidf(){ cout<<\};

class B :public A{ public:

B(){ cout<<\

virtual voidf(){ cout<<\};

class C:public B{ public:

C(){cout<<\ void f(){cout<<\};

void main(){ A * pa; B * pb;

pa = pb = new C; pa->f(); pb->f(); } 输出为：

A constructor called! B constructor called! C constructorcalled! f() is called in A! f() is called in A!

Rect是一个矩形类，main()函数中定义了3个对象，分别用到了两个构造函数，其中的缺省构造函数将数据成员全部初始化为0。main()中又执行了两矩形相加操作和输出操作。请完善程序。 class Rect{

private：

float x： //左下角X坐标 float y； //左下角Y坐标 float w： //宽 float h： //高 public：

Rect(){ (1) } Rect( (2) ){ x=a；y：=b；w=c；h=d； }；

Rect operator+(Rect b)； void Display()； }；

Rect (3) (Rect b){ Rect s；

s．x=x+b．x；s．y=y+b．y； s.w=w+b．w； s．h=h+b.h； return (4) ; }

void Rect：：Display(){

cout<<”x=”<

void main(){

Rect A，B(1．4，2，3，20)，c(2．5，5，3，4.8)； A=B+C：

A．Display()； }

阅读程序回答问题： #include class A {

int x; public:

void Show()

{ cout<<”x=”<

{ x=a;cout<<”A”<<’\\n’;- ~A(){ cout<<”~A”<<’\\n’;- };

void main(void) { A f; f.Show(); f=20; f.Show(); }

问题一：本程序共输出 行，依次是： 问题二：与语句f=20等价的语句是

问题三：语句f=20是系统采用了 的类型转换 问题四：语句f=20的作用是

A.将常数20赋给对象f，然后调用构造函数 B.先用对象f调用构造函数，然后将20赋给f

C.f自动产生一个临时对象，再调用构造函数，将20初始化构造函数

D.=左边调用构造函数，并将20转换为临时对象，完成初始化后将临时对象赋给f

问题五：程序执行结果是： 阅读程序，回答问题 #include class node {

int x,y; public:

node(int a,int b)

{ x=a;y=b;cout<<”node_1”<<’\\n’;- node()

{ x=a.x;y=a.y;cout<<”node_2”<<’\\n’;- void Show()

{ cout<<”x=”<

void main(void) {

node f1(5,6);node f2(f1);f2.Show(); }

问题一：构造函数node()的参数表中缺少一个形参，这个形参的正确定义是： 问题二：node()中的形参被正确定义后，执行结果依次是：

根据程序回答问题： #include class A{ public:

A(int a) ,x=a;cout<<”x=”<

class B

{ A y,z; int s; public:

B(int a,int b,int c);y(a+b+c),z(3-a)

{ s=c-b;cout<<”s=”<

void main(void) { B s(1,2,3);}

问题一：本程序共输出 行，其中第三、第四行分别是

问题二：本程序中，y,z是 的对象成员，它们是 的对象，它们的访问权属于

根据程序回答问题： #include class A {

int x,y;

public: A(int a,int b) {

x=a;y=b;cout<<”ABC”<<’\\t’; }

A(),x=3;y=4;cout<<”CBA”<<’\\n’;- VoidShow()

{ cout<<”x=”<

A *s1=new A(1,2),*s2=new A; s2->Show(); delete s1; delete s2; }

问题一：本程序的执行后输出结果是：

问题二：如果将语句s2->Show()改为s1->Show(),执行结果是：

?

试题9：Rect是一个矩形类，main()函数中定义了3个对象，分别用到了两个构造函数，其中的缺省构造函数将数据成员全部初始化为0。main()中又执行了两矩形相加操作和输出操作。请完善程序。 class Rect{ private：

float x： //左下角X坐标 float y； //左下角Y坐标 float w： //宽 float h： //高 public： Rect(){ x=y=w=h=0 }

Rect( float a , float b ,float c, float d ){ x=a；y：=b；w=c；h=d； }；

Rect operator+(Rect b)； void Display()； }； Rect Rect::operator+ (Rect b){ Rect s；

s．x=x+b．x；s．y=y+b．y； s.w=w+b．w； s．h=h+b.h； return s ; }

void Rect：：Display(){

cout<<”x=”<

cout<<”w=”<

void main(){

Rect A，B(1．4，2，3，20)，c(2．5，5，3，4.8)； A=B+C：

A．Display()； }

类别：[ 分析类 ] 难度：[ 较难 ] 入库时间：2014-3-23

?

试题10：阅读程序回答问题： #include class A {

int x; public:

void Show()

{ cout<<”x=”<

{ x=a;cout<<”A”<<’\\n’;} ~A(){ cout<<”~A”<<’\\n’;} };

void main(void) {

A f;

f.Show(); f=20; f.Show(); }

? ? ? ?

问题一：本程序共输出 4 行，依次是： A

x=10 A ~A

X=20 ~A

问题二：与语句f=20等价的语句是 A(20) 问题三：语句f=20是系统采用了 的类型转换 问题四：语句f=20的作用是 D A.将常数20赋给对象f，然后调用构造函数 B.先用对象f调用构造函数，然后将20赋给f

C.f自动产生一个临时对象，再调用构造函数，将20初始化构造函数

D.=左边调用构造函数，并将20转换为临时对象，完成初始化后将临时对象赋给f

问题五：程序执行结果是：

?

试题1：阅读程序，回答问题 #include class node {

int x,y; public:

node(int a,int b)

{ x=a;y=b;cout<<”node_1”<<’\\n’;} node()

{ x=a.x;y=a.y;cout<<”node_2”<<’\\n’;} void Show()

{ cout<<”x=”<

void main(void) {

node f1(5,6);node f2(f1);f2.Show(); }

问题一：构造函数node()的参数表中缺少一个形参，这个形参的正确定义是： node &a

问题二：node()中的形参被正确定义后，执行结果依次是： node_1 node_2 x=5 y=6

类别：[ 分析类 ] 难度：[ 中等 ] 入库时间：2014-3-23

?

试题2：根据程序回答问题： #include class A{ public:

A(int a) {x=a;cout<<”x=”<

class B

{ A y,z; int s; public:

B(int a,int b,int c);y(a+b+c),z(3-a)

{ s=c-b;cout<<”s=”<

void main(void) { B s(1,2,3);}

问题一：本程序共输出 ６ 行，其中第三、第四行分别是 ｓ＝１ class_B class_~B

问题二：本程序中，y,z是 B 的对象成员，它们是 A类 的对象，它们的访问权属于 私有

类别：[ 分析类 ] 难度：[ 较难 ] 入库时间：2014-3-23

?

试题3：根据程序回答问题： #include class A { int x,y; public: A(int a,int

b){x=a;y=b;cout<<”ABC”<<’\\t’;} A(){x=3;y=4;cout<<”CBA”<<’\\n’;} void Show() { cout<<”x=”<Show(); delete s1;delete s2;}

?

问题一：本程序的执行后输出结果是： ABC CBA x =3 y=4 XYZ XYZ 问题二：如果将语句s2->Show()改为s1->Show(),执行结果是： ABC CBA ｘ＝ １ ｙ＝２ ＸＹＺ ＸＹＺ

?

?

本文来源：https://www.bwwdw.com/article/fcjw.html