C++ Primer Plus(第六版)编程练习答案 第12章 类和动态内存分配

本章所有编程练习的工程源码可在此处下载(点击此链接下载),供大家参考交流!

 

1. 对于下面的类声明:

class Cow {

         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;      // display all new data

};

给这个类提供实现,并编写一个使用所有成员函数的小程序。

对于本题,首先题中已经给出了类声明,所以头文件不需要自己定义,可以直接使。

所以头文件cow.h代码如下:

// cow.h -- head file
#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

在这里,我们之所以在书中提供的类声明的前后加上#ifndef, #define, #endif主要是为了防止该.h文件被重复引用。详情请点击本链接查看

声明了头文件之后,我们首先要考虑去定义头文件中的函数声明。

头文件的私有成员变量中有字符串数组和字符串指针,因此需要用到strcpy_s函数,所以头文件中需要包含;在构造函数中,唯一需要注意的就是字符串指针变量需要使用new来动态分配内存,然后再使用strcpy_s函数进行赋值,而相应的析构函数一定要记得将构造函数中使用new动态分配的内存delete掉。

另外,在重载运算符=时,需要在一开始delete一下,以防止此时this指针的hobby变量储存的地址是被分配使用过的。

所以实现文件cow.cpp代码如下:

// cow.cpp -- containing the functions' definition 

#include "stdafx.h"
#include 
#include 
#include "cow.h"

using std::cout;
using std::endl;

Cow::Cow()
{
    strcpy_s(name, 20, "new cow");
    hobby = new char[4];
    strcpy_s(hobby, 4, "cow");
    weight = 0.0;
}

Cow::Cow(const char * nm, const char * ho, double wt)
{
    weight = wt;
    hobby = new char[strlen(ho) + 1];
    strcpy_s(hobby, strlen(ho)+1, ho);
    strcpy_s(name, 20, nm);
}

Cow::Cow(const Cow & c)
{
    strcpy_s(name, 20, c.name);
    hobby = new char[strlen(c.hobby) + 1];
    strcpy_s(hobby, strlen(c.hobby) + 1, c.hobby);
    weight = c.weight;
}

Cow::~Cow()
{
    delete[] hobby;
}

Cow & Cow::operator=(const Cow & c)
{
    delete[] hobby;
    hobby = new char[strlen(c.hobby) + 1];
    strcpy_s(hobby, strlen(c.hobby) + 1, c.hobby);
    weight = c.weight;
    strcpy_s(name, 20, c.name);
    return *this;
}

void Cow::ShowCow() const
{
    cout << "Now a new cow!\n";
    cout << "The name is " << name << endl;
    cout << "The hobby is " << hobby << endl;
    cout << "The weight is " << weight << endl;
}

接下来我们来考虑如何使用这些成员函数组成检验文件。

其实本题的文件的主要功能只有3个,各种方式的函数初始化,使用重载的运算符=,使用ShowCow函数进行显示。

检验文件checkcow.cpp代码如下:

// checkcow.cpp -- check all the functions
#include "stdafx.h"
#include 
#include "cow.h"

using namespace std;

int main()
{
    cout << "Let's start to see our cows!\n";
    Cow c1;
    c1.ShowCow();
    Cow c2("yellow", "eat grass", 123.456);
    c2.ShowCow();
    Cow c3("black", "drink water", 222.333);
    c3.ShowCow();
    c3 = c1;
    Cow c4(c2);
    c3.ShowCow();
    c4.ShowCow();
    system("pause");
    return 0;
}

运行结果如下图所示:

C++ Primer Plus(第六版)编程练习答案 第12章 类和动态内存分配_第1张图片

 

2. 通过完成下面的工作来改进String类声明(即将String1.h升级为String2.h)。

a. 对+运算符进行重载,使之可将两个字符串合并成1个。

b. 提供一个Stringlow()成员函数,将字符串中所有的字母字符转换为小写(别忘了cctype系列字符函数)。

