第17章c++面向对象程序设计作业参

1、第1章【解答】重点：标准输入输出库函数标准输入输出流对象#include <iostream.h>int main()char name20;cout<<”Hello!Whats your name?”<<endl;cin>>name;cout<<name<<”,Welcome to learn OOP using C+!”<<endl;return 0;const int model = 90; / model is a constconst int v =1,2,3,4; / vi is a constco

2、nst int x; / error: no initializer 未赋初值void f( )model =200; / error 不能修改常量的值v2+; / error 不能修改常量的值【修改1】const int model = 90; / model is a constconst int v =1,2,3,4; / vi is a constconst int x=0; /赋初值void f( )cout<<model<<endl; /修改常量的值cout<< v2<<endl; /修改常量的值或者int temp=v2+1;【修改

3、2】int *const model=90;const int* v=1,2,3,4; int strcmp(const char *, const char *);【解答】确保函数strcmp不会修改参数指针所指向的变量【解答】（讲义） C+语言是强类型化语言，任何函数在使用以前必须有该函数的原型说明，以便进行实际参数与形式参数之间的类型匹配检查。 函数返回值的类型和函数参数的类型、个数、次序在函数声明，函数定义和函数调用时必须匹配。 C+语言的编译器执行上述检查能显著减少很多隐藏的错误。使用函数原形执行强类型检查。任何函数在使用以前必须有该函数的原型说明，以便进行实际参数与形式参数之间的类

4、型匹配检查。函数返回值的类型和函数参数的类型、个数、次序在函数声明，函数定义和函数调用时必须匹配。如果某个函数的定义和调用与其原型不匹配，那么编译器会指出这种错误，而不用等到运行程序时才显示错误。创建带有缺省参数的函数时，应注意：1、缺省参数值应该代表最常使用的情况。如果在8090%的时间里能用上缺省值，缺省参数才比较有意义。2、如果给某个参数一个缺省值，那么其后的所有参数都需要赋给缺省值。【解答】#include <iostream>using namespace std;/Overload max( ) three ways 重载函数名max三次int max(int a,in

5、t b);long max(long a,long b);double max(double a,double b);int main() int a1=3,b1=10;long a2=123456,b2=567893;double a3=2*106,b3=-12.34;cout<<"int"<<max(a1,b1)<<endl;cout<<"long"<<max(a2,b2)<<endl;cout<<"double"<<max(a3,b3

6、)<<endl;/使用相同的函数名求不同类型数据的绝对值return 0;int max(int a,int b) int c; a>b?c=a:c=b;return(c);long max(long a,long b) long c;a>b?c=a:c=b;return(c);double max(double a,double b) double c;a>b?c=a:c=b;return(c);1.9要点：申请动态数组【解答】/ A simple example of new and delete.#include <iostream>#inclu

7、de <string>using namespace std;const int N=10;int main( ) char *p,q; int i=0; p=new charN; /allocate memory for a array 为数组分配动态内存空间 if(p=NULL) cout<<"Allocation errorn" return 1; cin>>q; while(q!='#') pi+=q; cin>>q; cout<<endl<<"Here is name

8、 at p: " i=0; while(i<N) cout<<pi+; cout<<endl; delete p; / release memory 释放new分配的动态内存空间 return 0;【解答】#include <iostream.h>void f(int a ,int n, int &max, int &min)max=min=a0;for(int i=1;i<n;i+)if(max<ai) max=ai;if (min>ai) min=ai;void main( )int a10=2,5,3,

9、9,0,8,1,7,6,4;int max,min;f(a,10,max,min);cout<<"Max: "<<max<<endl;cout<<"Min: "<<min<<endl;第2章 C+语言中类class和结构struct的主要区别是什么？【解答】在C+中，对结构体做了一个很重要的扩充，即允许结构体包含函数成员。如此一来，我们可以使用结构体中的数据成员描述对象的属性，使用结构体中的函数成员描述对象的操作。2.2什么是类的接口，什么是类的实现？【解答】一般把仅含函数原型的类声

10、明部分称为类的接口；一个类的内部数据结构和其所有成员函数的定义部分称为类的实现。2.3公用public成员和私有private成员有何区别？【解答】私有private成员只能被该类中的其他成员访问，而程序中的其它代码是不能直接访问这些变量的。公用public成员既可以被该类的其他成员访问，也可以被程序中的其它代码访问。类中的公用成员对外部代码是开放的，通常情况下，程序中的其它代码通过类的公用成员函数来访问类的私有成员。2.4构造函数和析构函数的主要作用是什么？它们各自有什么特性？【解答】构造函数是类的一种特殊成员函数，用来为对象进行初始化（给对象的成员变量赋初值、申请一些系统资源、打开文件操作

