c++.primer.plus第五版第十章编程练习答案

第一题、复习题5中的类：

BankAccout.h：

#ifndef _BANKACCOUNT_H
#define _BANKACCOUNT_H

#include <cstring>

// class definition
class BankAccount
{
private:
char name[40];			// or std::string name;
char acctnum[25];		// or std::string acctnum;
double balance;
public:
BankAccount(const char* client,const char * num,double bal = 0.0);
// or BankAccount(const std::string & client,const std::string & num,double bal = 0.0)

void  show(void)const;
void dposit(double cash);
void withdraw(double cash);
};

#endif

BankAccout.cpp为：

#include <iostream>
#include <cstring>
#include "BankAccount.h"

using std::cout;
using std::endl;
BankAccount::BankAccount(const char* client,const char * num,double bal) // 定义时参数不用默认值，否则编译不通过
{
strncpy(name,client,40);
name[39] = '\0';
strncpy(acctnum,num,25);
acctnum[24] = '\0';
balance = bal;
}
// or
//BankAccount::BankAccount(const std::string & client,const std::string & num,double bal)
//{
//    name = client;
//    acctnum = num;
//    balance = bal;
//}

void BankAccount::show(void)const
{
cout << "Name:\t" << name << endl
<< "Account:\t" << acctnum << endl
<< "Balance:\t" << balance << endl;
}

void BankAccount::dposit(double cash)
{
balance += cash;
}

void BankAccount::withdraw(double cash)
{
if(balance >= cash)
balance -= cash;
else
cout << "no much money!\n";
}

小程序演示类的特性：

#include <iostream>
#include "BankAccount.h"

using std::cin;
using std::cout;
using std::endl;
int main()
{
char client[40];
char num[25];
double bal = 0.0;
cout << "Please input your name: ";
cin.getline(client,40);
cout << "Please input your acctnum: ";
cin.getline(num,25);
cout << "Please input your balance: ";
cin >> bal;
cout << "Now make a BankAccount constructor!\n";
BankAccount tmp(client,num,bal);
int flag = 0;
cout << "Please input the flag: ";
while(cin >> flag)
{
if(flag == 0)
tmp.show();
else if(flag == 1)
{
double num;
cout << "How much money you want to dposit: ";
cin >> num;
tmp.dposit(num);
}
else if(flag == 2)
{
double num;
cout << "How much money you want to withdraw:";
cin >> num;
tmp.withdraw(num);
}
cout << "Please input the flag: ";
}

return 0;
}

第二题：

person.h:

// 2,下面是一个非常简单的类定义：
#ifndef PERSON_H_
#define PERSON_H_
#include <cstring>
#include <string>

using std::string;
class Person{
private:
static const int LIMIT = 25;
string lname;       // Person's last name
char fname[LIMIT];  // Person's first name
public:
Person() {lname = ""; fname[0] = '\0';}
Person(const string & ln,const char * fn = "Heyyou");   // #2
// the following methods display lname and fname
void show()const;       // firstname lastname format
void FormalShow()const; // lastname,firstname format
};

#endif // PERSON_H

person.cpp:

// 2
#include <iostream>

#include "person.h"

using std::cout;
using std::endl;
Person::Person(const string & ln,const char * fn)
{
lname = ln;
strncpy(fname,fn,LIMIT);
fname[LIMIT - 1] = '\0';
}

void Person::show()const
{
cout << "The name is:\t" << fname << ' ' << lname << endl;
}

void Person::FormalShow()const
{
cout << "The name is:\t" << lname << ',' << fname << endl;
}

测试程序：main.cpp

// 2
#include <iostream>
#include "person.h"

using std::cout;
using std::endl;
int main()
{
Person one;                     // use default constructor
Person two("Smythecraft");      // use #2 with one default argument
Person three("Dimwiddy","Sam"); // use #2,no defaults

one.show();
cout << endl;
one.FormalShow();
cout << endl;

two.show();
cout << endl;
two.FormalShow();
cout << endl;

three.show();
cout << endl;
three.FormalShow();
cout << endl;

return 0;
}

