issue with putting char type into stack

[nj1995]

Hi, my program seems to run fine, except for when it I attempt to insert random char types into the stack, where nothing happens and I am unsure why this is, any help is appreciated, thanks!

#include <iostream>
#include <algorithm>
#include <cassert>
#include <cstdlib>	
#include <ctime>
#include <stack>
#include <typeinfo>
#include <string>
using namespace std;

template <class T>
class container 
{
	template <class T1>
	friend ostream& operator<<(ostream& out, container<T1> &);
	// Postcondition: displays # of values stored in the container, storage 
	//                capacity of the contianer, and stored values in the container .
	//     

public:
	container();
	// Postcondition: set dynamic storage capacity to 1 and count to -1 where (count + 1)
	
   
	void insert(T);
	// Postcondition: if the container is not full, the value passed to the function 
	//                is stored in the first available element of the dynamic array. 
	//                Otherwise the function calls the private "allocate" member function
	//                requesting a new set of dynamic memory with twice the previous storage capacity 
	//			the insert function then increments count by 1 and insert the value into the new and larger array.
	
	void remove();
	//  Precondition: the data array must not be empty; i.e., count must be greater than or equal to 0.
	// Postcondition: if the container is not empty, then remove the most recently stored value ifrom the container and 
	//			decrement count by 1; otherwise, display the message "The container is empty; no action is taken!"
	
	T operator[](T sub);
	//  Precondition: value passed to the function must be a positive integer including 0
	// Postcondition: the value of stored in data[sub] is returned; if sub is out of range, 
	//                display a message and terminate the program .

	bool isFull();
	// Postcondition: return true if the container is full; return false otherwise 

	bool isEmpty();
	// Postcondition: return true if the container is empty; return false otherwise

	T Capacity();
	// Notice uppercase 'C' to avoid conflict with data member named "capacity"
	// Postcondition: returns the current storage capacity of the container
	
	T size();
	// Postcondition: returns the # of elements (# of objects) currently stored in the container

	void resize(T n);
	// Postcondition: container  is resized to n; contents of existing container have been copied to the new array; 
	// 			      old array is deleted to avoid memory leak.

protected:
	void allocate();
	// Postcondition: 1) the capacity of the container has been doubled, 2) existing values in the existing array have been copied to 
	//				   the new and larger dynamic array, 3) memory of the old array has been deleted (returned to "heap").
	
	const static int CAPACITY = 10;
	T data[CAPACITY];	
	int capacity;		// indicates the storage capcity of the container, i.e., the size of the dynamic array		
   	int count;		// used as a subscript to index into the array; size = count + 1
};

template <class T>
container<T>::container()
{
    capacity = 1;
	count = -1;	// container is empty
}

template <class T>
void container<T>::insert(T value)
{
	if (!isFull())
	{	
        data[++count] = value;
	}
	
	else 
    {
		count = count + 1;
	}
}

template <class T>
void container<T>::remove()
{
    if(!isEmpty())
    {
    	for (int i = 0; i < capacity; i++)
    	{
    		--count;
		}
	}
	
	else
	cout << "Container is empty!" << endl;
}

template <class T>
T container<T>::operator[](T sub)
{
    if(sub <= capacity)
	{
		return data[sub];
	}
	else
	{
		cout << endl << "Sub is out of range; program is terminated!";
		exit(1);
	}

}

template <class T>
bool container<T>::isFull()
{ 
    if (count != capacity)
    return false;
    
    else
    return true;

}

template <class T>
bool container<T>::isEmpty()
{ 
	if (count == -1)
	return true;
	
	else
	return false;
}

template <class T>
T container<T>::Capacity()
{
    return capacity;
}

template <class T>
T container<T>::size()
{
   return count + 1;
}

template <class T>
void container<T>::resize(T n)
{
	int *temptr;
	capacity = n;
	temptr = new int[n + 1];
	
	if(n > count + 1)
	{
	    for(int i = 0; i < count + 1; i++)
    		temptr[i] = data[i];
    	    for(int i = count + 1; i < n; i++)
    		temptr[i] = int();
	}
	
	else
	{
	    for(int i = 0; i < n; i++)
    		temptr[i] = data[i];
	}
	
}

