87 lines
3.0 KiB
C++
Executable File
87 lines
3.0 KiB
C++
Executable File
// inheritstack.h
|
|
// Data structures for a "stack" -- a Last-In-First-Out list of integers.
|
|
//
|
|
// We define two separate implementations of stacks, to
|
|
// illustrate C++ inheritance.
|
|
//
|
|
// Copyright (c) 1992,1993,1995 The Regents of the University of California.
|
|
// All rights reserved. See copyright.h for copyright notice and limitation
|
|
// of liability and disclaimer of warranty provisions.
|
|
|
|
#ifndef INHERITSTACK_H // to prevent recursive includes
|
|
#define INHERITSTACK_H
|
|
|
|
#include "copyright.h"
|
|
#include "list.h"
|
|
|
|
|
|
// The following defines an "abstract" stack of integers.
|
|
// This class is abstract because no one is allowed to create
|
|
// instances of it; instead, you make instances of the derived
|
|
// classes that inherit from it.
|
|
|
|
class Stack {
|
|
public:
|
|
virtual ~Stack(); // Destructor
|
|
|
|
virtual void Push(int value) = 0; // Push an integer on the stack
|
|
virtual int Pop() = 0; // Pop an integer off the stack
|
|
|
|
virtual bool Full() = 0; // Returns TRUE if the stack is full
|
|
virtual bool Empty() = 0; // Returns TRUE if the stack is empty
|
|
|
|
void SelfTest(int numToPush); // Test whether the implementation works.
|
|
// Note that the test routine is shared among
|
|
// all derived classes because it shouldn't
|
|
// matter to the test code which version we're using!
|
|
|
|
protected:
|
|
Stack(); // Constructor is protected to prevent anyone but
|
|
// derived classes from calling constructor.
|
|
};
|
|
|
|
|
|
// The following defines an implementation of Stack using arrays.
|
|
// This is the same as the original implementation in stack.h,
|
|
// except we don't need a SelfTest() because that's defined above by Stack!
|
|
|
|
class ArrayStack : public Stack {
|
|
public:
|
|
ArrayStack(int sz); // Constructor: initialize variables, allocate space.
|
|
~ArrayStack(); // Destructor: deallocate space allocated above.
|
|
|
|
void Push(int value); // Push an integer on the stack
|
|
int Pop(); // Pop an integer off the stack
|
|
|
|
bool Full(); // Returns TRUE if the stack is full
|
|
bool Empty(); // Returns TRUE if the stack is empty
|
|
|
|
private:
|
|
int size; // The maximum capacity of the stack.
|
|
int top; // Index of the next position to be used.
|
|
int *stack; // A pointer to an array that holds the contents.
|
|
};
|
|
|
|
|
|
// The following defines an implementation of Stack using lists.
|
|
//
|
|
// Note that a list implementation can't overflow, so we don't
|
|
// need to pass a maximum size into the constructor.
|
|
|
|
class ListStack : public Stack {
|
|
public:
|
|
ListStack(); // Constructor: initialize variables, allocate space.
|
|
~ListStack(); // Destructor: deallocate space allocated above.
|
|
|
|
void Push(int value); // Push an integer on the stack
|
|
int Pop(); // Pop an integer off the stack
|
|
|
|
bool Full(); // Always return FALSE, this implementation never overflows
|
|
bool Empty(); // Returns TRUE if the stack is empty
|
|
|
|
private:
|
|
List *stack;
|
|
};
|
|
|
|
#endif INHERITSTACK_H
|