C++程序设计教程--面向对象分册(郑秋生)答案.docx

第1章 类和对象
一、 选择题
1.C 2.B 3.C 4.A 5.C
6.A 7.C 8 C 9A 10 C
二、阅读题
1．x=2,y=3

2．x=2,y=3
x!=y

3．
Cstatic::va1=0
cs1.vaI=1
cs2.val=2
cs1.val=4
cs2.vaI=4
四、改错题
#include <string.h>
#include <iostream.h>
class person
{
public:
person(int n,char* nam,char s)
{
num=n;
strcpy(name,nam);
sex=s;
cout<<"Constructor called."<<endl;
}
~person( )
{
cout<<"Destructor called."<<endl;
}
void display( )
{
cout<<"num: "<<num<<endl;
cout<<"name: "<<name<<endl;
cout<<"sex: "<<sex<<endl<<endl;
}
private:
int num;
char name[10];
char sex;
};
int main( )
{
person s1(10010,"'Wang_li",'f');
s1.display( );
person s2(10011,"Zhang_fun",'m');
s2.display( );
return 0;
}
五、编程题
5．1
#include <iostream>
using namespace std;
class CBox
{
public :
CBox(double l=0,double w=0,double h=0);
double area();
double volume ();

private :
double lengh;
double width;
double high;
};

CBox::CBox(double l,double w,double h)
{
lengh=l;
width=w;
high=h;
}
double CBox::area()
{
return 2*(lengh*width+lengh*high+width*high);
}
double CBox::volume ()
{
return lengh*width*high;
}
void main()
{
CBox box1(4,5,6);
cout<<box1.area()<<endl;
cout<<box1.volume()<<endl;
}

5.2
#include <iostream>
using namespace std;
class CPoint
{
public :
CPoint(double a=0,double b=0)
{
x=a;
y=b;
}
CPoint(CPoint & p)
{
x=p.x;
y=p.y;
}
void print()
{
cout<<"("<<x<<","<<y<<")";
}

private :
double x,y;
};

class CLine
{
public:
CLine(double x1=0,double y1=0,double x2=0,double y2=0):p1(x1,y1),p2(x2,y2)
{
}
CLine(CPoint x,CPoint y):p1(x),p2(y)
{
}
CLine(CLine &lin)
{
p1=lin.p1;
p2=lin.p2;
}
void DrawLine()
{
cout<<"Line form";
p1.print();
cout<<"to";
p2.print();
cout<<endl;
}
void Linedel()
{
cout<<"delete line"<<endl;
}
void move(CPoint &x,CPoint &y)
{
cout<<"move line"<<endl;
p1=x;
p2=y;
}

private :
CPoint p1,p2;
};

void main()
{
CPoint point1(1,5),point2(5,8),point3(20,30),point4(40,50);
CLine line1(point1,point2);
CLine line2(2,3,8,12);
line1.DrawLine ();
line2.DrawLine ();
line2.move(point3,point4);
line2.DrawLine ();
line2=line1;
line2.DrawLine ();
line1.Linedel ();

}

5.3
#include <iostream>
using namespace std;
class CComplex
{
public:
CComplex(double, double);
CComplex(CComplex &c); //复数类的拷贝构造函数声明
double GetReal();
double GetImag();
void Print();
private:
double real;
double imag;
};
CComplex::CComplex (double r=0.0, double i=0.0)
{
real = r;
imag = i;
cout<<"调用两个参数的构造函数"<<endl;
}
CComplex::CComplex (CComplex &c) //复数类的拷贝构造函数定义
{
real = c.real;
imag = c.imag;
cout<<"调用拷贝构造函数"<<endl;
}
double CComplex::GetReal(){return real;}
double CComplex::GetImag(){return imag;}
void CComplex::Print() // 显示复数值
{
cout << "(" << real << "," << imag << ")" << endl;
}
CComplex add(CComplex &x,CComplex &y) //普通函数完成两个数的加法，对象作为函数参数,
{
return CComplex(x.GetReal() +y.GetReal() ,x.GetImag ()+y.GetImag ());
}

