2025年C语言编程挑战题库及详解

C++程序设计练习题

一、填空题

1.对象的三大基本特性分别为多态性、（）、封装性。

2.赋值运算符应重载为（）函数。

3.用（）申明的基类称为虚基类。

4.用（）申明的函数称为虚函数。

5.派生类对基类继承控制访问有三种。派生类可以定义其基类中不具有的（）。

6.静态组员是对象的组员，（）函数不是类的组员。

7.在函数体之前加（）关键字可以防止覆盖函数变化数据组员的值。

8.一种consi对象只能访问（）组员函数。

9.使用友元函数是为了提高程序效率，且节省了（）开销。

10.类名为“ClassName”的类，其拷贝构造函数的原型阐明是（）。

11.由关键字private、public和proiecled限定组员的访问权限分别是（）、（）和（）。缺

省关键字时组员的访问权限为（）。

12.假如想要公共基类在派生类中只有一种拷贝，就要将公共的基类阐明为（）；假如虚基类没有

默认构造函数，就必须在每一种派生类的构造函数中都要调用虚基类的（）函数。

13.静态组员函数是使用关键字（）阐明的组员函数。

14.一种函数的原型申明为"voidFunName（inl=0,double=0,char='x）;"，则调用FunName函数的措施

共有（）种。

15.编译时多态性是通过（）实现的；运行时多态性是通过（）实现的。

16.C++通过（）实现编译时多态性，通过（）实现运行时多态性。

17.在C++中，申明类的关键字是（）。

18.申明C++模板的关键字是（）。

19.调用函数原型申明为“voidFunName（short,ini=0,float=I.O）;”的措施有（）种。

20.处理C++异常的措施：采用（）构造。

21.用关键字（）、（）和（）限定的组员，其访问权限分别为：公有的、私有的和保护的。

缺省关键字时，组员的访问权限为（）。

22.在C++中，处理（）的措施是采用try-catch构造。

23.在C++中，用关键字（）阐明内置函数。

24.在C++中，申明友元函数的关键字是（）。

25.将公共基类阐明为（）时，多重派生过程中公共基类在派生类中就只有一种拷贝了。

26.在C++中，假如函数调用在前、定义在后，就必须先对函数进行（）。

27.在组员函数头之后、函数体之前加（）修饰的组员函数称为类的常组员函数。

28.包括纯虚函数的类称为抽象类，这种类只能用作（）来派生新类。由于抽象类的特殊性，我们

可以阐明抽象类的（）.但不能阐明抽象类的（）。

29.阐明函数类型为“double"、函数名为“virfun”且无参数的纯虚函数的体现形式为（）。

30.阐明静态组员要使用关键字（）。

31.当函数调用在前定义在后时，必须先对函数进行（）阐明。

32.类名为“ClassN”的类的拷贝构造函数的函数原型阐明为（）。

33.抽象类是包括（）的类，必须注意：不能阐明抽象类的（），但可阐明抽象类的（）。

34.流插入运算符＜＜只能重载为友元函数，重载流插入运算符＜＜的函数名为（）。

35.要防止在该组员函数中变化数据组员的值，就要在类的组员函数名之后、函数体之前加上关键字

36.类和对象的关系可表述为：类是对象的（），而对象则是类的（）。

37.在C++中，三种继承方式的阐明符号为（）、（）和（），假如不加阐明，则默认的继

承方式为（）。

38.假如只想保留公共基类的一种复制，就必须使用关键字（）把这个公共基类申明为虚基类。

39.若要把voidmyfun（）定义为类A的友元函数，则应在类A的申明中加入语句（）＞

40.类的静态组员分为（）和（）。

41.运算符重载规定保持其本来的操作数个数、（）、（）和语法构造。

42.通过关键字（）可•以申明模板，通过关键字（）指定函数模板的类型参数。

43.请列出C++中两种顾客自定义的数据类型：（）、（）。

44.构造函数的作用是（）。

45.后置自增运算符“++”重载为类的组员函数（设类名为ClassName）的形式为（）。

二、单项选择题

1.继承机制的作用是（）

A）信息隐藏B）数据封装C）定义新类D）数据抽象

2.类的析构函数的作用是（）

A）一般组员函数B）类的初始化C）对象的初始化D）删除对象创立的所有对象

3.类的析构函数是在（）调用的。

