A Comprehensive Look at C++ Stack

A stack is an abstract data form with a pre-defined bounded capacity. It's a basic data structure that allows web developers to add and remove elements in a specific order. When an element is inserted, it is placed at the top of the stack, and the only element that can be removed is the element at the top of the stack, similar to a pile of items.

Stack in C++

Stack is a form of container adapter that works on the LIFO (Last In First Out) principle, in which a new element is inserted at one end, and an element (top) is removed at the opposite end. Stack uses an encapsulated object of vector or deque (by default) or a list (sequential container class) as its primary container, and has a specific collection of member functions to access its components.

Elements are pushed/popped from the top of the stack, which is known as the "back" of the particular container. You may use any regular container class models or a custom container class as the underlying container.

The stack container must be capable of performing the following tasks:

empty: If the stack is empty, it will be returned.
size: Used to return the size of the stack.
top: Used to return the topmost element in the stack.
push_back: Adds elements to the top of the stack.
pop_back: Deletes the topmost element present in the stack.

What Is std::stack?

In a C++ stack, you can use only one end of the std::stack to add and remove elements. A container adapter is a std::stack type; container adapters don't support iterators, so they can't be used to manipulate data.

Container objects are used to store data of the same kind. You can construct a stack out of different sequence containers. And if no container is provided, the deque container is used by default.

C++ Stack Syntax

template<class Type, class Container = deque<Type>> class stack;

You need to include a <stack> header file in your code to create a stack.

Type represents the element type present in the std::stack. It can be any valid or user-defined type.
The container represents the underlying object of the container.

Member Types:

The member types present in the C++ stack include:

Value Type: This is the first argument that represents the type of elements.
Container Type: This is the second argument which represents the type of container.
Size Type: This is an unsigned integral type.

Sample Code:

#include <iostream>

#include <stack>

using namespace std;

int main() {

stack<int>st;

st.push(1);

st.push(2);

st.push(4);

st.push(5);

st.pop();

while (!st.empty()) {

cout<< ' ' <<st.top();

st.pop();

}

Output:

Cpp_Stack_1.

Advantages of Using Stack

Some of the advantages of using stack are:

It helps handle data using the Last In First Out (LIFO) process, which is not possible with a linked list or an array.
Local variables are stored in a stack when a function is called, and it is immediately discarded until the function is returned.
When a variable isn't used outside of a function, it is stored in a stack.
It enables you to manage memory allocation and deallocation.
The object is immediately cleaned up by stack.
Variables that aren't easily corrupted can't be resized.

Functions in Stack

push: Used to add an item to the stack.
pop: Used to remove an item from the stack.
peek: Used to fetch the top item from the stack without removing.
isFull: Used to check whether the stack is full.
isEmpty: Used to check whether the stack is empty.

Sample Code to Demonstrate Functions/Operations in Stack

push(), pop(), size(), empty(), top()

#include <iostream>

#include <stack>

using namespace std;

voidcreateStack(stack <int>mystack)

{

stack<int>ss = mystack;

while (!ss.empty())

{

cout<< '\t' <<ss.top();

ss.pop();

}

cout<< '\n';

}

int main()

{

stack<int>ss;

ss.push(32);

ss.push(21);

ss.push(39);

ss.push(89);

ss.push(25);

cout<< "The stack ss is: ";

createStack(ss);

cout<< "\n ss.size() : "<<"Size of the stack is:" <<ss.size();

cout<< "\n ss.top() : " <<"Top element in the stack is:"<<ss.top();

cout<< "\n ss.pop() : ";

ss.pop();

createStack(ss);

return 0;

}

Output

Cpp_Stack_2.

Explanation:

Including the header files is important to use input, output, and stack functions. You need to include the namespace std which helps to use the classes without calling. Create a stack which contains values belonging to integer data type, and an instance for a particular mystack and give it the name ss.

Using the function isempty() can help you check whether the stack is empty or not. Pop() is used to delete elements from the stack. Top() is used to push elements at top of the stack. And size() returns the number of elements in the stack.