How to display (or loop through) a stack in c++ - c++

Question

I am new to c++ and am trying to figure out how to display the contents of my stack after running it through a program.
int main(){
int userInput;
Stack st1,st2;
cin>>userInput;
int i,topStack;
while(userInput!=-9){
while(userInput>0){
st1.push(userInput);
topStack=st1.pop()
st2.push(topStack);
}
if(userInput<0){
for(i=0;i<(-userInput);++i){
st2.pop();
}
}
}
}
I want to see what st2 looks like after I input values. Not quite sure how to do that and/or if it is possible. Resources would be more than appreciated!
Here is the custom class definition:
class ListNode{
public:
int content;
ListNode* pNext;
};
class Stack{
private:
ListNode* top;
public:
Stack();
~Stack();
int pop();
void push(int);
};
Stack::Stack(){
top=nullptr;
}
void Stack::push(int x){
ListNode *newNode;
newNode=new ListNode;
newNode->content=x;
newNode->pNext=top;
top=newNode;
}
int Stack::pop(){
int fR=-17; //empty stack
if(top!=nullptr){
ListNode* newNode;
newNode=top;
top=top->pNext;
fR=newNode->content;
delete newNode;
}
return fR;
}
Stack::~Stack(){
while(top!=nullptr){
pop();
}
}

Answer 1

Here is a fairly minimal implementation of an iterator class to allow viewing the contents of a Stack object.
I've also made some changes in the existing code to be more in line with modern C++ best practices. In particular, you should hardly ever be using raw new and delete directly, so I've updated the code to use std::unique_ptr instead.
stack_iterator.hpp:
#include <iterator>
#include <memory>
#pragma once
class Stack {
private:
struct ListNode {
int content;
std::unique_ptr<ListNode> pNext;
};
public:
Stack() = default;
Stack(const Stack&) = delete;
Stack(Stack&&) = delete;
Stack& operator=(const Stack&) = delete;
Stack& operator=(Stack&&) = delete;
void push(int);
int pop();
class const_iterator {
public:
using difference_type = std::ptrdiff_t;
using value_type = const int;
using pointer = const int*;
using reference = const int&;
using iterator_category = std::forward_iterator_tag;
const_iterator() = delete;
const_iterator(const const_iterator&) = default;
const_iterator& operator=(const const_iterator&) = default;
// Constructor making a const_iterator pointing to a particular
// list node.
const_iterator(ListNode*);
// Pre-increment operator, e.g. called by ++i
const_iterator& operator++();
// Post-increment operator, e.g. called by i++
const_iterator operator++(int);
// Deference operator, e.g. called by *i
reference operator*() const;
// Comparison operators
bool operator==(const const_iterator&) const;
bool operator!=(const const_iterator&) const;
private:
ListNode* pNode;
friend class Stack;
};
// Accessors to create iterators to start and end of stack.
// Note that the stack is traversed from most recent to least
// recent entries. Also note that a pop() operation will invalidate
// any iterator referring to the most recent entry of the stack.
const_iterator begin() const;
const_iterator end() const;
private:
std::unique_ptr<ListNode> top;
};
stack_iterator.cpp:
#include "stack_iterator.hpp"
void Stack::push(int x) {
auto newNode = std::make_unique<ListNode>();
newNode->content = x;
newNode->pNext = std::move(top);
top = std::move(newNode);
}
int Stack::pop() {
static constexpr int retvalOnEmpty = -17;
auto oldTop = std::move(top);
if (oldTop != nullptr) {
top = std::move(oldTop->pNext);
return oldTop->content;
}
return retvalOnEmpty;
}
// pre-increment operator
Stack::const_iterator& Stack::const_iterator::operator++() {
pNode = pNode->pNext.get();
return *this;
}
// post-increment operator
Stack::const_iterator Stack::const_iterator::operator++(int) {
auto ret_iterator = *this;
++(*this);
return ret_iterator;
}
// dereference operator
Stack::const_iterator::reference Stack::const_iterator::operator*() const {
return pNode->content;
}
// comparison operators
bool Stack::const_iterator::operator==(const Stack::const_iterator& other) const {
return this->pNode == other.pNode;
}
bool Stack::const_iterator::operator!=(const Stack::const_iterator& other) const {
return this->pNode != other.pNode;
}
// semi-private constructor making an iterator pointing to a particular ListNode
Stack::const_iterator::const_iterator(ListNode* i_node) :
pNode(i_node)
{ }
Stack::const_iterator Stack::begin() const {
return Stack::const_iterator{top.get()};
}
Stack::const_iterator Stack::end() const {
return Stack::const_iterator{nullptr};
}
Example main program showing how to use the iterators:
#include "stack_iterator.hpp"
#include <iostream>
#include <algorithm>
int main() {
Stack s;
s.push(3);
s.push(5);
s.push(-4);
std::cout << "Contents of stack: ";
for (auto n : s)
std::cout << n << ' ';
std::cout << '\n';
// Alternative
std::cout << "Contents of stack, using ostream_iterator: ";
std::copy(s.begin(), s.end(), std::ostream_iterator<int>{std::cout, " "});
std::cout << '\n';
return 0;
}

Answer 2

Two approaches using the standard library's containers:
Give up your own implementation of a stack entirely, and using the one available as part of the standard library: std::stack. To display the elements, do something like:
void print(std::ostream& os, std::stack s, char delimiter = ' ')
{
if (not s.empty()) {
std::cout << s.top();
}
while (not s.empty()) {
std::cout << delimiter << s.top();
}
}
since you're passing the stack by value, you're really making a copy of it.
Use your own stack implementation, but implement it over an std::list, and expose the list's iterators (similar to Daniel Schepler's answer but without most of the hard work...).
Of course, it's better to implement an operator<< then a print function, but the principle is the same.