A）类创立时B）创立对象时C）删除对象时D）不自动调用

4.在（）状况下合适采用Hine定义内联函数。

A）函数体具有循环语句B）函数体具有递归语句

C）函数代码少、频繁调用D）函数代码多、不常调用

5.假如类A被阐明成类B的友元，则（）

A）类A的组员即类B的组员B）类B的组员即类A的组员

C）类A的组员函数不得访问类B的组员D）类B不一定是类A的友元

6.在类中申明转换函数时不能指定（）

A）参数B）访问权限C）操作D）标识符

7.在公有继承的状况下.，基类组员在派生类中的访问权限（）

A）受限制B）保持不变。受保护D）不受保护

8.在C++类体系中，不能被派生类继承的有（）

A）转换函数B）构造函数C）虚函数D）静态组员函数

9.假定QassN为一种类，则执行“QassNx:"语句时将自动调用该类的（）

A）有参构造函数B）无参构造函数C）拷贝构造函数D）赋值构造函数

10.C++语言建立类族是通过（）

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

11.重载一元运算符-为类A的组员运算符，若有类A的对象obj,则体现式-。bj被C+-编译器解释

为1）。

A）obj.operator-（）B）operator-（obj）C）obj::operator-（）D）obj:opcrator—（）

12.如下有四种有关类的说法，其中不对的的是（）。

A）构造函数可以指定参数，但不能指定函数类型B）一种类可以有多种构造函数

C）析构函数不可以指定参数，但可以指定函数类型D）一种类只能有一种析构困数

13.面向对象程序设计讲求封装性，在C++中封装是借助于（）实现的。

A）构造B）数组C）类D）函数

14.下面有四种有关类的说法，其中不对的的是（）。

A）一种类可以有多种构造函数B）析构函数不可以指定函数类型，但可以指定函数参数

C）一种类只能有一种析构函数D）在一种类中可以阐明其他类的对象

15.下列有关基类的论述中不对的的是（），前提为“公有派生二

A）基类的公有组员在派生类中仍然是公有的B）基类的保护组员在派生类中仍然是保护的

C）基类的私有组员在派生类中仍然是私有的D）基类的私有组员在派生类中是不可访问的

16.如下有四种有关友元的描述，其中错误的是（）。

A）类A的友元类B的组员函数都是类A的友元函数B）友元函数可以访问该类的私有数据组员

C）类与类之间的友元关系可以继承D）友元可以提高程序的运行效率

17.C++的封装性是借助于()实现的。

A)函数B)数组C)构造D)类

18.要将-重载为类ClassN的后置友元运算符，那么，要在类中添加的原型阐明为()。

A)friendClassNoperator-(ClassN&,int);B)friendClassNoperator—(ClassN&);

C)friendClassNoperator-(int);D)friendClassNoperator-();

19.在公有派生时，下列描述中不对的的是()。

A)派生类的对象可以赋给基类的对象B)派生类对象的地址可以赋给指向基类的指针

C)派生类的对象可以初始化基类的引用

D)当基类的指针指向派生类对象时，通过该指针可以直接访问派生类中的组员

20.如下有关继承组员的访问属性的论述中，不对的的是()。

A)基类的保护组员在私有派生类中是私有的B)对基类组员的访问必须没有二义性

C)基类的保护组员在保护派生类中是保护的D)基类的保护组员在派生类中是保护的

三、程序改错题(改正下列类中的错误)

1.

classClassN

{

private:intnmember;

ClassNpmember;

public:ClassN();

intClassN(intx);

)

2.

voidmain()

(

charc[]=newchar[20];

deletec;

)

3.

classMyClass

{

private:intn=l;

MyClasspO;

public:MyClass(inta=0);

void-MyClass(inta);

)；

4.

#include<iostream>

usingnamespacestd;

voidmain()

{

int&par=newint[6];

deletepar;

cout>>"主函数End!"«endl;

)

5.

#include<iostrcam>

usingnamespacestd;

voidmain()

long&par=newlong[9];

deletepar;

coutvv”主函数End!"vvEndl;

6.

CLassCN

{

private:longn;

CNpobj;

public:CN();

voidCN(intX);

)；

四、分析程序输出题

I.

#include<iostream>

usingnamespacestd;

classA