第三题：完成第九章的编程练习1，但要用正确的golf类声明替换那里的代码。用带合适参数的构造函数替换setgolf(golf &,const char *,int),以提供初始值。保留setgolf()的交互版本，但要用构造函数来实现它(例如,setgolf()的代码应该获得数据，将数据传递给构造函数来创建一个临时对象，并将其赋给调用对象，即*this).

// 第九章编程练习1
/*
// 1，下面是一个头文件：
// golf.h -- for pe9-1.cpp
static const int Len = 40;
struct golf
{
char fullname[Len];
int handicap;
};
// non-interactive version:
// function sets golf structure to provided name,handicap
// using values passed as arguments to the function
void setgolf(golf &g,const char *name,int hc);

// interactive version:
// function solicits name and handicap from user
// and sets the members of g to the values entered
// returns 1 if name is entered, 0 if name is empty string
int setgolf(golf & g);                    //交互版本

// function resets handicap to new value_type
void handicap(golf & g,int hc);

// function displays contents of golf structure
void showgolf(const golf & g);

setgolf()被重载，可以这样使用其第一个版本：
golf ann;
setgolf(ann,"Ann Birdfree",24);
上述函数调用提供了存储在Ann结构中的信息。可以这样使用其第二个版本：
golf andy;
setgolf(andy);
上述函数将提示用户输入姓名和等级，并将它们存储在andy结构中。这个函数可以(但不一定必须)在内部使用第一个版本。根据这个头文件，创建一个多文件程序。其中的一个文件名为golf.cpp，它提供了与头文件中的原型匹配的函数定义；另一个文件应包含main(),并演示原型化函数的所有特性。例如，包含一个让用户输入的循环，并使用输入的数据来填充一个由golf结构组成的数组，数组被填满或用户将高尔夫选手的姓名设置为空字符串时，循环将结束。main()函数只使用头文件中原型化的函数来访问golf结构。
*/

golf.h:

#ifndef GOLF_H
#define GOLF_H
class Golf{
private:
static const int Len = 40;
char fullname[Len];
int handicap;
public:
Golf(const char * name = "AAAAA",int hc = 10);
~Golf();
int setGolf();
void sethandicap(int hc);
void showGolf()const;
};
#endif // GOLF_H

golf.cpp:

#include <iostream>
#include <cstring>
#include "golf.h"

Golf::Golf(const char * name,int hc)
{
strncpy(fullname,name,40);
fullname[39] = '\0';
handicap = hc;
}

Golf::~Golf()
{
using std::cout;
using std::endl;
cout << "Bye!" << endl;
}

int Golf::setGolf()
{
using std::cin;
using std::cout;
using std::endl;

char fullname[Len];
int handicap;

cout << "Please input the name of the golf player: ";
cin.get(fullname,Len);   // 读取一行
if(cin)
{
cout << "Please input the handicap of the golf player: ";
cin >> handicap;
cin.get();
*this = Golf(fullname,handicap);
return 1;
}
else
return 0;

}

void Golf::sethandicap(int hc)
{
handicap = hc;
}

void Golf::showGolf()const
{
std::cout << "hullname: " << fullname << ", \thandicap: " << handicap << std::endl;
}

测试程序：main.c

#include <iostream>
#include "golf.h"

using std::cin;
using std::cout;
using std::endl;
int main()
{
Golf one;
Golf two;
Golf three;

one.showGolf();         // 默认构造函数
two.setGolf();          // 交互版本
two.showGolf();
two.sethandicap(2000);  //成员函数
two.showGolf();         //成员函数
three.sethandicap(50);
three.showGolf();

return 0;
}

第四题：完成第九章的编程练习4，但将Sales结构相关的函数转换为一个类及其方法。用构造函数替换setSales[sales &,double[],int)函数。用构造函数实现setSales(Sales &)方法的交互版本。将类保留在名称空间SALES中。