11、等）。在对象生成的时候自动执行初始化，这会消除任何错误地不执行初始化的可能。这是C+面向对象程序设计帮助减少复杂性的另一途径。 析构函数的作用与构造函数正好相反，当对象被删除时，利用析构函数进行一些善后处理。一般情况下析构函数执行构造函数的逆操作，例如可以利用析构函数来释放构造函数所动态申请的内存空间。2.5使用const修饰作为参数的对象引用有什么好处？【解答】 【解答】class counterint value;public:counter(int number)value=number; void increment()value+; /给原值加1void decrement()val

12、ue-; /给原值减1int getvalue()return value; /取得计数器的值void print()cout<<”value is:”<<value; /显示计数器的值; void main() counter Count(10); Count.increment(); Count.print(); Count.decrement(); Count.print(); cout<<Count.getvalue(); 2.7试定义一个字符串类my_string ，使其至少具有内容（contents）和长度（length）两个数据成员，并具有显示

13、字符串，求字符串长度、给原字符串后添加一个字符串等功能。【解答】#include <iostream.h>#include <string.h>class my_stringprivate:char *contents;int length;public:my_string(char *s);void show();int getlength();void add(char *s);my_string:my_string(char *s) contents=new charstrlen(s)+1; strcpy(contents,s); length=strlen(s)

14、; void my_string:show() cout<<contents<<endl;int my_string:getlength() return length;void my_string:add(char *s) strcat(contents,s);void main() my_string ST("I am "); cout<<ST.getlength()<<endl;ST.show(); ST.add("a student");ST.show();2.8 定义一个矩形类Rectangle，

15、它有长length和宽width两个属性，有成员函数计算矩形的面积。并在main()函数中测试这个类。-【解答】#include <iostream.h>class Rectangleprivate:int length;int width;public:Rectangle(int l,int w);int area();Rectangle:Rectangle(int l,int w) length=l; width=w;int Rectangle:area() return (length*width); void main() Rectangle Rect(10,15); co

16、ut<<"Area is:"<<Rect.area()<<endl; 第3章3.1 解释下列名词：类 对象 方法 消息类：“类”是对一组具有共同属性特征和行为特征的对象的抽象。一个类中所包含的方法和数据描述了一组对象的共同行为和属性。对象：面向对象软件系统中的对象是基本的运行时（runtime）实体，它既包含数据，也包括作用于数据的操作。面向对象软件系统中的对象是现实世界中对象的模型，换句话说，是用来模仿或者描述客观现实世界中的对象的。方法：面向对象程序设计中的术语“方法”对应于对象的行为（能力），即它是实现对象所具有的功能操作的代码段。

17、在C+程序中，方法即是类中定义的成员函数，它是该类对象所能执行的操作的算法实现。消息：在面向对象的程序中，一个对象向另一个对象发出的请求称为消息。消息是要求某个对象执行其中某个功能操作的规格说明。程序中的所有对象通过消息传递实现相互协作，完成一些特定的任务。3.3 试述面向对象程序设计的基本思想。面向对象程序设计（Object-Oriented Programming，简称OOP）的主要思想是：用面向对象程序设计语言中的对象和类直接模拟现实世界中的对象，将问题空间直接映射到软件空间。从而设计出尽可能直接、自然地表示问题求解方法的软件。3.4 试述面向对象程序设计的主要特征。面向对象程序设计的主

18、要特征有封装性、继承性和多态性。什么是面向对象程序设计中的封装性? 封装性有什么好处？在C+语言中如何实现封装性？ 所谓封装，就是包含和隐藏对象信息，如内部数据结构和代码的能力。在C+语言中使用类class实现封装性，将需要隐藏的数据和代码用关键字private限制，通过使用public修饰类的一些成员，形成对外的接口。封装性的好处：（1）封装性降低了程序设计的复杂度。（2）提高了数据的安全性和代码的可靠性。（3）封装改善了软件的可维护性。（4）封装性也改善了程序模块可重用性。第4章4.1设计一个C+程序，在其中创建一个含有5个元素的Student类的对象数组，并给对象数组成员赋值，然后输出对

