pasta dla debili

#include <iostream>
#include <cassert>
#include <cstring>
#include <cmath>
#define ILOSC_SYMBOLI 5
using namespace std;


/*
  Definicja typu wyliczeniowego "Symbol" dla symboli a, b, c, d, e.
                   e a b c d

                e  e,a,b,c,d
                a  a,d,e,b,c
                b  b,e,c,d,a
                c  c,b,d,a,e
                d  d,c,a,e,b

*/
enum Symbol{ e,a,b,c,d };
Symbol TabliczkaDzialania[5][5] = {{ e,a,b,c,d },{a,d,e,b,c },{ b,e,c,d,a },{ c,b,d,a,e },{ d,c,a,e,b }};

Symbol TabliczkaMnozenia[5][5] = {{ e,e,e,e,e},{ e,a,b,c,d },{ e,b,a,d,c},{ e,c,d,b,a },{ e,d,c,a,b }};

/* struktura do statystyk */
struct statTestu
{
  int ilowszyswyraz = 0;
  int poprawnyzapis = 0;
  int poprawnywynik = 0;
  float procentpoprawnych = 0;
  int dododej = 0;
  int mnodziel = 0;
};
/* Struktura ze zmiennymi przydatnymi w funkcjach */
struct stalewyrazenia
{
  Symbol Arg1;
  Symbol Arg2;
  char znak;
  bool wczytanewyr;
  Symbol wprowadzonywynik;
  Symbol wynik;
  char tmp;
};





/*
  Definicja funkcji: Dodaj, PrzeciwnyDodawania, Odejmij, Mnoz, OdwrotnyMnozenia, Dziel.
*/
Symbol Dodaj(Symbol y, Symbol x)
{
  return TabliczkaDzialania[y][x];
}
Symbol operator + ( Symbol y, Symbol x)
{
  return TabliczkaDzialania[y][x];
}


Symbol operator - (Symbol Arg1)
{
  int ind=0;
  Symbol tabSymboli[]={e,a,b,c,d};
 Symbol tmpSymbol=tabSymboli[0];
 for(ind=0 ; ind<ILOSC_SYMBOLI ; ++ind, tmpSymbol=tabSymboli[ind])
   {
     if(Arg1+tmpSymbol==e)
       return tmpSymbol;

   }
 assert(0);
 return e;
 }
Symbol operator - (Symbol Arg1 , Symbol Arg2)
{
  return Arg1+(-Arg2);
}
/*
  Definicja przeciążeń operatorów
*/
Symbol operator * (Symbol Arg1 , Symbol Arg2) /*przeciazenie operatora * */
 {
   return TabliczkaMnozenia[Arg1][Arg2];
    }

Symbol  OdwrotnyMnozenia (Symbol Arg1) /* funkcja odwrócenia argumentu */
{
  int ind=0;
  Symbol tabSymboli[]={e,a,b,c,d};
  Symbol tmpSymbol=tabSymboli[0];
  for(ind=0 ; ind<ILOSC_SYMBOLI ; ++ind, tmpSymbol=tabSymboli[ind])
    {
     if(Arg1*tmpSymbol==a)
       return tmpSymbol;
    }

  return a;
}

Symbol operator / (Symbol Arg1 , Symbol Arg2)

{

    return  TabliczkaMnozenia[Arg1][OdwrotnyMnozenia(Arg2)] ;


    }




Symbol operator ^ (Symbol Arg1 , Symbol Arg2)
{
  return Arg2*Arg1*Arg1*Arg2+Arg2/Arg1-Arg1;
}



/* Inkrementacje statystyk */


void iloscwyrazen (statTestu &struc)
{
  (struc.ilowszyswyraz)++;
}

void popzap (statTestu &struc)

{
  (struc.poprawnyzapis)++;
}

void popwyn (statTestu &struc)
{
  (struc.poprawnywynik)++;
}
void dodajodejmij (statTestu &struc)
{
  (struc.dododej)++;
}

void mnozeniedzielenie (statTestu &struc)
{
  (struc.mnodziel)++;
}

void WyswietlStaty(statTestu struc) /* funkcja odpowiedzialna za wyswietlanie statystyk */
{
  cout<< "Podsumowanie" <<endl;
  cout<<"                               Ilosc wszystkich wyrazen: " << struc.ilowszyswyraz <<endl;
  cout<<"Ilosc poprawnie zapisanych wyrazen pod wzgledem skladni: "<<struc.poprawnyzapis<<endl;
  cout<<"           Ilosc wyrazen z poprawnie zapisanym wynikiem: "<<struc.poprawnywynik<<endl;
  struc.procentpoprawnych=(struc.poprawnywynik/struc.ilowszyswyraz)*100;
  cout<<"                             Procent poprawnych wynikow: "<<struc.procentpoprawnych<<"%"<<endl;
  cout<<"                  Ilosc operacji dodawania i odjmowania: "<<struc.dododej<<endl;
  cout<<"                    Ilosc operacji mnozenia i dzielenia: "<<struc.mnodziel<<endl;
}


