Iterating over a std::stack

You're right, std::stack doesn't provide a direct way to iterate over its elements. This is intentional and aligns with the purpose of the stack data structure, which is designed for LIFO (last-in, first-out) access where only the top element is accessible.

However, if you really need to iterate over a stack's elements, you have a couple of options:

Pop and process

You can pop each element off the stack one by one until the stack is empty. However, this will destroy the stack in the process:

1#include <iostream>
2#include <stack>
3
4int main() {
5  std::stack<int> s;
6  s.push(1);
7  s.push(2);
8  s.push(3);
9
10  while (!s.empty()) {
11    int top = s.top();
12    std::cout << top << ' ';
13    s.pop();
14  }
15}

13 2 1

Access the underlying container

std::stack is a container adaptor, which means it uses another container internally. By default, it uses std::deque.

If you're okay with depending on implementation details, a method like _Get_container() in MSVC provides access to the underlying container, which you can then iterate over:

1#include <iostream>
2#include <stack>
3
4int main() {
5  std::stack<int> s;
6  s.push(1);
7  s.push(2);
8  s.push(3);
9
10  const std::deque<int>& d = s._Get_container();
11  for (int i : d) {
12    std::cout << i << ' ';
13  }
14}

11 2 3

However, accessing the underlying container like this is not recommended as it's not part of the public interface of std::stack. It relies on implementation details that are not part of the C++ specification.

This means that different compilers may use a different way to provide access to the underlying container, and some may not provide it at all.

If you find yourself frequently needing to iterate over a stack, it might be a sign that a stack is not the right data structure for your use case. Consider if a std::vector or std::deque would be more appropriate.