面向对象程序设计远程教育习题及答案3.docx

面向对象程序设计远程教育习题及答案3.docx

《面向对象程序设计远程教育习题及答案3.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计远程教育习题及答案3.docx（16页珍藏版）》请在冰豆网上搜索。

面向对象程序设计远程教育习题及答案3

5.#include

voidmain（）

{inti（3）,j（8）;

int*constp=&i;

cout<<*p<

p=&j;

cout<<*p<

}

答案：

int*constp=&i;在指针变量前加const表示一个常指针即地址不能变化，它指向的变

量不能改变且定义时必须设置指向变量或对象的地址。

［修改］int*p=&i;

2.#include

classT

{protected:

intp;

public:

T（intm）{p=m;}

};

voidmain（）

{Ta（10）;

cout<

}

答案：

［修改］public

［解析］protected保护类型的成员，不能在类外访问。

3.#include

usingnamespacestd;

classDate;

classTime

{public:

Time（inth,intm,ints）

{hour=h,minute=m,sec=s;}

voidshow（Date&d）;

private:

inthour,minute,sec;};

classDate

{public:

Date（intm,intd,inty）

{month=m,day=d,year=y;}

voidTime:

:

show（Date&）;

private:

intmonth,day,year;};

voidTime:

:

show（Date&d）

