Решение всех задач из учебника Стивена Праты

template <typename Type>
class QueueTP
{
private:
    struct Node { Type item; struct Node * next; };
    enum {Q_SIZE = 10};
    Node * front;
    Node * rear;
    int items;
    const int qsize;
    QueueTP(const QueueTP & q) :qsize(0) {}
    QueueTP & operator=(const QueueTP & q) { return *this; }
public:
    QueueTP(int qs = Q_SIZE);
    ~QueueTP();
    bool isempty() const { return items == 0; }
    bool isfull() const {return items  == qsize; }
    int queuecount() const {return items; }
    bool enqueue(const Type & item);
    bool dequeue(Type & item);
};
template <typename Type>
QueueTP<Type>::QueueTP(int qs) :qsize(qs)
{
    front = rear = nullptr;
    items = 0;
}
template <typename Type>
QueueTP<Type>::~QueueTP()
{
    Node * temp;
    while(front != nullptr)
    {
        temp = front;
        front = front->next;
        delete temp;
    }
}
template <typename Type>
bool QueueTP<Type>::enqueue(const Type & item)
{
    if (isfull()) return false;
    Node * add = new Node;
    add->item = item;
    add->next = nullptr;
    items++;
    if (front == nullptr) front = add;
    else rear->next = add;
    rear = add;
    return true;
}
template <typename Type>
bool QueueTP<Type>::dequeue(Type & 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;
}
class Worker
{
private:
    std::string fullname;
    long id;
protected:
    virtual void Data() const;
    virtual void Get();
public:
    Worker() :fullname("no one"), id(0L) {}
    Worker(const std::string & s, long n) :fullname(s), id(n) {}
    virtual ~Worker() = 0;
    virtual void Set() = 0;
    virtual void Show() const = 0;
};
class Waiter: virtual public Worker
{
private:
    int panache;
protected:
    void Data() const;
    void Get();
public:
    Waiter() :Worker(), panache(0) {}
    Waiter(const std:: string & s, long n, int p = 0) :Worker(s,n), panache(p) {}
    Waiter(const Worker & wk, int p = 0) :Worker(wk), panache(p) {}
    void Set();
    void Show() const;
};
class Singer : virtual public Worker
{
protected:
    enum {other, alto, contralto, soprano, bass, baritone, tenor};
    enum {Vtypes = 7};
    void Data() const;
    void Get();
private:
    static char *pv[Vtypes];
    int voice;
public:
    Singer() :Worker(), voice(other) {}
    Singer(const std::string & s, long n, int v = other) :Worker(s, n), voice(v) {}
    Singer(const Worker & wk, int v = other) :Worker(wk), voice(v) {}
    void Set();
    void Show() const;
};
//multiple inheritance
class SingingWaiter : public Singer, public Waiter
{
protected:
    void Data() const;
    void Get();
public:
    SingingWaiter() {}
    SingingWaiter(const std::string & s, long n, int p = 0, int v = other) 
        :Worker(s, n), Waiter(s, n, p), Singer(s, n, v) {}
    SingingWaiter(const Worker & wk, int p = 0, int v = other) 
        :Worker(wk), Waiter(wk, p), Singer(wk, v) {}
    SingingWaiter(const Waiter & wt, int v = other) 
        :Worker(wt), Waiter(wt), Singer(wt, v) {}
    SingingWaiter(const Singer & wt, int p = 0)
        :Worker(wt), Waiter(wt, p), Singer(wt) {}
    void Set();
    void Show() const;
};

#include <iostream>
#include <cstring>
#include "workermi.h"
const int SIZE = 5;
int main()
{
    using std::cin;
    using std::endl;
    using std::cout;
    using std::strchr;
    QueueTP<Worker *> lolas;
    Worker * temp;
    while (!lolas.isfull())
    {
        char choice;
        cout << "Enter the employee category:\n"
            << "w: waier s: singer t: singingwaiter q: quit\n";
        cin >> choice;
        while (strchr("wstq", choice) == NULL)
        {
            cout << "Please enter a w, s, t, or q: ";
            cin >> choice;
        }
        if(choice == 'q') break;
        switch(choice)
        {
            case 'w': temp = new Waiter; break;
            case 's': temp = new Singer; break;
            case 't': temp = new SingingWaiter; break;
        }
        cin.get();
        temp->Set();
        lolas.enqueue(temp);
                delete temp;
    }
    cout << "\nHere is your staff:\n";
    while (!lolas.isempty())
    {
        cout << endl;
        lolas.dequeue(temp);
        temp->Show();
        
    }
    
    cin.get();
    return 0;
}