c. 提供String()成员函数,将字符串中所有字母字符转换成大写。

d. 提供一个这样的成员函数,它接受一个char参数,返回该字符在字符串中出现的次数。

使用下面的程序来测试您的工作:

(……代码忽略……)

输出应与下面相似:

(……代码忽略……)

本题是在String1.h的基础上进行升级,添加几项功能再测试。

首先,需要重载+运算符,将两个字符串合并成1个,这里看起来只需要添加一个成员函数,其实不然。由于检验文件中既有将string对象相加,又有将字符串指针相加,还存在将string对象和字符串指针相加的情况,所以我们需要对应的定义3个函数来分别重载这三种情况下的+运算符。

其次,提供两个函数将字符串中的所有字母字符转换为小写或大写,这个功能使用中的函数将非常轻松。

最后,提供一个成员函数,接受一个char参数,返回该参数在字符串中出现的次数,该函数将需要遍历整个字符串进行计数。

对于头文件,我们只需要添加以上6个函数即可,所以头文件string2.h代码如下:

// string2.h -- fixed and augmented string class definition
#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 &);
    ~String();
    int length() const { return len; }
    void stringlow();
    void stringup();
    int has(char x);
    String & operator=(const String &);
    String & operator=(const char *);
    char & operator[] (int i);
    const char & operator[] (int i) const;
    friend bool operator<(const String &st1, const String &st2);
    friend bool operator>(const String &st1, const String &st2);
    friend bool operator==(const String &st, const String &st2);
    friend ostream & operator<<(ostream & os, const String &st);
    friend istream & operator>>(istream & is, String & st);
    static int HowMany();
    String operator+(const String &) const;
    String operator+(const char *) const;
    friend String operator+(const char *, const String &);
};

对于实现文件,其他的功能可以沿用string1.cpp,新添加的几个函数需要自定义。

首先,对于重载+运算符,我们分为三个函数。第一个是两个string对象之间的加法,在这里呢,我们可以使用strcat_s函数,直接将两个string对象进行拼接,但是由于默认情况下string对象的最后一个字符都是'\0',所以处理起来比较麻烦,我选择依然使用strcpy_s函数,只是复制的地址不一样,比如说str1的长度为10,str2的长度为10,我们新定义一个str3,要想把str1的内容和str2的内容加起来放进str3中,就把str1的内容从str3的第一个字符处开始赋值,把str2的内容从str3的第11个字符处开始赋值,这样就可以了。对于字符串指针变量的情况,可以完全类似处理。对于字符串指针变量和string对象相加的情况,我们可以人为地进行强制类型转换,将字符串指针变量转换为string对象,再加,那么此时相加就会调用前面定义的两个string对象相加的函数,即可以完成任务。

其次,我们在实现文件中包含头文件,然后定义stringow()函数和stringup()函数,分别来对字符串的字母字符进行小写或大写的转换。在转换的时候,我们需要首先对整个字符串进行遍历,然后使用tolower()函数和toupper()函数来进行大小写转换,注意这里this是指针,指向某一个变量时要使用->符号。

最后,我们需要定义has()函数。该函数遍历整个字符串,然后识别输入的特定char类型变量,然后计数。我们在for循环内部嵌套一个if条件判断即可。

实现文件string2.cpp代码如下所示:

// string2.cpp -- String class methods
//

#include "stdafx.h"
#include 
#include "string2.h"
#include 
using std::cin;
using std::cout;

int String::num_strings = 0;

int String::HowMany()
{
    return num_strings;
}

String::String(const char * s)
{
    len = std::strlen(s);
    str = new char[len + 1];
    strcpy_s(str, std::strlen(s) + 1, s);
    num_strings++;
}

String::String()
{
    len = 4;
    str = new char[1];
    str[0] = '\0';
    num_strings++;
}

