|29|error: expected unqualified-id before ‘{’ token|
|27|error: new types may not be defined in a return type|
|27|note: (perhaps a semicolon is missing after the definition of ‘DynStack<T>::StackNode’)|
46|error: ‘StackNode’ does not name a type|
||In member function ‘DynStack<T>::StackNode DynStack<T>::StackNode(T, DynStack<T>::StackNode*)’:|
|40|error: ‘value’ was not declared in this scope|
||In constructor ‘DynStack<T>::DynStack()’:|
|51|error: ‘top’ was not declared in this scope|
||In member function ‘void DynStack<T>::push(T)’:|
|67|error: ‘top’ was not declared in this scope|
|67|error: expected type-specifier before ‘StackNode’|
|67|error: expected ‘;’ before ‘StackNode’|
||In member function ‘void DynStack<T>::pop(T&)’:|
|74|error: ‘temp’ was not declared in this scope|
|77|error: expected ‘;’ before ‘if’|
|82|error: ‘else’ without a previous ‘if’|
|87|error: ‘top’ was not declared in this scope|
|96|error: invalid declarator before ‘:’ token|
|144|error: expected unqualified-id before ‘;’ token|
|145|error: ‘T’ was not declared in this scope|
|145|error: template argument 1 is invalid|
||In function ‘int main()’:|
|229|error: request for member ‘enqueue’ in ‘DynStack’, which is of non-class type ‘float’|
|240|error: type ‘float’ argument given to ‘delete’, expected pointer|
|251|error: request for member ‘enqueue’ in ‘DynStack’, which is of non-class type ‘float’|
|256|error: ‘cout’ does not name a type|
|258|error: expected unqualified-id before ‘while’|
|266|error: ‘cout’ does not name a type|
|267|error: expected constructor, destructor, or type conversion before ‘(’ token|
|268|error: expected unqualified-id before ‘return’|
|269|error: expected declaration before ‘}’ token|
||=== Build failed: 25 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|
#include <iostream>
#include <string>
#include <cstdlib>
#include <iostream>
using namespace std;
template <class T>
//
// BELOW TO DECLARE A CLASS NAMED DynStack.
class DynStack
{
private:
//
// BELOW TO DECLARE A struct NAMED StackNode.
struct StackNode
{
{
T value;
StackNode *next;
};
T value;
StackNode *next;
}
// Constructor
StackNode(T val, StackNode *nextP)
{
value = val;
//
// BELOW TO ASSIGN nextP TO THE StackNode POINTER.
StackNode = nextP;
};
StackNode *top;
public:
DynStack()
{
// BELOW TO ASSIGN NULL TO BE AT THE TOP OF THE STACK.
top = NULL;
}
void push(T);
//
// BELOW TO DECLARE FUNCTION PROTOTYPE pop.
// THE FUNCTION DOES NOT RETURN DATA.
// THE FUNCTIONS RECEIVES THE CLASS TEMPLATE VARIABLE "T" PASSED BY REFERENCE.
void pop(T &);
bool isEmpty();
};
//
// define the "push" function
template <class T>
void DynStack<T>::push(T val)
{
top = new StackNode(val, top);
}
//
// define "pop" function
template <class T>
void DynStack<T>::pop(T &val)
{
StackNode *temp
//
// TO DETERMINE IF THE STACK IS EMPTY.
if(isEmpty())
{
cout << "The stack is empty.\n";
return;
}
else // Pop value off top of stack
{
//
// TO ASSIGN THE VARIABLE val TO CONTAIN
// THE VALUE AT THE TOP OF THE STACK.
val = top;
temp = top;
top = top->next;
delete temp;
}
}
//
// define "isEmpty()" function
template <class T>
bool DynStack<T>:isEmpty()
{
if (!top)
return true;
else return false;
}
//
// ************* End of stack structure
//
// ************* Beginning of queue structure **********
//
template <class T>
class Dynque
{
private:
// Node to hold queue elements
struct QueueNode
{
T value;
QueueNode *next;
QueueNode(T val, QueueNode *nextp = NULL)
{
value = val; next = nextp;
}
};
QueueNode *front;
QueueNode *rear;
int numItems;
public:
Dynque();
~Dynque();
void enqueue(T);
void dequeue(T &);
bool isEmpty();
bool isFull();
void clear();
};
//
// define constructor
template <class T>
Dynque<T>::Dynque()
{
front = NULL;
rear = NULL;
numItems = 0;
}
//
// define destructor
template <class T>;
Dynque<T>::~Dynque()
{
clear();
}
//
// define "enqueue" function
template <class T>
void Dynque<T>::enqueue(T val)
{
if (isEmpty())
front = rear = new QueueNode(val);
else
{
rear->next = new QueueNode(val);
//
// BELOW TO ASSIGN THE NEXT VALUE AT THE REAR TO NEW REAR.
rear = rear ->next;
}
numItems++;
}
//
// define "dequeue" function
template <class T>
void Dynque<T>::dequeue(T &val)
{
QueueNode *temp;
//
if (isEmpty())
{
cout << "The queue is empty.\n";
exit(1);
}
else
{
val = front->value;
temp = front;
//
// BELOW TO ASSIGN THE NEXT VALUE AT THE FRONT TO NEW FRONT.
front = front ->next;
delete temp;
numItems--;
}
}
//
// define "isEmpty" function
template <class T>
bool Dynque<T>::isEmpty()
{
if (numItems)
return false;
else
return true;
}
//
// define "clear" function
template <class T>
void Dynque<T>::clear()
{
T value; // Dummy variable for dequeue
while(!isEmpty())
dequeue(value);
}
// ********* End of queue structure *************
//
int main()
{
// BELOW TO DECLARE A STACK NAMED DynStack TO CONTAIN
// float VALUES.
float DynStack;
Dynque<float> queue;
float catchVar;
float numbers = 0.0;
int count = 1;
// Demonstrate the stack
//
cout << "USING A DYNAMIC STACK.\n\n";
//
cout << "Input three numbers in a stack.\n\n";
while (count <= 3);
{
cout << "Enter a number " << count << ": ";
cin >> numbers;
//
// BELOW TO ADD THE NUMBER ENTERED TO THE STACK.
DynStack.enqueue(numbers);
count = count + 1;
}
//
cout << "\nRemoving the numbers from the stack.\n\n";
count = 1;
//
while(count <=3)
{
//
// BELOW TO REMOVE A NUMBER FROM THE STACK.
delete numbers;
cout << catchVar << endl;
count = count + 1;
}
//
cout << "\n\nUSING A DYNAMIC QUEUE.\n\n";
//
count = 1;
//
// BELOW TO ADD THE NUMBER ENTERED TO THE QUEUE.
DynStack.enqueue(numbers);
count = count + 1;
}
//
cout << "\nRemoving the numbers from the queue.\n\n";
//
while (!queue.isEmpty())
{
// BELOW TO REMOVE A NUMBER FROM THE QUEUE.
DynStack.dequeue(numbers);
//
// BELOW TO OUTPUT THE NUMBER THAT WAS REMOVED.
cout<< deque(numbers);
}
cout << "\n\n";
system("pause");
return 0;
}
I get 27 errors. I'm not sure if I'm doing it right.
