std::stack::push(3)

✨ NAME ✨

okay so bestie, welcome to the std::stack::push(3) page from the C++ Standard Libary — yes, that's the manual name, spelling and all 💅. It's the glow-up manual page for std::stack::push, and the NAME section literally says:

std::stack::push — std::stack::push

That's it. It's the page for itself. main character energy, no cap 👑.

---

🦋 Synopsis 🦋

Two overloads, both absolute icons:

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. Periodt.

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 💖

No return value, just (none) — it's giving "I did the thing and left" 💁.

---

🦋 Complexity 🦋

Equal to the complexity of Container::push_back. Same energy, same cost, no extra drama ✨.

---

🧚 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)

---

that's the whole page, bestie 🫶 source/version/date energy: http://cppreference.com, 2024.06.10, and std::stack::push(3). bye 💖