String::String(const String & st)
{
    num_strings++;
    len = st.len;
    str = new char[len + 1];
    strcpy_s(str, std::strlen(st.str) + 1, st.str);
}

String::~String()
{
    --num_strings;
    delete[] str;
}

void String::stringlow()
{
    for (int i = 0; i < this->len + 1; i++)
    {
        this->str[i] = tolower(this->str[i]);
    }
}

void String::stringup()
{
    for (int i = 0; i < this->len + 1; i++)
    {
        this->str[i] = toupper(this->str[i]);
    }
}

int String::has(char x)
{
    int count = 0;
    for (int i = 0; i < this->len + 1; i++)
    {
        if (this->str[i] == x)
            count++;
    }
    return count;
}

String & String::operator=(const String & st)
{
    if (this == &st)
        return *this;
    delete[] str;
    len = st.len;
    str = new char[len + 1];
    strcpy_s(str, std::strlen(st.str) + 1, st.str);
    return *this;
}

String & String::operator=(const char * s)
{
    delete[] str;
    len = std::strlen(s);
    str = new char[len + 1];
    strcpy_s(str, std::strlen(s) + 1, s);
    return *this;
}

char & String::operator[] (int i)
{
    return str[i];
}

const char & String::operator[] (int i) const
{
    return str[i];
}

bool operator<(const String &st1, const String &st2)
{
    return (std::strcmp(st1.str, st2.str) < 0);
}

bool operator>(const String &st1, const String &st2)
{
    return st2 < st1;
}

bool operator==(const String &st1, const String &st2)
{
    return (std::strcmp(st1.str, st2.str) == 0);
}

ostream & operator<<(ostream & os, const String & st)
{
    os << st.str;
    return os;
}

istream & operator>>(istream & is, String & st)
{
    char temp[String::CINLIM];
    is.get(temp, String::CINLIM);
    if (is)
        st = temp;
    while (is &&is.get() != '\n')
        continue;
    return is;
}

String String::operator+(const String & st) const
{
    int total_len = len + st.len;
    char *temp = new char[total_len + 1];
    strcpy_s(temp, len + 1, str);
    strcpy_s(temp + len, st.len + 1, st.str);
    temp[total_len] = '\0';
    return String(temp);
}

String String::operator+(const char * s) const
{
    int total_len = len + strlen(s);
    char *temp = new char[total_len + 1];
    strcpy_s(temp, len + 1, str);
    strcpy_s(temp + len, std::strlen(s) + 1,s);
    temp[total_len] = '\0';
    return String(temp);
}

String operator+(const char * s, const String & st)
{
    return String(s) + st;
}

检验文件题中直接给出,saying2.cpp代码如下所示:

// saying1.cpp -- using expanded String class
#include "stdafx.h"
#include 
#include "string2.h"
using namespace std;
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 for 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";
    system("pause");
    return 0;
}

运行结果如下图所示:

C++ Primer Plus(第六版)编程练习答案 第12章 类和动态内存分配_第2张图片

从运行结果可以看出,该检验文件完成的功能和预期完全一致。

 

3. 新编写程序清单10.7和程序清单10.8描述的Stock类,使之使用动态内存分配的内存,而不是string类对象来存储股票名称。另外,使用重载的operator<<()定义代替show()成员函数。再使用程序清单10.9测试新的定义程序。

本题要求将Stock类进行修改,使用动态内存分配代替string类对象,所以string对象company必须改为char *类型,然后去掉show()函数,改为使用重载的operator<<()来进行输出,该函数我们选择使用友元。

所以头文件stock20.h代码如下:

// stock20.h -- augmented version
#ifndef STOCK20_H_
#define STOCK20_H_
#include 
using std::ostream;

class Stock
{
private:
    char * company;
    int shares;
    double share_val;
    double total_val;
    void set_tot() { total_val = shares * share_val; }
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);
    friend ostream & operator<<(ostream & os, const Stock &st);
    const Stock & topval(const Stock & s) const;
};

