In C++ programming. Adding as many comments as possible will be greatly appreciated.

- Implement array based stack (50 pts)

- Implement linked-list based stack (50 pts)

In either of which,

- Push: (15 pts)

- Pop: (15 pts)

- Others (constructor, destructor, clear(), isEmpty(), isFull()):

(20 pts)

Note: For linked-list implementation isFull() function must have just one statement which is return false;

StackArray.cpp

#include "StackArray.h"

template

StackArray::StackArray(int maxNumber)

{

}

template

StackArray::StackArray(const StackArray& other)

{

}

template

StackArray& StackArray::operator=(const StackArray& other)

{

}

template

StackArray::~StackArray()

{

}

template

void StackArray::push(const DataType& newDataItem) throw (logic_error)

{

}

template

DataType StackArray::pop() throw (logic_error)

{

}

template

void StackArray::clear()

{

}

template

bool StackArray::isEmpty() const

{

return false;

}

template

bool StackArray::isFull() const

{

return false;

}

template

void StackArray::showStructure() const

// Array implementation. Outputs the data items in a stack. If the

// stack is empty, outputs "Empty stack". This operation is intended

// for testing and debugging purposes only.

{

if( isEmpty() ) {

cout << "Empty stack." << endl;

}

else {

int j;

cout << "Top = " << top << endl;

for ( j = 0 ; j < maxSize ; j++ )

cout << j << "\t";

cout << endl;

for ( j = 0 ; j <= top ; j++ )

{

if( j == top )

{

cout << '[' << dataItems[j] << ']'<< "\t"; // Identify top

}

else

{

cout << dataItems[j] << "\t";

}

}

cout << endl;

}

cout << endl;

}

StackLinked.cpp

#include "StackLinked.h"

template

StackLinked::StackLinked (int maxNumber)

{

}

template

StackLinked::StackLinked(const StackLinked& other)

{

}

template

StackLinked& StackLinked::operator=(const StackLinked& other)

{

}

template

StackLinked::~StackLinked()

{

clear();

}

template

void StackLinked::push(const DataType& newDataItem) throw (logic_error)

{

}

template

DataType StackLinked::pop() throw (logic_error)

{

}

template

void StackLinked::clear()

{

StackNode* t;

while ( top != NULL)

{

t = top;

top = top->next;

delete t;

}

}

template

bool StackLinked::isEmpty() const

{

return false;

}

template

bool StackLinked::isFull() const

{

return false;

}

template

void StackLinked::showStructure() const

{

if( isEmpty() )

{

cout << "Empty stack" << endl;

}

else

{

cout << "Top\t";

for (StackNode* temp = top; temp != 0; temp = temp->next) {

if( temp == top ) {

cout << "[" << temp->dataItem << "]\t";

}

else {

cout << temp->dataItem << "\t";

}

}

cout << "Bottom" << endl;

}

}

Test6.cpp

#include

using namespace std;

#include "config.h"

#if !LAB6_TEST1

# include "StackArray.cpp"

#else

# include "StackLinked.cpp"

#endif

void print_help()

{

cout << endl << "Commands:" << endl;

cout << " H : Help (displays this message)" << endl;

cout << " +x : Push x" << endl;

cout << " - : Pop" << endl;

cout << " C : Clear" << endl;

cout << " E : Empty stack?" << endl;

cout << " F : Full stack?" << endl;

cout << " Q : Quit the test program" << endl;

cout << endl;

}

template

void test_stack(Stack& testStack)

{

DataType testDataItem; // Stack data item

char cmd; // Input command

print_help();

do

{

testStack.showStructure(); // Output stack

cout << endl << "Command: "; // Read command

cin >> cmd;

if ( cmd == '+' )

cin >> testDataItem;

try {

switch ( cmd )

{

case 'H' : case 'h':

print_help();

break;

case '+' : // push

cout << "Push " << testDataItem << endl;

testStack.push(testDataItem);

break;

case '-' : // pop

cout << "Popped " << testStack.pop() << endl;

break;

case 'C' : case 'c' : // clear

cout << "Clear the stack" << endl;

testStack.clear();

break;

case 'E' : case 'e' : // isEmpty

if ( testStack.isEmpty() )

cout << "Stack is empty" << endl;

else

cout << "Stack is NOT empty" << endl;

break;

case 'F' : case 'f' : // isFull

if ( testStack.isFull() )

cout << "Stack is full" << endl;

else

cout << "Stack is NOT full" << endl;

break;

case 'Q' : case 'q' : // Quit test program

break;

default : // Invalid command

cout << "Inactive or invalid command" << endl;

}

}

catch (logic_error e) {

cout << "Error: " << e.what() << endl;

}

} while ( cin && cmd != 'Q' && cmd != 'q' );

}

int main() {

#if !LAB6_TEST1

cout << "Testing array implementation" << endl;

StackArray s1;

test_stack(s1);

#else

cout << "Testing linked implementation" << endl;

StackLinked s2;

test_stack(s2);

#endif

}

StackLinked.h

#ifndef STACKARRAY_H

#define STACKARRAY_H

#include

#include

using namespace std;

#include "Stack.h"

template

class StackLinked : public Stack {

public:

StackLinked(int maxNumber = Stack::MAX_STACK_SIZE);

StackLinked(const StackLinked& other);

StackLinked& operator=(const StackLinked& other);

~StackLinked();

void push(const DataType& newDataItem) throw (logic_error);

DataType pop() throw (logic_error);

void clear();

bool isEmpty() const;

bool isFull() const;

void showStructure() const;

private:

class StackNode {

public:

StackNode(const DataType& nodeData, StackNode* nextPtr)

{

dataItem = nodeData;

next = nextPtr;

}

DataType dataItem;

StackNode* next;

};

StackNode* top;

};

#endif //#ifndef STACKARRAY_H

StackArray.h

#ifndef STACKARRAY_H

#define STACKARRAY_H

#include

#include

using namespace std;

#include "Stack.h"

template

class StackArray : public Stack {

public:

StackArray(int maxNumber = Stack::MAX_STACK_SIZE);

StackArray(const StackArray& other);

StackArray& operator=(const StackArray& other);

~StackArray();

void push(const DataType& newDataItem) throw (logic_error);

DataType pop() throw (logic_error);

void clear();

bool isEmpty() const;

bool isFull() const;

void showStructure() const;

private:

int maxSize;

int top;

DataType* dataItems;

};

#endif //#ifndef STACKARRAY_H

Stack.h

#pragma warning( disable : 4290 )

#ifndef STACK_H

#define STACK_H

#include

#include

using namespace std;

template

class Stack {

public:

static const int MAX_STACK_SIZE = 8;

virtual ~Stack();

virtual void push(const DataType& newDataItem) throw (logic_error) = 0;

virtual DataType pop() throw (logic_error) = 0;

virtual void clear() = 0;

virtual bool isEmpty() const = 0;

virtual bool isFull() const = 0;

virtual void showStructure() const = 0;

};

template

Stack::~Stack()

// Not worth having a separate class implementation file for the destuctor

{}

#endif // #ifndef STACK_H