ООП - не получается разобраться в задании

#include <iostream>
#include <cstdlib>
#include <cmath>
 
template< typename T >
class Processor {
public:
    typedef enum { NONE, ADD, SUB, MUL, DIV } state_type;
public:
    Processor() : state(NONE), left_result(T()), right_(T()) {}
    ~Processor() {}
 
    void resetState()
    {
        state = NONE;
    }
 
    void operate()
    {
        switch (state)
        {
        case ADD:
            left_result += right_;
            break;
        case SUB:
            left_result -= right_;
            break;
        case MUL:
            left_result *= right_;
            break;
        case DIV:
            if (right_)
                left_result /= right_;
            break;
        default:
            break;
        }
    }
 
    void calculate(T (*func)(T))
    {
        left_result = func(right_);
    }
 
    state_type operation() const
    {
        return state;
    }
 
    void setOperation (state_type st)
    {
        state = st;
    }
 
    T result() const
    {
        return left_result;
    }
 
    void setLeft(const T& val)
    {
        left_result = val;
    }
 
    T right() const
    {
        return right_;
    }
 
    void setRight(const T& val)
    {
        right_ = val;
    }
 
    void reset()
    {
        state       = NONE;
        left_result = T();
        right_      = T();
    }
private:
    state_type state;
    T          left_result;
    T          right_;
};
 
 
int main()
{
    typedef Processor<float> FPCPU;
    FPCPU proc;
    proc.setRight(4.0f);
    proc.setLeft(12.0f);
    proc.setOperation(FPCPU::ADD);
    proc.operate();
    std::cout << ">>> " << proc.result() << '\n';
    proc.setOperation(FPCPU::SUB);
    proc.operate();
    std::cout << ">>> " << proc.result() << '\n';
    proc.setOperation(FPCPU::MUL);
    proc.operate();
    std::cout << ">>> " << proc.result() << '\n';
    proc.setOperation(FPCPU::DIV);
    proc.operate();
    std::cout << ">>> " << proc.result() << '\n';
    proc.calculate(std::sqrt);
    std::cout << ">>> " << proc.result() << '\n';
    std::system("pause");
    return 0;
}

#include <vcl.h>
#ifndef EDITOR_ERROR_H
#define EDITOR_ERROR_H
class TEditor
{   String Line;
   bool fraction;
   static const String NullChar;
   static const String Comma;
   String GetLineStr();
   void SetLineStr(String a);
   bool GetFract();
   void SetFract(bool a);
   String Change(String str);
   public:
      TEditor();
      ~TEditor();
      bool NullNumber();
      String AddSign();
      String AddComma();
      String AddPNum(int a);
      String AddNull();
      String BaskSpace();
      String Clear();
      String Edit(int a);
      String Display();
      String AddSpace(String str);
      String DelSpace(String str); 
      __property String PLine = {read = GetLineStr, write = SetLineStr};
      __property bool PFract = {read = GetFract, write = SetFract};
};#endif //EDITOR_ERROR_H

#include <UEditor.h>
//---------------------------------------------------------------------------
const String TEditor::NullChar = "0,";
const String TEditor::Comma = ",";
//---------------------------------------------------------------------------
TEditor::TEditor()
{   Line =  NullChar;
   fraction = false;};
//---------------------------------------------------------------------------
TEditor::~TEditor(){};
//---------------------------------------------------------------------------
bool TEditor::NullNumber()
{   if (PLine == NullChar)
   {      return true;   }
   else
   {      return false;   };};
//---------------------------------------------------------------------------
String TEditor::AddSign()
{   if (NullNumber())
   {      return PLine;   };
   String Result;
   Result = PLine;
   if (Result[1]=='-')
   {      Result.Delete(1,1);
      PLine = Result;   }
   else
   {       Result.Insert("-",1);
       PLine = Result;   };
   return PLine;};