{

public:

A(){cout«"constructingA"«endl;

〜A(){cout«"dcstructingA"«endl;

}；

classB:publicA

(

public:

B(){cout«"constructingB"«endl;

-B(){coul«"deslructingB"«endl;

)；

classC:publicB

|

public:

C(){cout«"constructingC"«endl;

-C(){cout«"destructingC"«endl;

)；

voidmain()

{Cel;}

2.

#include<iostream>

usingnamespacestd;

voidfun(int&a,int&b)

{

intp;p=a;a=b;b=p;

I

voidexchange(in(&a,int&b,in(&c)

|

if(a<b)fun(a,b);

if(a<c)fun(a,c);

if(b<c)fun(b,c);

}

voidmain()

inta=12,b=89,c=56;

exchange(a,b,c);

cout«"a=',«a«,,,b="«b«",c="«c«endl;

I

3.

#include<iostream.h>

classTC{

private:

ininum;

public:

TC();

intTEST(){returnnum;}

~TC();

}；

TC::TC(){num=O;}

TC::-TC(){cout«"Destinctorisactive"«endl;}

voidmain()

|

TCtarr[51;

cout«"Exitingrnain"«endl;

I

4.

#includc<iostrcam.h>

classCBase

{

private:intn;

public:CBase(intm=0){n=m;}

virtualvoidprint(){cout«"InsideCBase"«n«endl;

)；

classCDrive:publicCBase

{

private:intn;

public:CDrive(){n=0;}

CDrive(inta,intb):CBase(a),n(b){}

voidprint(){cout«"InsideCDrive"«n«end);}

)；

voidmain()

{

CBasebl,b2(99),*pb;

CDrivedd(l1,22);

pb=&bl;

pb->print();

pb=&b2;

pb->print();

pb=ⅆ

pb->print();

pb->CBase::print();

)

5.

#include<iostream.h>

classCTest

private:

longnum;

public:

CTcst();

~CTest();

I；

CTest::CTest(){num=0.}

CTest::~CTest(){cout«"调用析构函数"vvendl;

voidmain()

{

CTestcobj;

cout«”退出主函数”<<cndl;

}

6.

#include<iostream.h>

classCN

(

private:intn;

public:CN(inti){n=i;}

operatorint(){returnn;}

}；

voidmain()

(

CNcobj(123);

cout«cobj«endl;

I

7.

#include<ioslream.h>

voidmain()

{

intnum=I()0;

int&ref=num;

cout«ref«endl;

ref=ref+100;

cout«num«endl;

num=num+100;

cout«ref«cndl;

I

8.

#include<iostream.h>

classCName

{

private:longnum;

public:CName();

-CNamc();

)；

CName::CName(){num=0;

CName:>CName(){coutvv"调用析构函数"vvendI;}

voidmain()

{

CNamecan[2];

cout«"退出main"«endl;

)

9.分析下列程序并写出程序的运行成果。

#include<iostream.h>

classCBase

{

private:intn;

public:CBase(intm=0){n=m;}

virtualvoidprint(){cout«"InsideCBase"«n«endl;

}；

classCDrivc:publicCBase

(

private:intn;

public:CDrive(){n=0;}

CDrive(inta,intb):CBase(a),n(b){}

voidprint(){cout«"InsideCDrivc"«n«cndl;

I；

voidmain()

{

CBaseba,bb(100),*pb;

CDrivedd(123,456);

pb=&ba;

pb->print();

pb=&bb;

pb->print();

pb=ⅆ

pb->print();

pb->CBase::print();

)

10.

#includc<iostrcam.h>

classCT

(

private;intn;

public:CT(inti){n=i;}

operatorint(){returnn;}

}；

voidmain()

{

CTcObj(1234);

cout«cObj«end1;

I

五、编程题

1.下列类组员函数的定义不完整，请在一处填代码以使其完整。

classTC{

private:

intnum;

floatx;

public:

TC(int,float);

TC(TC&);

)；

TC::TC(intn,floatf)

{

num=n;

)

TC::TC(TC&()

x=t.x;

)

2.根据下面的主程序，完毕类阐明的最小形式(不规定实现组员函数的定义)。

#include<iostream.h>

classBase

{

private:_______;

public:;

}；

voidmain()

{Basebo(6);}

3.一种类的头文献如下所示，程序产生对象tco,且tco.num=10,并使用Show()函数输出这个对象

的值。

//ten.h

classTCN{

private:intnum;

public:TCN(intn){num=n;}

voidShow(){cout«nuin«cndl;}

}；

#includc<iostrcam.h>

#include"ten.h"

voidmain()

4.完毕下面类中的组员函数的定义(在一处填写合适的内容)。

classCTN

(

private:inimen;

floatmef;

public:CTN(int,float);

CTN(CTN&);

)；

CTN::CTN()

{men=a;

一=b;

CTN::CTN(—i£)bj)

{men=___;

mcf-____.mef;

}

5.在一处填写合适内容，以便完毕下列类组员函数的定义。

classCN

{

private:intmn;

floatmf;

public:CN(int=0,float=0);

CN(CN&);

}；

CN::CN()

{this->mn=mn;

___=mf;

}

CN::CN(rObj)

(

mn=;

mf=.f:

}

6.填上合适的字句，使程序的最终止果为200。

#includc<iostrcani.h>

classCNumber

{

private:intval;

public:CNuniber(inti){val=i;}

_int()；

}；

CNumber::operatorint(){}

classnum:publicCNumber{

public:

num(inti):CNuniber(i){)

}；

voidmain()

{

numn(100);

inti=n;

cont«i+n«endl;

)

7.下面是一种类的测试程序，设计出能使用如下测试程序的类:

voidmain()

{

Testto;

to.Init(300,200);

to.Print();

输出成果：300-200=100

8.已知复数类Complex的申明如下:

classComplex

public:

Coniplex();

Complex(double);

Complcx(double,double);

friendComplexoperator+(Complex&,Complex&);

friendostream&operator«(oslream&,Complex&);

friendistream&operator»(istream&,Complex&);

private:

doublereal,imag;

}；

规定：

(1)写出该类的所有构造函数的类外定义代码。

(2)写出对运算符“+”、“<<"、“>>”进行重载的运算符重我函数的定义。

9.下列Abstract类是一种表达形状的抽象类，area()为求图形面积的函数，total。)则是一种通用的用

以求不一样形状的图形面积总和的函数.

classAbstractC

{

public:

virtualdoublearea()=0;

}；

doubletotal(AbslractC*sa[],intn)

(

doubles=0.0;

for(inti=0;i<n;i++)s+=sa[i]->area();

returns;

)

规定：

(I)从AbstraciC类派生圆类(Circle)、正方形类(Square),圆类新增数据组员半径(r),正方形类新增数据

组员边长(a),圆类和正方形类均有构造函数，修改、显示数据组员值的函数，求面积函数。

(2)写出main()函数，计算半径为3.5的圆和边长为7.9的正方形的面积和(必须通过调用tolal函数计

Mio

10.一种类的头文献cn.h的内容如下所示：

//cn.h

#include<iostream.h>

classCN

{

private:intn;

public:CN(inl);

voidPrint。；

)；

CN::CN(intN){n=N;}

voidCN::Print(){cout«n«cndl;}

(1)编写一种主程序，产生对象Obj,且使Obj对象中的n组员的值为100,并使用Print。函数输出这

个对象中私有组员n的值。

(2)在主程序中，创立一动态对象，使该动态对象的数据组员值为，并使用指针pObj指向该动态对象,

然后输出该动态对象的数据组员的值。

11.一种类的头文献CT.h的内容如下所示；

//CT.h

#include<iostreain>

usingnamespacestd;

classCT

private:intm;

public:CT(int);

voidShowM();

)；

CT::CT(intn){m=n;}

voidCT::ShowM(){cout«m«endl;}

(1)编写一种主程序，产生对象mObj,且使mObj对象中的m组员的值为11,并使用ShowM()函数

输出这个对象中私有组员m的值。

(2)在主程序中，创立一动态对象，使该动态对象的数据组员值为126,并使用指针pObj指向该动态

对象，然后输出该动态对象的数据组员的值。

12.使用运行时多态性编程实现三角形、矩形和圆的总面积的记录并输出成果。三角形、矩形和圆类

的类名分别为T、R和C。T类必须以S类作基类,R类必须从T类派生，C类必须以S作基类。Shape

类妁定义如下：

classS

{

private:intx,y;

public:S(in(a=0,intb=0):x(a),y(b){}

virtualintArea()=0;

}；

不必建立工程，将所有代码都放在一种源文献中。在主函数中，必须调用下列Sum函数来记录各类图

形面积的总和。

intSum(S*s[],intn)

(

intsum=0;

for(inti=0;i<n;i++)sum+=s[i]->Area();

returnsum;

参照答案

一、填空题

1.继承性

2.组员

3.virtual

4.virtual

5.组员

6.友元

7.const

8.const

9.调用类组员函数的

10.ClassName(ClassName&);

II.私有公有保护私有

12.虚基类构造

13.static

14.4

15.函数重载虚函数

16.函数重载虚函数

17.class

18.template

19.3

20.try-catch

21.privatepublicprotectedprivate

22.异常

23.inline

24.friend

25.虚基类

26.原型申明

27.const

28.基类指针对象

29.virtualdoublevirfun()=0;

30.static

31.原型

32.ClassN(ClassN&);

33.纯虚函数对象指针

34.operator«

35.const

36.抽象实例

37.publicprotectedprivateprivate

38.virtual

39.friendvoidmyfun();

40.静态数据组员静态组员函数

41.结合性优先级

42.templatetypenameHJCclass

43.classstruct

44.初始化对象中的数据组员等

45.ClassNameoperator++(int);

二、单项选择题

1-5；CDCCD

6~IO：ABBBB

11-15：ACCBC

16-20：CDADD

三、程序改错题(改正下列类中的错误)

1.

uClassNpmember;"->"QassN*pmember;"

uintClassN(intx);M->uClassN(intx);w

“}”少

2.

"charc[]=newchar[20];”今"char*c=newchar[20];“

“deletec;”->^delete[]c/

3.

“intn=l;”->“intn;”

“MyClasspO:")"MyClass*pO;”

“void~MyClass(inta);”->“~MyClass();”

4.

“ini&pai-newint[61;w->“int+pai-newin([61;w

44deletepar;”->“delete[]par;"

“cout>>"主函数End!"vvendl;"主"coutvv”主函数End!n«endl;w

5.

4<long&par=newlong[9]；w玲ulong*par=newlong[9]；”

udeletepar;v->udelete[]par;w

“coutv<"主函数End!”<<Endl;"T"coul<<”主函数End!n«endl;M

6.

“CNpobj;”1"CN*pobj;"

“voidCN(intX);”->“CN(inlX);”

四、分析程序输出题

1.

constructingA

constructingB

constructingC

destructingC

destructingB

destructingA

2.

a=89,b=56,c=12

3.

Exitingmain

Destructorisactive

Destructorisactive

Destructorisactive

Destructorisactive

Destructorisactive

4.

InsideCBase0

InsideCBase99

InsideCDrivc22

InsideCBase11

5.

退出主函数

调用析构函数

6.

123

7.

100

20()

300

8.

退出main

调用析构函数

调用析构函数

9.

InsideCBase0

InsideCBase100

InsideCDrive456

InsideCBase123

10.

1234

五、编程题

I.

x=fnum=t.num

2.

intnBase(intm)

3.

TCNtco(l0)tco.Show()

4.

inta,lloaibmefCTN&rObj.mnrObj

5.

intmn,floatmfthis->mfCN&rObj.niObj

6.

operatorreturnval

7.

classTest

{

private:intx,y;

public:voidInit(inta,intb)(x=a;y=b;)

voidPrint(){cout«x«"-"«y«"="«x-y«endl;

)；

8.

Complex::Complex()

{

real=0;

imag=0;

}

Complex::Complex(doubler)

{real=r;}

Complex::Complex(doublendoublei)

{real=r;imag=i;}

Complexoperator+(Complex&cl,Complex&c2)

{

Complexc;

c.real=cl.real+c2.real;

c.imag=cl.imag+c2.imag;

returnc;

I

ostream&operator«(ostrcam&output,Complex&c)

|

output«"("«c.real«"+"«c.imag«Hi)"«end);

returnoutput;

I

istreani&operator»(istream&input,Complex&c)

|

cout«"inputrealandimaginarypartofcomplexnumber:";

input»c.real»c.imag;

returninput;

I

9.

#include<iostrcam>

usingnamespacestd;

classAbstractC

{

public:virtualdoublearea()=0;

}；

doubletotal(AbstractC*sa[],intn)

{

doubles=0.0;

for(inti=0;i<n;i++)s+=sa[i]->area();

returns;

I

classCircle:publ