c++补考题目(附答案)

更新时间:2024-04-21 05:31:01 阅读量: 综合文库 文档下载

说明:文章内容仅供预览,部分内容可能不全。下载后的文档,内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的,是否完整无缺。

选择题

若定义: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() 若类A和类B的定义如下: 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);}

问题一:本程序共输出 6 行,其中第三、第四行分别是 s=1 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 x= 1 y=2 XYZ XYZ

?

?

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

Top