YouTipCpp Libs Stack
## C++ Standard Library: ``
In C++, the Standard Template Library (STL) provides a rich set of containers and algorithms to help developers write efficient and clean code.
The `` header is a key component of the STL. It implements a **LIFO (Last In, First Out)** data structure, which is ideal for scenarios where the last element added must be the first one removed.
The `std::stack` is a **container adapter**. This means it does not implement the underlying memory storage itself. Instead, it wraps around an existing sequence container (such as `std::deque` or `std::vector`) and exposes a restricted, linear interface that allows operations only at one end (the top of the stack).
---
### Core Operations
The `std::stack` class provides a simple and intuitive set of member functions:
* `push()`: Inserts an element at the top of the stack.
* `pop()`: Removes the element at the top of the stack.
* `top()`: Returns a reference to the top element without removing it.
* `empty()`: Checks whether the stack is empty.
* `size()`: Returns the number of elements currently in the stack.
---
### Syntax and Basic Usage
To use `std::stack`, you must include the `` header. Here is a basic example demonstrating how to declare a stack and perform fundamental operations:
```cpp
#include
#include
int main() {
// Declare a stack of integers
std::stack s;
// Push elements onto the stack
s.push(1);
s.push(2);
s.push(3);
// Access the top element
std::cout << "Top element is: " << s.top() << std::endl;
// Remove the top element
s.pop();
std::cout << "After popping, top element is: " << s.top() << std::endl;
// Check if the stack is empty
if (!s.empty()) {
std::cout << "Stack is not empty." << std::endl;
}
// Print the size of the stack
std::cout << "Size of stack: " << s.size() << std::endl;
return 0;
}
```
---
### Complete Code Example
Below is a comprehensive, runnable example that demonstrates the full lifecycle of a stack, including pushing, popping, checking sizes, and emptying the container.
```cpp
#include
#include
int main() {
std::stack s;
// Push elements onto the stack
s.push(10);
s.push(20);
s.push(30);
// Print the top element
std::cout << "Top element is: " << s.top() << std::endl; // Output: 30
// Remove the top element
s.pop();
std::cout << "After popping, top element is: " << s.top() << std::endl; // Output: 20
// Check if the stack is empty
if (!s.empty()) {
std::cout << "Stack is not empty." << std::endl; // Output: Stack is not empty.
}
// Print the size of the stack
std::cout << "Size of stack: " << s.size() << std::endl; // Output: 2
// Pop the remaining elements
s.pop();
s.pop();
// Check if the stack is empty again
if (s.empty()) {
std::cout << "Stack is empty." << std::endl; // Output: Stack is empty.
}
return 0;
}
```
#### Output:
```text
Top element is: 30
After popping, top element is: 20
Stack is not empty.
Size of stack: 2
Stack is empty.
```
---
### Important Considerations
When working with `std::stack` in production environments, keep the following rules in mind:
1. **No Direct Access / Iteration**: `std::stack` does not support iterators. You cannot use a `for` loop to traverse its elements, nor can you access elements by index (e.g., `s`). You can only access the element at the very top using `top()`.
2. **Undefined Behavior on Empty Stacks**: Calling `top()` or `pop()` on an empty stack results in **undefined behavior** (often causing a segmentation fault or crash). Always check `!s.empty()` before accessing or removing the top element.
3. **Underlying Containers**: By default, `std::stack` uses `std::deque` as its underlying container. However, you can customize this by passing a second template argument. For example, if you want a stack backed by a `std::vector` or `std::list`:
```cpp
std::stack> vector_backed_stack;
std::stack> list_backed_stack;
```
4. **Performance**: All core operations (`push()`, `pop()`, `top()`, `empty()`, and `size()`) run in **$O(1)$ constant time**, making the stack an exceptionally fast and lightweight data structure.