Stack implementation C++ - c++

Question

I have implemented a stack using the next class:
template <typename T, int lungime> class Depou
{
private:
T *depouarray;
int top;
public:
Depou ()
{
this -> top = -1;
depouarray = (T *) calloc (lungime, sizeof (T));
}
~Depou ()
{
free (depouarray);
}
void push (T x)
{
if (top >= lungime - 1)
{
return;
}
top ++;
depouarray [top] = x;
}
T pop ()
{
if (isEmpty ())
{
return -1;
}
T x;
x = depouarray [top];
top --;
return x;
}
T peek ()
{
if (isEmpty ())
{
return -1;
}
return depouarray[top];
}
int isEmpty ()
{
return (top < 0);
}
}
My problem is the next one:
After I've added an element to the stack, let's say 3, I verified it and it showed 3.
Next, I added another element, let's say 4, I verified the content of the stack and it showed a very high number (which is surely junk) and 4. I cannot understand why it transforms the first elements into junk, leaving only the last element added as it should be.

Answer 1

As my colleague pointed out, you have many errors within your code and I think i t would be too much effort to correct it. Hence I'm giving you a stack implementation.
A stack is a FILO structure. The best way to implement it is to use Node and to link them together. Look at the code below, it is straight forward. Let me know if you have questions.
template <class T>
class Stack {
public:
Stack();
~Stack();
void push(const T&);
void pop(T& out);
T pop();
bool is_empty() const;
void clear();
private:
class Node {
public:
Node(const T& t, Node* c);
T contain;
Node* next;
};
Node* peak;
};
template <class T>
Stack<T>::Stack()
{
peak = NULL;
}
template <class T>
Stack<T>::~Stack()
{
clear();
}
template <class T>
bool Stack<T>::is_empty() const
{
return peak == NULL;
}
template <class T>
void Stack<T>::clear()
{
while(!is_empty())
pop();
}
template <class T>
Stack<T>::Node::Node(const T& t, Node* c) : next(c)
{
contain = t;
}
template <class T>
void Stack<T>::push(const T& t)
{
peak = new Node(t, peak);
assert(peak);
}
template <class T>
T Stack<T>::pop()
{
assert(peak);
Node c(*peak);
delete peak;
peak = c.next;
return c.contain;
}
template <class T>
void Stack<T>::pop(T& t)
{
assert(peak != NULL);
t = peak->contain;
Node* c = peak;
peak = peak->next;
delete c;
}