第九章第四题：请基于下面这个名称空间编写一个由3个文件组成的程序：

<span style="color:#ff6600;">namespace SALES
{
const int QUARTERS = 4;
struct Sales
{
double sales[QUARTERS];
double average;
double max;
double min;
}

// copies the lesser of 4 or n items from the array ar
// to the sales member of s and computes and stores the
// average, maximum, and minimum values of the entered items;
// remaining elements of sales,if any,set to 0
void setSales(Sales & s,const double ar[],int n);

// gathers sales for 4 quarters interactively,stores them
// in the sales member of s and computes and stores the
// average,maximum, and minimum values
void setSales(Sales & s);

// display all information in structure s
void showSales(const Sales & s);
}
</span>

第一个文件是一个头文件，其中包含名称空间。第二个文件是一个源代码文件，它对这个名称空间进行扩展，以提供3个函数的定义。第三个文件声明两个Sales对象，并使用setSales()的交互式版本为一个结构提供值，然后使用setSales()的非交互式版本为另一个结构提供值。另外它是使用showSales()来显示 这两个结构的内容。

sales.h

#ifndef SALES_H_
#define SALES_H_
namespace SALES
{
class Sales
{
private:
static const int QUARTERS = 4;
double sales[QUARTERS];
double average;
double max;
double min;
public:
Sales(const double ar[],int n);
Sales();
~Sales();
void showSales();
};
}
#endif // SALES_H_

sales.cpp

// 4 对题意的理解可能有问题，这里Sales(const double ar[],int n)的是将ar中前四个或n(n < 4时)复制给sales
#include <iostream>
#include "sales.h"

namespace SALES
{
using SALES::Sales;
using std::cout;
using std::endl;
using std::cin;
Sales::Sales(const double ar[],int n)
{
max = min = ar[0];
double sum = 0.0;
for(int i = 0;i < QUARTERS;i++)
{
if(i <= n)
sales[i] = ar[i];
else
sales[i] = 0.0;
if(max < sales[i])
max = sales[i];
if(min > sales[i])
min = sales[i];
sum += sales[i];
}
average = sum * 1.0 / QUARTERS;
}

Sales::Sales()
{
double arr[QUARTERS];
cout << "Please fill the array: \n";
for(int i = 0;i < QUARTERS;i++)
{
cout << "arr[" << i << "] = ";
cin >> arr[i];
}
*this = Sales(arr,QUARTERS);
}

Sales::~Sales()
{
cout << "Bye!\n";
}

void Sales::showSales()
{
cout << "\n=============================================\n";
for(int i = 0;i < QUARTERS;i++)
cout << "sales[" << i << "] = " << sales[i] << endl;
cout << "max = " << max << endl;
cout << "min = " << min << endl;
cout << "average = " << average << endl;
cout << "\n=============================================\n";
}
}

测试程序：main.cpp

#include <iostream>
#include "sales.h"

using SALES::Sales;

int main()
{
const int limit = 4;
double arr[limit] = {3.4,1.3,0,0};

Sales one(arr,limit);
Sales two;

one.showSales();
two.showSales();
return 0;
}

第五题：考虑下面的结构声明：

struct customer{
char fullname[35];
double payment;
};

编写一个程序，它从堆栈中添加和删除customer结构(堆栈用Stack类声明表示)。每次customer结构被删除时，其payment的值都被加入到总数中，并报告总数。注意：应该可以直接使用Stack类而不作修改；只需修改typedef声明，使Item的类型为customer，而不是unsigned long即可。

/*
// 程序清单10.10 stack.h
// stack.h -- class definition for the stack ADT
#ifndef STACK_H_
#define STACK_H_
typedef unsigned long Item;
class Stack
{
private:
    enum {MAX = 10};    // constant specific to class
    Item items[MAX];    // holds stack items
    int top;            // index for top stack item
public:
    Stack();
    bool isempty()const;
    bool isfull()const;
    // push()returns false if stack already is full,true otherwise
    bool push(const Item & item);   // add item to stack
    // pop()returns false if stack already is empty,true otherwise
    bool pop(Item & item);          // pop top into item
};
#endif // STACK_H_
*/