//---------------------------------------------------------------------------
String TEditor::AddPNum(int a)
{   switch (a)
   {   case 1: case 2:case 3: case 4: case 5: case 6: case 7: case 8:  case 9:
         PLine = Change(IntToStr(a));  break;
      case 10:    PLine = Change("A");     break;
      case 11:    PLine = Change("B");      break;
      case 12:   PLine = Change("C");     break;
      case 13:     PLine = Change("D");     break;
      case 14:     PLine = Change("E");      break;
      case 15:      PLine = Change("F");      break;
      default: ShowMessage("Передан неверный числовой код "+IntToStr(a) +". Строка не изменилась");  break;
   };   return PLine;};
//---------------------------------------------------------------------------
String TEditor::AddNull()
{   if ( !NullNumber() || (fraction == true)  )
   {      PLine = Change("0");   }
   return PLine;};
//---------------------------------------------------------------------------
String TEditor::AddComma()
{   //знак разделителя заведомо входит в строку.
   PFract = true;
   return PLine;};
//---------------------------------------------------------------------------
String TEditor::BaskSpace()
{    int len;
    String Result;
    Result = PLine;
    len = Result.Length(); //здесь длина строки, включяя пробелы
    //если число представляет собой начальное значение "0,", ничего не делаем
    //пробелы удалять не нужно - их нет
    if (Result == NullChar)
    {       return PLine;    };
    //если сейчас записано дробное число /и последний символ - разделитель,
    //то при нажатии BaskSpace необходимо, чтобы число стало целым, но разделитель остался.
    //пробелы удалять не нужно - строковое представление не меняется
    //при этом, если до этого дробное число было "-0,", то целое должно стать "0," без знака.
    if ((Result[len] == ',') && (PFract))
    {       PFract = false;     //показали, что число теперь имеет только целую часть
       if (Result == "-0,")
       {          Result = "0,";
          PLine = Result;       };
       return PLine;       //строковое представление осталось прежним    };
    //если число дробное, то его строковое представление заканчивается цифрой. Удалим её и проверим на
     // "-0,"пробелы удалять не нужно - в дробной части их нет
    if (PFract)
    {    Result.Delete(len,1);
       PLine = Result;
       return Result;   };
   //если число целое, нужно удалить предыдущий символ перед разделителем и в случае, если это была
    //последняя цифра, установить "0,". пробелы удалим, потом вновь добавим.
    //кроме того, "-5," должно преврытиться в "0,"
    Result = DelSpace(Result); //удалили пробелы
    len = Result.Length();
    if (!PFract)
    {       Result.Delete(len-1,1); //удалили число перед разделителем
       if (Result.Length() == 1)   //осталось ","
       {          Result = NullChar;       }
       else
       {          Result = AddSpace(Result);       };
       PLine = Result;
       return Result;    };
    ShowMessage("Функция BaskSpace: возникла непредвиденная ситуация. Символ не может быть удалён.");
    return PLine;};
//---------------------------------------------------------------------------
String TEditor::Clear()
{   PLine = NullChar;
   PFract = false;
   return PLine;};
//---------------------------------------------------------------------------
String TEditor::GetLineStr()
{   return Line;};
//--------------------------------------------------------------------------
void TEditor::SetLineStr(String a)
{   int i;
   int len;
   int com_count;
   String Result;
   Result = DelSpace(a);
   len = Result.Length();
   //1. В строке должны быть минимум два символа.
   if (len<2)
   {      ShowMessage("Строка должна содержать хотя бы одну цифру и знак-разделитель.");
      return;   };
   //2. Если первая - запятая, число задано неверно.
   if (Result[1] == ',')
   {      ShowMessage("Строка задана некорректно. Возможно, пропущена первая цифра.");
      return;   };
   //3. Проверим, нет ли лишних нулей в начале.
   //Если первый минус, то второй может быть нулём, только если  число дробное и третий знак - запятая.
   if (Result[1]=='-')
   {      //если первый минус, то в строке д.быть минимум 3 символа "-x,"
      if(len<3)
      {         ShowMessage("Строка должна содержать хотя бы одну цифру и знак-разделитель.");
         return;      };
      //если второй '0' и третий не ',' - ошибка.
      if ((Result[2] == '0') && (Result[3] != ','))
      {         ShowMessage("Строка задана некорректно. Возможно, пропущена первая цифра.");
         return;      };
      //кроме того, комбинация "-0," допустима, только если число дробное
      //на данный момент известно, что если второй '0', то третий точно ','
      if ((Result[2] == '0') && (len<4))
      {             if (!fraction) //если число целое, обнулим строку
         {            Result = NullChar;         }; //если дробное, оставим "-0," без изменений
         Line =  Result;         return;      };
   }
   else
   //проверим лишние нули в начале для положительных.
   {      //если первый '0' и второй не ',' - ошибка.
      if ((Result[1] == '0') && (Result[2]) != ',')
      {         ShowMessage("Строка задана некорректно. Возможно, пропущена первая цифра.");
         return;      };
    }; //end проверка лишних нулей
   //4. Проверим строку на число разделителей и лишние -.
   com_count = 0; //подсчёт числа разделителей в строке
   for (i=1; i<=len; i++)
   {      //если найдём минус и он не первый
      if ((Result[i]=='-') && (i>1))
      {         ShowMessage("Заданная строка содержит более одного знака '-'. Строка не записана.");
         return;      };
      //если разделитель встречается больше 1 раза
      if (Result[i]==',')
      {com_count+=1;};
      if (com_count > 1)
      {         ShowMessage("Заданная строка содержит более одного разделителя. Строка не записана.");
         return;      };
      //проверим тек. символ на принадлежность допустимым числам в с/с
      if ((Result[i] != ',') && (Result[i]) != '-')
      {         switch(Result[i])
         { case '0': case '1': case '2': case '3':  case '4':  case '5':  case '6': case '7': case '8': case '9': case 'A':
            case 'B':  case 'C':  case 'D':case 'E':    case 'F':          break;
            default:
               ShowMessage("Строка содержит недопустимый символ.\r\nДопускаются знак '-', разделитель ',', цифры 1..9 и буквы A..F");        return;
         }; //end switch
      };//end if - проверка на принадлежность символа данным с/с
   };//end for
   //если ни разу не встретился разделитель
   if (com_count == 0)
   {      ShowMessage("Строка должна содержать хотя бы одну цифру и знак-разделитель.");
      return;   };
   //5. Итак, в строке присутсвует 1 разделитель, она содержит только допустимые символы, нет лишних 
   //нолей впереди. определим, целое число или дробное. если последний символ строки - не разделитель, 
  //значит, она задаёт дробное число.
//Есть дробное число 5,5 , сделали BackSpace, получилось 5, - но оно должно остаться дробным
   //при добавлении 6 получится 5,6 - но не 56. поэтому однозначно можно сказать, дробное число или нет,
   //только если последний знак  - не , если последний знак , - число может быть и целым, и дробным
   //в этом случае оставляем старое значение fraction ,оно изменится, если нажать , или ещё раз backspace
   if (Result[len] != ',')
   {      PFract = true;   };
   a=AddSpace(Result);
   Line = a;};
//---------------------------------------------------------------------------
String TEditor::Edit(int a)
{   String Result;
   switch(a)
   {      case 0:    Result = AddNull();   break;
      case 1:   case 2: case 3:case 4:case 5: case 6:  case 7: case 8:case 9: case 10: case 11: case 12:  case 13:
      case 14:   case 15:   Result = AddPNum(a);  break;
      case 20:    //+/-
         Result = AddSign();   break;
      case 21:    //,
         Result = AddComma();    break;
      case 22:    //BaskSpace
         Result = BaskSpace();    break;
      case 23:    //CE
         Result = Clear();   break;
      default:     ShowMessage("Задана некорректная команда.");
         Result = PLine;      break;  };
   return Result;};
//---------------------------------------------------------------------------
String TEditor::Change(String str)
{   String Result;
   int len;
   Result = PLine;
   //если число 0, уберём 0 и введём первую цифру
   if ((Result == NullChar) && (PFract == false))
   {       Result = str + Comma;
       Result = DelSpace(Result);
       Result = AddSpace(Result);
       return Result;   };
   //если число не 0 и целое
   if (!fraction)
   {       //удалим последнюю запятую
       len = Result.Length();
       Result.Delete(len,1);
       Result = Result + str + Comma; //добавим цифру и вернём запятую
       Result = DelSpace(Result);
       Result = AddSpace(Result);
       return Result;   };
   //если число дробное, просто добавим цифру в конец строки
   if (fraction)
   {      Result = Result + str;
      Result = DelSpace(Result);
      Result = AddSpace(Result);
      return Result;   };
 
   ShowMessage("Функция Change(): возникла непредвиденная ситуация. Строка не изменена.");
   return PLine;};
//---------------------------------------------------------------------------
String TEditor::AddSpace(String str)
{   int i;
   int pos; //позиция разделителя
   int len;
   String Result;
   len = str.Length(); //посчитали длину строки
   for(i=1;i<=len;i++)
   {      if (str[i] == ',' ) //нашли позицию разделителя
      {    pos = i;
         break;     };   };
   //поставим пробелы в целой части числа
   for (i=pos-3;i>1;i=i-3)
   {      if (str[pos-3-1] != '-')
      {str.Insert(" ",i);};   };
   return str;};
//---------------------------------------------------------------------------
String TEditor::DelSpace(String str)
{   int i;
   int len;
   len = str.Length();
   for (i=1;i<=len;i++)
   {      if (str[i] == ' ')
      {         str.Delete(i,1);
         len = str.Length();      };   };
      return str;};
//---------------------------------------------------------------------------
bool TEditor::GetFract()
{   return fraction;};
//---------------------------------------------------------------------------
void TEditor::SetFract(bool a)
{   fraction = a;};
//---------------------------------------------------------------------------
String TEditor::Display()
{   String Result;
   Result = PLine+"\r\n\Дробь "+BoolToStr(PFract);
   return Result; };

//выполнить команду калькулятора
String TCtrl::CltrOprtnRun(int a, String* MState, String* Error)
{   String Result;
   try
   {      if (PCState == cError)
      {         if ((a != 23) && (a != 50))
         return "Err";      };
      if (Error)
      {         *Error = "";      };
      switch (a)
      {  case 0:case 1: case 2: case 3: case 4: case 5: case 6: case 7:case 8:case 9: case 10: case 11:  case 12:
         case 13:  case 14:   case 15:
         case 20:   // +/-
         case 21:   // ,
         case 22:   // BaskSpace
         case 23:   // CE
            Result = EditorOprtnRun(a, & *Error);           break;
         case 30: // =  !!!!!!!
            Result = GetResult(a, & *Error);           break;
         case 31: // /  9+-=   9-=
         case 32: // *
         case 33: // -
         case 34: // +
            Result = OprtnRun(a, &  *Error);            break;
         case 35:  // sqr
         case 36:  // 1/x
            Result = FunRun(a, &  *Error);            break;
         case 40:  //M+ прибавить к содержимому памяти
         case 41:  //MC очистить память
         case 42:  //MR получить содержимое памяти
         case 43:  //MS записать число в память
            Result = MemoryOprtnRun(a,& *MState);            break;
         case 50: //C
            Result = GetStartCtrlState(a, &  *Error);            break;
         default:
            if (Error)
            {               *Error = "Недопустимая команда";            };
            PCState = cError;            return 0;
      };//end switch
   }//end try
   catch(...)
   {      if (Proc.PError != "")
      {         if (Error)         {            *Error = Proc.PError;         };
         PCState = cError;         return 0;
      }
      else
      {         if (Error)
         {            *Error = "Команда не выполнена";         };
         PCState = cError;         return 0;      };
   }; //end catch
   if (MState)
   {      *MState = Memory.PMState;   };
   //уберём лишние 0 вконце дробного числа
   int len;
   if (PCState != cEditing) //если строка не в состоянии редактирования
   {      String line = Editor.PLine;
      len = line.Length();
      if (line[len] == '0')
      {         while(line[len] == '0')
        {            line.Delete(len,1);
            len = line.Length();        };      };
      //убрали все крайние нули в дробной части
      //если теперь строка заканчивается , - число стало целым
      if(line[len] == ',')
      {         Editor.PFract = false;      };
      Editor.PLine = line;
   };//end if (PCState != cEditing)
   len = Editor.PLine.Length();
   if (len>29)
   {      PCState = cError;      return "Превышена длина строки";   }
   return Editor.PLine;};