void main(void)
{
CComplex a(3.0,4.0), b(5.6,7.9);
CComplex c(a); //调用复数类的拷贝构造函数
cout << "a = ";
a.Print();
cout << "b = ";
b.Print();
cout << "c = ";
c.Print();
cout<<"c=a+b"<<endl;
c=add(a,b);
cout << "c = ";
c.Print ();
}

5.4
#include <iostream>
#include <string>
using namespace std;
class CStudent //类声明
{
public:
CStudent(char *,float,float,float);
CStudent(CStudent &s);
~CStudent();
void display();
friend float avg(CStudent &s);
private:
char *name;
float grad[3];
};
CStudent::CStudent(char *na,float a,float b,float c)
{
name=new char[strlen(na)+1];
strcpy(name,na);
grad[0]=a;
grad[1]=b;
grad[2]=c;
}
CStudent::CStudent(CStudent &s)
{
name=new char[strlen(s.name)+1];
strcpy(name,s.name);
grad[0]=s.grad[0];
grad[1]=s.grad [1];
grad[2]=s.grad [2];

}
CStudent::~CStudent()
{
delete []name;
}
void CStudent::display( )
{
int i;
cout<<"name:"<<name<<endl;
for(i=0;i<3;i++)
cout<<"grad["<<i<<"]:"<<grad[i]<<endl;

}
float avg(CStudent &s) //普通函数，需要引用私有成员，声明为学生类的友元函数
{
return (s.grad[0]+s.grad[1] +s.grad[2])/3;
}

int main( )
{
CStudent stud1("张三",79,98,82); //定义对象
stud1.display();
cout <<"平均成绩："<<avg(stud1)<<endl;
return 0;
}

5.5
#include <iostream>
using namespace std;
class CString
{
public :
CString(); //缺省构造函数，初始化为空串
CString(char ch,int nRepeat);//用一个字符重复n次，初始化字符串
CString(const char*psz); //用一个字符串初始化
CString(CString &stringser); //拷贝构造函数
~CString();
int GetLength() const;
bool IsEmpty() const;
char GetAt(int nindex) const;
void Setat(int nindex,char ch);
void Print();
int compare(CString& string);
int compare(const char* psz)const;
void Vacate();
private :
char *s;
};
CString::CString()
{
s=NULL;
}
CString::CString(CString& stringser)
{
s=new char[strlen(stringser.s)+1];
if(s!=0)
strcpy(s,stringser.s);
}
CString::CString(char ch,int nRepeat)
{
s=new char[nRepeat+1];
for(int i=0;i<nRepeat;i++)
s[i]=ch;
s[nRepeat]='\0';
}

CString::CString(const char*psz)
{
s=new char[strlen(psz)+1];
if(s!=0)
strcpy(s,psz);
}
int CString::GetLength() const
{ int i=0;
while (s[i]!='\0')
i++;
return i;
}
bool CString::IsEmpty() const
{
if(s==NULL)
return 1;
else
return 0;
}
void CString::Vacate()
{
s[0]='\0';

cout<<"Now have vacated string."<<endl;
}
char CString::GetAt(int nindex) const
{

if(nindex>1&&nindex<=GetLength()+1)
return s[ nindex-1];
else
return '0';
}
void CString::Setat(int nindex,char ch)
{

if(nindex>1&&nindex<=GetLength()+1)
s[ nindex-1]=ch;
}
void CString::Print()
{
cout<<s<<endl;
}

int CString::compare(CString& string)
{

if(strcmp(s,string.s)>0)
return 1;
else if(strcmp(s,string.s)<0)
return -1;
else
return 0;
}
int CString::compare(const char* psz)const
{
if(strcmp(s,psz)>0)
return 1;
else if(strcmp(s,psz)<0)
return -1;

else return 0;

}
CString::~CString()
{
//cout<<endl<<"析构:"<<s<<endl;
if(s!=NULL)
delete[]s;
}