19、象数组。输出对象数组时分别使用点（.）运算符和箭头（->）运算符。【解答】#include <iostream.h>#include <string.h>class Studentprivate:int number;char name15;float score;public:Student(int number1,char *name1,float score1); /构造函数的声明void modify(float score1) score=score1; void print( );/构造函数的定义Student:Student (int number1

20、,char *name1,float score1)number=number1;strcpy(name,name1);score=score1;void Student:print( )cout<<"number: "<<number<<" name: "<<name<<" score: "<<score<<'n'int main( )Student aSA4=Student(1,"Li_Ming",98),Stu

21、dent(2,"Bill",78),Student(3,"Wang_Wei",85),Student(4,"David",96);for(int i=0;i<4;i+) aSAi.print( );Student *p=aSA; for(i=0;i<4;i+,p+)p->print();return 0;阅读下列程序，指出其中的错误。并分析出错的原因。#include <iostream>using namespace std;class myclass int a, b;public: void set

22、(int i, int j) a = i; b = j; void show() cout << a << ' ' << b << "n" ;class yourclass int a, b;public: void set(int i, int j) a = i; b = j; void show() cout << a << ' ' << b << "n" ;int main() myclass obj1,obj3; you

23、rclass obj2; obj1.set(10, 4);obj3= obj1; obj2= obj1; obj1.show( ); obj2.show( ); obj3.show( ); return 0;【解答】obj2= obj1;两个对象不属于同一种类类型/不是由同一个类声明的4.6 下列Circle类的定义中哪个是静态数据成员？哪个是静态成员函数？请在主函数mani( )演示它们的应用。class Circle public: Circle(float r) radius=r;+count; Circle() -count; static int num() return count

24、; private:float radius; static int count;【解答】l 静态成员变量应在创建类的对象前进行定义并初始化l 一个类的静态数据成员为该类所有对象共用，不管我们创建了这个类的多少对象，其静态数据成员在内存中只有一份拷贝l 静态成员变量的最一般的作用就是对一些共享资源提供存取控制l 静态数据成员的主要用途是定义类的各个对象所共用的数据，如统计总数，平均数等。int Circle:count=0;l 一般来说，类的静态成员函数是用来访问静态数据成员的，当然也可以访问全局变量。l 静态成员函数不具有this指针(静态成员函数不与某个具体的对象相联系，它只属于该类)Ci

25、rcle:num();#include <iostream.h>class Circle public: Circle(float r) radius=r;+count; Circle() -count; static int num() return count; private:float radius; static int count;int Circle:count=0;void main() Circle c1(10),c2(20); cout<<Circle:num(); 第5章什么是堆？请举例说明如何在堆上创建对象。【解答】在固定存储区域与堆栈之间的自由

26、区域称为堆，我们可以使用C+的动态内存分配系统从堆中为程序的数据分配存储单元。#include <iostream>using namespace std;class Square int side;public:Square(int x) side = x; cout<<"Constructiongn" Square( ) cout<<"Destructiongn" void display() cout << side << "n" ;int main()Square *

27、ps=new Square(10); /分配堆内存并调用构造函数初始化ps->display(); delete ps; /自动调用析构函数，然后释放堆内存return 0;5.3假设有以下的类定义，class Square int side;public:Square(int x=10) side = x; cout<<"Constructiongn" Square( ) cout<<"Destructiongn" void display() cout << side << "n&quo

28、t; ;请问以下几个语句有什么区别？Square s1(),s3(5);Square s2=s1;Square s2(s1);S3=s1;【解答】Square s1(),s3(5); /调用普通构造函数Square s2=s1; /调用复制构造函数Square s2(s1); /调用复制构造函数S3=s1; /执行赋值运算，非初始化有了默认的复制构造函数，为何还需要自定义复制构造函数？在什么情况下需要自定义复制构造函数？【解答】 由于普通的构造函数通常用于初始化对象的某些成员，因此就不能调用普通构造函数创建对象的副本，因为这样产生的对象可能与现有的对象不完全相同。 当把一个对象传递给函数时，我