template <class T1>
ostream& operator<<(ostream& out, container<T1> &c)
{
    out << "Container capacity = " << c.Capacity();
    out << " Size or actual # of values stored in the container = " << c.size() << endl;
    out << "Contents of the container = ";
    
    if(c.isEmpty() == true)
	{
		out << "empty!";
	}
	
	else
	{
		for(int i = 0; i < c.count + 1; i++)
			out << c.data[i] << "  ";
	}

	return out;
    
}

template <class T>
void container<T>::allocate()
{
	capacity = capacity * 2;
	
	resize(capacity);
	
}


template <class T>
class Stack : protected container<int>
{
	public:
		Stack();
		void push(T);
		T top();
		void pop();
		bool empty();
		bool full();
		void erase();
	
};
template <class T>
Stack<T>::Stack() : container<int>()
{
	
}

template <class T>
void Stack<T>::push(T n)
{
	insert(n);
}

template <class T>
T Stack<T>::top()
{
	if(!isEmpty())
	return data[count];
	
	else
	{
		cout << "Stack is empty!" << endl;
		return -99;
	}
}

template <class T>
void Stack<T>::pop()
{
	if(!isEmpty())
	remove();
	
	else
	{
		cout << "Stack is empty! Program terminated!" << endl;
		system("PAUSE");
		exit(1);
	}
}

template <class T>
bool Stack<T>::empty()
{
	return isEmpty();
}

template <class T>
bool Stack<T>::full()
{
	return isFull();
}

template <class T>
void Stack<T>::erase()
{
	while(!empty())
	{
		cout << top() << " has been removed from the stack!" << endl;
		pop();
	}
}

char genRandom()
{
	static const char alphanum[] =
	"0123456789"
	"!@#$%^&*"
	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	"abcdefghijklmnopqrstuvwxyz";
	
	int stringLength = sizeof(alphanum) - 1;
	
	return alphanum[rand() % stringLength];
}

template <class T>
void writeStack(T& stk)
{
	if (stk.empty())
		cout << "stack is empty!";
	else
	{
		cout << "stack is not empty!" << endl;
		cout << endl;
		cout << "We now pop 5 times";
		cout << endl << endl;
	
		for(int i = 0; i < 5; i++)
		{
			cout << stk.top() << " has been pushed off of the stack" << endl;
			cout << endl;
			stk.pop();
		}
	}
}

int main()
{
	Stack<int> stk;

	if (stk.empty())
		cout << "stack is empty!";
	else
		cout << "stack is not empty!" << endl;

	stk.push(11);
	cout << endl << stk.top() << " has been pushed on top " << endl;

	if (stk.empty())
		cout << "stack is empty!";
	else
		cout << "stack is not empty!" << endl;


	cout << "We now perform the pop operation:" << endl;
	cout << stk.top();
	stk.pop(); 
	cout << endl;
	if (stk.empty())
		cout << "stack is empty!";
	else
		cout << "stack is not empty!" << endl;

	srand(static_cast<unsigned int> (time(0)));
	cout << "we now push 5 random int numbers onto empty stack " << endl;
	
	for(int i = 0; i < 5; i++)
	{
		stk.push(rand() % 99 +1);
		cout << stk.top() << " has been pushed onto the stack," << endl;
	}
	
	writeStack(stk);
	
	Stack<char> stk2;
	
	srand(static_cast<unsigned char> (time(0)));
	cout << "we now push 10 random char letters onto empty stack " << endl;
	for(int i = 0; i < 10; i++)
	{
		char c;
		c = (rand() % 26 + 65);
		stk.push(c);
	}
	
	writeStack(stk2);
	
	
    system("PAUSE");
    return 0;
}

[Thomas1965]

  Stack<char> stk2;
	
  srand(static_cast<unsigned char> (time(0)));
  cout << "we now push 10 random char letters onto empty stack " << endl;
  for(int i = 0; i < 10; i++)
  {
    char c;
    c = (rand() % 26 + 65);
    stk.push(c);
  }

Shouldn't you push the chars onto stk2 ?
These type of errors are easier to spot if you give your variables a little more meaningful names - like CharStack and IntStack