Compile-Time Fixed Stack

Question

Problem: Compile-Time Fixed Stack. Solve this hands-on electronics task on EWskills.

Accepted Answer

#include 
#include 

template 
class StaticStack {
private:
    T buffer[Capacity]; // Compile-time fixed array
    int top_index;      // Index of the *current* top element

public:
    // Initialize top_index to -1 (empty state)
    StaticStack() : top_index(-1) {}

    void push(T val) {
        if (top_index >= Capacity - 1) {
            std::cout << "Stack Overflow" << std::endl;
            return;
        }
        buffer[++top_index] = val;
    }

    void pop() {
        if (top_index < 0) {
            std::cout << "Stack Underflow" << std::endl;
            return;
        }
        top_index--;
    }

    T peek() const {
        if (top_index < 0) {
            return T(); // Return default if empty (caller should check)
        }
        return buffer[top_index];
    }

    bool isEmpty() const {
        return top_index < 0;
    }
};

int main() {
    // Instantiate a stack of int with capacity 3
    StaticStack stack;

    int N;
    if (!(std::cin >> N)) return 0;

    for (int i = 0; i < N; ++i) {
        std::string cmd;
        std::cin >> cmd;

        if (cmd == "PUSH") {
            int val;
            std::cin >> val;
            stack.push(val);
        } else if (cmd == "POP") {
            stack.pop();
        } else if (cmd == "PEEK") {
            if (!stack.isEmpty()) {
                std::cout << "Top: " << stack.peek() << std::endl;
            } else {
                 std::cout << "Stack Empty" << std::endl; // Matches logic when main checks empty
            }
        } else if (cmd == "EMPTY") {
            std::cout << "Empty: " << (stack.isEmpty() ? "Yes" : "No") << std::endl;
        }
    }
    return 0;
}

Explanation & Logic Summary:

Standard C++ containers like std::stack or std::vector use the heap to grow dynamically. In strict embedded environments, we cannot assume heap availability.

Class Templates: Allow the stack to store any type (int, float, SensorData).
Non-Type Template Parameters: The int Capacity parameter allows passing a size (like 3) at compile time.
Effect: StaticStack generates a class with int buffer[3] inside it. The memory is allocated on the stack (or BSS/Data segment if global), ensuring zero fragmentation and predictable RAM usage.

Firmware Relevance & Real-World Context:

Communication Buffers: A UART driver might need a small queue for incoming bytes. RingBuffer is a standard pattern.
Menu Systems: Storing the history of nested menu screens (MenuStack) to allow the "Back" button to work.
Safety Standards (MISRA): Dynamic memory is often banned (MISRA C++ Rule 18-4-1). Templates provide the flexibility of dynamic structures with the safety of static allocation.

Code	Compiler Action	Memory Usage
`sort<int>(arr)`	Generates `sort_int(int* arr)`	Code size increases by size of function.
`sort<float>(arr)`	Generates `sort_float(float* arr)`	Code size increases again.
`sort<int>(arr2)`	Reuses existing `sort_int`	No new code generated.

Pitfall	Details
❌ Header Definitions	Template code must be implemented in the Header File (`.h`), not the Source File (`.cpp`). Why? The compiler needs to see the entire source code to generate the specific version when it compiles `main.cpp`. If it's hidden in `impl.cpp`, you get Linker Errors.
❌ Cryptic Error Messages	If you make a typo in a template, the compiler vomits 100 lines of error garbage. Tip: Always scroll to the very top error message; it usually points to the actual line. Ignore the "instantiated from here" chain below it.
❌ Bloat via Permutation	Be careful with integer parameters. `Delay<10>()` and `Delay<11>()` create TWO separate functions. If you use `Delay<N>` with 100 different numbers, you generate 100 functions. Use function arguments (`delay(int n)`) for values that change often.
✅ `typename` vs `class`	`template <typename T>` and `template <class T>` are identical. `typename` is preferred in modern C++ because `T` can be an `int`, which isn't technically a "class".

171. Compile-Time Fixed Stack

Syntax & Usage

How It Works (Template Instantiation)

Specialized Templates (Template Specialization)

Relevance in Embedded/Firmware

The "Code Bloat" Myth vs Reality

Common Pitfalls & Best Practices