chap4（谭浩强版） - c++ 部分作业及答案

4-1 解释public 和private 的作用，公有类型成员与私有类型成员有些什么区别？ 解：

公有类型成员用public 关键字声明，公有类型定义了类的外部接口；私有类型的成员用 private 关键字声明，只允许本类的函数成员来访问，而类外部的任何访问都是非法的，这样，

私有的成员就整个隐蔽在类中，在类的外部根本就无法看到，实现了访问权限的有效控制。 4-2 protected 关键字有何作用？

解：

protected 用来声明保护类型的成员，保护类型的性质和私有类型的性质相似，其差别在于继

承和派生时派生类的成员函数可以访问基类的保护成员。 4-3 构造函数和析构函数有什么作用？

解：

构造函数的作用就是在对象被创建时利用特定的值构造对象，将对象初始化为一个特定的状 态，使此对象具有区别于彼对象的特征，完成的就是是一个从一般到具体的过程，构造函数 在对象创建的时候由系统自动调用。

析构函数与构造函数的作用几乎正好相反，它是用来完成对象被删除前的一些清理工作，也 就是专门作扫尾工作的。一般情况下，析构函数是在对象的生存期即将结束的时刻由系统自 动调用的，它的调用完成之后，对象也就消失了，相应的内存空间也被释放。 4-4 数据成员可以为公有的吗？成员函数可以为私有的吗？ 解：

可以，二者都是合法的。数据成员和成员函数都可以为公有或私有的。但数据成员最好定义 为私有的。

4-5 已知class A 中有数据成员int a，如果定义了A 的两个对象A1、A2，它们各自的数据 成员a 的值可以不同吗？

解：

可以，类的每一个对象都有自己的数据成员。

4-6 什么叫做拷贝构造函数？拷贝构造函数何时被调用？ 解：

拷贝构造函数是一种特殊的构造函数，具有一般构造函数的所有特性，其形参是本类的对象 的引用，其作用是使用一个已经存在的对象，去初始化一个新的同类的对象。在以下三种情 况下会被调用：在当用类的一个对象去初始化该类的另一个对象时；如果函数的形参是类对 象，调用函数进行形参和实参结合时；如果函数的返回值是类对象，函数调用完成返回时； 4-7 拷贝构造函数与赋值运算符(=)有何不同？

解：

赋值运算符(=)作用于一个已存在的对象；而拷贝构造函数会创建一个新的对象。

4-8 定义一个Dog 类，包含的age、weight 等属性，以及对这些属性操作的方法。实现并测 试这个类。 解：

源程序：

#include using namespace std; class Dog {

public:

Dog(int A=0,int W=0); ~Dog(){};

void setAge(int newA) { }

age=newA;

void setWeight(int newW) { }

int showAge() { }

return age; weight=newW;

int showWeight() { return weight;

} private:

int age; int weight; };

Dog::Dog(int A,int W) {

age=A;

weight=W; }

void main() { }

Dog mydog(5,16); mydog.showAge(); mydog.showWeight();

cout<<\

cout<<\ mydog.setAge(8);

mydog.setWeight(20);

cout<<\cout<<\

4-9 设计并测试一个名为Rectangle 的矩形类，其属性为矩形的左下角与右上角两个点的坐 标，能计算矩形的面积。 解：

源程序：

#include using namespace std; class point {

public: point(int xx=0,int yy=0)

{ } int getx() {

return x; x=xx; y=yy;

}

int gety() { }

return y;

private: };

int x,y;

class Rectangle {

public: Rectangle(point xp1,point xp2);

int getarea() { }

return area;

private: };

Rectangle::Rectangle(point xp1,point xp2) { p1=xp1;

point p1; point p2;

int area;

}

p2=xp2;

int height=p2.gety()-p1.gety(); int width=p2.getx()-p1.getx(); area=height*width;

int main() { }

4-10 设计一个用于人事管理的People（人员）类。考虑到通用性，这里只抽象出所有类型 人员都具有的属性：number（编号）、sex（性别）、birthday（出生日期）、id（身份证号）等

等。其中\出生日期\定义为一个\日期\类内嵌子对象。用成员函数实现对人员信息的录入和 显示。要求包括：构造函数和析构函数、拷贝构造函数、内联成员函数、带缺省形参值的成 员函数、聚集。 解：

#include #include using namespace std;

class Date //日期类 {

private: int year; int month; int day; public:

Date(){} //默认构造

Date(int y,int m,int d) //带参构造 {

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

void set() //设置数据函数 {

cin>>year>>month>>day;

point a(1,1),b(4,5); Rectangle myrectangle(a,b);

cout<<\return 0;

}

void display() //显示函数 {

cout<

class Person //人员类 { private: int num; char sex; Date birthday; char ID[18];

public:

Person(){} //默认构造

Person(int n,int y,int m,int d,char id[18],char s='m'):birthday(y,m,d) {

num=n; sex=s;

strcpy(ID,id);

} //有默认值的带参构造

Person(Person& p) //拷贝构造 {

num=p.num; sex=p.sex;

birthday=p.birthday; strcpy(ID,p.ID); }

void input() //输入函数 {

cout<<\录入数据：\ cout<<\编号：\ cin>>num;

cout<<\性别(m/f)：\ cin>>sex; cout<<\生日：\ birthday.set();

cout<<\身份证号：\ cin>>ID; ID[18]='\\0';