#include "workermi.h"
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
//worker
Worker::~Worker() {}
void Worker::Data() const
{
    cout << "Name: " << fullname << endl;
    cout << "Emplyee ID: " << id << endl;
}
void Worker::Get()
{
    getline(cin, fullname);
    cout << "Enter worker's ID: ";
    cin >> id;
    while(cin.get() != '\n') continue;
}
//waiter
void Waiter::Set()
{
    cout << "Enter waiter's name: ";
    Worker::Get();
    Get();
}
void Waiter::Show() const
{
    cout << "Category: waiter\n";
    Worker::Data();
    Data();
}
void Waiter::Data() const
{
    cout << "Panache raiting: "<< panache << endl;
}
void Waiter::Get()
{
    cout << "Enter waiter's panache raiting: ";
    cin >> panache;
    while (cin.get() != '\n') continue;
}
//singer
char * Singer::pv[Singer::Vtypes] = {"other", "alto", "contralto", "soprano", "bass", "baritone", "tenor"};
 
void Singer::Set()
{
    cout << "Enter singer's name: ";
    Worker::Get();
    Get();
}
void Singer::Show() const
{
    cout << "Category: singer\n";
    Worker::Data();
    Data();
}
void Singer::Data() const
{
    cout << "Vocal range: " << pv[voice] << endl;
}
void Singer::Get()
{
    cout << "Enter number for singer's vocal range:\n";
    int i;
    for(i = 0; i < Vtypes; i++)
    {
        cout << i << ": " << pv[i] << " ";
        if (i % 4 == 3) cout << endl;
    }
    if (i % 4 != 0) cout << '\n';
    cin >> voice;
    while (cin.get() != '\n') continue;
}
//singingwaiter
void SingingWaiter::Data() const
{
    Singer::Data();
    Waiter::Data();
}
void SingingWaiter::Get()
{
    Waiter::Get();
    Singer::Get();
}
void SingingWaiter::Set()
{
    cout << "Enter singing waiter's name: ";
    Worker::Get();
    Get();
}
void SingingWaiter::Show() const
{
    cout << "Category: singing waiter\n";
    Worker::Data();
    Data();
}

#include <iostream>
#include <clocale>
#include <cstring>
#include <string>
#include <cstdio>
 
using std::cout;
using std::cin;
using std::string;
using std::getline;
using std::endl;
 
const int len = 40;
 
struct golf {
    char fullname[len];
    int handicap;
};
 
void set_golf(golf &g, const char *name, int hc);
int set_golf(golf &g);
void handicap(golf &g, int hc);
void show_golf(const golf &g);

#include "golf.h"
 
void set_golf(golf &g, const char *name, int hc)
{
    strcpy(g.fullname, name);
    g.handicap = hc;
}
 
int set_golf(golf &g)
{
    char *tmp_arr = new char[len];
    
    cout << "Enter a fullname(null for Quit): ";
    gets(tmp_arr);
 
    if(strlen(tmp_arr) != 0)
    {   
        strcpy(g.fullname, tmp_arr);
        cout << "Enter a handicap of " << tmp_arr << ": ";
        cin >> g.handicap;
    
        delete [] tmp_arr;
        return 1;
    }
    else return 0;
}
 
void handicap(golf &g, int hc)
{
    
}
 
void show_golf(const golf &g)
{
    cout << endl;
    cout << "Golfer name: " << g.fullname << endl;
    cout << g.fullname << "'s handicap: " << g.handicap << endl;
}

#include "golf.h"
 
int main()
{
    setlocale(LC_CTYPE, "");
    const int max_g_arr_size = 5;
    
    golf *g_arr = new golf[max_g_arr_size];
    int count = 0;
    
    while(count < max_g_arr_size && set_golf(g_arr[count]))
    {
        set_golf(g_arr[count]);
        ++count;
    }
    
    if(count)
    {
        for(int i = 0; i < count; ++i)
            show_golf(g_arr[i]);
    }
    else
        cout << "Empty!\n";
    
    delete [] g_arr;
    return 0;
}