プログラマ専用SNS ミクプラ

コード:

#include <iostream>
#include <stdexcept>

typedef struct Node
{
    char data;
    struct Node *next;
} Node;

typedef struct
{
    Node *head;
    Node *crnt;
} List;

typedef struct
{
    int max;
    int num;
    List stk;
} Stack;

class ListManager
{
public:
    static List Create()
    {
        return { nullptr, nullptr };
    }

    static void Add(List& l, char c)
    {
        if (l.head == nullptr)
        {
            l.head = l.crnt = CreateNode(c, nullptr);
        }
        else
        {
            l.crnt = l.crnt->next = CreateNode(c, nullptr);
        }
    }

    static void RemoveAt(List& l, int index)
    {
        if (index < 0)
        {
            throw std::out_of_range("index is out of range");
        }
        else if (index == 0)
        {
            if (l.head == nullptr)
            {
                throw std::out_of_range("index is out of range");
            }
            auto* temp = l.head;
            l.head = l.head->next;
            delete temp;
        }
        else
        {
            auto* node = NodeIndexOf(l, index - 1);
            if (node == nullptr || node->next == nullptr)
            {
                throw std::out_of_range("index is out of range");
            }
            auto* temp = node->next;
            node->next = node->next->next;
            delete temp;
        }
    }

    static char IndexOf(List& l, int index)
    {
        auto* node = NodeIndexOf(l, index);
        if (node == nullptr)
        {
            throw std::out_of_range("index is out of range");
        }
        return node->data;
    }

    static void Destroy(List& l)
    {
        Destroy(l.head);
    }

private:
    static Node* CreateNode(char c, Node* next)
    {
        return new Node { c, next };
    }

    static Node* NodeIndexOf(List& l, int index)
    {
        if (l.head == nullptr)
        {
            return nullptr;
        }
        auto* node = l.head;
        for (int i = 0; i < index && node != nullptr; ++i)
        {
            node = node->next;
        }
        return node;
    }

    static void Destroy(Node* n)
    {
        if (n != nullptr)
        {
            Destroy(n->next);
            delete n;
        }
    }
};

class StackManager
{
public:
    static Stack Create(int max)
    {
        if (max < 0)
        {
            throw std::out_of_range("max must not be negative");
        }
        return Stack { max, 0, ListManager::Create() };
    }

    static void Push(Stack& s, char c)
    {
        if (s.num < s.max)
        {
            ListManager::Add(s.stk, c);
            s.num++;
        }
        else
        {
            throw std::runtime_error("stack is full");
        }
    }

    static char Pop(Stack& s)
    {
        if (s.num == 0)
        {
            throw std::runtime_error("stack is empty");
        }
        else
        {
            auto c = ListManager::IndexOf(s.stk, s.num - 1);
            ListManager::RemoveAt(s.stk, s.num - 1);
            s.num--;
            return c;
        }
    }

    static void Destroy(Stack& s)
    {
        ListManager::Destroy(s.stk);
    }
};

Stack& operator %(Stack& s, char c)
{
    StackManager::Push(s, c);
    return s;
}

char operator *(Stack& s)
{
    return StackManager::Pop(s);
}

int main()
{
    auto stk = StackManager::Create(3);
    for (int i = 0; i < 3; ++i)
    {
        stk % i;
    }
    for (int i = 0; i < 2; ++i)
    {
        std::cout << (int)*stk << std::endl;
    }
    StackManager::Destroy(stk);
}