cout<

void output() //输出函数

{

cout<<\编号：\ cout<<\性别：\ cout<<\生日：\ birthday.display();

cout<

cout<<\身份证号：\ }

~Person() //析构函数 {

cout<<\号人员已经录入\ } };

int main() {

Person p1; p1.input(); p1.output(); return 0; }

4-11 定义一个矩形类，有长、宽两个属性，有成员函数计算矩形的面积 解：

#include using namespace std; class Rectangle {

public: Rectangle(float len,float wid) {

length=len; width=wid;

}

~Rectangle(){}; float getlen() {

return length; }

float getwid() {

return width;

}

float getarea();

private:

float length; float width; };

float Rectangle::getarea() { }

void main() { }

float length, width;

cout << \请输入矩形的长度：\cin >> length;

cout << \请输入矩形的宽度：\cin >> width;

Rectangle r(length, width);

cout << \长为\宽为\的矩形的面积为：\<< r.getarea () << endl;

return length*width;

4-12 定义一个\数据类型\类，能处理包含字符型、整型、浮点型三种类型的数据， 给出其构造函数。 解：

#include class datatype {

enum { character,

integer,

floating_point

}vartype; union { };

char c; int i; float f;

public: datatype(char ch)

{

vartype = character; c = ch;

}

datatype(int ii) { vartype = integer; i = ii; }

datatype(float ff) { }

void print();

vartype = floating_point; f = ff;

};

void datatype::print() { switch (vartype)

{

case character: cout << \字符型: \ break; case integer:

cout << \整型: \ break;

case floating_point: cout << \浮点型: \ }

break;

}

void main() { datatype A('c'), B(12), C(1.44F); }

A.print(); B.print(); C.print();

4-13 定义一个Circle 类，有数据成员半径Radius，成员函数GetArea()，计算圆的面积，构 造一个Circle 的对象进行测试。 解：

#include using namespace std; const float PI=3.141593; class Circle {

public: Circle(float r)

{

radius=r; } float getarea(); private: };

float radius;

float Circle::getarea() { }

void main() { float a; }

cout<<\：\cin>>a;

Circle mycircle(a);

cout<<\return PI*radius*radius;

4-14 定义一个tree 类，有成员ages，成员函数grow(int years)对ages 加上years,age()显示tree 对象的ages 的值。

#include

class Tree {

int ages;

public: Tree(int n=0); ~Tree(); };

Tree::Tree(int n) { }

Tree::~Tree() { }

age(); ages = n;

void grow(int years); void age();

void Tree::grow(int years) { ages += years; }

void Tree::age() { } {

Tree t(12); t.age(); t.grow(4);

cout << \这棵树的年龄为\

void main()

}

/* 2011-10-25

provided ty Liu Hui

4-19 编写一个名为CPU的类，描述一个CPU的以下信息：时钟频率，最大不会超过3000MHz；字长，可以是32为或是64位；核数，可以是单核，双核或四核；是否支持超线程。

各信息要求使用位域来表示。通过输出sizeof（CPU）来观察该类所占的字节数。 */

#include using namespace std;

class CPU

//定义一个CPU类

{

private: //CPU类的私有成员 double clockrate;//时钟频率，最大不超过3000MHz

int wordsize;//字长，32或64 bit int heshu;//可单核，双核或四核

bool m;//是否支持超线程 public:

CPU(double Newclockrate,int Newwordsize,int Newheshu,bool Newm) //构造函数 { clockrate=Newclockrate;

wordsize=Newwordsize; heshu=Newheshu; m=Newm;

//描述CPU信息的函数

}

void describe();

};

void CPU::describe()

//描述CPU信息的函数

{ int main() { }

/* 2011-10-25 provided ty Liu Hui

4-20定义一个复数Complex，使得下面的代码能够工作。 Complex c1(3,5); Complex c2=4.5; c1.sdd(c2); C1.show(); */

#include using namespace std;

class Complex {

public: Complex(float r1,float i1); //有虚部的复数构造函数的声明

Complex(float r); void add(Complex &c);

//无虚部复数的构造函数的声明

//定义一个Complex类

//用复数3+5i初始化c1 //用实数4.5初始化c2

//将c1与c2相加，结果保存在c1中 //将c1输出（这时的结果应该是7.5+5i）

CPU MyCPU(2500,32,4,true); //初始化一个CPU类的对象c MyCPU.describe(); //描述这个对象c cout<<\类在内存中所占的字节数为：\cout<

cout<<\对象在内存中所占的字节数为：\cout<

cout<<\时钟频率为：\cout<<\字长为：\cout<<\核数为：\if(m==true)

cout<<\支持超线程\\n\else }

cout<<\不支持超线程\\n\

void show(); private: float real;

float i;

};

Complex::Complex(float r1,float i1)//有虚部的复数构造函数的实现 { }

Complex::Complex(float r1)//无虚部复数的构造函数的实现 { }

real=r1; i=0; real=r1; i=i1;

void Complex::add(Complex &c) //add函数的实现 { }

void Complex::show() //show函数的实现 { cout<0 ? '+':'-')<

int main() { Complex c1(3,5); }

Complex c2=4.5;

c1.add(c2); //将对象c2作为参数计算c1+c2 c1.show(); return 0; real=real+c.real; i=i+c.i;

本文来源：https://www.bwwdw.com/article/czyo.html