void main()
{
char a[4]="y";char b[4];
CString c1("Hellow"),c2(c1);
cout<<"Stringc1 is:"<<" "; c1.Print();
cout<<endl;
cout<<"Stringc2 is:"<<" "; c2.Print();
cout<<endl;
CString c3('b',3);
cout<<"Stringc3 is:"<<" "; c3.Print();
cout<<endl;

cout<<"*******************以下是对串的基本操作****************"<<endl;
int num=c1.GetLength();
char ch;
cout<<"c1的长度是:"<<" "<<num<<endl;
ch=c1.GetAt(5);
cout<<"获得字符串c1中第"<<5<<"个字符是:"<<ch<<endl;
cout<<"下面是插入字符串c1中一个特殊字符'd'"<<endl;
c1.Setat(5,'d');
cout<<"插入后字符串c1变为:"<<" ";
c1.Print();
//////////////////////
cout<<endl;
if(c1.IsEmpty()==1)
cout<<"String is empty."<<endl;
else
cout<<"String isn't empty."<<endl;
cout<<"下面是判断字符串c1清空"<<endl;
c1.Vacate();
cout<<"清空后输出字符串c1:"<<" \n";
c1.Print();
cout<<"字符串已被清空"<<endl;
cout<<"请按任意键继续"<<endl;
cin>>b;
///////////////////////////
cout<<"****************以下是对串的赋值******************"<<endl;

CString c5=c2;
cout<<"String c5=c2 is:"<<" ";c5.Print();
cout<<endl;

cout<<"****************以下是对串的比较******************"<<endl;

int temp=pare(c3);
cout<<"以下比较c2与c3"<<endl;
if(temp>0)
cout<<"Stringc2>Stringc3"<<endl;
else if(temp<0)
cout<<"Stringc2<Stringc3"<<endl;
else
cout<<"Stringc9==Stringc4"<<endl;
cout<<endl;
cout<<"以下比较c2与任意字符串Goodboy!"<<endl;

if(pare("Goodboy!")>0)
cout<<"Stringc2>'Goodboy!'"<<endl;
else if(pare("Goodboy!")<0)
cout<<"Stringc2<'Goodboy!"<<endl;
else
cout<<"Stringc2 =='Goodboy!'"<<endl;

}

第二章 继承和派生

一、 选择题
1．D 2.B 3. D
一、 阅读程序题

四、编程题
4.1
#include <iostream.h>
#include<string.h>
#define PAI 3.14
class Circle
{
public:
Circle(){r=0;}
Circle (double d){r=d;}
double area(){return(PAI*r*r);}
void display1(){cout<<"桌子的面积:"<<area()<<endl;}
private:
double r;
};
class Table
{
public:
Table(){heig=0;}
Table (double h) {heig=h;}
void display2(){cout<<"桌子的高度:"<<heig<<endl;}
private:
double heig;
};
class Roundtable : public Circle,public Table
{
public:
Roundtable(){strcpy(color,"白色");}
Roundtable(double a,double b,char* c):Circle(a),Table(b){strcpy(color,c);}
void display ()
{ display1();
display2();
cout<<"桌子的颜色:"<<color<<endl; }
private:
char color[20];
};
void main()
{
Roundtable s(2.0,3.0,"黑色");
s.display();
}

4.2
如果Age在基类中被定义为私有的，SetAge(int n)不能直接给Age赋值，如果Age是基类的公有成员变量，则可以直接赋值。
class Animal
{
public:
Animal(){};

int Age;
};
class Dog:public Animal
{
public:
Dog(){};
Void SetAge(int n)
{
Age=n;
}
};

4.3
#include <iostream.h>
class Rectangle
{
public:
Rectangle (double l,double w){length=l,width=w}
double area(){return length*width;}
void display1();
private:
double length;
double width;
};
void Rectangle::display1()
{cout<<"长:"<<length<<endl;
cout<<"宽:"<<width<<endl;}
class Cuboid:public Rectangle
{
public:
Cuboid (double L,double w,double h):Rectangle(L,w){high=h,volume=L*w*high };
double vol(){return area()*high;}
void show ();
private:
double high;
double volume;
};
void Cuboid::show()
{
display1();
cout<<"高:"<<high<<endl;
cout<<"体积:"<<vol()<<endl;
}
void main()
{
Cuboid cub (10,20,30);
cub.show();
}