29、们需要使用的是对象的当前状态，而不是初始状态 （复制构造函数只有在初始化对象时才被调用当创建一个对象的副本作为函数的参数时，普通的构造函数没有被调用，所调用的构造函数是按位复制的默认复制构造函数。默认的复制构造函数将以按位复制的形式创建一个对象的副本，即创建一个与原对象一模一样的副本。 ）当对象中（成员变量）包含指针时，按位复制对象副本的方法产生了问题。为了避免这类问题，可以创建自定义的复制构造函数来精确地定义生成一个对象副本时的行为。5.5、运行后的输出结果为：X(). Y():T:q = 003751C0. X().X(). Y():T:q = 003761E8. X().X(). Y()

30、:T:q = 00377210. X().X(). Y():T:q = 00378238. X().X(). Y():T:q = 00379260. X().X(). Y():T:q = 0037A288. X().X(). Y():T:q = 0037B2B0. X().X(). Y():T:q = 0037C2D8. X().从输出结果发现没有调用class Y的析构函数，出现了内存泄漏。解决这个问题的方法之一就是将class X的析构函数定义为虚函数：virtual X() delete p; cout << "X().n"然后重新编译运行，得到如下的输出

31、结果：X(). Y():T:q = 003751C0. Y(). X().X(). Y():T:q = 003751C0. Y(). X().X(). Y():T:q = 003751C0. Y(). X().X(). Y():T:q = 003751C0. Y(). X().X(). Y():T:q = 003751C0. Y(). X().X(). Y():T:q = 003751C0. Y(). X().X(). Y():T:q = 003751C0. Y(). X().X(). Y():T:q = 003751C0. Y(). X().#include <iostream>

32、using namespace std;class Xpublic: X() p = new int2; cout << "X(). " virtual X() delete p; cout << "X().n" private: int* p;class Y : public Xpublic: Y( ) q = new int1023; cout << "Y( ):T:q = " << q << ". " Y( ) delete q; cout <

33、< "Y(). " private: int* q;int main() for (int i = 0; i < 8; i+) X* r = new Y; delete r; return 0;5.6 阅读下列程序，指出其中的错误并改正之。#include <iostream>#include <cstring>#include <cstdlib>using namespace std;class strtype char *p;public: strtype(char *s); strtype() delete p; cha

34、r *get() return p; ;strtype:strtype(char *s) int l; l = strlen(s)+1; p = new char l; if(!p) cout << "Allocation errorn" exit(1); strcpy(p, s);void show(strtype x) char *s; s = x.get(); cout << s << "n"int main() strtype a("Hello"), b("There")

35、; show(a); show(b); return 0;【解答】#include <iostream>#include <cstring>#include <cstdlib>using namespace std;class strtype char *p;public: strtype(char *s); strtype(const strtype &obj); strtype() delete p; char *get() return p; ;strtype:strtype(char *s) int l; l = strlen(s)+1; p

36、 = new char l; if(!p) cout << "Allocation errorn" exit(1); strcpy(p, s);strtype:strtype(const strtype &obj) /需定义：自定义复制构造函数（对象含指针） p=new charstrlen(obj.p)+1; strcpy(p,obj.p); cout<<"Copy constructor called.n"void show(strtype x) char *s; s = x.get(); cout <<

37、s << "n"int main() strtype a("Hello"), b("There"); show(a); show(b); return 0;第6章6.1什么是继承性？请举例说明。继承性有哪些好处？【解答】继承：保持已有类的特性而构造新类的过程继承的目的：实现代码重用。class 派生类名：访问权限 基类名1, . 成员定义；继承的好处： 面向对象的程序设计中通过继承实现重用reuse便于重用，扩充。 可以在原有的基础上扩充，不修改原有代码。 即使原来的代码完全不符合当前的要求，也不必修改原有的代码。可以只增

38、加新的代码来实现新的功能。6.6 什么是赋值兼容规则？请举例说明。【解答】赋值兼容规则时指在公有派生条件下，任何可以使用基类对象的地方都可以用其派生类的对象替代。1） 可以用派生类的对象给基类对象赋值。比如：class A ;class B : public A void fun( ) ; A a;B b; A a=b; /将对象b中所含类A成员的值赋给对象a 复制的结果是将派生类对象中所含基类成员的值赋给基类对象中相同的成员。2）可以用派生类的对象初始化基类对象的引用。比如：class A class B : public A void fun( ) ; A a;B b; A &a=

