Доступ к элементу std::string через указатель

#include "WinForm.h"
 
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    cWinForm *System = new cWinForm;
 
    if(System->Initialize())
        System->Run();
    else
        return 1;
 
    delete System;
 
    return 0;
}

#ifndef _WINFORM_H_
#define _WINFORM_H_
 
#include <Windows.h>
#include "CalcInfoHandler.h"
 
#define BUTTON_0 3000
#define BUTTON_1 3001
#define BUTTON_2 3002
#define BUTTON_3 3003
#define BUTTON_4 3004
#define BUTTON_5 3005
#define BUTTON_6 3006
#define BUTTON_7 3007
#define BUTTON_8 3008
#define BUTTON_9 3009
#define BUTTON_RESULT 3010          //=
#define BUTTON_DELETESYMBOL 3011    //Удалить один символ
#define BUTTON_REMOVEALL 3012       //Удалить все
#define BUTTON_SUM 3013             //+
#define BUTTON_DIFFERENCE 3014      //-
#define BUTTON_PRODUCT 3015         //*
#define BUTTON_QUOTIENT 3016        // ""
#define BUTTON_POW 3017             //POW
#define BUTTON_POINT 3018           // ,
#define BUTTON_EXIT 3019            // Выход
#define TEXTFIELD_ELEMENT 3020      //Поле ввода/вывода
#define BUTTON_ABOUT 3021           //Справка о программе
 
class cWinForm
{
public:
 
    void Run();
    bool Initialize();
    bool InitializeWindows();
    void Shutdown();
 
    LRESULT CALLBACK MessageHandler(HWND, UINT, WPARAM, LPARAM);
 
private:
    HWND m_mainWnd;
    HWND m_buttonHandles[21];
    HWND m_textField;
    HINSTANCE m_hInstance;
    HBRUSH m_backgroundMainWnd;
 
    std::string test;
    cCalcInfoHandler *m_pInfoHandler;
};
 
static cWinForm *ApplicationHandle;
static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
 
#endif

#include "WinForm.h"
 
