std::stack::push(3)

NAME
std::stack::push - std::stack::push

Synopsis
   void push( const value_type& value );
   void push( value_type&& value ); (since C++11)
   Pushes the given element value to the top of the stack.
   1) Effectively calls c.push_back(value).
   2) Effectively calls c.push_back(std::move(value)).

Parameters
   value - the value of the element to push

Return value
   (none)

Complexity
   Equal to the complexity of Container::push_back.

Example
   This program implements the BrainHack DSL, when the use of std::stack is an
   idiomatic way to process paired brackets. // Run this code
 #include <array>
 #include <cstdint>
 #include <iostream>
 #include <map>
 #include <stack>
 #include <stdexcept>
 #include <string_view>
 class BrainHackInterpreter
 {
     std::map<unsigned, unsigned> open_brackets, close_brackets;
     unsigned program_pos_{0};
     std::array<std::uint8_t, 32768> data_;
     int data_pos_{0};
     void collect_brackets_positions(const std::string_view program)
     {
         std::stack<unsigned> brackets_stack;
         for (auto pos{0U}; pos != program.length(); ++pos)
         {
             const char c{program[pos]};
             if ('[' == c)
                 brackets_stack.push(pos);
             else if (']' == c)
             {
                 if (brackets_stack.empty())
                     throw std::runtime_error("brackets [] do not match!");
                 else
                 {
                     open_brackets[brackets_stack.top()] = pos;
                     close_brackets[pos] = brackets_stack.top();
                     brackets_stack.pop();
                 }
             }
         }
         if (!brackets_stack.empty())
             throw std::runtime_error("brackets [] do not match!");
     }
     void check_data_pos(int pos)
     {
         if (pos < 0 || pos >= static_cast<int>(data_.size()))
             throw std::out_of_range{"data pointer out of bound"};
     }
 public:
     BrainHackInterpreter(const std::string_view program)
     {
         collect_brackets_positions(program);
         data_.fill(0);
         for (; program_pos_ < program.length(); ++program_pos_)
             switch (program[program_pos_])
             {
                 case '<':
                     check_data_pos(--data_pos_);
                     break;
                 case '>':
                     check_data_pos(++data_pos_);
                     break;
                 case '-':
                     --data_[data_pos_];
                     break;
                 case '+':
                     ++data_[data_pos_];
                     break;
                 case '.':
                     std::cout << data_[data_pos_];
                     break;
                 case ',':
                     std::cin >> data_[data_pos_];
                     break;
                 case '[':
                     if (data_[data_pos_] == 0)
                        program_pos_ = open_brackets[program_pos_];
                     break;
                 case ']':
                     if (data_[data_pos_] != 0)
                        program_pos_ = close_brackets[program_pos_];
                     break;
             }
     }
 };
 int main()
 {
     BrainHackInterpreter
     {
         "++++++++[>++>>++>++++>++++<<<<<-]>[<+++>>+++<-]>[<+"
         "+>>>+<<-]<[>+>+<<-]>>>--------.<<+++++++++.<<----.>"
         ">>>>.<<<------.>..++.<++.+.-.>.<.>----.<--.++.>>>+."
     };
     std::cout << '\n';
 }

Output:
 Hi, cppreference!

See also
   emplace constructs element in-place at the top
   (C++11) (public member function)
   pop removes the top element
           (public member function)