C++练习题.docx
《C++练习题.docx》由会员分享，可在线阅读，更多相关《C++练习题.docx（13页珍藏版）》请在冰豆网上搜索。
C++练习题
填空题
1.如果要把A类成员函数f（）且返回值为void声明为类B的友元函数，则应在类B的定义中加入的语句___。
friendvoidA:
:
f（）
2．在保护派生中，基类权限为Private的成员在派生类中____。
3．不同对象可以调用相同名称的函数，但可导致完全不同的行为的现象称为____。
4.在C++中，虽然友元提供了类之间数据进行访问的一种方式，但它破坏了面向对象程序设计的_______特性
5．设类A有成员函数voidsum（void）；若要定义一个指向类成员函数的指针变量p来指向sum，该指针变量的声明语句是。
6.基类的公有成员在派生类中的访问权限由访问控制方式或___决定。
选择题
1.下列关于类与对象的说法中，不正确的是（）
A．对象是类中的一个实例
B．任何一个对象只能属于一个具体的类
C．一个类只能有一个对象
D．类与对象的关系和数据类型与变量的关系相似
2．下列关于类的权限的描述错误的是（）
A．类本身的成员函数只能访问自身的私有成员
B．类的对象只能访问该类的公有成员
C．普通函数不能直接访问类的公有成员，必须通过对象访问
D．一个类可以将另一个类的对象作为成员
3.基类中的（）不允许外界访问，但允许派生类的成员访问，这样既在一定的隐藏能力，又提供了开放的接口
Ａ．公有成员B．私有成员C．保护成员D．私有成员函数
4.要禁止修改指针p本身，又要禁止修改p所指向的数据，这样的指针应定义为（）
A.constchar*p=“abc”；B.char*constp=“abc”；
C.charconst*p=“abc”；D.constchar*constp=“abc”；
5．下面描述中，表达错误的是（）。
A）公有继承时基类中的public成员在派生类中仍是public的
B）公有继承是基类中的private成员在派生类中仍是private的
C）公有继承时基类中的protected成员在派生类中仍是protected的
D）私有继承时基类中的public成员在派生类中是private的
6假定一个类的构造函数为“A（inti=2,intj=0）{a=i;b=j;}”,则执行“Ax
（1）;”语
句后，x.a和x.b的值分别为（）
A.1和0B.1和2
C.2和0D.2和1
7．要让一个类中的所有对象具有共同的数据，请使用（）。
A.常数成员变量B.私有数据成员
C.静态数据成员D.以上都是
8.对类A，复制构造函数的原型是（）
A.A：
：
A（constA&）；B.A：
：
A（constA*）；
C.A：
：
A（constA）；D.A：
：
A（）；
9．下列描述错误的是（）
A．在创建对象前，静态成员不存在B．静态成员是类的成员
C．静态成员不能是虚函数D．静态成员函数不能直接访问非静态成员
10．可以在派生类的成员函数中访问基类的非私有成员，并能通过派生类的对象直接访问基类公有成员的派生方式是（）
A．publicB．protectedC．privateD．friend
classB:
publicA
{
intk;
public:
voidmake（）{k=m;k=i*j;}
};
11．若类A和类B的定义如下：
classA
{
inti,j;
protected:
intm;
public:
intgeti（）{returni;}
};
则上述中，（）是非法的表达式。
A.voidmake（）;B.intk;
C.k=m;D.k=i*j;
12．下面类的定义,有（）处错误.
classtest
{inti=0;
public:
voidtest（）;
~test（intn）;};
A.1B.2C.3D.4
13.以下基类中的成员函数表示纯虚函数的是（）
A.virtualvoidvf（int）
B.voidvf（int）=0
C.virtualvoidvf（）=0
D.virtualvoidyf（int）{}
14.如果表达式++X中的“++”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（）
A.a.operator++
（1）B.operator++（X）C.operator++（X,1）
D.a.operator++（）
判断题
1．在私有继承中，基类中只有公有成员对派生类是可见的。
（）
2．析构函数是一种函数体为空的成员函数。
（）
3．基类中的保护成员在其派生类中可以访问，而派生类对象不可访问。
（）
程序分析题
1.#include
classA
{public:
A（）
{cout<<"A构造函数＼n";}
}
classB:
publicA
{public:
B（）
{cout<<"B构造函数＼n";
fun（）;}
voidfun（）{cout<<"B:
:
fun（）calle函数＼n";}
};
voidmain（）{Bd;}
2.#include
classB{
public:
B（inti）{b=i+10;show（）;}
B（）{}
virtualvoidshow（）{cout<<"B:
:
show（）被调用."<protected:
intb;
};
classD:
publicB{
public:
D（inti）:
B（i）{d=i+20;show（）;}
D（）{}
voidshow（）{cout<<"D:
:
show（）被调用."<protected:
intd;
};
voidmain（）{Dd1（5）}
3．#include
voidswap（int&a,int&b）
{a=a+b;
b=a-b;
a=a-b;
}
voidmain（）
{inta=15,b=20;
cout<<"a="<swap（a,b）;
cout<<"a="<}
4.#include
classa
{public:
virtualvoidprint（）
{cout<<"aprog..."<};
classb:
publica
{};
classc:
publicb
{public:
voidprint（）{cout<<"cprog..."<};
voidshow（a*p）
{（*p）.print（）;
}
voidmain（）
{aa;
bb;
cc;
show（&a）;
show（&b）;
show（&c）;
}
5.#include
usingnamespacestd；
classCMax{
private:
intxx；intyy；
public:
CMax（intx，inty）
{xx=x；yy=y；}
voidsetValue（intx，inty）
{xx=x；yy=y；}
intmax（）{
returnxx>yy?
xx:
yy；
}
}；
voidmain（）{
CMaxm（）；
m.setValue（50，70）；
cout<<″Max=″<}
6．#include
usingnamespacestd；
classA{
inta；
public：
A（intaa=0）{a=aa；}
～A（）{cout<<″DestructorA!
″<}；
classB：
publicA{
intb;
public:
B（intaa=0,intbb=0）:
A（aa）{b=bb;}
～B（）{cout<<″DestructorB!
″<};
voidmain（）
{
Bx（3）,y（4,5）;
}
7．#include
intf（inta）;
voidmain（）
{
inta=2,i;
for（i=0;i<3;i++）
cout<}
staticintc=5;
intf（inta）
{
intb=0;
b++;c++;
return（a+b+c）;
}
8.#include
classA
{
public:
voidShow（）{cout<<"A:
:
Show\n";};
};
classB:
publicA
{
public:
voidShow（）{cout<<"B:
:
Show\n";};
voidDisplay（）{Show（）;};
};
voidmain（）
{
Aa;
Bb;
a.Show（）;
b.Show（）;
b.Display（）;
}
9．#include
usingnamespacestd;
classA
{
public:
virtualvoidfun（inti）
{cout<<"A.i="<};
classB:
publicA
{
public:
voidfun（intj）
{cout<<"B.j="<};
voidshow（A&a）
{
intk=50;
a.fun（k）;
}
intmain（）
{
Aa;
Bb;
cout<<"Callingshow（a）.\n";
show（a）;
cout<<"Callingshow（b）.\n";
show（b）;
return0;
}
10.#include
classClass
{
public:
staticintvar;
Class（）
{
var++;
}
};
intClass：
：
var=1；
voidmain（）
{
cout<<″Class：
：
var=″<:
var<Classcl;
cout<<″cl.var=″<Classc2,c3;
cout<<″c2.var=″<}
程序改错题
1.classA{
private:
intnum;
public:
A（）;
intgetint（）{returnnum;}
void~A（）;
};
2.#include
classT
{protected:
inta;
public:
T（intm）{p=m;}
};
voidmain（）
{Tt（10）;
cout<}
3．classA
{
public:
A（intx,inty）
{
X=x;Y=y;
}
……
private:
intX,Y;
}
classB:
publicA
{
public:
B（intp,intq）
{
P=p;
Q=q;
}
privare:
intP,Q;
};
4.#include
voidmain（）
{inti,*p;
i=5;
p=i;
cout<<*p<}
5．#include
voidmain（）
{inti
（2）,j（5）;
int*constp=&i;
cout<<*p<p=&j;
cout<<*p<}
6．#include
intmain（）{
intx=1，y=2；
constint*p=＆x；
*p=y；
cout<<*p<return0；}
7.#include
classpoint
{private：
floatx；
public：
voidf（floata）{x=a;}
voidf（）{x=0;}
friendfloatmax（point&a，point&b）；
}；
floatmax（point&a，point&b）
{return（a.x>b.x）?
a.x：
b.x；}
voidmain（）{
pointa，b；
a.f（2.0）；b.f（4.0）；
cout<}
8．#include
classA
{
private：
intx，y；
public：
A（inta=3，b=4）；
voidShow（）；
}；
A：
：
A（inta，intb）
{
x=a；
y=b；
}
voidA：
：
Show（）
{
cout<<″x=″<cout<<″y=″<}
升级会员 