C++ Primer Plus

The private section has to commit itself to how to hold the data. For example, you can use an ordinary array, a dynamically allocated array, or some more advanced data structure, such as a linked list. However, the public interface should hide the exact representation. Instead, it should be expressed in general terms, such as creating a stack, pushing an item, and so on. Listing 10.10 shows one approach. It assumes that the bool type has been implemented. If it hasn’t been implemented on your system, you can use int, 0, and 1 rather than bool, false, and true.

Listing 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

In the example in Listing 10.10, the private section shows that the stack is implemented by using an array, but the public section doesn’t reveal that fact. Thus, you can replace the array with, say, a dynamic array without changing the class interface. This means changing the stack implementation doesn’t require that you recode programs that use the stack. You just recompile the stack code and link it with existing program code.

The interface is redundant in that pop() and push() return information about the stack status (full or empty) instead of being type void. This provides the programmer with a couple options as to how to handle exceeding the stack limit or emptying the stack. He or she can use isempty() and isfull() to check before attempting to modify the stack, or else use the return value of push() and pop() to determine whether the operation is successful.

Rather than define the stack in terms of some particular type, the class describes it in terms of a general Item type. In this case, the header file uses typedef to make Item the same as unsigned long. If you want, say, a stack of doubles or of a structure type, you can change the typedef and leave the class declaration and method definitions unaltered. Class templates (see Chapter 14, “Reusing Code in C++”) provide a more powerful method for isolating from the class design the type of data stored.

Next, you need to implement the class methods. Listing 10.11 shows one possibility.

Listing 10.11. stack.cpp

// stack.cpp -- Stack member functions

#include "stack.h"

Stack::Stack()    // create an empty stack

{

    top = 0;

}

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)

    {

        item = items[--top];

        return true;

    }

    else

        return false;

}

The default constructor guarantees that all stacks are created empty. The code for pop() and push() guarantees that the top of the stack is managed properly. Guarantees like this are one of the things that make OOP reliable. Suppose that, instead, you create a separate array to represent the stack and an independent variable to represent the index of the top. In that case, it is your responsibility to get the code right each time you create a new stack. Without the protection that private data offers, there’s always the possibility of making some program blunder that alters data unintentionally.

Let’s test this stack. Listing 10.12 models the life of a clerk who processes purchase orders from the top of his in-basket, using the LIFO (last-in, first-out) approach of a stack.

Listing 10.12. stacker.cpp

// stacker.cpp -- testing the Stack class

#include

#include   // or ctype.h

#include "stack.h"

int main()

{

    using namespace std;

    Stack st; // create an empty stack

    char ch;

    unsigned long 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 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 << "Bye\n";

    return 0;

}

The little while loop in Listing 10.12 that gets rid of the rest of the line isn’t absolutely necessary at this point, but it will come in handy in a modification of this program in Chapter 14. Here’s a sample run:

Please enter A to add a purchase order,

P to process a PO, or Q to quit.

A