static.h:

// stack.h
// stack.h -- class definition for the stack ADT
#ifndef STACK_H_
#define STACK_H_
typedef struct customer
{
char fullname[35];
double payment;
}CUSTOMER;

typedef customer Item;

class Stack
{
private:
enum {MAX = 10};    // constant specific to class
Item items[MAX];    // holds stack items
int top;            // index for top stack item
int total;
public:
Stack();
~Stack();
bool isempty()const;
bool isfull()const;
// push()returns false if stack already is full,true otherwise
bool push(const Item & item);   // add item to stack
// pop()returns false if stack already is empty,true otherwise
bool pop(Item & item);          // pop top into item
};
#endif // STACK_H_

static.cpp:

// stack.cpp -- Stack member functions
#include <iostream>
#include "stack.h"
Stack::Stack()  // create an empty stack
{
top = 0;
total = 0;
}

Stack::~Stack()
{
using std::cout;
cout << "Bye!\n";
}

bool Stack::isempty()const
{
return top == 0;
}

bool Stack::isfull()const
{
return top == MAX;
}

bool Stack::push(const Item & item)
{
if(top < MAX)
{
items[top++] = item;
return true;
}
else
return false;
}

bool Stack::pop(Item & item)
{
if(top > 0)
{
using std::cout;
using std::endl;
item = items[--top];
total = total + item.payment;
cout << "PO#" << item.fullname << endl;
cout << "Total = " << total << endl;
return true;
}
else
return false;
}

测试程序：main.cpp

// testing the Stack class
#include <iostream>
#include <cctype>   // or ctype.h
#include "stack.h"

int main()
{
using namespace std;
Stack st;   // create an empty stack
char ch;
CUSTOMER po;
cout << "Please enter A to add a purchase order.\n"
<< "P to process a PO,or Q to quit.\n";
while(cin >> ch && toupper(ch) != 'Q')
{
while(cin.get() != '\n')
continue;
if(!isalpha(ch))
{
cout << '\a';
continue;
}
switch(ch)
{
case 'A':
case 'a':
cout << "Enter a PO fullname to add:\t";
cin.getline(po.fullname,35);
cout << "Enter a PO payment to add:\t";
cin >> po.payment;
if(st.isfull())
cout << "stack already full\n";
else
st.push(po);
break;
case 'P':
case 'p':if(st.isempty())
cout << "Stack already empty\n";
else
st.pop(po);
break;
}
cout << "Please enter A to add a purchase order,\n"
<< "P to process a PO, or Q to quit.\n";
}
cout << "Bye\n";
return 0;
}

第六题：

// 下面是一个类声明：

class Move
{
private:
double x;
double y;
public:
Move(double a = 0,double b = 0);        // sets x,y to a,b
void showmove()const;                        // shows current x,y values
Move add(const Move & m)const;
// this function adds x of m to x of invoking object to get new x,
// adds y of m to y of invoking object to get new y,creates a new
// move object initialized to new x,y values and returns it
void reset(double a = 0,double b = 0);       // reset x,y to a,b
};

// 请提供成员函数的定义和测试这个类的程序。

move.h:

// 下面是一个类声明：
#ifndef _MOVE_H_
#define _MOVE_H_

class Move
{
private:
    double x;
    double y;
public:
    Move(double a = 0,double b = 0);        // sets x,y to a,b
    void showmove()const;                        // shows current x,y values
    Move add(const Move & m)const;
    // this function adds x of m to x of invoking object to get new x,
    // adds y of m to y of invoking object to get new y,creates a new
    // move object initialized to new x,y values and returns it
    void reset(double a = 0,double b = 0);       // reset x,y to a,b
};
#endif // _MOVE_H_
// 请提供成员函数的定义和测试这个类的程序。