4.4
#include <iostream.h>
class Vehicle
{
public:
Vehicle():maxspeed(0),weight(0){}
Vehicle(double m,double w):maxspeed(m),weight(w){};
void run ()
{ cout<<" 可以奔跑"<<endl; }
void stop ()
{ cout<<" 可以停止奔跑"<<endl;}
private:
double maxspeed;
double weight;
};
class Bicycle:virtual public Vehicle
{
public:
Bicycle (double m,double w,double h):Vehicle(m,w),height(h){}
private:
double height;
};
class Motorcar : virtual public Vehicle
{
public:
Motorcar (double m,double w,double s):Vehicle(m,w),setnum(s){}
private:
double setnum;
};
class Motorcycle:public Bicycle,public Motorcar
{
public:
Motorcycle(double m,double w,double h,double s):Bicycle(m,w,h),Motorcar(m,w,s), Vehicle(m,w){}
};
void main()
{
Motorcycle s1(300,10,6,30);
s1.run();
s1.stop();
}
如果不把Vehicle设置为虚基类，会产生二义性问题。

第3章 多态性
3.1 简答题
3.1.1 哪些运算符可以重载？
几乎所有的运算符都可以重载，除了以下的几个运算符：
．, ：： ，?:
3.1.2 运算符重载后，优先级和结合性如何？
用户重新定义运算符，不改变原运算符的的优先级和结合性。同时运算符重载后，也不改变运算符的语法结构，即单目运算符只能重载为单目运算符，双目运算符只能重载为双目运算符。
3.1.3 编译程序如何选用运算符函数？
在每一种编译系统中，运算符实际上都对应一个函数，只是这种运算对用户具有透明性，使用者并不知道函数的存在。运算符重载实际上是运算符函数的重载，所以运算符的重载实际上是函数的重载。
编译程序对运算符重载的选择，遵循着函数重载的选择原则。当遇到不很明显的运算符时，编译程序将去寻找参数相匹配的运算符函数。
3.1.4 重载运算符有哪些限制？
（1） 不可臆造新的运算符
（2） 坚持四个不能改变。
l 不能改变运算符原有的优先级
l 不能改变运算符原有的结合性
l 不能改变运算符原有的语法结构
l 不能改变运算符原有的操作数个数
但允许改变
运算符的返回类型
（3）C++规定，运算符中，参数类型都是内部类型时，不允许重载。 “：：、*、->、？：”这五个运算符不能重载。
3.1.5 运算符重载必须遵循哪些原则？
运算符重载可以使程序更加简洁，使表达式更加直观，增强可读性。但是，运算符重载使用不宜过多，否则会带来一定的麻烦。
运算符重载必须遵循以下原则：
（1） 重载运算符含义必须清楚。
（2） 重载运算符不能有二义性。
3.2 填空题
3.2.1 C++中多态性包括两种多态性： （1） 和 （2） 。前者是通过 （3） 实现的，而后者是通过 （4） 和 （5） 来实现的。
答案：（1）编译时的
（2）运行时的
（3）函数和运算符的重载
（4）类继承关系
（5）虚函数
3.2.2 纯虚函数定义时在函数参数表后加 （1） ，它表明程序员对函数 （2） ，其本质是将指向函数体的指针定为 （3） 。
答案：（1）=0
（2）不定义
（3）NULL
3.2.3在基类中将一个成员函数说明成虚函数后，在其派生类中只要 （1） 、 （2） 和 （3） 完全一样就认为是虚函数，而不必再加关键字 （4） 。如有任何不同，则认为是 （5） 而不是虚函数。除了非成员函数不能作为虚函数外， （6） 、 （7） 和 （8） 也不能作为虚函数。
答案：（1）同虚函数名
（2）同参数表
（3）同返回类型。如基类中返回基类指针，而派生类中返回派生类指针是允许的
（4）virtual
（5）重载
（6）静态成员函数
（7）内联函数
（8）构造函数
第三大题答案：
3．1答案：
#include<iostream.h>
#include<string.h>
class CStudent
{

char name[20];
char nativeplace[20];
char code[30];
int age;
float score;
public :
CStudent(char *, char*,char*,int ,float);
CStudent(CStudent &s);
void display();
float operator+(CStudent s1);
};
CStudent::CStudent(char *name, char*native,char*code,int age,float score)
{
strcpy(this->name,name);
strcpy(this->nativeplace,native);
strcpy(this->code,code);
this->age=age;
this->score=score;
}
CStudent::CStudent(CStudent &s)
{
strcpy(this->name,s.name);
strcpy(this->nativeplace,s.nativeplace);
strcpy(this->code,s.code);
this->age=s.age;
this->score=s.score;
}
void CStudent::display()
{
cout<<name<<" "<<nativeplace<<" "<<code<<" "<<age<<" "<<score<<endl;
}
float CStudent::operator +(CStudent s1)
{
return this->score+s1.score;
}
void main()
{
CStudent w("whl","zhengzhou","13783580182",30,90);
w.display();
CStudent c("ctm","zhengzhou","13783580182",30,90);
c.display();
cout<<w+c<<endl;
}
3．2答案：
#include<iostream.h>
#include<string.h>
#include<math.h>
class CTriangle
{
float a,b,c;
public:
CTriangle(float a,float b,float c)
{
this->a=a;
this->b=b;
this->c=c;
}
float GetArea()
{
float t=(a+b+c)/2;
return sqrt(t*(t-a)*(t-b)*(t-c));
}
float operator +(CTriangle t)
{
return this->GetArea()+t.GetArea();
}
};
void main()
{
CTriangle tr1(3,4,5),tr2(6,8,10);
cout<<tr1+tr2<<endl;
}
3．3答案：