void cWinForm::Run()
{
    MSG msg;
    while(GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    UnregisterClass("Calculator", m_hInstance);
    DestroyWindow(m_mainWnd);
}
bool cWinForm::Initialize()
{
    m_mainWnd = NULL;
    for(short count = 0; count < 21; count++)
        m_buttonHandles[count] = NULL;
    m_textField = NULL;
    m_hInstance = NULL;
    m_backgroundMainWnd = CreateSolidBrush(RGB(219, 215, 210));
    m_pInfoHandler = new cCalcInfoHandler;
    m_pInfoHandler->ResetAllInfo();
 
    if(!InitializeWindows())
    {
        MessageBox(m_mainWnd, "Error Initialize()", "Error", MB_OK);
        return false;
    }
 
    return true;
}
bool cWinForm::InitializeWindows()
{
    ApplicationHandle = this;
    WNDCLASSEX wc;
 
    ZeroMemory(&wc, sizeof(wc));
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.cbSize = sizeof(wc);
    wc.lpszClassName = "Calculator";
    wc.lpszMenuName = NULL;
    wc.hbrBackground = m_backgroundMainWnd;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
    wc.hIconSm = wc.hIcon;
    wc.hInstance = m_hInstance;
    wc.lpfnWndProc = WndProc;
 
    if(!RegisterClassEx(&wc))
    {
        MessageBox(m_mainWnd, "Error register class", "Error", MB_OK);
        return false;
    }
 
    m_mainWnd = CreateWindowEx(NULL, "Calculator", "Калькулятор", WS_VISIBLE | WS_OVERLAPPEDWINDOW, 870, 400, 190, 360, NULL, NULL, m_hInstance, NULL);
    if(!m_mainWnd)
    {
        MessageBox(m_mainWnd, "Error create main window", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[0] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "EX", WS_VISIBLE | WS_CHILD, 10, 120, 30, 30, m_mainWnd, (HMENU)BUTTON_EXIT, m_hInstance, NULL);
    if(!m_buttonHandles[0])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_EXIT", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[1] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "CA", WS_VISIBLE | WS_CHILD, 50, 120, 30, 30, m_mainWnd, (HMENU)BUTTON_REMOVEALL, m_hInstance, NULL);
    if(!m_buttonHandles[1])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_REMOVEALL", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[2] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "C", WS_VISIBLE | WS_CHILD, 90, 120, 30, 30, m_mainWnd, (HMENU)BUTTON_DELETESYMBOL, m_hInstance, NULL);
    if(!m_buttonHandles[2])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_DELETESYMBOL", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[3] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "+", WS_VISIBLE | WS_CHILD, 130, 120, 30, 30, m_mainWnd, (HMENU)BUTTON_SUM, m_hInstance, NULL);
    if(!m_buttonHandles[3])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_SUM", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[4] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "0", WS_VISIBLE | WS_CHILD, 10, 160, 30, 30, m_mainWnd, (HMENU)BUTTON_0, m_hInstance, NULL);
    if(!m_buttonHandles[4])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_0", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[5] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "1", WS_VISIBLE | WS_CHILD, 50, 160, 30, 30, m_mainWnd, (HMENU)BUTTON_1, m_hInstance, NULL);
    if(!m_buttonHandles[5])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_1", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[6] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "2", WS_VISIBLE | WS_CHILD, 90, 160, 30, 30, m_mainWnd, (HMENU)BUTTON_2, m_hInstance, NULL);
    if(!m_buttonHandles[6])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_2", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[7] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "-", WS_VISIBLE | WS_CHILD, 130, 160, 30, 30, m_mainWnd, (HMENU)BUTTON_DIFFERENCE, m_hInstance, NULL);
    if(!m_buttonHandles[7])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_DIFFERENCE", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[8] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "3", WS_VISIBLE | WS_CHILD, 10, 200, 30, 30, m_mainWnd, (HMENU)BUTTON_3, m_hInstance, NULL);
    if(!m_buttonHandles[8])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_3", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[9] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "4", WS_VISIBLE | WS_CHILD, 50, 200, 30, 30, m_mainWnd, (HMENU)BUTTON_4, m_hInstance, NULL);
    if(!m_buttonHandles[9])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_4", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[10] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "5", WS_VISIBLE | WS_CHILD, 90, 200, 30, 30, m_mainWnd, (HMENU)BUTTON_5, m_hInstance, NULL);
    if(!m_buttonHandles[10])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_5", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[11] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "*", WS_VISIBLE | WS_CHILD, 130, 200, 30, 30, m_mainWnd, (HMENU)BUTTON_PRODUCT, m_hInstance, NULL);
    if(!m_buttonHandles[11])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_PRODUCT", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[12] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "6", WS_VISIBLE | WS_CHILD, 10, 240, 30, 30, m_mainWnd, (HMENU)BUTTON_6, m_hInstance, NULL);
    if(!m_buttonHandles[12])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_6", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[13] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "7", WS_VISIBLE | WS_CHILD, 50, 240, 30, 30, m_mainWnd, (HMENU)BUTTON_7, m_hInstance, NULL);
    if(!m_buttonHandles[13])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_7", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[14] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "8", WS_VISIBLE | WS_CHILD, 90, 240, 30, 30, m_mainWnd, (HMENU)BUTTON_8, m_hInstance, NULL);
    if(!m_buttonHandles[14])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_8", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[15] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "/", WS_VISIBLE | WS_CHILD, 130, 240, 30, 30, m_mainWnd, (HMENU)BUTTON_QUOTIENT, m_hInstance, NULL);
    if(!m_buttonHandles[15])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_QUOTIENT", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[16] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "9", WS_VISIBLE | WS_CHILD, 10, 280, 30, 30, m_mainWnd, (HMENU)BUTTON_9, m_hInstance, NULL);
    if(!m_buttonHandles[16])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_9", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[17] = CreateWindowEx(WS_EX_STATICEDGE, "Button", ".", WS_VISIBLE | WS_CHILD, 50, 280, 30, 30, m_mainWnd, (HMENU)BUTTON_POINT, m_hInstance, NULL);
    if(!m_buttonHandles[17])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_POINT", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[18] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "=", WS_VISIBLE | WS_CHILD, 90, 280, 30, 30, m_mainWnd, (HMENU)BUTTON_RESULT, m_hInstance, NULL);
    if(!m_buttonHandles[18])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_RESULT", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[19] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "P", WS_VISIBLE | WS_CHILD, 130, 280, 30, 30, m_mainWnd, (HMENU)BUTTON_POW, m_hInstance, NULL);
    if(!m_buttonHandles[19])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_POW", "Error", MB_OK);
        return false;
    }
    m_buttonHandles[20] = CreateWindowEx(WS_EX_STATICEDGE, "Button", "О программе...", WS_VISIBLE | WS_CHILD, 10, 80, 150, 30, m_mainWnd, (HMENU)BUTTON_ABOUT, m_hInstance, NULL);
    if(!m_buttonHandles[20])
    {
        MessageBox(m_mainWnd, "Error create BUTTON_ABOUT", "Error", MB_OK);
        return false;
    }
    m_textField = CreateWindowEx(WS_EX_CLIENTEDGE, "Static", "", WS_VISIBLE | WS_CHILD, 10, 10, 150, 60, m_mainWnd, (HMENU)TEXTFIELD_ELEMENT, m_hInstance, NULL);
    if(!m_textField)
    {
        MessageBox(m_mainWnd, "Error create TEXTFIELD_ELEMENT", "Error", MB_OK);
        return false;
    }
 
    ShowWindow(m_mainWnd, SW_SHOW);
    UpdateWindow(m_mainWnd);
 
    return true;
}
LRESULT CALLBACK cWinForm::MessageHandler(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch(uMsg)
    {
    case WM_COMMAND:
        switch(wParam)
        {
        case BUTTON_0:
            if(m_pInfoHandler->assert('0'))
                m_pInfoHandler->AddAction('0');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_1:
            if(m_pInfoHandler->assert('1'))
                m_pInfoHandler->AddAction('1');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_2:
            if(m_pInfoHandler->assert('2'))
                m_pInfoHandler->AddAction('2');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            return 0;
 
        case BUTTON_3:
            if(m_pInfoHandler->assert('3'))
                m_pInfoHandler->AddAction('3');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            return 0;
 
        case BUTTON_4:
            if(m_pInfoHandler->assert('4'))
                m_pInfoHandler->AddAction('4');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            return 0;
 
        case BUTTON_5:
            if(m_pInfoHandler->assert('5'))
                m_pInfoHandler->AddAction('5');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            return 0;
 
        case BUTTON_6:
            if(m_pInfoHandler->assert('6'))
                m_pInfoHandler->AddAction('6');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            return 0;
 
        case BUTTON_7:
            if(m_pInfoHandler->assert('7'))
                m_pInfoHandler->AddAction('7');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            return 0;
 
        case BUTTON_8:
            if(m_pInfoHandler->assert('8'))
                m_pInfoHandler->AddAction('8');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            return 0;
 
        case BUTTON_9:
            if(m_pInfoHandler->assert('9'))
                m_pInfoHandler->AddAction('9');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            return 0;
 
        case BUTTON_RESULT:
            if(m_pInfoHandler->assert('='))
                m_pInfoHandler->AddAction('=');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_DELETESYMBOL:
            if(m_pInfoHandler->assert('C'))
                m_pInfoHandler->AddAction('C');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_REMOVEALL:
            if(m_pInfoHandler->assert('R'))
                m_pInfoHandler->AddAction('R');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_SUM:
            if(m_pInfoHandler->assert('+'))
                m_pInfoHandler->AddAction('+');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_DIFFERENCE:
            if(m_pInfoHandler->assert('-'))
                m_pInfoHandler->AddAction('-');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_PRODUCT:
            if(m_pInfoHandler->assert('*'))
                m_pInfoHandler->AddAction('*');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_QUOTIENT:
            if(m_pInfoHandler->assert('/'))
                m_pInfoHandler->AddAction('/');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_POW:
            if(m_pInfoHandler->assert('^'))
                m_pInfoHandler->AddAction('^');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_POINT:
            if(m_pInfoHandler->assert('.'))
                m_pInfoHandler->AddAction('.');
            SetWindowText(m_textField, m_pInfoHandler->GetExpression());
            break;
 
        case BUTTON_EXIT:
            PostQuitMessage(0);
            return 0;
 
        case BUTTON_ABOUT:
            MessageBox(hwnd, "Calculator", "About", MB_OK);
            break;
        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
        }
        return 0;
 
    default:
        return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
}
void cWinForm::Shutdown()
{
    delete m_pInfoHandler;
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT umessage, WPARAM wParam, LPARAM lParam)
{
    switch(umessage)
    {
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
 
    case WM_CLOSE:
        PostQuitMessage(0);
        return 0;
 
    default:
        return ApplicationHandle->MessageHandler(hwnd, umessage, wParam, lParam);
    }
}

#ifndef _CALCINFOHANDLER_H_
#define _CALCINFOHANDLER_H_
 
#define _CRT_SECURE_NO_WARNINGS
 
#include <string>
#include <sstream>
#include <cctype>
#include <cmath>
 
enum eOperationType
{
    OT_SUM,
    OT_DIFFERENCE,
    OT_PRODUCT,
    OT_QUOTIENT,
    OT_POW,
    OT_NONE
};
class cTextHandler
{
public:
    const char* GetExpressionText();
    void AddSymbol(char);
    void AddOperation(char);
    void SetResult(std::string);
    void RemoveSymbol();
    void RemoveAll();
 
private:
    std::string str;
 
};
class cCalcInfoHandler
{
public:
    const char* GetExpression();
    void ResetAllInfo();
    bool assert(char);
    void AddAction(char);
 
private:
    long double StringToDouble(std::string);
    std::string DoubleToChar(long double);
    void FindResult();
    void SwapValue();
    void SetCalculateMode(bool);
    
 
    std::string val_1, val_2;
    std::string *currentVal;
 
    eOperationType operationType;
 
    bool val_1_IsActive, val_2_IsActive;
    bool calculateModeIsActive;
    bool floatlyModeIsActive;
 
    long double result;
 
    cTextHandler textHandler;
};
 
#endif

#include "CalcInfoHandler.h"
 
const char* cCalcInfoHandler::GetExpression()
{
    return textHandler.GetExpressionText();
}
bool cCalcInfoHandler::assert(char symbol)
{
    //Если первый элемент - ноль и вводится не точка
    if(currentVal->size() == 1 && (*currentVal)[0] == '0' && symbol != '.' && symbol != 'C' && symbol != 'R')
        return false;
 
    //Если вводится ноль
    if(symbol == '0')
    {
        //Если первый элемент операнда ноль, и вводится ноль
        if(currentVal->size() == 1 && (*currentVal)[0] == '0')
            return false;
    }
 
    //Если вводится точка
    if(symbol == '.')
    {
        //Если ввод происходит в первый элемент
        if(currentVal->empty())
            return false;
        //Если точка уже присутствует
        if(floatlyModeIsActive == true)
            return false;
    }
 
    //Если вводится операция
    if(std::ispunct(symbol) && symbol != '.' && symbol != '=')
    {
        //Если операция уже введена
        if(calculateModeIsActive == true)
            return false;
        //Если первый операнд пустой и вводится операция
        if(val_1.empty())
            return false;
    }
 
    //Если вводится число
    if(std::isdigit(symbol))
    {
        //Если вводится число во второй элемент и первый равен '0'
        if(currentVal->size() == 1 && (*currentVal)[0] == '0')
            return false;
    }
 
    //Если вводится равно
    if(symbol == '=')
    {
        if(val_1.empty() || val_2.empty() || operationType == OT_NONE)
            return false;
    }
 
    //Стереть символ
    if(symbol == 'C')
    {
        if(val_1.empty())
            return false;
    }
 
    return true;
}
void cCalcInfoHandler::AddAction(char symbol)
{
    //Цифра или точка
    if(std::isdigit(symbol) || symbol == '.')
    {
        //Если точка - установить дробную систему
        if(symbol == '.')
            floatlyModeIsActive = true;
 
        *currentVal += symbol;
        textHandler.AddSymbol(symbol);
    }
    //Операция
    else if(std::ispunct(symbol) && symbol != '=')
    {
        if(symbol == '+')
            operationType = OT_SUM;
        else if(symbol == '-')
            operationType = OT_DIFFERENCE;
        else if(symbol == '*')
            operationType = OT_PRODUCT;
        else if(symbol == '/')
            operationType = OT_QUOTIENT;
        else if(symbol == '^')
            operationType = OT_POW;
 
        if(val_1[val_1.size() - 1] == '.')
        {
            val_1.erase(val_1.end() - 1);
            textHandler.RemoveSymbol();
        }
 
        calculateModeIsActive = true;
        SwapValue();
        textHandler.AddOperation(symbol);
    }
    //Результат
    else if(symbol == '=')
    {
        if(val_2[val_2.size() - 1] == '.')
        {
            val_2.erase(val_2.end() - 1);
            textHandler.RemoveSymbol();
        }
        FindResult();
    }
    //Стереть символ
    else if(symbol == 'C')
    {
        //Если стирается точка
        if(!currentVal->empty() && (*currentVal)[currentVal->size() - 1] == '.')
        {
            currentVal->erase(currentVal->end() - 1);
            textHandler.RemoveSymbol();
            floatlyModeIsActive = false;
            return;
        }
        //Если операнд не пустой просто стереть символ
        if(!currentVal->empty())
        {
            currentVal->erase(currentVal->end() - 1);
            textHandler.RemoveSymbol();
            if(val_1.empty())
                ResetAllInfo();
            return;
        }
        //Если операнд 2 активен и он пустой
        if(val_2_IsActive == true && val_2.empty())
        {
            SwapValue();
            operationType = OT_NONE;
            calculateModeIsActive = false;
            textHandler.RemoveSymbol();
            return;
        }   
    }
    //Стереть все
    else if(symbol == 'R')
    {
        ResetAllInfo();
        textHandler.RemoveAll();
    }
}
long double cCalcInfoHandler::StringToDouble(std::string str)
{
    std::string::size_type sz;
    return std::stold(str, &sz);
 
}
std::string cCalcInfoHandler::DoubleToChar(long double input)
{
    std::stringstream ss;
    ss.precision(20);
    ss << input;
    return ss.str();
}
void cCalcInfoHandler::FindResult()
{
    if(operationType == OT_SUM)
        result = StringToDouble(val_1) + StringToDouble(val_2);
    else if(operationType == OT_DIFFERENCE)
        result = StringToDouble(val_1) - StringToDouble(val_2);
    else if(operationType == OT_PRODUCT)
        result = StringToDouble(val_1) * StringToDouble(val_2);
    else if(operationType == OT_QUOTIENT)
        result = StringToDouble(val_1) / StringToDouble(val_2);
    else if(operationType == OT_POW)
        result = std::pow(StringToDouble(val_1), static_cast<int>(StringToDouble(val_2)));
 
    val_1.erase(val_1.begin(), val_1.end());
    val_2.erase(val_2.begin(), val_2.end());
    SwapValue();
    operationType = OT_NONE;
    calculateModeIsActive = false;
    *currentVal = DoubleToChar(result);
    for(unsigned int i = 0; i < currentVal->size(); i++)
    {
        if((*currentVal)[i] == '.')
        {
            floatlyModeIsActive = true;
            break;
        }
    }
    textHandler.SetResult(DoubleToChar(result));
}
void cCalcInfoHandler::SwapValue()
{
    if(val_1_IsActive == true && val_2_IsActive == false)
    {
        currentVal = &val_2;
        val_1_IsActive = false;
        val_2_IsActive = true;
        floatlyModeIsActive = false;
    }
    else if(val_1_IsActive == false && val_2_IsActive == true)
    {
        currentVal = &val_1;
        val_1_IsActive = true;
        val_2_IsActive = false;
        floatlyModeIsActive = false;
    }
}
void cCalcInfoHandler::ResetAllInfo()
{
    val_1.erase(val_1.begin(), val_1.end());
    val_2.erase(val_2.begin(), val_2.end());
    operationType = OT_NONE;
    currentVal = &val_1;
    val_1_IsActive = true;
    val_2_IsActive = false;
    calculateModeIsActive = false;
    floatlyModeIsActive = false;
    result = 0.0;
    textHandler.RemoveAll();
}
 
const char* cTextHandler::GetExpressionText()
{
    return str.c_str();
}
void cTextHandler::AddSymbol(char symbol)
{
    str += symbol;
}
void cTextHandler::AddOperation(char symbol)
{
    str = str + '\n' + symbol + '\n';
}
void cTextHandler::SetResult(std::string result)
{
    str = result;
}
void cTextHandler::RemoveSymbol()
{
    if(str.empty())
        return;
    else if(str[str.size() - 1] == '\n' && std::ispunct(str[str.size() - 2]) && str[str.size() - 3] == '\n')
    {
        str.erase(str.end() - 1);
        str.erase(str.end() - 1);
        str.erase(str.end() - 1);
    }
    else
        str.erase(str.end() - 1);
}
void cTextHandler::RemoveAll()
{
    if(str.empty())
        return;
    str.erase(str.begin(), str.end());
}