39、b; /用派生类对象初始化基类对象的引用3）可以用派生类的对象的地址给基类对象的指针赋值。比如：class A ;class B : public A void fun( ) ; A a;B b; A *pa =&b; /用派生类对象的地址初始化基类对象的指针赋值兼容规则的注意事项：1) 不能将一个派生类对象的指针指向其基类对象。2) 通过指向基类对象的指针可以指向它的公有派生的对象，但不能指向私有派生的对象。3) 这种指针只能访问从基类中继承的公有成员，不能访问派生类本身的成员。6.7下面是一个含有派生类的C+程序，请编译并运行这个C+程序。#include <iostream

40、.h>class Aprotected:int m,n;public:void set(int a, int b)m=a; n=b;void show( )cout<<m<<" "<<n<<'n" ;class B:public Aint s;public:void sets( )s=m*n; void shows( )cout<<s<<endl; ;int main( )B obj;obj.set(2,3);obj.show( );obj.sets( );obj.shows(

41、);return 0;【解答】 运行结果：2 366.8已知下面的C+程序框架，请按照注释中的提示补充细节，并编译、运行该程序。【解答】#include <iostream.h>class planet protected:double distance;/ miles from the sunint revolve;/ in dayspublic:planet(double d,int r) distance=d; revolve=r;class earth: public planetdouble circumference;/ circumference of orbitpu

42、blic:earth(double d,int r):planet(d,r) circumference=2*r*3.1416; void show() cout<<"n The circum is:"<<circumference; ;int main( )earth ob(93000000,365);ob.show( );return 0;7.2友元运算符函数和成员运算符函数有什么不同？【解答】l 成员运算符函数具有如下特点：u 重载为类成员函数时，参数个数=原操作数个数-1（后置+、-除外）u 当类的对象调用这种运算符函数时，对象中的成员数据就

43、可以是一个操作数，另一个操作数才通过参数传递来获得。l 友元运算符函数具有如下特点：u 重载为友元函数时 参数个数=原操作数个数，且至少应该有一个自定义类型的形参。u 友元函数是类以外的函数，调用这种运算符函数时，所有的操作数都要通过参数传递来获得。u friend operator 函数不能重载=，（），->运算符。u 在重载增值和减值运算符时，用friend operator 函数需要使用引用参数。l C+的大部分运算符即可以说明为成员函数运算符，也可以说明成友元函数运算符。究竟选择哪一种运算符函数好一些，没有定论，这主要取决于实际情况和程序员的习惯。第7章7.3 完成下列的Stri

44、ng类，并在主函数main( )中测试它。class Stringpublic:String(const char *str = NULL);/ constructor String(const String &other); / copy constructor String(void);/ destructorString & operate =(char *str); String & operate =(const String &other);/ 重载=运算符int operator=(String &other);/ 重载=运算符int op

45、erator=(char *str);private: char *m_data; / used for storing the stringint length;【解答】#include <iostream.h>#include <string.h>class Stringpublic:String(char *str);/ constructor String(const String &other); / copy constructor String()/ destructorString & operator =(char *str); Str

46、ing & operator =(const String &other);/ 重载=运算符int operator=(String &other);/ 重载=运算符int operator=(char *str);private: char *m_data; / used for storing the stringint length;String:String(char *str) length=strlen(str); m_data=new charlength+1; strcpy(m_data,str); String:String(const String

47、&other) m_data=new charother.length+1; strcpy(m_data,other.m_data); length=other.length;String & String:operator=(char *str) return String(str);String & String:operator =(const String &other) return String(other);int String:operator=(String &other) if(strcmp(m_data,other.m_data)=

48、0) return 1; else return 0;int String:operator=(char *str) if(strcmp(m_data,str)=0) return 1; else return 0;void main() String s1("Hello"),s2("hello"); String s3(s1); if(s1=s2) cout<<"s1=s2true"<<endl; else cout<<"s1=s2false"<<endl; if(

49、s1=s3) cout<<"s1=s3true"<<endl; else cout<<"s1=s3false"<<endl;7.3 第二种方案：#include "iostream.h"#include "string.h"class Stringpublic:String(const char *str = NULL); String(const String &other); String(void);String & operator=(char

50、 *str); String & operator=(const String &other); int operator=(String &other)return (strcmp(m_data,other.m_data)=0)?1:0); friend ostream &operator<<(ostream &output, String &obj)output<<obj.m_data; return output;private: char *m_data; / used for storing the String objectint length;String:String(const char *str)int length=strlen(str);m_data=new charlength+1;strcpy(m_data,str);String:String(const String& s) int length=strlen(s.m_data);m_data=new charlength+1;