面向对象编程部分习题答案.docx
《面向对象编程部分习题答案.docx》由会员分享，可在线阅读，更多相关《面向对象编程部分习题答案.docx（24页珍藏版）》请在冰豆网上搜索。
面向对象编程部分习题答案
1类与对象
1.1填空题
（1）类和对象是面向对象程序设计的两个最基本概念，类表示抽象的概念，而___对象___则是___类___的实例化。
（2）类的成员包括__数据成员____和__成员函数____两类，其中类的___成员函数___是为类的所有对象所共有的。
（3）类的数据成员___不能___在类定义时进行初始化。
（能/不能）
（4）类成员的访问方式包括___private___、___protected___和__public____3种，默认的访问方式是___private___。
（5）类中声明友元的关键字是___friend___。
（6）在类的外部定义成员函数时应在函数名的前面加上__类名____和___作用域运算符___。
（7）访问对象的成员有___对象名.成员名___、__指针变量名->成员名____和___（*指针变量名）.成员名___3种格式。
（8）__构造____函数和___析构___函数是类的两种特殊的成员函数。
__构造____函数负责完成对象的创建和初始化工作，__析构____函数负责完成对象消失时的内存清理工作。
（9）类的__常量数据____成员和__引用数据____成员需用初始化表的方式提供初值。
（10）类的静态数据成员的初始化应该写在___全局___区域上，而且要指明___数据类型___和____所属的类__。
（11）常对象只能调用类中的___常成员___函数，该函数为类的___只读___函数。
（12）类的私有成员和保护成员只能被该类的__成员____函数和__友元____函数访问。
（13）类的每一个成员函数都有一个隐含定义的指针，称为___this___指针，它的类型是成员函数所属类的类型。
1.2选择题
（1）下列关于类和对象的描述中，不正确的是（C）。
A一个对象只能属于一个类
B对象是类的一个实例
C一个类只能有一个对象
D类和对象的关系与数据类型和变量的关系类似
（2）若有如下声明：
classA{inta；}；
则A类的成员a是（C）。
A公有数据成员B公有成员函数
C私有数据成员D私有成员函数
（3）下列关于成员函数的描述中，不正确的是（B）。
A成员函数可以重载B成员函数一定是内联函数
C成员函数可以是静态的D成员函数可以设置参数的默认值
（4）在类外定义成员函数时，需要在函数名前加上（C）。
A对象名B类名
C类名和作用域运算符D作用域运算符
（5）下列关于this指针的描述中，正确的是（D）。
A任何与类相关的函数都有this指针B类的成员函数都有this指针
C类的友元函数都有this指针D类的非静态成员函数才有this指针
（6）下列关于构造函数的描述中，不正确的是（C）。
A构造函数的函数名与类名相同B构造函数可以重载
C构造函数必须指定函数类型D构造函数可以设置参数的默认值
（7）在下列函数原型中，可以作为类A构造函数的是（D）。
AvoidA（int）；BintA（）；
CA（int）constDA（int）；
（8）下列关于析构函数的描述中，不正确的是（B）
A析构函数有且只有一个
B析构函数可以参数
C析构函数没有函数类型
D析构函数的作用是在对象被撤销时清理其内存空间
（9）若有如下定义类：
classPoint
{intx，y；
public：
Point（）：
x（0），y（0）{}
Point（inta，intb=0）：
x（a），y（b）{}
}；
若执行语句
Pointa
（2），b[3]，*c[4]；
则Point类的构造函数被调用的次数是（C）。
A2次B3次C4次D5次
（10）下列关于new运算符的描述中，不正确的是（D）。
A使用new运算符可以用来动态创建对象和对象数组
B使用new运算符创建的对象可以使用delete运算符来释放
C使用new运算符创建对象时，会调用类的构造函数
D使用new运算符创建对象数组时，必须定义初始值
（11）下列关于常对象和常成员的描述中，正确的是（A）
A类的普通成员函数不能对常对象进行操作
B类的成员函数可以对常对象进行操作
C除常成员函数外，其他函数不可以对常对象进行操作
D在常成员函数中，常对象可以被更新
（12）下列关于静态数据成员的描述中，正确的是（C）。
A类的不同对象有不同的静态数据成员
B静态数据成员不能通过类的对象访问
C静态数据成员是类的所有对象共享的
D类的每一个对象都有自己的静态数据成员
（13）一个类的友元函数或友元类可以访问该类的（D）。
A私有成员B保护成员
C公有成员D私有成员、保护成员和公有成员
（14）在C++语言中，数据封装要解决的问题是（D）
A数据的规范化B便于数据的转换
C避免数据的丢失D防止不同模块之间非法的数据访问
（15）若有如下类定义：
ClassA
{inta;
public:
intgetRef（）const{return&a;}//①
intgetVlaue（）const{returna;}//②
voidset（intn）const{a=n;}//③
friendvoidshow（Aaa）const{count<};
其中的4个函数定义中正确的是（B）。
A①B②C③D④
1.3改错题
下列程序段中是否有错？
如果有错，请指出错误的位置和原因。
（1）
classWorker
{private:
charname[20];
floatsalary;
public:
voidinit（charname[],floatsalary）;
voidprint（）;
};
……
voidmain（）
{Workerman1,man2;
man1.salary=1000.00;
//…
}
答案：
man1.salary=1000.00;不能在类域外通过对象直接访问类的私有成员
（2）
classC1
{private:
floatr=0;
floatc=0;
//…
}
答案：
①floatr=0;和floatc=0;类本身是抽象的，不能在类的定义体中给其数据成员赋值；
②}后缺少分号“；”
（3）
#include
classCircle
{private:
floatx;
floaty;
floatr;
public:
voidsetdata（floatx1,floaty1,floatr1）;
voidprintdata（）;
};
voidprintdata（）
{cout<}
……
答案：
成员函数voidprintdata（）定义时应在函数名之前添加所属类的类名及作用域运算符。
（4）
classPoint
{private:
floatx;
floaty;
public:
point（）{x=0;y=0;}
voidprint（）{cout<};
答案：
构造函数名point（）应与类名同名，为Point。
1.4读程序写结果题
（1）
#include
classMyclass
{private:
intx;
inty;
public:
Myclass（inta,intb）{x=a;y=b;}
Myclass（）{x=0;y=0;}
voidprint（）;
};
voidMyclass:
:
print（）
{cout<<”x=”<}
voidmain（）
{
Myclassc1,c2（100.200）;
C1.print（）;
C2.print（）;
}
答案：
x=0,y=0
x=100,y=200
（2）
#include
classC1
{private:
intx;
inty;
public:
C1（）{}
C1（inta,intb）;
voidprintc1（）;
};
classC2
{private:
C1z;
floatt;
public:
C2（）{}
C2（inta,intb,float）;
voidprintc2（）;
};
C1:
:
C1（inta,intb）
{x=a;
Y=b;
}
C2:
:
C2（inta,intb,floatc）:
z（a,b）,t（c）
{}
voidC1:
:
printc1（）
{cout<<”x=”<}
voidc2:
:
printc2（）
{z.printc1（）;
cout<<”t=”<}
voidmain（）
{c1m（100.200）;
m.printc1（）;
c2n（1000,2000,float（3.14））;
n.printc2（）;
}
答案：
x=100,y=200
x=1000,y=2000
t=3.14
（3）
#include
classSta
{pricate:
inta;
staticintb;
public:
voidfun1（Sta&r）;
staticintfun2（）;
};
intSta:
:
b=10;
voidSta:
:
fun1（Sta&r）
{r.a=20;
cout<<”r.a=”<}
intSta:
:
fun2（）
{returnb++;
}
voidmain（）
{
cout<<”Sta:
:
fun2（）=”<:
fun2（）<Stas:
cout<<”s.fun2（）=”<s.fun1（s）;
}
答案：
Sta:
:
fun2（）=10
s.fun2（）=11
r.a=20
（4）
#include
classCall
{private:
intx;
public:
Call（）;
Call（inta）;
voidshow（）;
~Call（）;
};
Call:
:
Call（）
{x=0;
cout<<”Constructor1called!
”<}
Call:
:
Call（inta）
{x=a;
cout<<”Constructor2called!
”<}
voidCall:
:
show（）
{
cout<<”x=”<}
Call:
:
~Call（）
{cout<<”Destructorcalled!
”<}
voidmain（）
{callc1;
c1.show（）;
callc2（100）;
c2.show（）;
}
答案：
Constructor1called!
x=0
Constructor2called!
x=100
Destructorcalled!
Destructorcalled!
（5）
#include
usingnamespacestd;
classA
{intn;
public:
A（intk）:
n（k）{}
intget（）{returnn};
intget（）const{returnn+1;}
};
intmain（）
{Aa（5）;
constAb（6）;
cout<Return0;
}
答案：
57
2继承与派生
2.1填空题
（1）面向对象程序设计的继承机制实现了代码重用，有效地缩短了程序的开发周期。
（2）在继承关系中，被继承的类成为基类，通过继承关系定义出来的新类称为
派生类。
（3）派生类的继承方式有private、protected和public3种，其中默认的继承方式为private。
（4）公有继承时，基类的私有成员成为派生类的不可访问成员，基类的保护成员成为派生类的保护成员，基类的公有成员成为派生类的公有成员。
（5）在派生类中不能访问基类的私有成员，这符合面向对象程序设计的封装思想。
（6）C++语言不仅支持单
（一）继承，也支持多（重）继承。
（7）根据联编实现的不同阶段，可将其分为静态联编和动态联编两种。
（8）声明了纯虚函数的类，称为抽象类。
（9）运算符重载是一种特殊的函数重载
（10）对于运算符的重载可以有__重载为类的成员函数___和___重载为类的友元函数__两种方法。
（11）__Operator__和运算符一起可以组成运算符函数的函数名。
（12）对于双目运算符，若重载为类的成员函数，有__1___个参数；若重载为友元函数，则有__2___个参数。
（13）运算符[]不能作为类的__友元___函数重载。
2.2选择题
（1）下列关于派生类的描述中，不正确的是（B）。
A派生类的成员除了包含它自己的成员外，还包含其基类的成员。
B派生类中继承的基类的成员的访问权限在派生类中保持不变。
C派生类至少有一个基类。
D一个派生类可以作为另一个派生类的基类
（2）在保护继承中，基类的私有成员变成派生类的（A）
A不可访问成员B私有成员C保护成员D公有成员
（3）若有如下类声明：
ClassBase
{intk;
public:
voidset（intn）{k=n;}
intget（）const{returnk;}
};
Classderived:
protectedBase
{
protected:
intj;
public:
voidset（intm,intn）
{Base:
:
set（m）;
j=n;
}
intget（）const
{returnbase:
:
get（）+j;
}
};
则类derived中保护的数据成员和成员函数的个数是（B）。
A4B3C2D1
（4）在派生类的构造函数的初始化表中，不能包含（C）。
A基类的构造函数B派生类的一般数据成员的初始化
C基类的子对象的初始化D派生类的子对象的初始化
（5）若有如下类声明：
ClassX
{intx；
public：
X（intn）{x=n；}
}；
ClassY：
publicX
{inty；
public：
Y（inta，intb）；
}；
在构造函数Y的下列定义中，正确的是（B）。
AY:
:
Y（inta，intb）：
x（a）,y（b）{}BY:
:
Y（inta,intb）:
X（a）,y（b）{}
CY:
:
Y（inta，intb）：
x（a）Y（b）{}DY:
:
Y（inta，intb）：
X（a）,Y（b）{}
（6）在多重继承中，对于基类成员在派生类中的访问权限与单继承的规则（A）。
A完全相同B完全不同C部分相同D以上均不正确
（7）下列说法中不正确的是（D）。
A私有继承时，基类的公有成员在派生中是私有成员
B保护继承时，基类的公有成员在派生中是保护成员
C公有继承时，基类的公有成员在派生中是公有成员
D公有继承时，基类的私有成员在派生中是私有成员
（8）下列描述中不正确的是（B）。
A派生类的对象可以赋值给基类对象
B基类的对象可以赋值给派生类对象
C派生类的对象可以初始化为基类的引用
D派生类的对象的地址可以赋给指向基类的指针
（9）下列关于虚基类的描述中，不正确的是（B）。
A使用虚基类的目的是消除多重继承下的二义性
B虚基类中的子对象的初始化次数与该虚基类的派生类的个数有关
C虚基类中的子对象只初始化一次
D虚基类的多层派生类构造函数的成员初始化列表中都要列出对虚基类构造函数的调用
（10）运行时的多态性是指（B）。
A用指向对象的基类指针或引用调用一个纯虚函数
B用指向对象的基类指针或引用调用一个虚函数
C以任何方式调用一个纯虚函数
D以任何方式调用一个虚函数
（11）在C++中，用于实现运行时多态性的是（D）。
A内联函数B重载函数C模板函数D虚函数
（12）下列关于虚函数的描述中，正确的是（B）。
A从虚基类继承的函数都是虚函数B虚函数不得是静态成员函数
C只能通过指针或引用调用虚函数D抽象类中的成员函数都是虚函数
（13）下列关于运算符重载的描述中，正确的是（B）。
A）通过运算符重载，可以定义新的运算符
B）有的运算符只能作为成员函数重载
C）若重载运算符+，则相应的运算符函数名是+
D）重载一个二元运算符时，必须声明两个形参
（14）下列表达式中，运算符“/”的意义相同的一对是（D）。
A）3/2和3.0/2.0B）3/2和3/2.0
C）3/2和3.0/2D）3.0/2.0和3.0/2
（15）在重载一个运算符时，其函数的参数表中没有任何参数，这说明该运算符是（A）。
A）一元成员运算符B）二元成员运算符
C）一元友元运算符D）二元友元运算符
（16）以下运算符中既可以重载为类的成员函数，又可以重载为类的友元函数的是（D）。
A）=B）（）C）[]D）++
（17）已知在一个类体中包含如下函数原型：
Xoperator-（X）const；
下列关于这个函数的描述中，不正确的是（B）。
A）这是运算符-的重载运算符函数
B）这个函数所重载的运算符是一个一元运算符
C）这是一个成员函数
D）这个函数不改变类的任何数据成员的值
（18）在表达式x+y*z中，+是作为成员函数重载的运算符，*是作为友元函数重载的运算符。
下列描述中正确的是（C）。
A）operator+有两个参数，operator*有两个参数
B）operator+有两个参数，operator*有一个参数
C）operator+有一个参数，operator*有两个参数
D）operator+有一个参数，operator*有一个参数
（19）运算符重载是对已有的运算符赋予多重含义，下列描述中正确的是（C）。
A）可以对基本类型（如int类型）的数据，重新定义“+”运算符的含义
B）可以改变一个已有运算符的优先级和操作个数
C）只能重载C++中已有的运算符，不能定义新运算符
D）C++中已有的所有运算符都可以重载
2.3改错题
（1）
#include
classA
{public:
inta1;
protected:
inta2;
private:
inta3;
};
classB:
publicA
{public:
intb1;
voidfb（）;
protected:
intb2;
private:
intb3;
};
voidB:
:
fb（）
{a1=10;a2=20;a3=30;
b1=100;b2=100;b3=100;
}
voidmain（）
{Ax;
By;
x.a1=10;x.a2=20;x.a3=30;
y.a1=100;y.a2=200;y.a3=300;
y.b1=1000;y.b2=2000;y.b3=3000;
}
本题的错误主要是数据成员的访问权限问题：
基类的私有成员在派生类中不可访问，如fb（）函数中的a3=30;语句；类的私有和保护成员在类外不能访问，如main函数中的x.a2=20;.a3=30;，y.a2=200;，y.a3=300;，y.b2=2000;和y.b3=3000;语句。
（2）
#include
usingnamespacestd;
classbase
{private:
voidfun1（）const{cout<<”fun1”;}
protected:
voidfun2（）const{cout<<”fun2”;}
public:
voidfun3（）const{cout<<”fun3”;}
};
classderived:
protectedbase
{public:
voidfun4（）const{cout<<”fun4”;}
};
intmain（）
{derivedobj;
obj.fun1（）;
obj.fun2（）;
obj.fun3（）;
obj.fun4（）;
return0;
}
本题的错误主要是成员函数的访问权限问题：
由于派生类Derived是基类Base的保护派生类，所以基类中的私有成员变成派生类的不可访问成员，而基类的保护和公有成员则变成派生类的保护成员。
对于类的不可访问和保护成员在类外是不能访问的，故main函数中的语句obj.funl（）;，obj.fun2（）;和obj.fun3（）;是错误的。
2.4读程序写结果题
（1）
#include
classB
{public:
B（inti）{b=i-10;}
B（）{b=0;}
virtualvoidshow（）
{cout<<”b=”<prot
升级会员 