#endif

对于实现文件,当company变量从string对象变成char *类型之后,构造函数那里就必须要改变,必须使用new来动态分配它的内存,而且析构函数必须要delete。对于重载的<<运算符,我们也按照原来的show()函数一样的格式,对ios_base里面的处理不变,只是在此之后,按照标准的重载<<运算符的方式进行输出,同时将cout完全换成我们的输出os。

实现文件stock20.cpp代码如下:

// stock20.cpp -- augnented version
#include "stdafx.h"
#include 
#include "stock20.h"
using std::ostream;

Stock::Stock()
{
    company = new char[std::strlen("no name") + 1];
    strcpy_s(company, std::strlen("no name") + 1, "no name");
    shares = 0;
    share_val = 0.0;
    total_val = 0.0;
}

Stock::Stock(const char * co, long n, double pr)
{
    company = new char[std::strlen(co) + 1];
    strcpy_s(company, std::strlen(co) + 1, co);
    if (n < 0)
    {
        std::cout << "Number of shares can't be negative; " << company << " shares set to 0.\n";
        shares = 0;
    }
    else
        shares = n;
    share_val = pr;
    set_tot();
}

Stock::~Stock()
{
    delete[] company;
}

void Stock::buy(long num, double price)
{
    if (num < 0)
    {
        std::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)
{
    using std::cout;
    if (num < 0)
    {
        cout << "Number of shares sold 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();
}

ostream & operator<<(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: " < total_val)
        return s;
    else
        return *this;
}

检验文件题目要求直接使用程序清单10.9,所以usestock20.cpp代码如下:

// usestock20.cpp -- using the Stock class
// compile with stock20.cpp
#include "stdafx.h"
#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++)
        cout << stocks[st];
    const Stock * top = &stocks[0];
    for (st = 1; st < STKS; st++)
        top = &top->topval(stocks[st]);
    cout << "\nMost valuable holding:\n";
    cout << *top;
    system("pause");
    return 0;
}

运行结果如下图所示:

C++ Primer Plus(第六版)编程练习答案 第12章 类和动态内存分配_第3张图片

 

4. 请看下面程序清单10.10定义的Stack类的变量:

(……代码忽略……)

正如私有成员表明的,这个类使用动态内存分配的数组来保存栈项。请重新编写方法,以适应这种新的表示法,并编写一个程序来演示所有的方法,包括复制构造函数和赋值运算符。

本题提供了头文件代码,需要注意的地方在于,本题的私有成员中,定义了一个无符号long类型的指针,对于这种类型的变量,我们同样需要使用new来动态分配内存。

头文件stack.h代码如下:

// stack.h -- class declaration for the stack ADT
#include 
using std::ostream;
typedef unsigned long Item;

class Stack
{
private:
    enum { MAX = 10 };
    Item * pitems;
    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);
    friend ostream & operator<<(ostream & os, const Stack &st);
};

对于实现文件,大部分内容我们可以参考程序清单10.11,而新增的size变量和修改过的pitems对象,我们需要单独编写,且要注意pitems对象必须使用new来动态分配内存,析构函数里面必须将其delete,另外在赋值运算符进行重载时,必须首先将pitems对象进行delete,以防止它的内存已经被占用。

另外我们需要额外编写赋值构造函数,因为要防止初始化时默认构造函数产生二义性;还需要重载<<运算符用来输出。

实现文件stack.cpp代码如下:

// stack.cpp -- functions' definition
#include "stdafx.h"
#include 
using std::endl;
#include "stack.h"

Stack::Stack(int n)
{
    pitems = new Item[n];
    for (int i = 0; i < n; i++)
    {
        pitems[i] = 0;
    }
    top = 0;
    size = n;
}

Stack::Stack(const Stack & st)
{
    pitems = new Item[st.size];
    for (int i = 0; i < st.size; i++)
    {
        pitems[i] = st.pitems[i];
    }
    top = st.top;
    size = st.size;
}