#include<iostream.h>
class BaseClass
{
public:
virtual void f1()
{cout<<"BaseClass::f1()"<<endl;}
void f2()
{cout<<"BaseClass::f2()"<<endl;}
};
class DerivedClass: public BaseClass
{
public:
void f1()
{cout<<"DerivedClass::f1()"<<endl;}
void f2()
{cout<<"DerivedClass::f2()"<<endl;}
};

void main()
{
DerivedClass d1;
BaseClass* Bptr;
DerivedClass* Dptr;
Bptr=&d1;
Bptr->f1();
Bptr->f2();
Dptr=&d1;
Dptr->f1();
Dptr->f2();
}

习题四
一、选择题

1．D 2．A 3．B 4．C 5. C 6．C 7． A
二、简答题

1．什么叫做流？流的提取和插入是指什么？I/O流在C++中起着怎样的作用？
答：流是一种抽象，它负责在数据的生产者（程序/文件）和数据的消费者（文件/程序）之间建立联系，并管理数据的流动。
一般意义下的读操作在流数据抽象中被称为（从流中）提取，写操作被称为（向流中）插入。
完成数据从动态（内存）到静态（外存）的转换，或着是从静态（外存）到动态（内存）的转换。
2．什么是字节流、字符流和二进制流？
答：根据对字节内容的解释方式，字节流分为字符流（也称文本流）和二进制流。
字符流将字节流的每个字节按ASCⅡ字符解释，它在数据传输时需作转换，效率较低。例如源程序文件和文本文件都是字符流。由于ASCⅡ字符是标准的，所以字符流可以直接编辑，显示或打印，字符流产生的文件通行于各类计算机。
二进制流将字节流的每个字节以二进制方式解释，它在数据传输时不作任何转换，故效率高。但各类计算机对数据的二进制存放格式各有差异，且无法人工阅读，故二进制流产生的文件可移植性较差。
3．cerr和clog作用是什么？有何区别？
答：对于输入提示信息或输出结果而言， cerr和clog的用法相同，但作用不同。cerr的作用是向标准错误设备(standard error device)输出有关出错信息。cerr流中的信息只能在显示器输出。当调试程序时，往往不希望程序运行时的出错信息被送到其他文件，而要求在显示器上及时输出，这时应该用cerr，cerr流中的信息是用户根据需要指定的。clog流对象也是标准错误流，它是console log的缩写。它的作用和cerr相同，都是在终端显示器上显示出错信息。不同的是cerr不经过缓冲区，直接向显示器上输出有关信息，而clog中的信息存放在缓冲区中，缓冲区满后或遇endl时向显示器输出。
4．用什么方法来控制输入输出流中出现的错误？
答：为提高程序的可靠性，应在程序中检测I/O流的操作是否正常。当检测到流操作出现错误时，可以通过异常处理来解决问题。
5．比较读写文本文件与二进制文件的异同。
答：从文件编码的方式来看，文件可分为ASCII码文件和二进制码文件两种。
　　ASCII文件也称为文本文件，这种文件在磁盘中存放时每个字符对应一个字节，用于存放对应的ASCII码。例如，数