{cout<

cout<

"<

"<

voidmain（）

{Timet1（9,23,50）;

Dated1（12,20,2008）;

t1.show（d1）;

答案：

voidTime:

:

show（Date&）;成员函数作为友元函数，要加friend。

［修改］friendvoidTime:

:

show（Date&）;

4.输出最小值，有一处错误。

#include

classTest

{inta,b;

intgetmin（）

{return（a

a:

b）;}

public:

intc;

voidsetValue（intx1,intx2,intx3）

{a=x1;b=x2;c=x3;}

intGetMin（）;

};

intTest:

:

GetMin（）

{intd=getmin（）;

return（d=d

d:

c）;

}

voidmain（）

{Testt1;

t1.setValue（34,6,2）;

cout<

}

答案：

cout<

［修改］cout<

5.实现数值、字符串的交换。

#include

#include

usingnamespacestd;

template

voidSwap（T&a,T&b）

{Ttemp;

　temp=a,a=b,b=temp;

}

voidmain（）

{inta=5,b=9;

chars1［］="Hello",s2［］="hi";

Swap（a,b）;

Swap（s1,s2）;

cout<<"a="<

cout<<"s1="<

}

答案：

chars1［］="Hello",s2［］="hi";使用Swap（s1,s2）调用交换的是地址。

字符指针作实

参，形参值发生改变，实参也就发生变化。

　［修改］char*s1="Hello",*s2="hi";

1.#include

classA

{private:

intx;

public:

A（inti）{x=i;}

A（）{x=0;}

friendintmin（A&,A&）;};

intmin（A&a,A&b）

{return（a.x>b.x）?

a.x:

b.x;}

voidmain（）

{Aa（3）,b（5）;

cout<

}

答案：

cout<

。

min就是一个普通的友元函数。

　［修改］cout<

2.#include

classshape

{public:

virtualintarea（）{return0;}

};

classrectangle:

publicshape

{public:

inta,b;

voidsetLength（intx,inty）{a=x;b=y;}

intarea（）{returna*b;}};

voidmain（）

{rectangler;

r.setLength（3,5）;

shapes1,*s2=&r;

cout<

s2=s1;

cout<

}

答案：

shapes1,*s2=r;指针使用错误。

s是指针使用它指向对象的成员有两种方法，有下面两行

可知，使用的是引用。

［修改］改为shape&s=r;

3.下面的类定义中有一处错误，请用下横线标出错误所在行并给出修改意见。

#include

template

classA

{private:

Tx,y,s;

public:

A（Ta,Tb）

{x=a,y=b;s=x+y;}

voidshow（）

{cout<<"x+y="<

voidmain（）

{Aadd（10,100）;

add.show（）;

}

答案：

［修改］Aadd（10,100）;

［解析］Aadd（10,100）;类模板的使用，参数实例化后生成模板类。

用类模板定义对象时要指定

参数类型。

4.生成具有n个元素的动态数组。

#include

voidmain（）

{intn;

cin>>n;

inta［n］;

a［0］=2;

cout<

答案：

inta［n］;生成具有n个元素的动态数组，要使用new，所以inta［n］;错误。

［修改］int*a=newint［n］;

5.#include

classA

{inti;

public:

virtualvoidfun（）=0;

A（inta）

{i=a;}};

classB:

publicA

{intj;

public:

voidfun（）

{cout<<"B:

:

fun（）＼n";}

B（intm,intn=0）:

A（m）,j（n）{}};

voidmain（）

{A*pa;

Bb（7）;

pa=&b;}

答案：

B（intm,intn=0）:

A（m）,j（n）{}因为基类是抽象类，不能被实例化，所以在派生类中不能

调用初始化基类对象。

所以B（intm,intn=0）:

A（m）,j（n）{}错误，删去A（m）。

［修改］B（intm,intn=0）:

j（n）{}

1.#include

#include

#include

usingnamespacestd;

classA

{public:

A（constchar*na）{strcpy（name,na）;}

private:

charname［80］;};

classB:

publicA

{public:

B（constchar*nm）:

A（nm）{}

voidshow（）;};

voidB:

:

show（）

{cout<<"name:

"<

voidmain（）

{Bb1（"B"）;

b1.show（）;}

答案：

private:

因为name如果是私有的，在派生类中无法访问，而基类没有提供成员函数来访问

name，所以更改name访问权限为公有或保护，这样对于派生类来说是透明的。

［修改］public：

或protected：

2.下面的程序有错误，请修改。

#include

classA

{private:

inta;

public:

voidfunc（B&）;

A（inti）{a=i;}};

classB

{private:

intb;

friendvoidA:

:

func（B&）;

public:

B（inti）{b=i;}};

voidA:

:

func（B&r）

{a=r.b;

cout<

voidmain（）

{Bbt（3）;

Aat（10）;

at.func（bt）;

}

答案：

［修改］classB;

classA

［解析］classA类A中使用B类中的成员增加对B声明。

3.#include

classTest

{private:

intx,y=20;

public:

Test（inti,intj）{x=i,y=j;}

intgetx（）{returnx;}

intgety（）{returny;}};

voidmain（）

{Testmt（10,20）;

cout<

cout<

答案：

intx,y=20;在类内部不能对数据成员直接赋值。

［修改］intx,y;

4.#include

classA

{private:

intx,y;

public:

voidfun（inti,intj）

{x=i;y=j;}

voidshow（）

{cout<

voidmain（）

{Aa1;

a1.fun

（2）;

a1.show（）;}

答案：

voidfun（inti,intj）调用时有一个参数，形参有两个，可以使第二个带默认值。

［修改］voidfun（inti,intj＝0）

5.#include

classA

{private:

intx;

protected:

inty;

public:

A（inti,intj）{x=i;y=j;}};

classB:

publicA

{public:

　　　B（inta,intb）:

A（a,b）{}

　　　voidshow（）{cout<

voidmain（）

{Bb（8,9）;

b.show（）;}

答案：

private:

在基类中是私有成员，即使采用公有派生，但在派生类无法访问。

［修改］public:

或protected:

21．分析下列程序中的错误，并说明出错原因。

　　　　#include

　　　　classbase{

　　　　constintn;

　　　　public:

　　　　base（）{cout<<”Initializingdefault\n”;}

　　　　base（intm）{cout<<”Initializing\n”;n=m;}

　　　　~base（）{cout<<”Destroying\n”;}

　　　　};

　　　　voidmain（）

　　　　{basex=1;

　　　　basey=x;

　　　　}

　　　　　答：

（1）n=m;const数据成员不以该形式赋值

（2）错误处basey=x;，以对象初始化对象

　　[解析]

（1）作为const数据成员n不能用赋值表达式的形式为其赋初值，必须在定义构造函数时在函数头中以“base（intm）：

n（m）”形式来初始化。

（2）basey=x;语句中‘=’不是赋值的意思，而是初始化的意思。

即在定义类base的对象y时，以对象x给它初始化，相当于basey（x）;。

但是以对象初始化对象时，必须调用拷贝构造函数才行。

因程序中没给出拷贝构造函数，也不能调用系统的缺省拷贝构造函数，因用户给出了构造函数后，再也不能调用系统提供的任何缺省构造函数。

所以，basey=x；是错误的。

22．分析下列程序中的错误，并说明出错原因。

　　　　#include

　　　　classAA{

　　　　public:

intaa;

　　　　};

　　　　classBB:

virtualpublicAA{

　　　　intbb;

　　　　};

　　　　classCC:

virtualpublicAA{

　　　　public:

intbb;

　　　　};

　　　　classDD:

publicBB,publicCC{

　　　　public:

floatdd;

　　　　};

　　　　voidmain（）

　　　　{DDp;

　　　　intm=p.aa;

　　　　AA*pr=&p;

　　　　AA&pt=p;

　　　　DD*pp=（DD*）（BB*）pr;

　　　　AAr;

　　　　DD&ps=r;

　　　　}

　　　　　答：

（1）DD*pp=（DD*）（BB*）pr;，虚基类指针不能赋给派生类指针

（2）DD&ps=r;，虚基类对象不能初始化派生类对象引用

　　[解析]赋值兼容规则的三条规则是：

公有派生的情况下，派生类的对象可以赋给基类的对象；派生类的对象可以初始化基类对象的引用；派生类对象地址可以赋给指向基类对象的指针。

反过来，以上三条规则是错误的。

（1）将虚基类AA的指针pr赋给派生类DD的指针pp，这违背了赋值兼容规则。

（2）虚基类AA的对象r初始化派生类DD的引用ps，这违背了赋值兼容规则。

　　23．分析下列程序中的错误，并说明出错原因。

　　　　#include

　　　　classA{

　　　　intx;

　　　　public:

　　　　A（inta）{x=a;fun（）;}

　　　　virtualvoidfun（）=0;

　　　　};

　　　　classB:

publicA{

　　　　public:

　　　　B（intb）:

A（b）{}

　　　　voidfun（）{}

　　　　};

　　　　voidmain（）

　　　　{Aaa（5）;

　　　　Bbb（8）;

　　　　}

　　　　　答：

（1）fun（）;，构造函数不能调用纯虚函数

（2）Aaa（5）;抽象类不能定义对象

　　[解析]

（1）在构造函数“A（inta）”调用了纯虚函数“fun（）”，因构造函数调用虚函数是静态联编，即调用的是它自己类的虚函数。

在此调用的是纯虚函数，它只被说明，而未定义，所以不可能被执行，因此出错。

（2）抽象类相当于是对类的引用性声明，所以它只能定义该类的指针和引用，而不能定义它的对象。

在此，A为抽象类，而“Aaa（5）”却定义了A的对象，因此是错误的。

　24．分析下列程序中的错误，并说明出错原因。

　　　　#include

　　　　voidfun（）

　　　　{ifstreammyfile（“d:

\abcd”）;

　　　　myfile<<”myfile\n”;

　　　　}

　　　　voidmain（）

　　　　{fun（）;}

　　　　　答：

（1）ifstream，输出必须用输出流ofstream

（2）myfile（“d:

\abcd”）;，必须用‘\’

　　[解析]

（1）由函数“fun（）”的函数体可见，它要输出信息“myfile”，为此必须让文件与输出流相关联，但“ifstream”是输入流，与之关联的文件只能输入信息。

所以，必须使用输出流“ofstream”。

（2）作为文件面的“d:

\abcd”是字符串，其中字符‘\’一般作为转义符使用。

为了在字符串中使用该字符的原义必须用双字符，即“\”。

　　25．分析下列程序中的错误，并说明出错原因。

　　　　#include

　　　　classAA{

　　　　intaa;

　　　　AA（intxx）{aa=xx;}

　　　　public:

　　　　intget（）{returnaa;}

　　　　~AA（）{cout<<”Destroying”<

　　　　};

　　　　main（）

　　　　{AAelem[3]={5,8,4};

　　　　for（*inti=0;i<3;i++）cout<

　　　　}

　　　　　答：

（1）AA（intxx）的访问属性错、应具有公有属性

（2）数组elem[3]初始化错、因调用构造函数

　　[解析]

（1）构造函数虽是由系统自动调用来生成对象的，但一般都是在类外调用，所以它的访问属性必须是公有的。

程序中构造函数的访问属性是私有的（缺省值），运行中必定出错。

（2）对于数组元素的初始化，当程序中提供了带参构造函数时，一般不能直接用数值表的形式来实现（如程序中所示），对只含有一个参数的构造函数，初始化数组的实现方式如下所示：

AAelem[3]={AA（5）,AA（8）,AA（4）};