bool WczytajSymbol(Symbol &Arg)
{
  Symbol tabSymboli[]={e,a,b,c,d};
  char* ptrSymbol;
  char* tabZnakow = "eabcd";
  char tmpZnak = 'x';
  cin>> tmpZnak;
  ptrSymbol =  strchr(tabZnakow,tmpZnak);
  if(ptrSymbol==nullptr)
    return false;
Arg=tabSymboli[ptrSymbol-tabZnakow];
}
void WypiszSymbol(Symbol Arg)
{
  char* tabZnakow = "eabcd";
  cout << tabZnakow[Arg];

}
ostream & operator<<(ostream&wyj, Symbol Arg)
{
  char* tabZnakow = "eabcd";
  wyj << tabZnakow[Arg];
  return wyj;

}

istream & operator>>(istream &wej, Symbol & Arg)
{
  Symbol tabSymboli[]={e,a,b,c,d};
  char* ptrSymbol;
  char* tabZnakow = "eabcd";
  char tmpZnak = 'x';
  wej>> tmpZnak;
  if(ptrSymbol=strchr(tabZnakow,tmpZnak))
  {
 Arg=tabSymboli[ptrSymbol-tabZnakow];
  }
  else
    {
      wej.unget();
      wej.setstate(ios::failbit);
    }
    return wej;
    }

istream & operator>>(istream &wej, stalewyrazenia & Arg)
{

      Arg.wczytanewyr = false;
      wej>>Arg.Arg1;              /* Wczytujemy pierwszy argument z wejscia */
      if(cin.fail())                     /* Sprawdzamy czy pierwszy argument jest poprawny */
    {
      cout<<"Blad skladni wyrazenia.  Niepoprawny pierwszy argument. "<<endl;   /* wyswietlamy blad jezeli, pierwszy argument nie znajduje sie w tablicy {e,a,b,c,d} */
      cin.clear();
      return wej;
    }
  wej>>Arg.tmp;
  if(strchr( "+-*/",Arg.tmp)==nullptr)

    {
    cout<<"Blad skladni wyrazenia. Niedozwolony znak operatora."<<endl;
    cin.clear();
    return wej;
    }
  wej>>Arg.Arg2;
  if(cin.fail())                     /* Sprawdzamy czy drugi argument jest poprawny */
    {
      cout<<"Blad skladni wyrazenia. Niepoprawny drugi argument."<<endl;    /* wyswietlamy blad jezeli, drugi argument nie znajduje sie w tablicy {e,a,b,c,d} */
      cin.clear();
      return wej;
    }
      wej>>Arg.znak;
      if(Arg.znak!= '=')
	{
	  cout<<"Blad skladni wyrazenia. Brak znaku '='."<<endl;
	  cin.clear();
          return wej;
	}
      wej>>Arg.wprowadzonywynik;
      if(cin.fail())
	{
	  cout<<"Wprowadzony wynik jest nie poprawny."<<endl;

      cin.clear();
      return wej;
	}
        Arg.wczytanewyr = true;
      return wej;

}
ostream & operator<<(ostream&wyj, stalewyrazenia & Arg)
{
  cout<<"Odczytano wyrazenie: "<<Arg.Arg1<<Arg.tmp<<Arg.Arg2<<"="<<Arg.wprowadzonywynik<<"    " <<endl;
}

bool InterpretujOperacje(stalewyrazenia Arg, statTestu &struc)
{
  switch(Arg.tmp)
    {
    case '+' :
	dodajodejmij(struc);
	Arg.wynik=Arg.Arg1+Arg.Arg2;
      if(Arg.wprowadzonywynik!=Arg.wynik)
	cerr<<"Wynik niepoprawny. Wlasciwy wynik to: "<<Arg.wynik<<endl;
      else
	{
	popwyn(struc);
       cout<<"Wynik Poprawny"<<endl;
	}
       break;
    case '-' :
	dodajodejmij(struc);
	 Arg.wynik=Arg.Arg1-Arg.Arg2;
      if(Arg.wprowadzonywynik!=Arg.wynik)
		cerr<<"Wynik niepoprawny. Wlasciwy wynik to: "<<Arg.wynik<<endl;
      else
	{
	popwyn(struc);
	cout<<"Wynik Poprawny"<<endl;
	}
	break;
    case '*' :
     	mnozeniedzielenie(struc);
	Arg.wynik=Arg.Arg1*Arg.Arg2;
      if(Arg.wprowadzonywynik!=Arg.wynik)
		cerr<<"Wynik niepoprawny. Wlasciwy wynik to: "<<Arg.wynik<<endl;
      else
	{
	popwyn(struc);
      cout<<"Wynik Poprawny"<<endl;
    }
      break;
    case '/' :
         mnozeniedzielenie(struc);
	 Arg.wynik=Arg.Arg1/Arg.Arg2;
      if(Arg.wprowadzonywynik!=Arg.wynik)
		cerr<<"Wynik niepoprawny. Wlasciwy wynik to: "<<Arg.wynik<<endl;
       else
	 {
	 popwyn(struc);
	 cout<<"Wynik Poprawny"<<endl;
	 }
	 break;
    }
}
int main()
{

      stalewyrazenia wArg1;
      statTestu statys;
      int i;
      for(i=0;i<9;i++)
	{
      cin>>wArg1;
      iloscwyrazen(statys);
      InterpretujOperacje(wArg1,statys);
      if(wArg1.wczytanewyr)
	{
	  cout<<wArg1;
	  popzap(statys);
	}
	}
      WyswietlStaty(statys);
      return 0;

}