面向对象程序设计作业.docx

面向对象程序设计作业.docx

《面向对象程序设计作业.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计作业.docx（16页珍藏版）》请在冰豆网上搜索。

面向对象程序设计作业

C++程序设计

第一次作业

一、问答题

1、什么是面向对象程序设计？

面向对象程序设计的优点是什么？

2、什么是类？

什么是对象？

它们之间关系如何？

3、C++的主要特点有哪些？

4、什么叫函数重载？

什么叫运算符重载？

请书写一个函数重载的程序例子，分别计算圆、矩形、三角形的图形面积。

5、使用内联函数的优点是什么？

如何将函数说明为内联函数？

6、构造函数和析构函数的主要特点各是什么？

7、什么是this指针？

它的主要作用是什么？

8、什么是拷贝构造函数？

在哪三种情形下会触发拷贝构造函数的执行？

9、什么是友元函数？

使用它有什么好处？

10、什么情况下需要预约存贮空间？

试解释下列程序每一语句的含义。

float*p;

p=newfloat[10];

for（inti=0;i<=9;i++,p++）*p=i;

11、如果要释放上一题中指针p所指的空间，应如何操作？

二、程序设计题

（1）建立一个三角形类tri，有三个私有数据a，b，c，设计一个缺省的3参数构造函数，缺省值分别为3，3，3，再设计一个成员函数showarea，当参数能组成三角形时输出面积值，否则输出-1。

（2）建立一个类book，有二个私有的数据成员qu和price，建立一个有5个元素的数组对象，将qu初始化为1，2，3，4，5，将price初始化为qu的10倍，并设计一个成员函数disp，输出每个对象的qu*pricer的值。

（3）有一个向量类vector，包括一个点的坐标位置x和y，设计二个友元函数，实现两个向量的加法和减法运算。

（4）编写一个程序，设计一个类score，用于统计一个班的学生成绩，其中使用一个静态数据成员sumfs存储总分和一个静态成员函数rsumf（）返回该总分。

三、分析题

请仔细阅读下列程序，回答问题。

1:

#include

2:

classexam{

3:

inti;

4:

public:

5:

exam（intn）{i=n;cout<<"constructing...\n";}

6:

~exam（）{cout<<"destructing...\n";}

7:

intget_i（）{returni;}

8:

};

9:

intsqr_it（exams）

10:

{

11:

returns.get_i（）*s.get_i（）;

12:

}

13:

voidmain（）

14:

{

15:

examx（11）;

16:

cout<

17:

cout<

18:

}

（1）第1行能省略吗？

为什么？

（2）第4行的public:

是什么含义？

（3）第5行、第6行分别定义的是什么函数？

它们在什么情况下执行？

（4）第7行和第9-12行定义的函数中，哪一个是普通的自定义函数？

哪一个是类exam的成员函数？

（5）第15行的含义是什么？

（6）试写出该程序的运行结果。

（7）如果将9-12行改为如下内容：

9:

intsqr_it（exam*s）

10:

{

11:

returns->get_i（）*s->get_i（）;

12:

}

并将第17行改为

17:

cout<

请写出此时该程序的运行结果。

第二次作业

一、简答题

1、什么是类？

什么是对象？

2、什么叫函数重载和运算符重载？

使用重载有何优点？

3、何谓内联函数？

采用内联函数有何好处？

4、构造函数和析构函数的主要作用是什么？

5、类成员的访问控制属性有哪三种？

我们在外部只能访问具备有哪一种属性的对象成员？

6、在什么情况下应当采用成员初始化列表方式传递数据？

7、拷贝构造函数的参数与一般的构造函数有何不同？

在哪三种情况下拷贝构造函数被执行？

8、什么是this指针？

它的主要作用是什么？

二、判断题

1、定义一个整型指针p，在内存中预约10个连续单元，p指向这10个单元之首，可以使用以下语句操作。

（）

int*p=newint（10）；

2、如果定义char*constname=＂yang＂，则可执行name=newchar[4];（）

3、从一个类定义的各个不同的具体对象，其结构不相同。

（）

4、类的构造函数可以用public、private或protected中任一访问属性说明。

（）

5、重载运算符既可改变其执行功能，又可改变它的基本语法形式。

（）

6、利用模板可以大幅度地节约程序代码。

（）

7、引入虚基类的好处是防止最派生类对继承成员的二义性。

（）

