Also added a makefile

Makefile

@@ -0,0 +1,12 @@
+all:
+	cc command.cpp input_resolver.cpp main.cpp -lstdc++ -std=c++17 -O3 -L./ -lCalc -o calculator 
+
+libs:
+	cc -c -fPIC basecalc.cpp Operation.cpp
+	cc -shared basecalc.o Operation.o -o libCalc.so
+
+compile:
+	cc *.cpp -O3 -c
+
+debug:
+	cc *.cpp -g -std=c++17 -o calculator -lstdc++

Operation.cpp

@@ -0,0 +1,6 @@
+#include "Operation.h"
+
+Operation::Operation(const OpType type, int a, int b):
+type{type}, a{a}, b{b}
+{
+}

Operation.h

@@ -0,0 +1,15 @@
+enum class OpType
+{
+    Addition, Subtraction, Multiplication, Division, Modulo, Special
+};
+
+class Operation
+{
+    public:
+    int a;
+    int b;
+    OpType type;
+
+    Operation(const OpType type, int a, int b = 0);
+
+};

basecalc.cpp

@@ -0,0 +1,54 @@
+#include "basecalc.h"
+
+BaseCalculator::~BaseCalculator()
+{}
+
+int BaseCalculator::calculate(const Operation& op)
+{
+    switch(op.type)
+    {
+        case OpType::Addition:
+        result = op.a + op.b;
+        break;
+
+        case OpType::Subtraction:
+        result = op.a - op.b;
+        break;
+
+        case OpType::Multiplication:
+        result = op.a * op.b;
+        break;
+
+        case OpType::Division:
+        result = op.a / op.b;
+        break;
+
+        case OpType::Modulo:
+        result += op.a % op.b;
+        break;
+
+        case OpType::Special:
+        result = special(op.a);
+        break;
+
+        default:
+        result = 0;
+    }
+    return result;
+}
+
+BaseCalculator::operator int()
+{
+    return result;
+}
+
+int BaseCalculator::negate()
+{
+    result = -result;
+    return result;
+}
+
+int BaseCalculator::special(int a)
+{
+    return a * a;
+}

basecalc.h

@@ -0,0 +1,17 @@
+#include "Operation.h"
+class BaseCalculator
+{
+    public:
+    
+    int calculate(const Operation& a);
+
+    virtual ~BaseCalculator();
+
+    explicit operator int();
+
+    virtual int negate();
+    virtual int special(int a);
+
+    private:
+    int result = 0;
+};

command.cpp

@@ -0,0 +1,27 @@
+#include "command.h"
+
+Command::Command(bool shouldTerminate, char nextChar, int nextArg, bool shouldPrint):
+m_shouldTerminate{shouldTerminate}, m_nextChar{nextChar}, m_nextArg{nextArg}, m_shouldPrint{shouldPrint}
+{
+
+}
+
+bool Command::shouldTerminate() const
+{
+    return m_shouldTerminate;
+}
+
+char Command::getNextChar()
+{
+    return m_nextChar;
+}
+
+int Command::getNextArg()
+{
+    return m_nextArg;
+}
+
+bool Command::shouldPrint() const
+{
+    return m_shouldPrint;
+}

command.h

@@ -0,0 +1,15 @@
+class Command
+{
+    public:
+    Command(bool shouldTerminate, char nextChar, int nextArg, bool shouldPrint);
+    bool shouldTerminate() const;
+    char getNextChar();
+    int getNextArg();
+    bool shouldPrint() const;
+
+    private:
+    bool m_shouldTerminate;
+    char m_nextChar;
+    int m_nextArg;
+    bool m_shouldPrint;
+};

input_resolver.cpp

@@ -0,0 +1,83 @@
+#include "input_resolver.h"
+#include <string>
+#include <iostream>
+
+#define delimiter " "
+
+struct ValidationResult
+{
+    bool ok() 
+    {
+        return isItOk;
+    }
+
+    char incorrect_token()
+    {
+        return in_t;
+    }
+
+    int next_arg()
+    {
+        return nextArg;
+    }
+
+    bool isItOk;
+    char in_t;
+    int nextArg;
+};
+
+
+ValidationResult validate_token(const std::string &token)
+{
+
+    static const std::string allowedTokens{"+-*/%$qp"};
+    char incorrectToken;
+    size_t digitpos = -1, counter = 0;
+
+    for (const char c: token)
+    {
+        if (allowedTokens.find(c) == allowedTokens.npos && !isdigit(c) && !isspace(c))
+            return {false, c};
+
+        if (digitpos == -1 && isdigit(c))
+            digitpos = counter;
+
+        counter++;
+    }
+
+    
+    if (digitpos == -1)
+        return {true, ' ', 0};
+
+    int next = stoi(token.substr(digitpos));
+    return {true, ' ', next};
+}
+
+Command resolveCommand()
+{
+    std::string st;
+    getline(std::cin, st);
+
+    std::string token = st.substr(0, st.find(delimiter)); 
+
+    auto validation_result = validate_token(token);
+    if (!validation_result.ok())
+    {
+        throw std::runtime_error{"invalid token " + validation_result.incorrect_token()};
+    }
+
+    bool shouldQuit = token.find("q") != token.npos;
+    bool shouldPrint = token.find("p") != token.npos;
+    char operation;
+
+    for (const char c: token)
+    {
+        static const std::string operators {"+-*/%"};
+        if(operators.find(c) != operators.npos)
+        {
+            operation = c;
+        }
+    }
+
+    return {shouldQuit, operation, validation_result.next_arg(), shouldPrint};
+}

input_resolver.h

@@ -0,0 +1,2 @@
+#include "command.h"
+Command resolveCommand();

main.cpp

@@ -0,0 +1,68 @@
+#include <iostream>
+#include "basecalc.h"
+#include <memory>
+#include "input_resolver.h"
+
+int main()
+{
+    auto calc = std::make_unique<BaseCalculator>();
+
+    std::cout << "Initializing calculator";
+
+    while (true)
+    {
+        std::cout << "What's your next input? (+,-,*,/,%,$,q,p)";
+        auto command = resolveCommand();
+
+        if (command.shouldTerminate())
+        {
+            break;
+        }
+
+        switch(command.getNextChar())
+        {
+            case '+':
+            {
+                calc->calculate({OpType::Addition, static_cast<int>(*calc), command.getNextArg()});
+            }
+            break;
+
+            case '-':
+            {
+                calc->calculate({OpType::Subtraction, static_cast<int>(*calc), command.getNextArg()});
+            }
+            break;
+
+            case '*':
+            {
+                calc->calculate({OpType::Multiplication, static_cast<int>(*calc), command.getNextArg()});
+            }
+            break;
+
+            case '/':
+            {
+                calc->calculate({OpType::Division, static_cast<int>(*calc), command.getNextArg()});
+            }
+            break;
+
+            case '%':
+            {
+                calc->calculate({OpType::Modulo, static_cast<int>(*calc), command.getNextArg()});
+            }
+            break;
+
+            case '$':
+            {
+                calc->calculate({OpType::Special, static_cast<int>(*calc)});
+            }
+            
+            break;
+        }
+
+        if(command.shouldPrint())
+            std::cout << "Intermediary result: " << static_cast<int>(*calc) << std::endl;
+    }
+
+    std::cout << "Final output: " << static_cast<int>(*calc) << std::endl;
+    return 0;
+}

special_calculator.h

@@ -0,0 +1,6 @@
+#include "basecalc.h"
+
+class SpecialCalculator: public BaseCalculator
+{
+    int special(int a) override;
+};