Solutions to Assignment 5

 

#include 

#define DATATYPE char		// current type of information
#define EMPTY 0

#define TOP 1
#define END 2

//------------------------------------------------------------
// Structure of list
//------------------------------------------------------------
typedef struct deque_data {
    DATATYPE data;
    struct deque_data *prev, *next; // duble linked list

    // Constructor
    deque_data(DATATYPE d, deque_data* p, deque_data* n);

    // Public get/set
    DATATYPE getData() { return data; }
    void setData(DATATYPE d) { data = d; } 
} deque_data; 

//------------------------------------------------------------
// Constructor for previous structure
//------------------------------------------------------------
deque_data::deque_data(DATATYPE d, deque_data* p, deque_data* n) {
    data = d;
    prev = p;
    next = n;
 }


//------------------------------------------------------------
// Class definition
//------------------------------------------------------------
class Deque {
    protected:
        deque_data *head, *tail;

    private:
        deque_data* newNode(DATATYPE data, deque_data* prev, deque_data* next);
        void delNode(deque_data* node);
        void destroy();

    public:
        // Constructor & Destructor
        Deque();
        ~Deque();

        // Public functions
        DATATYPE top(int fromWhere = TOP); 
        void  enque(DATATYPE data, int where = TOP);
        DATATYPE deque(int fromWhere = TOP);
 };

//------------------------------------------------------------
// Constructor
//------------------------------------------------------------
Deque::Deque() {
    head = NULL;
    tail = NULL;
 }

//------------------------------------------------------------
// Destructor
//------------------------------------------------------------
Deque::~Deque() {
    destroy();
    head = NULL;
    tail = NULL;
 }

//------------------------------------------------------------
// Private functions
//------------------------------------------------------------
void
Deque::destroy() {
    while (top()) 
       deque();
 }

deque_data*
Deque::newNode(DATATYPE data, deque_data* prev, deque_data* next) {
    return new deque_data(data, prev, next);
 }

void
Deque::delNode(deque_data* n) {
    delete n;
 }

//------------------------------------------------------------
// Public functions
//------------------------------------------------------------
DATATYPE
Deque::top(int fromWhere = TOP) {
    if (!head) return EMPTY;
    return (fromWhere == TOP ? head->getData() : tail->getData());
 }

void 
Deque::enque(DATATYPE d, int where = TOP) {
    deque_data* newnode;

    if (where == TOP) {
        newnode = newNode(d, NULL, head);
        if (head) { 
            head->prev = newnode;
        } else {
            tail = newnode;
        }
        head = newnode;
    } else {
        newnode = newNode(d, tail, NULL);
        if (tail) {
            tail->next = newnode;
        } else {
            head = newnode;
        }
        tail = newnode;
    }
 }

DATATYPE 
Deque::deque(int fromWhere = TOP) {
    DATATYPE crt;
    deque_data *old;

    crt = top(fromWhere);
    if (crt == EMPTY) 
        return crt;
    if (fromWhere == TOP) {
        old = head;
        head = head->next;
        if (head) {
            head->prev = NULL;
        } else {
            tail = NULL;
        }
    } else {
        old = tail;
        tail = tail->prev;
        if (tail) {
           tail->next = NULL;
        } else {
           head = NULL;
        }
    }
    delNode(old);
    return crt;
 }

//------------------------------------------------------------
// Main function
//------------------------------------------------------------
#ifndef LIBRARY

int
main () {
    Deque aInstance;

    cout << aInstance.top() << aInstance.top(END) << endl;
 
    for (char c = 'a'; c <= 'z'; c++) 
       aInstance.enque(c, END);

    cout << aInstance.top() << aInstance.top(END) << endl;
    cout << aInstance.deque() << aInstance.deque(END) << endl;
    cout << aInstance.deque() << aInstance.deque(END) << endl;
    cout << aInstance.deque() << aInstance.deque(END) << endl;
    cout << aInstance.top() << aInstance.top(END) << endl;

    return 1;
 }

#endif // LIBRARY


    [ Part 3: "Attached Text" ]



#include 
#include 

// ------------------------------------
// What is a Person ?
// ------------------------------------
class Person {
    char SSN[9];
    char FName[20], LName[20], MName[20], HAddr[40], HPhone[12];
    int MaritalStatus;

  public:
    Person(char *s) { strncpy(SSN, s, 9); }
    ~Person() {} 

    // get / set methods
    void setFName(char *s) { strncpy(FName, s, 20); }
    char *getFName() { return FName; }
  
    // print this person
    friend ostream &operator << (ostream &stream, Person p);

 };

ostream&
operator << (ostream &stream, Person p) {
    stream << p.SSN << " - " << p.FName;
    return  stream;
 }


// -----------------------------------------
// Employee is a first Person in this world
// -----------------------------------------
class Employee : public Person {
    char Office[20], OPhone[20], Title[20], CProjects[20];
    float Salary;

  public:
    Employee(char *s) : Person(s) {}
    ~Employee() {} 

    // get / set methods 
    void setOffice(char *s) { strncpy(Office, s, 20); }
    char *getOffice() { return Office; }
    
    // print this employee
    friend ostream &operator << (ostream &stream, Employee e);

 };

ostream&
operator << (ostream &stream, Employee e) {
    stream << static_cast(e) << " - " << e.Office;
    return stream;
 }


int
main() {
    Employee e("991919");

    e.setFName("Catalin");
    e.setOffice("UofC");

    cout << "That me: " << e << endl;
 
    return 1;
 }



    [ Part 4: "Attached Text" ]


#include 

class Pair {
  public:
    Pair() {}
    Pair(int f, int s) { first = f; second = s; }
    ~Pair() {}

    int getFirst() { return first; }
    void setFirst(int f) { first = f; }
    int getSecond() { return second; }
    void setSecond(int s) { second = s; }

    void swap() { first += second; second = first - second; first -= second; } 

  private:
    int first;
    int second;
 };