C++ Primer Plus 第6版 第12章 编程练习答案
1. 对于下面的类声明：
class Cow {
private:
char name[20];
char* hobby;
double weight;
public:
Cow();
Cow(const char* nm, const char* ho, double wt);
Cow(const Cow& c);
~Cow();
Cow& operator=(const Cow& c);
void ShowCow() const;
};
给这个类提供实现，并编写一个使用所有成员函数的小程序。
#pragma once
#ifndef COW_H_
#define COW_H_
class Cow {
private:
char name[20];
char* hobby;
double weight;
public:
Cow();
Cow(const char* nm, const char* ho, double wt);
Cow(const Cow& c);
~Cow();
Cow& operator=(const Cow& c);
void ShowCow() const;
};
#endif // !COW_H_
// cow.cpp
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include "cow.h"
using std::strncpy;
using std::strcpy;
// 默认构造函数
Cow::Cow() {
hobby = nullptr;
weight = 0.0;
}
// 构造函数
Cow::Cow(const char* nm, const char* ho, double wt) {
strncpy(name, nm, 20);
hobby = new char[strlen(ho) + 1];
strcpy(hobby, ho);
weight = wt;
}
// 复制构造函数
Cow::Cow(const Cow& c) {
strncpy(name, c.name, 20);
hobby = new char[strlen(c.hobby) + 1];
strcpy(hobby, c.hobby);
weight = c.weight;
}
// 析构函数，delete[]
// 最后将hobby置为空指针很重要
Cow::~Cow() {
delete[] hobby;
hobby = nullptr;
}
Cow& Cow::operator=(const Cow& c) {
strncpy(name, c.name, 20);
hobby = new char[strlen(c.hobby) + 1];
strcpy(hobby, c.hobby);
weight = c.weight;
return *this;
}
void Cow::ShowCow() const {
std::cout << "name: " << name
<< ", hobby: " << hobby << ", weight: " << weight;
} // 12-1
#include
#include "cow.h"
int main() {
Cow cow1;
Cow cow2 = Cow("XiaoHua", "Run", 23.5);
Cow cow3 = Cow("XiaoHong", "Eat", 45.7);
Cow cow4 = cow2;
cow1 = cow3;
std::cout << "cow1: ";
cow1.ShowCow();
std::cout << "\ncow2: ";
cow2.ShowCow();
std::cout << "\ncow3: ";
cow3.ShowCow();
std::cout << "\ncow4: ";
cow4.ShowCow();
return 0;
} 2. 通过完成下面的工作来改进String类声明（即将String1.h升级String2.h）。
a. 对+运算符进行重载，使之可将两个字符串合并成1个。
b. 提供一个Stringlow()成员函数，将字符串中所有的字母字符转换为小写（别忘了cctype系列字符函数）。
c. 提供String()成员函数，将字符串中所有字母字符转换成大写。
d. 提供一个这样的成员函数，它接受一个char参数，返回该字符在字符串中出现的次数。
使用下面的程序测试：
// pe12-2
#include
using namespace std;
#include "string2.h"
int main() {
String s1(" and I am a C++ student.");
String s2 = "Please enter your name: ";
String s3;
cout << s2;
cin >> s3;
s2 = "My name is " + s3;
cout << s2 << ".\n";
s2 = s2 + s1;
s2.Stringup();
cout << "The string\n" << s2 << "\ncontains " << s2.has('A')
<< " 'A' characters in it.\n";
s1 = "red";
String rgb[3] = { String(s1), String("green"), String("blue") };
cout << "Enter the name of a primary color of mixing light: ";
String ans;
bool success = false;
while (cin >> ans) {
ans.Stringlow();
for (int i = 0; i < 3; i++) {
if (ans == rgb[i]) {
cout << "That's right!\n";
success = true;
break;
}
}
if (success)
break;
else
cout << "Try again!\n";
}
cout << "Bye\n";
return 0;
}
解答：
#pragma once
// string2.h
#ifndef STRING2_H_
#define STRING2_H_
#include
using std::ostream;
using std::istream;
class String {
private:
char* str;
int len;
static int num_strings;
static const int CINLIM = 80;
public:
String(const char* s);
String(); // 默认构造函数
String(const String& s); // 复制构造函数
~String();
int length() const { return len; }
String& Stringlow();
String& Stringup();
int has(char c); // 返回c在字符串中出现的次数
// 重载运算符
String& operator=(const String& s);
String& operator=(const char* s);
char& operator[](int i);
const char& operator[](int i) const;
// 友元函数
friend bool operator<(const String& s1, const String& s2);
friend bool operator>(const String& s1, const String& s2);
friend bool operator==(const String& s1, const String& s2);
friend ostream& operator<<(ostream& os, const String& s);
friend istream& operator>>(istream& is, String& s);
friend String operator+(const String& s1, const String& s2);
friend String operator+(const String&, const char*);
friend String operator+(const char*, const String&);
// 静态函数
static int HowMany();
};
#endif // !STRING2_H_
// string2.cpp
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include "string2.h"
using std::strlen;
using std::strcpy;
using std::strcat;
using std::strcmp;
using std::ostream;
using std::istream;
// 初始化static类成员 ！！！
int String::num_strings = 0;
int String::HowMany() {
return num_strings;
}
String::String(const char* s) {
len = strlen(s);
str = new char[len + 1];
strcpy(str, s);
num_strings++;
}
String::String() {
str = nullptr;
len = 0;
num_strings++;
}
String::String(const String& s) {
len = s.len;
str = new char[len + 1];
strcpy(str, s.str);
num_strings++;
}
String::~String() {
delete[] str;
str = nullptr;
len = 0;
num_strings--;
}
String& String::Stringlow() {
if (len == 0) return *this;
for (int i = 0; i < len; i++) {
str[i] = std::tolower(str[i]);
}
return *this;
}
String& String::Stringup() {
if (len == 0) return *this;
for (int i = 0; i < len; i++)
str[i] = std::toupper(str[i]);
return *this;
}
int String::has(char c) {
if (len == 0) return 0;
int res = 0;
for (int i = 0; i < len; i++) {
if (str[i] == c)
res++;
}
return res;
}
String& String::operator=(const String& s) {
// 首先防止自己赋给自己
if (this == &s) return *this;
len = s.len;
delete[] str;
str = new char[len + 1];
strcpy(str, s.str);
return *this;
}
String& String::operator=(const char* s) {
len = strlen(s);
delete[] str;
str = new char[len + 1];
strcpy(str, s);
return *this;
}
// 主要为修改
char& String::operator[](int i) {
// if(len == 0)
// if (i >= len) return str[len - 1];
return str[i];
}
const char& String::operator[](int i) const {
return str[i];
}
bool operator<(const String& s1, const String& s2) {
return strcmp(s1.str, s2.str) < 0;
}
bool operator>(const String& s1, const String& s2) {
return strcmp(s1.str, s2.str) > 0;
}
bool operator==(const String& s1, const String& s2) {
return strcmp(s1.str, s2.str) == 0;
}
ostream& operator<<(ostream& os, const String& s) {
os << s.str;
return os;
}
// !!!
istream& operator>>(istream& is, String& s) {
char temp[String::CINLIM];
is.get(temp, String::CINLIM);
if (is)
s = temp;
while (is && is.get() != '\n')
continue;
return is;
}
String operator+(const String& s1, const String& s2) {
int len = s1.len + s2.len;
char* str = new char[len + 1];
strcpy(str, s1.str);
// strcpy(temp + s1.len, st.str);
strcat(str, s2.str);
return String(str);
}
String operator+(const String& s1, const char* s2) {
int len = s1.len + strlen(s2);
char* str = new char[len + 1];
strcpy(str, s1.str);
strcpy(str + s1.len, s2);
return String(str);
}
String operator+(const char* s1, const String& s2) {
return String(s1)+s2;
}
// pe12-2
#include
using namespace std;
#include "string2.h"
int main() {
String s1(" and I am a C++ student.");
String s2 = "Please enter your name: ";
String s3;
cout << s2;
cin >> s3;
s2 = "My name is " + s3;
cout << s2 << ".\n";
s2 = s2 + s1;
s2.Stringup();
cout << "The string\n" << s2 << "\ncontains " << s2.has('A')
<< " 'A' characters in it.\n";
s1 = "red";
String rgb[3] = { String(s1), String("green"), String("blue") };
cout << "Enter the name of a primary color of mixing light: ";
String ans;
bool success = false;
while (cin >> ans) {
ans.Stringlow();
for (int i = 0; i < 3; i++) {
if (ans == rgb[i]) {
cout << "That's right!\n";
success = true;
break;
}
}
if (success)
break;
else
cout << "Try again!\n";
}
cout << "Bye\n";
return 0;
} 3. 新编写程序清单10.7和程序清单10.8描述的Stock类，使之使用动态内存分配的内存，而不是string类对象来存储股票名称。另外，使用重载的operator<<()定义代替show()成员函数。再使用程序清单10.9测试新的定义程序。
#pragma once
#ifndef STOCK20_H_
#define STOCK20_H_
#include
class Stock {
private:
char* company;
int shares;
double share_val;
double total_val;
void set_tot() { total_val = share_val * shares; }
public:
Stock();
Stock(const char* co, long n = 0, double pr = 0.0);
~Stock();
void buy(long num, double price);
void sell(long num, double price);
void update(double price);
const Stock& topval(const Stock& s) const;
friend std::ostream& operator<<(std::ostream& os, const Stock& st);
};
#endif // !STOCK20_H_
// stock20.cpp
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include "stock20.h"
using std::strlen;
using std::strcpy;
using std::cout;
Stock::Stock() {
company = nullptr;
shares = 0;
share_val = total_val = 0.0;
}
Stock::Stock(const char* co, long n, double pr) {
int len = strlen(co);
company = new char[len + 1];
strcpy(company, co);
if (n < 0)
cout << "Number of shares can't be negative; "
<< company << " shares set to 0.\n";
else
shares = n;
share_val = pr;
set_tot();
}
Stock::~Stock() {
delete[] company;
}
void Stock::buy(long num, double price) {
if (num < 0)
cout << "Number of shares purchased can't be negative. Transaction is aborted.\n";
else {
shares += num;
share_val = price;
set_tot();
}
}
void Stock::sell(long num, double price) {
if (num < 0)
cout << "Number of shares purchased can't be negative. Transaction is aborted.\n";
else if (num > shares)
cout << "You can't sell more than you have! Transaction is aborted.\n";
else {
shares -= num;
share_val = price;
set_tot();
}
}
void Stock::update(double price) {
share_val = price;
set_tot();
}
const Stock& Stock::topval(const Stock& s) const {
if (s.total_val > total_val)
return s;
else
return *this;
}
std::ostream& operator<<(std::ostream& os, const Stock& st) {
using std::ios_base;
ios_base::fmtflags orig = os.setf(ios_base::fixed, ios_base::floatfield);
std::streamsize prec = os.precision(3);
os << "Company: " << st.company
<< " Shares: " << st.shares << '\n';
os << " Share Price: $" << st.share_val;
os.precision(2);
os << " Total Worth: $" << st.total_val << '\n';
os.setf(orig, ios_base::floatfield);
os.precision(prec);
return os;
} // 12-3
#include
#include "stock20.h"
using std::cout;
const int STKS = 4;
int main(){
Stock stocks[STKS] = {
Stock("NanoSmart", 12, 20.0),
Stock("Boffo Objects", 200, 2.0),
Stock("Monolithic Obelisks", 130, 3.25),
Stock("Fleep Enterprises", 60, 6.5)
};
std::cout << "Stock holdings:\n";
int st;
for (st = 0; st < STKS; st++)
{
std::cout << stocks[st];
}
const Stock* top = &stocks[0];
for (st = 0; st < STKS; st++)
{
top = &(top->topval(stocks[st]));
}
std::cout << "\nMost valuable holding:\n";
cout << *top;
return 0;
} 4. 请看下面程序定义的Stack类变量：
class Stack {
private:
enum { MAX = 10 };
Item* pitems; // hold stack items
int size;
int top;
public:
Stack(int n = MAX);
Stack(const Stack& st); // 复制构造函数
~Stack();
bool isempty() const;
bool isfull() const;
bool push(const Item& item);
bool pop(Item& item);
Stack& operator=(const Stack& st);};
正如私有成员表明的，这个类使用动态分配的数组来保存栈项。请重新编写方法，以适应这种新的表示法，并编写一个程序来演示所有的方法，包括复制构造函数和赋值运算符。
#pragma once
#ifndef STACK2_H_
#define STACK2_H_
typedef unsigned long Item;
class Stack {
private:
enum { MAX = 10 };
Item* pitems; // hold stack items
int size;
int top;
public:
Stack(int n = MAX);
Stack(const Stack& st); // 复制构造函数
~Stack();
bool isempty() const;
bool isfull() const;
bool push(const Item& item);
bool pop(Item& item);
Stack& operator=(const Stack& st);
};
#endif // !STACK2_H_
#include
#include "stack2.h"
Stack::Stack(int n) {
pitems = new Item[n];
size = n;
top = 0;
}
Stack::Stack(const Stack& st) {
size = st.size;
pitems = new Item[size];
top = st.top;
for (int i = 0; i < top; i++) {
pitems[i] = st.pitems[i];
}
}
Stack::~Stack() {
delete[] pitems;
pitems = nullptr;
}
bool Stack::isempty() const {
return top == 0;
}
bool Stack::isfull() const {
return top == size;
}
bool Stack::push(const Item& item) {
if (isfull())
return false;
pitems[top++] = item;
return true;
}
bool Stack::pop(Item& item) {
if (isempty())
return false;
item = pitems[--top];
return true;
}
Stack& Stack::operator=(const Stack& st) {
if (this == &st) return *this;
size = st.size;
delete[] pitems;
pitems = new Item[size];
top = st.top;
for (int i = 0; i < top; i++)
pitems[i] = st.pitems[i];
return *this;
} #include
#include "stack2.h"
using std::cout;
using std::endl;
int main() {
Stack st1(10);
srand(time(0));
for (size_t i = 0; i < 10; i++) {
if (!st1.push(rand() % 100))
cout << "Push error!" << endl;
}
if (!st1.push(0))
cout << "Push 0 error!" << endl;
Stack st2(st1);
Stack st3 = st1;
for (size_t i = 0; i < 11; i++) {
Item item;
cout << "#" << i + 1 << ": " << endl;
if (!st1.pop(item))
cout << "st1 pop error!" << endl;
else
cout << "st1: " << item << endl;
if (!st2.pop(item))
cout << "st2 pop error!" << endl;
else
cout << "st2: " << item << endl;
if (!st3.pop(item))
cout << "st3 pop error!" << endl;
else
cout << "st3: " << item << endl;
cout << endl;
}
} 5. Heather银行进行的研究表明，ATM客户不希望排队时间超过1分钟。使用程序清单12.10中的模拟，找出要使平均等候时间为1分钟，每小时到达的客户数应为多少（试验时间不短于100小时）？
#pragma once
// queue.h -- 12.10 -- interface for a queue
#ifndef QUEUE_H
#define QUEUE_H
class Customer {
private:
long arrive;
int processtime;
public:
Customer() { arrive = processtime = 0; }
void set(long when);
long when() const { return arrive; }
int ptime() const { return processtime; }
};
typedef Customer Item;
class Queue {
private:
struct Node {
Item item;
struct Node* next;
};
enum { Q_SIZE = 10 };
Node* front; // 指向链表头
Node* rear; // 指向链表尾
int items; // 目前链表里的成员数量
const int qsize; // 链表里Item的最大数量
Queue(const Queue& q): qsize(0){}
Queue& operator=(const Queue& q) { return *this; }
public:
Queue(int qs = Q_SIZE);
~Queue();
bool isempty() const;
bool isfull() const;
int queuecount() const;
bool enqueue(const Item& item); // 结尾加节点
bool dequeue(Item& item); // 链表头删节点
};
#endif // !QUEUE_H// queue.cpp
#include
#include "queue.h"
Queue::Queue(int qs) : qsize(qs) {
front = rear = nullptr;
items = 0;
}
Queue::~Queue() {
Node* temp;
while (front != nullptr) {
temp = front;
front = front->next;
delete temp;
}
}
bool Queue::isempty() const {
return items == 0;
}
bool Queue::isfull() const {
return items == qsize;
}
int Queue::queuecount() const {
return items;
}
bool Queue::enqueue(const Item& item) {
if (isfull()) return false;
Node* add = new Node;
// on failure, new throws std::bad_alloc exception
add->item = item;
add->next = nullptr;
items++;
if (front == nullptr)
front = add;
else
rear->next = add;
rear = add;
return true;
}
bool Queue::dequeue(Item& item) {
if (front == nullptr)
return false;
item = front->item;
items--;
Node* temp = front;
front = front->next;
delete temp;
if (items == 0)
rear = nullptr;
return true;
}
// time set to a random value in the range 1-3
void Customer::set(long when) {
processtime = std::rand() % 3 + 1;
arrive = when;
} // 12-5
#include
#include // rand(), srand(), RAND_MAX
#include // time()
#include "queue.h"
const int MIN_PER_HR = 60;
bool newcustomer(double x); // 判断是否有新用户到来
int main() {
using std::cin;
using std::cout;
using std::endl;
using std::ios_base;
std::srand(std::time(0)); // 随机初始化rand()
cout << "Case Study: Bank of Heather Automatic Teller\n";
cout << "Enter maximum size of queue: ";
int qs;
cin >> qs;
Queue line(qs);
cout << "Enter the number of simulation hours (no less than 100): ";
int hours;
cin >> hours;
// 循环每1分钟运行一次
long cyclelimit = MIN_PER_HR * hours;
//cout << "Enter the average number of customers per hour: ";
//double perhour;
//cin >> perhour;
//double min_per_cust;
//min_per_cust = MIN_PER_HR / perhour;
Item temp;
long turnaways = 0; // 因满队列而拒绝接收的人数
long customers = 0; // 加入队列的数量
long served = 0; // 仿真期间服务的人数
long sum_line = 0; // 累计队列长度
int wait_time = 0; // 自动存取机的空闲时间
long line_wait = 0; // 累计在队列中的时间
double avg_wait_time = 0.0; // 顾客平均等待时间
// 每小时使用人数初始值设为15，之后进行+1枚举测试
double perhour = 15;
double min_per_cust;
// 仿真开始
do {
min_per_cust = MIN_PER_HR / perhour;
turnaways = 0; // 因满队列而拒绝接收的人数
customers = 0; // 加入队列的数量
served = 0; // 仿真期间服务的人数
sum_line = 0; // 累计队列长度
wait_time = 0; // 自动存取机的空闲时间
line_wait = 0; // 累计在队列中的时间
avg_wait_time = 0.0; // 顾客平均等待时间
// 清空队列
while (!line.isempty())
line.dequeue(temp);
for (int cycle = 0; cycle < cyclelimit; cycle++) {
if (newcustomer(min_per_cust)) // 有新顾客到来
{
if (line.isfull())
turnaways++;
else {
customers++;
temp.set(cycle); // cycle = time of arrival
line.enqueue(temp);
}
}
if (wait_time <= 0 && !line.isempty()) {
line.dequeue(temp); // 下一个客户
wait_time = temp.ptime();
line_wait += cycle - temp.when();
served++;
}
if (wait_time > 0)
wait_time--;
sum_line += line.queuecount();
}
// 报告结果
if (customers > 0) {
cout << "custormers accepted: " << customers << endl;
cout << " customers served: " << served << endl;
cout << " turnaways: " << turnaways << endl;
cout << " average queue size: ";
cout.precision(2);
cout.setf(ios_base::fixed, ios_base::floatfield);
cout << double(sum_line / cyclelimit) << endl;
avg_wait_time = double(line_wait / served);
cout << " average wait time: " << avg_wait_time << " minutes\n";
}
else
cout << "No customers!\n";
} while ((perhour++) && ((avg_wait_time < 0.9) || (avg_wait_time > 1.1)));
cout << "When perhour = " << perhour << ", the average wait time will be about 1 minute.\n";
cout << "Done!\n";
return 0;
}
bool newcustomer(double x) {
return (std::rand() * x / RAND_MAX < 1);
} 6. Heather银行想知道，如果再开设一台ATM，情况将如何。请对模拟进行修改，以包含两个队列。假设当第一台ATM前的排队人数少于第二台ATM时，客户将排在第一队，否则排在第二队。然后再找出要使平均等候时间为1分钟，每小时到达的客户数应该为多少（注意，这是一个非线性问题，即将ATM数量加倍，并不能保证每小时处理的客户数量也加倍，并确保客户等候的时间少于1分钟）？
// 12-6
#include
#include // rand(), srand(), RAND_MAX
#include // time()
#include "queue.h"
const int MIN_PER_HR = 60;
bool newcustomer(double x); // 判断是否有新用户到来
int main() {
using std::cin;
using std::cout;
using std::endl;
using std::ios_base;
std::srand(std::time(0)); // 随机初始化rand()
cout << "Case Study: Bank of Heather Automatic Teller\n";
cout << "Enter maximum size of queue: ";
int qs;
cin >> qs;
Queue line1(qs);
Queue line2(qs);
cout << "Enter the number of simulation hours (no less than 100): ";
int hours;
cin >> hours;
// 循环每1分钟运行一次
long cyclelimit = MIN_PER_HR * hours;
//cout << "Enter the average number of customers per hour: ";
//double perhour;
//cin >> perhour;
//double min_per_cust;
//min_per_cust = MIN_PER_HR / perhour;
Item temp;
long turnaways = 0; // 因满队列而拒绝接收的人数
long customers = 0; // 加入队列的数量
long served = 0; // 仿真期间服务的人数
long sum_line = 0; // 累计队列长度
int wait_time1 = 0; // 自动存取机1的空闲时间
int wait_time2 = 0; // 自动存取机2的空闲时间
int line1_size = 0; // 队列1当前长度
int line2_size = 0; // 队列2当前长度
long line_wait = 0; // 累计在队列中的时间
double avg_wait_time = 0.0; // 顾客平均等待时间
// 每小时使用人数初始值设为15，之后进行+1枚举测试
double perhour = 15;
double min_per_cust;
// 仿真开始
do {
min_per_cust = MIN_PER_HR / perhour;
turnaways = 0; // 因满队列而拒绝接收的人数
customers = 0; // 加入队列的数量
served = 0; // 仿真期间服务的人数
sum_line = 0; // 累计队列长度
wait_time1 = 0; // 自动存取机1的空闲时间
wait_time2 = 0;
line1_size = 0;
line2_size = 0;
line_wait = 0; // 累计在队列中的时间
avg_wait_time = 0.0; // 顾客平均等待时间
// 清空队列
while (!line1.isempty())
line1.dequeue(temp);
while (!line2.isempty())
line2.dequeue(temp);
for (int cycle = 0; cycle < cyclelimit; cycle++) {
if (newcustomer(min_per_cust)) // 有新顾客到来
{
if (line1.isfull() && line2.isfull())
turnaways++;
else if(line1_size > line2_size){
customers++;
temp.set(cycle); // cycle = time of arrival
line2.enqueue(temp);
line2_size++;
}
else {
customers++;
temp.set(cycle);
line1.enqueue(temp);
line1_size++;
}
}
if (wait_time1 <= 0 && !line1.isempty()) {
line1.dequeue(temp); // 下一个客户
line1_size--;
wait_time1 = temp.ptime();
line_wait += cycle - temp.when();
served++;
}
if (wait_time2 <= 0 && !line2.isempty()) {
line2.dequeue(temp); // 下一个客户
line2_size--;
wait_time2 = temp.ptime();
line_wait += cycle - temp.when();
served++;
}
if (wait_time1 > 0)
wait_time1--;
if (wait_time2 > 0)
wait_time2--;
sum_line += line1.queuecount();
sum_line += line2.queuecount();
}
// 报告结果
if (customers > 0) {
cout << "custormers accepted: " << customers << endl;
cout << " customers served: " << served << endl;
cout << " turnaways: " << turnaways << endl;
cout << " average queue size: ";
cout.precision(2);
cout.setf(ios_base::fixed, ios_base::floatfield);
cout << double(sum_line / cyclelimit) << endl;
avg_wait_time = double(line_wait / served);
cout << " average wait time: " << avg_wait_time << " minutes\n";
}
else
cout << "No customers!\n";
} while ((perhour++) && ((avg_wait_time < 0.9) || (avg_wait_time > 1.1)));
cout << "When perhour = " << perhour << ", the average wait time will be about 1 minute.\n";
cout << "Done!\n";
return 0;
}
bool newcustomer(double x) {
return (std::rand() * x / RAND_MAX < 1);
}