Stack::~Stack()
{
    delete[] pitems;
}

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

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

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

bool Stack::pop(Item & item)
{
    if (top > 0)
    {
        item = pitems[--top];
        return true;
    }
    else
        return false;
}

Stack & Stack::operator=(const Stack & st)
{
    if (this == &st)
        return *this;
    delete[] pitems;
    top = st.top;
    size = st.size;
    pitems = new Item[st.size];
    for (int i = 0; i < st.size; i++)
    {
        pitems[i] = st.pitems[i];
    }
    return *this;
}

ostream & operator<<(ostream & os, const Stack & st)
{
    for (int i = 0; i < st.top; i++)
    {
        os << st.pitems[i] << endl;
    }
    return os;
}

接下来我们可以在程序清单10.12的基础上进行少量修改,就可以检验上面编写的类方法了。对于检验栈是否为空和是否为满,以及入栈出栈,我们都可以完全参考程序清单10.12,下面我们主要检验新的功能,包括使用复制构造函数进行赋值,使用重载的=运算符和<<运算符。

检验文件usestack.cpp代码如下:

// usestack.cpp -- tetsing the Stack class
#include "stdafx.h"
#include 
#include 
#include "stack.h"


int main()
{
    using namespace std;
    Stack st;
    char ch;
    unsigned long po;
    cout << "Please enter A to add a purchase order,\n" << "P to process a PO, 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 number to add: ";
            cin >> po;
            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);
                      cout << "PO #" << po << " popped.\n";
                  }
                  break;
        }
        cout << "Please enter A to add a purchase order,\n" << "P to process a PO, or Q to quit.\n";
    }
    cout << "So our stack is:\n" << st;
    Stack st2;
    st2 = st;
    cout << "stack2 = stack is:\n" << st2;
    cout << "Bye\n";
    system("pause");
    return 0;
}

运行结果如下图所示:

C++ Primer Plus(第六版)编程练习答案 第12章 类和动态内存分配_第4张图片

从结果图可以看出,我们首先检验了一下程序清单10.12检验的功能,都可以正确运行,接下来我们对栈内数据进行了填充,然后进行了复制构造函数式赋值,以及=运算符赋值,都是正确的。

 

5. Heather银行进行的研究表明,ATM客户不希望排队时间超过1分钟。使用程序清单12.10中的模拟,找出要使平均等候时间为1分钟,每小时到达的客户数应为多少(试验时间不短于100小时)?

首先,我个人认为本题的所谓不希望排队时间不超过1分钟是写错了,应该是不希望排队时间超过1分钟,后面的代码也都是基于这个假设写的。

其次,由于本题涉及的功能完全是程序清单12.10头文件和程序清单12.11实现文件可以完成的,所以头文件我们不需要修改,直接使用即可。

所以头文件queue.h代码如下:

// queue.h -- 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;
    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.cpp代码如下:

// queue.cpp -- Queue and Customer methods
#include "stdafx.h"
#include "queue.h"
#include 

Queue::Queue(int qs) : qsize(qs)
{
    front = rear = NULL;
    items = 0;
}

