Modern C++ class based Stack Iterator

main.cpp

#include <iostream>

struct AdditionModule {
    const char * name = "ADD";

    void print() {
        std::cout << name << "\n";
    };
};

struct MinusModule {
    const char * name = "MINUS";

    void print() {
        std::cout << name << "\n";
    };
};

struct Module {
    enum { EMPTY, ADD, MINUS } tag;
    
    union {
        AdditionModule    addition;
        MinusModule       minus;
    };
    
    Module() {
        this -> tag = Module::EMPTY;
    }

    Module(AdditionModule m) {
        this -> tag      = Module::ADD;
        this -> addition = m;
    }
    
    Module(MinusModule m) {
        this -> tag   = Module::MINUS;
        this -> minus = m;
    }
    
    void
    print() {
        switch(this -> tag)
        {
            case Module::EMPTY: std::cout << "EMPTY" << "\n"; break;
            case Module::ADD:   this -> addition.print(); break;
            case Module::MINUS: this -> minus.print();    break;
        }
    }
};


struct Stack {
    struct Iter {
        Iter& operator++ () { --ptr; return *this; }
        bool  operator!= (Iter const& other) const { return ptr != other.ptr; }
        Module&  operator*() { return *ptr; }
        Module *  ptr;
    };
    Iter begin() { return Iter{&modules[ size + 1 ]}; }
    Iter end()   { return Iter{&modules[-1]}; }
    
    Stack() {
        auto m1 = AdditionModule();
        auto m2 = MinusModule();

        this -> modules[0] = m1; size++;
        this -> modules[1] = m2; size++;
    }
    
    void
    print() {
        for (auto e: modules)
            e.print();
    }

private:
    Module modules[4] = {};
    size_t size = 0;
};

int main(int argc, const char * argv[]) {
    std::cout << "Hello, Module!\n\n";

    auto S = Stack();
    
    for ( auto m: S ) {
        m.print();
    }
    
    return 0;
};