move.cpp:

#include <iostream>
#include "move.h"

Move::Move(double a,double b)
{
x = a;
y = b;
}

void Move::showmove()const
{
using std::cout;
using std::endl;
cout << "=============================\n";
cout << "x = " << x << endl;
cout << "y = " << y << endl;
cout << "=============================\n";
}

Move Move::add(const Move & m)const
{
return Move(x + m.x,y + m.y);
}

void Move::reset(double a,double b)
{
x = a;
y = b;
}

测试小程序 main.cpp：

#include <iostream>
#include "move.h"

int main()
{
Move one;
Move two(3,3);
one.showmove();
two.showmove();
one = one.add(two);
one.showmove();
one.reset(1,1);
one.showmove();
return 0;
}

第七题：Betelgeusean plorg有这些特征：

数据：

plorg的名称不超过19个字符。

plorg有满意指数(CI)，这是一个整数。

操作：

新的plorg将有名称，其CI值为50。

plorg的CI可以修改。

plorg可以报告它的名称和CI。

plorg的默认名称为"Plorga"。

请编写一个Plorg类声明(包括数据成员和成员函数原型)来表示plorg，并编写成员函数的定义。然后编写一个小程序，以演示Plorg类的所有特性。

betelgeuseanplorg.h：

#ifndef _BETELGEUSEANPLORG_H_
#define _BETELGEUSEANPLORG_H_
class Bplorg
{
private:
enum {MAX = 20};
char name[MAX];
unsigned int CI;
public:
Bplorg(const char *nm = "Plorga",int numci = 50);  // 默认参数CI=50 默认名称为Plorga
~Bplorg();
void setCI(int numci);                 // 修改CI值
void showBplorg()const;              // 报告它的名称和CI
};

#endif // _BETELGEUSEANPLORG_H_

betelgeuseanplorg.cpp：

#include <iostream>
#include <cstring>
#include "betelgeuseanplorg.h"

Bplorg::Bplorg(const char *nm,int numci)     // 默认参数CI=50 默认名称为Plorga
{
strncpy(name,nm,19);
name[19] = '\0';
CI = numci;
}
Bplorg::~Bplorg()
{
using std::cout;
using std::endl;
cout << "Bye" << endl;
}
void Bplorg::setCI(int numci)           // 修改CI值
{
CI = numci;
}
void Bplorg::showBplorg()const          // 报告它的名称和CI
{
using std::cout;
using std::endl;
cout << "Name:\t" << name
<< "\nCI:\t" << CI << endl;
}

测试小程序：main.cpp:

#include <iostream>
#include "betelgeuseanplorg.h"

int main()
{
Bplorg one;
Bplorg two("two two two",20);

one.showBplorg();
one.setCI(10);
one.showBplorg();

two.showBplorg();
two.setCI(15);
two.showBplorg();

return 0;
}

第八题:(待做)

可以将简单列表描述成下面这样：

可存储0或多个某种类型的列表。

可创建空列表。

可在列表中添加数据项。

可确定列表是否为空。

可确定列表是否为满。

可访问列表中的每一个数据项，并对它执行某种操作。

可以看到，这个列表确实很简单，例如，它不允许插入或删除数据项。

请设计一个List类来表示这种抽象类型。您应提供头文件list.h和实现文件list.cpp，前者包含类定义，后者包含类方法的实现。您还应创建一个简短的程序来使用这个类。

可以选择使用数组或链表来实现该列表，但公有接口不应该依赖于所做的选择。也就是说，公有接口不应有数组索引、节点指针等。应使用通用概念来表达创建列表、在列表中添加数据项等操作。对于访问数据项以及执行操作，通常应使用将函数指针作为参数的函数来处理：

void visit(void (*pf)(Item &));

其中，pf指向一个将Item引用作为参数的函数(不是成员函数),Item是列表中数据项的类型。visit()函数将该函数用于列表中的每个数据项。