8、虚函数的定义在基类中进行，此虚函数就可以在一个或多个派生类中被重新定义，但函数的返回类型、函数名、形参个数和类型必须相同。

（）

9、当某个函数以对象为参数时，调用这个函数必定会执行类的拷贝构造函数。

（）

10、在可以重载的运算符中，并不是都可使用友元函数进行重载的。

（）

三、填空题

1、构造函数的名字必须与相同，可以有任意类型的形参，但返回类型，且访问控制属性为，当其参数为时，称之为拷贝构造函数。

2、已经定义好了一个类student，现在要定义一个类pupil，它是从student私有派生而来，那么，定义pupil类的写法是。

3、由于不能直接对一个类的二个对象做加法，因此，必须对+进行，这主要由名为+（参数表）的函数完成。

4、动态内存分配采用语句，释放这种方式分配的内存空间则用语句。

5、在C++中，单行注释或行尾注释通常采用进行。

四、综合分析题

1、分析下列程序中继承的关系。

（3分）

2、指明构造函数和析构函数执行顺序。

（5分）

3、写出程序的运行结果。

（7分）

#include＂iostream.h＂

classA

{

public:

A（）{a=0;cout<<＂A:

:

defaultcon.＂<

A（inti）{a=i;cout<<＂A’scon.＂<

~A（）{cout<<＂A’sdes.＂<

voidprint（）{cout<

intgeta（）{returna;}

private:

inta;

};

classC

{

public:

C（）{c=0;cout<<＂C:

:

defaultcon.＂<

C（inti）{c=i;cout<<＂C’scon.＂<

~C（）{cout<<＂C’sdes.＂<

voidprint（）{cout<

intgetc（）{returnc;}

private:

intc;

};

classB:

publicA,publicC

{

public:

B（）{b=0;cout<<＂B:

:

defaultcon.＂<

B（inti,intj,intk,intl,intn）:

A（i）,C（j）,cc（k）,aa（l）,b（n）

{cout<<＂B’scon.＂<

~B（）{cout<<＂B’sdes.＂<

voidprint（）

{A:

:

print（）;

C:

:

print（）;

cout<

cout<

}

private:

intb;

Ccc;

Aaa;

};

voidmain（）

{

Bbb（1,2,3,4,5）;

bb.print（）;

}

五、程序设计题

1、应用C++的多态性，计算三角形、矩形和圆的面积。

建议公共基类命名为Figure，含有二个数据成员及纯虚函数，形式如下：

ClassFigure{

protected:

floatx,y;

public:

Figure（floata,floatb）{x=a,y=b;}

virtualvoidshow_area（）=0；

};

三角形类、矩形类和圆类命名分别为Tri、Rec、Cir，并在主函数中写出一个调用的例子，三角形对象、矩形对象和圆对象的初始数据为（3，4，5）、（2，4），（10）。

最后请写出你的程序运行结果。

2、编写程序，设计一个时间类Time，它的基本定义如下：

classTime{

inthour,minute,second;

public:

Time（）;

Time（inth,intm,ints）

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

voidshow（）

{cout<<＂Timeis＂<

＂<

＂<

};

试重载运算符+，当加上一个整数（秒）时，输出新的时间。

例如：

Times（12,34,16）,s1;

s1=s+100;//从12点34分16秒后，再过100秒，即加100秒

s1.show（）;

第三次作业

一、选择题（在A、B、C、D四个答案中选择一个正确的填入后面的括号中）

1．下面（）是对类ttt的声明。

A．voidclassttt;

B．classintttt;

C．classttt（）;

D．classttt;

2．用于类中虚成员函数说明的关键字是（）

A.publicB.virtualC.protectedD.private

3．下面是关于静态成员的说法，其中不正确的是（）。

A．静态成员有类作用域，但与普通非静态成员有所不同

B．静态函数没有this指针，同一个类的不同对象拥有相同的静态数据成员

C．静态数据成员的初始化必须在类外进行

D．静态函数同样可以访问非静态数据成员

4．下面的说法中，不正确的一句是（）。

A．类的友元函数是类的特殊成员函数，它对所有的类成员、保护成员和私有成员享有完全访问特权。

B.一个类的友元类中的成员函数都是这个类的友元函数

C.适用于类成员函数和数据的访问控制同样适用于枚举和嵌套类

D.与结构类似，类也可以互相嵌套，适用于嵌套结构的规则也适用于嵌套类

5．（）语言是面向对象的语言。

A.CB.PascalC.FortranD.C++

6．C++风格的源文件包含的输入输出头文件为（）

A.stdio.hB.stdafx.hC.iostream.hD.stream.h

7．与C语言printf（“Helloword\n”）；语句功能相同的C++语句是（）

A.cout>>”Helloword\n”

B.cin>>”Helloword\n”

C.cout<<”Helloword\n”

D.cin<<”Helloword\n”

8．在下面几个元素中，不是面向对象的要素的是（）；

A.重载B.对象C.类D.继承

9．对于int*pa[5];的描述，下面叙述正确的是（）；

A.pa是一个指向数组的指针，所指向的数组是5个int型元素；

B.pa是一个指向某数组中第5个元素的指针，该元素是int型变量；

C.pa是一个具有5个元素的指针数组，每个元素是一个int型指针；

D.pa[5]表示某个数组的第5个元素的值。

10.下面程序使用new与delete命令：

#include

main（）

{

long*p,i;

p=newlong;

if（!

p）{

cout<<”Allocationerror\n”;

return1;

}

*p=1000;

i=（long）p;

cout<<”Hereisintegeratp:

”<<*p<<”\n”;

cout<<”Hereisi:

“<

deletep;

return0;

}

下面是对这段程序的叙述，其中正确的是（）。

A.有错误，编译不能通过

B．正确，执行结果为：

10001000

C．正确，但执行结果的第二个数值不定

D．正确，执行结果的各个数值均不为1000

二、判断下列描述正确性，对者划√，错者划×（每小题2分）。

1．C++中标识符内的大小写字母是没有区别的。

2．宏定义命令是分号结束的。

3．C++的程序中，对变量一定要先说明再使用，说明只要在使用之前就可以。

4．while循环语句的循环体至少执行一次。

5．在C++中，所有函数在调用前都要说明。

6．析构函数是一种函数体为空的成员函数。

7．如果一个函数没有返回值时，定义时需要用void说明。

8.派生类是从基类派生出来的，它不能再生成新的派生类。

9.对象成员的表示与结构变量成员表示相同，使用运算符.或->。

10．构造函数和析构函数都可以重载，因为它们都是成员函数。

三、写出下面程序的输出结果。

1．#include

voidmain（）

{inta,b,c;

a=1,b=2,c=a+b+3;

cout<

c=（a++,a+=6,a+b）;cout<

}

2.#include

voidswap（int&x,int&y）

{

inttemp;

temp=x;

x=y;

y=temp;

cout<<”x=”<

}

voidmain（）

{

inta（5）,b（9）;

swap（a,b）;

cout<<”a=”<

}

3.#include

classA

{

public:

A（）;

A（inti,intj）;

voidprint（）;

private:

inta,b;

};

A:

:

A（）

{a=b=0;

cout<<”Defaultconstructorcalled.\n”;

}

A:

:

A（inti,intj）

{a=i;b=j;

cout<<”Constructorcalled.\n”;

}

voidA:

:

print（）

{cout<<”a=”<

}

voidmain（）

{Am,n（4,8）;

m.print（）;

n.print（）;

}

四、编程或程序填空。

1．在下划线处填上正确的语句并给出程序的输出结果（6分）。

#include

#include____

（1）_______

classstrA

{

public:

strA（float,float,float）;

______

（2）________;

______（3）________;

public:

floata,b,c;

};

floatstrA:

:

fun1（）

{

returna+b+c;

}

strA:

:

strA（floati,floatj,floatk）

{

a=i;b=j;c=k;

}

doublestrA:

:

fun2（）

{

floats;

s=float（（a+b+c）/2.0）;

returnsqrt（s*（s-a）*（s-b）*（s-c））;

}

voidmaina（）

{

strAtri（3,4,5）;

cout<

cout<

}

2．编写分别可求两个整型、浮点型和双精度型数和的重载函数，并写主函数调用之；

3．使用引用作为函数参数，编写一个交换两变量值的函数，并写主函数调用之。

C++模拟试题2

一、选择题（在A、B、C、D四个答案中选择一个正确的填入后面的括号中）

1.C++中，封装是借助于（）达到的。

E．指针B.类C.数组D.函数

3．宏定义由（）结束。

A．分号B.句号C.新行D.冒号

3.下面是关于一个类的友元的说法，其中不正确的是（）

A．友元函数可以访问该类的私有数据成员

B．友元的声明必须放在类的内部

C．友元函数可以是类的成员函数

D．类与类之间的友元关系不能被继承

4.C++中声明常量的关键字是（）。

A.constB.externC.publicD.enum

5.关于动态联编的下列描述中，错误的是（）。

A.动态联编是以虚函数为基础的

B.动态联编时在运行时确定所调用的函数代码的

C.动态联编调用函数操作是使用指向对象的指针或对象引用

D.动态联编是在编译时确定操作函数的

6.下面函数（）的表示方法说明它使用对象的引用作为参数。

A.test（pt*p）B.test（ptp）

C.test（pt&p）D.test（constP）

7.虚函数的调用（）。

A．一定使用动态联编

B．必须使用动态联编

C．一定使用静态联编

D．不一定使用动态联编

8．关于C++与C语言的关系的描述中，错误的是（）；

A.C语言是C++的子集；B.C语言与C++是兼容的；

C．C++对C语言进行了一些改进；D.C++和C语言都是面向对象的。

9．重载函数在调用时选择的依据中，（）是错误的。

A.参数个数B.参数类型C.函数名字D.函数类型

10.下面的程序是关于函数承载的，假定A，B，C，D是它们可能的输出之一，其中正确的输出是（）。

A.2510B.2010C.2011.4D.2014.076

源程序如下：

#include

intMultiply（intn1,intn2）

{

returnn1*n2;

}

floatMultiply（intf1,floatf2）

{

returnf1*f2;

}

voidmain（）

{

inta1=10;

inta2=2.5;

floatb1=2.55;

floatb2=5.52;

cout<

cout<

}

二、判断下列描述正确性，对者划√，错者划×。

1．C++中数组元素的下标是从0开始，数组元素是连续存储在内存单元中的。

2．函数一定要有函数体。

3．在说明语句inta（5）,&b=a,*p=&a;中b的值和*p值是相等的。

4．for循环是只有可以确定的循环次数时才可使用，否则不能用for循环。

5.在C++中，定义函数时必须给出函数的类型。

6.对象引用作函数参数不如使用对象指针更方便。

7.说明或定义对象时，类名前必须要加class关键字。

8．C++语言中，允许单一继承，不允许多重继承。

9．面向对象方法具有三大特性：

封装性、继承性和继承性。

10．在共有继承中，派生类可以访问基类中的私有成员。

三、按要求写结果：

1．计算下列表达式的值：

（1）已知：

inti（10）,j（5）;

A.++i-j--;B.i=i*=j;C.i=3/2*（j=3-2）;

（2）已知：

inta（5）,b（3）;计算下面表达式的值及a和b的值。

A.!

a&&b++;B.a||b+4&&a*b;

C.a=1,b=2,a>b?

++a:

++b;

2.写出下面程序的输出结果。

（1）#include

voidfun（）

{

staticintn=25;

n--;

cout<<”n=”<

}

voidmain（）

{

for（inti=0;i<2;i++）

fun（）;

}

（2）#include

classBase

{

public:

voidSetc（chara）{c2=（c1=a）-32;}

voidShow（）

{cout<

“<

private:

charc1,c2;

};

voidmain（）

{

Basea,b;

a.Setc（‘a’）;

b.Setc（‘b’）;

a.Show（）;

b.Show（）;

}

（3）定义类Tpoint如下：

classTPoint

{

public:

TPoint（intx,inty）{X=x;Y=y;}

TPoint（TPoint&p）;

~TPoint（）{cout<<”destructorCalled.\n”;}

intGetX（）{returnX;}

intGetY（）{returnY;}

private:

intX,Y;

};

TPoint:

:

TPoint（TPoint&p）

{

X=p.X;

Y=p.Y;

}

并将其存入tpoint.h文件中，分析并写出下面主函数的执行结果：

#include

#include

voidmain（）

{

TPointP1（5,7）;

TPointP2（P1）;

cout<<”P2=”<

}

四、编程或程序填空。

1．在下划线处填上正确的语句成分，并编写一个测试主程序。

#include

classTest

{

public:

Test（inta,intb）{___

（1）______}

voidshow（）{____

（2）_____}

private:

intx,y;

};

2．编写分别可计算2、3或4个int型数的和的重载函数，并写主函数调用之；

3.设计一个类，使它具有一个求两个整数中较大者的成员函数以及输出成员函数，并写一个测试程序。