Queue::~Queue()
{
    Node * temp;
    while (front != NULL)
    {
        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;
    add->item = item;
    add->next = NULL;
    items++;
    if (front == NULL)
        front = add;
    else
        rear->next = add;
    rear = add;
    return true;
}

bool Queue::dequeue(Item &item)
{
    if (front == NULL)
        return false;
    item = front->item;
    items--;
    Node * temp = front;
    front = front->next;
    delete temp;
    if (items == 0)
        rear = NULL;
    return true;
}

void Customer::set(long when)
{
    processtime = std::rand() % 3 + 1;
    arrive = when;
}

接下来主要需要修改的就是检验文件了。

首先呢,我们这里假设试验时间不短于100小时,为了简单起见,我就将试验时间定为100小时,接下来我们初始化perhour为1,再对perhour变量进行累加循环,即对每小时到达的客户数量进行累加循环;定义一个avetime变量,表示平均等候时间;使用while语句,判断条件为(perhour++ && avetime <= 1),即从每小时到达客户数为1开始,依次增加每小时到达的客户数,同时满足平均等候时间不超过1分钟,以此作为循环条件。再在循环内部去进行for循环操作。

这里需要注意的是,在for循环之前,我们需要先清空队列,这样才是真正的从完全为空开始进行试验,不然无法控制初始条件下队列中原来就存在的客户数量。

在for循环的最后,我们需要计算一下avetime,即将line_wait除以served。

具体详情请阅读代码,检验文件bank.cpp代码如下:

// bank.cpp -- using the Queue interface
// compile with queue.cpp

#include "stdafx.h"
#include 
#include 
#include 
#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));
    cout << "Case Study: Bank of Heather Automatic Teller\n";
    cout << "Enter maximum size of queue: ";
    int qs;
    cin >> qs;
    Queue line(qs);

    cout << "The simulation hours: 100\n";
    int hours = 100;
    long cyclelimit = MIN_PER_HR * hours;

    double perhour;
    double min_per_cust;
    perhour = 1;
    Item temp;
    long turnaways = 0;
    long customers = 0;
    long served = 0;
    long sum_line = 0;
    int wait_time = 0;
    long line_wait = 0;
    double avetime = 0;
    while (perhour++ && avetime <= 1)
    {
        while (!line.isempty())
        {
            line.dequeue(temp);
        }
        min_per_cust = MIN_PER_HR / perhour;
		
        for (int cycle = 0; cycle < cyclelimit; cycle++)
        {
            if (newcustomer(min_per_cust))
            {
                if (line.isfull())
                    turnaways++;
                else
                {
                    customers++;
                    temp.set(cycle);
                    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 << "customers 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;
            cout << " average wait time: " << (double)line_wait / served << " minutes\n";
        }
        else
            cout << "No customers!\n";
        avetime = (double)line_wait / served;
    }
    cout << "When there comes " << perhour << " people per hour, the average wait time will be about 1 minute.\n";
    cout << "Done!\n";

    system("pause");
    return 0;
}

bool newcustomer(double x)
{
    return (std::rand() * x / RAND_MAX < 1);
}

运行结果如下图所示:

C++ Primer Plus(第六版)编程练习答案 第12章 类和动态内存分配_第5张图片

C++ Primer Plus(第六版)编程练习答案 第12章 类和动态内存分配_第6张图片

在这里我输入的队列最大客户数是10,由于需要输出100组数据,所以我只截了开头和结尾,无法全部显示中间的细节结果。从最后的结果上来看,根据100小时的实验,当每小时到达客户数为25.00时,排队时间刚好不超过1分钟。

 

6. Heather银行想知道,如果再开设一台ATM,情况将如何。请对模拟进行修改,以包含两个队列。假设当第一台ATM前的排队人数少于第二台ATM时,客户将排在第一队,否则将排在第二队。然后再找出要使平均等候时间为1分钟,每小时到达的客户数应该为多少(注意,这是一个非线性问题,即将ATM数量加倍,并不能保证每小时处理的客户数量也翻倍,并确保客户等候的时间少于1分钟)?

本题要求多开设一个ATM,所以我们就会有两个队列,一起进行服务,客户到达之后的排队方式即是,如果第一台人数少于第二台,则排第一队,否则排第二队。所以在这里,头文件和实现文件依然不变,因为本质性功能依然没变。

所以头文件queue.h代码如下:

// queue.h -- 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;
    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.cpp代码如下:

// queue.cpp -- Queue and Customer methods
#include "stdafx.h"
#include "queue.h"
#include 

Queue::Queue(int qs) : qsize(qs)
{
    front = rear = NULL;
    items = 0;
}

Queue::~Queue()
{
    Node * temp;
    while (front != NULL)
    {
        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;
    add->item = item;
    add->next = NULL;
    items++;
    if (front == NULL)
        front = add;
    else
        rear->next = add;
    rear = add;
    return true;
}

bool Queue::dequeue(Item &item)
{
    if (front == NULL)
        return false;
    item = front->item;
    items--;
    Node * temp = front;
    front = front->next;
    delete temp;
    if (items == 0)
        rear = NULL;
    return true;
}

void Customer::set(long when)
{
    processtime = std::rand() % 3 + 1;
    arrive = when;
}

接下来我们着重修改检验文件。

首先,本题有两台ATM,所以我们需要两个Queue对象,分别称为line1和line2,接下来的处理方法和上一题类似,我们假设试验时间为100小时,初始化perhour为1,然后自定义avetime,对perhour进行累加循环,同时判断avetime <= 1;但是这里需要注意,我们现在是两个ATM同时服务,所以到达的客户需要有一个选择,即排哪个队,根据题目要求,我们肯定需要有两个line_size和wait_time,所以定义wait_time1和wait_time2分别表示队列1和队列2的等候时间,定义line1_size和line2_size分别表示队列1和队列2的尺寸。

在循环内部,我们首先依然还是要清空队列,这里就要清空两次了;然后在for循环内部,当有客户到达时,判断是否turnaway就需要去判断两个队列了;如果不满足turnaway的条件,就比较line1_size和line2_size,来决定到达的客户排哪个队列;后面判断出队和计算sum_line,注意都需要进行两次。

其他操作和上题相同,注意有些需要操作两次即可。

具体详情请阅读代码,检验文件bank.cpp代码如下:

// bank.cpp -- using the Queue interface
// compile with queue.cpp

#include "stdafx.h"
#include 
#include 
#include 
#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));
    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 << "The simulation hours: 100\n";
    int hours = 100;
    long cyclelimit = MIN_PER_HR * hours;

    double perhour;
    double min_per_cust;
    perhour = 1;
    Item temp;
    long turnaways = 0;
    long customers = 0;
    long served = 0;
    long sum_line = 0;
    int wait_time1 = 0;
    int wait_time2 = 0;
    int line1_size = 0;
    int line2_size = 0;
    long line_wait = 0;
    double avetime = 0;

    while (perhour++ && avetime <= 1)
    {
        while (!line1.isempty())
        {
            line1.dequeue(temp);
        }
        while (!line2.isempty())
        {
            line2.dequeue(temp);
        }
        min_per_cust = MIN_PER_HR / perhour;

        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);
                    line1.enqueue(temp);
                    line1_size++;
                }
                else
                {
                    customers++;
                    temp.set(cycle);
                    line2.enqueue(temp);
                    line2_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 << "customers 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;
            cout << " average wait time: " << (double)line_wait / served << " minutes\n";
        }
        else
            cout << "No customers!\n";
        avetime = (double)line_wait / served;
    }
    cout << "When there comes " << perhour << " people per hour, the average wait time will be about 1 minute.\n";
    cout << "Done!\n";

    system("pause");
    return 0;
}

bool newcustomer(double x)
{
    return (std::rand() * x / RAND_MAX < 1);
}

运行结果如下图所示:

C++ Primer Plus(第六版)编程练习答案 第12章 类和动态内存分配_第7张图片

C++ Primer Plus(第六版)编程练习答案 第12章 类和动态内存分配_第8张图片

从结果上可以看出,当只有1台ATM时,每小时到达客户数为25时,平均等候时间为1分钟,而两台ATM时,每小时到达客户数为60,平均等候时间为1分钟,所以效果不止翻倍。

 

本章所有编程练习的工程源码可在此处下载(点击此链接下载),供大家参考交流!

你可能感兴趣的:(C++,C++,Primer,Plus,(第六版),中文版,编程练习)