Two implementation methods of stack

Dynamic array implementation :

#define CURL_STATICLIB
# include<iostream>
# include<string>
#include<assert.h>
using namespace std;
template<typename T>
class Mystack
{
private:
    T* arr;
    int _count;
    int cap;// Capacity 
    int length;
public:
    Mystack<T>()
    {
        this->cap = 1024;
        _count = 0;
        arr = new T[cap];
        length = 0;
    }
    Mystack<T>(int cap)
    {
        this->cap = cap;
        _count = 0;
        arr = new T[cap];
        length = 0;
    }
    ~Mystack()
    {
        delete[]arr;
    }
    void push(T val)
    {
        assert(_count < cap);// If it is true, no error will be reported , Avoid out of bounds access 
        arr[_count] = val;
        ++_count;
        ++length;
    }
    T pop()
    {
        assert(length>0);
        --length;
        return arr[--_count];
    }
    T top()
    {
        return arr[_count-1];//return arr[_count-1]
    }
    bool empty()
    {
        return length == 0;
    }
    int size()
    {
        return length;
    }
    int capacity()
    {
        return cap;
    }
    T get_count(int num)
    {
        return arr[num];
    }
};
int main()
{
    Mystack<string>s;
    s.push("abc");
    s.push("def");
    s.push("ghi");
    s.push("jkl");
    s.push("mno");
    int len = s.size();
    for (int i = 0; i <len; i++)
    {
        cout << s.top() << endl;
        s.pop();
    }
    if (s.empty())
    {
        cout << "I like coding" << endl;
    }
    return 0;
}

Linked list implementation :

1. In the process of stacking , Use inverse interpolation ;

That is, fill elements between the head node and the first node :

temp->next = topNode;
topNode = temp;// Use the head insertion method to realize the built-in of the linked list 

2. Head insertion and tail insertion

// The tail interpolation 
rear->next=newNode
rear=rear->next  
 // The first interpolation 
 temp->next=head->next
 head->next=temp

Complete code :

#define CURL_STATICLIB
# include<iostream>
# include<string>
#include<assert.h>
using namespace std;
template<typename T>
class Node
{
public:
	Node<T>* last;
	Node<T>* next;
	T val;
	Node(T val) :val(val), next(NULL), last(NULL) {}
	~Node() { delete next; delete last; }
};
template <typename T>
class Mystack
{
private:
	Node<T>* topNode;
	int _size;
public:
	Mystack() :topNode(NULL), _size(0) {}
	~Mystack() { delete topNode; }
	void push(T x)
	{
		if (NULL == topNode) { topNode = new Node<T>(x); topNode->last = NULL; ++_size; return; }
		Node<T>* temp = new Node<T>(x);
		temp->next = topNode;// Inverse interpolation 
		topNode = temp;
		//temp->next=topNode;topNode=temp;
		//rear->next=newNode;rear=rear->next  Of queues and stacks pop() It's all location-based movement   Insert first and then determine the position movement 
		//newNode->next=head->next;
		//head->next=newNode;
	}
	void pop()
	{
		assert(NULL != topNode);
		Node<T>* temp = topNode;
		topNode = topNode->next;
		--_size;
	}
	T top()
	{
		assert(NULL != topNode);
		return topNode->val;
	}
	void size()
	{
		return _size;
	}
	bool empty()
	{
		return topNode == NULL;
	}
};
int main()
{
	Mystack<string>s;
	s.push("passion");
	s.push("optimistic");
	s.push("Tencent");
	while (!s.empty())
	{
		cout << s.top() << endl;
		s.pop();
	}
}