Symbole2

#include <iostream>
#include <cassert>
#include <stdio.h>
#include <cstring>

using namespace std;
const int WLK=5;        //ilosc elementow zbioru typu Symbol

/***********************************************************************/
/* bc - bład czytania znaku (niepoprawny)                              */
/* bw - bład wyswietlania symbolu                                      */
/* z  - inny, nie zdefiniowany bład                                    */
/***********************************************************************/
enum Symbol {e, a, b, c, d, jablko, bc=10, bw=11, z=100};



struct WyrAlg{                             //elementy wyrazenia algebr.
  Symbol Arg1, Arg2, Wynik;
  char Op;
};

struct Staty{                              //liczniki statystyk
  int CalkowitaLiczbaWyrazen;
  int PoprawneWyniki;
  int BlednaSkladnia;
  int NiepoprawnyWynik;
};

/************************************************************************/
/* InicjujStaty - inicjuje elementy statystyki zerami                   */
/* PRE:    brak                                                         */
/* POST:   wszystkie elementy "stat" mają wartośc zero                  */
/************************************************************************/
void InicjujStaty (Staty &stat)
{
  stat.CalkowitaLiczbaWyrazen=0;
  stat.PoprawneWyniki=0;
  stat.BlednaSkladnia=0;
  stat.NiepoprawnyWynik=0;
}

/************************************************************************/
/* Dodaj - dodawanie symboli                                            */
/* PRE:    brak                                                         */
/* POST:   Funkcja zwraca sume dwoch argumentow na podstawie tabliczki  */
/************************************************************************/
Symbol Dodaj (Symbol Arg1, Symbol Arg2)
{
  Symbol TabDod[WLK][WLK]={{e,a,b,c,d},        //arytmetyka dodawania symboli
               {a,d,e,b,c},
               {b,e,c,d,a},
               {c,b,d,a,e},
               {d,c,a,e,b}};
  return TabDod [Arg1][Arg2];
}

/************************************************************************/
/* Pierwiastkowanie - pierwiastowanie symbolu                           */
/* PRE:    brak                                                         */
/* POST:   Funkcja zwraca pierwiastek argumentu na podstawie tabliczki  */
/************************************************************************/
Symbol Pierwiastkowanie (Symbol x)
{
  Symbol TabPierw[WLK]={e,a,c,d,b};           //arytmetyka pierwiastkowania

  return TabPierw[x];
}

/************************************************************************/
/* PrzeciwnyDodawania - zwraca symbol przeciwny                         */
/* PRE:    brak                                                         */
/* POST:   Funkcja zwraca symbol przeciwny lub komunikat o bledzie      */
/************************************************************************/
Symbol PrzeciwnyDodawania (Symbol Arg1)
{
  for (int i=0;i!=WLK;i++)
    if (TabDod[Arg1][i]==e) return TabDod[0][i];
  assert(!"Blad: Nie znaleziono elementu przeciwnego! Cos jest nie tak!");
  return z;
}

/************************************************************************/
/* Odejmij - odejmowanie symboli                                        */
/* PRE:    brak                                                         */
/* POST:   Funkcja zwraca roznice dwoch argumentow                      */
/************************************************************************/
Symbol Odejmij (Symbol Arg1, Symbol Arg2)
{
  return Dodaj (Arg1,PrzeciwnyDodawania(Arg2));
}

/*************************************************************************/
/* Mnozenie - mnozenie symboli                                           */
/* PRE:    brak                                                          */
/* POST:   Funkcja zwraca iloczyn dwoch argumentow na podstawie tabliczki*/
/*************************************************************************/
Symbol Mnozenie (Symbol Arg1, Symbol Arg2)
{
  Symbol TabMnoz[WLK][WLK] = {{e,e,e,e,e},   //arytmetyka mnozenia symboli
                  {e,a,b,c,d},
                  {e,b,a,d,c},
                  {e,c,d,b,a},
                  {e,d,c,a,b}};
  return TabMnoz [Arg1][Arg2];
}

/************************************************************************/
/* OdwrotnyMnozenia - zwraca symbol odwrotny                            */
/* PRE:    brak                                                         */
/* POST:   Funkcja zwraca symbol odwrotny                               */
/************************************************************************/
Symbol OdwrotnyMnozenia(Symbol Arg1)
{
  if (Arg1==e) return e;
  for (int i=1;i!=WLK;i++)
    if (TabMnoz[Arg1][i]==a) return Symbol(i);
  assert(!"Blad: Nie znaleziono elementu odwrotnego! Cos jest nie tak!");
  return z;
}

/************************************************************************/
/* Dzielenie - dzielenie symboli                                        */
/* PRE:    brak                                                         */
/* POST:   Funkcja zwraca iloraz dwoch argumentow na podstawie tabliczki*/
/************************************************************************/
Symbol Dzielenie (Symbol Arg1, Symbol Arg2)
{
  if (Arg2==e) return jablko;
  return Mnozenie(Arg1,OdwrotnyMnozenia(Arg2));
}

/************************************************************************/
/* WczytajSymbol - zwraca symbol (wczytany jako char)                   */
/* Argumet:  Ch - wczytywany znak                                       */
/* PRE:      brak                                                       */
/* POST:     funkcja zwraca symbol (wczytany wcześniej jako char) lub   */
/*           kod błędu w przypadku niepowodzenia                        */
/************************************************************************/
Symbol WczytajSymbol (char Ch)
{
  Symbol TabS[]={a,b,c,d,e};
  if (Ch<'a' || Ch>'e') return bc;
  return TabS[Ch-'a'];
}
/************************************************************************/
/* WyswietlSymbol - wyswietla symbol jako char                          */
/* Argument: Arg1 - argument, który ma byc wyswietlony                  */
/* PRE:      brak                                                       */
/* POST:     funkcja wyswietla symbol lub kod błędu w przypadku         */
/*           niepowodzenia (przekroczenia zakresu)                      */
/************************************************************************/
char WyswietlSymbol (Symbol Arg1)
{
  const char *Nazwa="eabcd";
  if (Arg1<e || Arg1>d) return bw;
  return Nazwa[Arg1];
}


/************************************************************************/
/* Przeciazenia operatorow                                              */
/************************************************************************/


istream& operator >> (istream& stream, Symbol &Sym)
{
  char Znak;
  stream >> Znak;
  Sym = WczytajSymbol(Znak);
  if (Sym==bc) stream.setstate(ios::failbit);  //gdy czytanie się nie powiodło
  return stream;
}

ostream& operator << (ostream& stream, Symbol Sym)
{
  stream << WyswietlSymbol(Sym);
  return stream;
}

ostream& operator << (ostream& stream, const WyrAlg &wa)
{
  stream << wa.Arg1 << " ";
  stream << wa.Op << " ";
  stream << wa.Arg2;
  stream << " = ";
  stream << wa.Wynik;
  return stream;
}

istream& operator >> (istream& stream, WyrAlg &wa)
{
  char Rowna;              //znak '=' czy inny
  stream >> wa.Arg1;
  if (cin.fail())
    {
      cerr << "Blad skladni wyrazenia. Niepoprawny pierwszy argument" << endl;
      cin.ignore(10000,'\n');
      return stream;
    }
  stream >> wa.Op;
  if (!(strchr("+-*/",wa.Op)))
    {
      cerr << "Blad skladni wyrazenia. Niedozwolony znak operatora" << endl;
      stream.setstate(ios::failbit);
      cin.ignore(10000,'\n');
      return stream;
    }
  stream >> wa.Arg2;
  if (cin.fail())
    {
      cerr << "Blad skladni wyrazenia. Niepoprawny drugi argument" << endl;
      cin.ignore(10000,'\n');
      return stream;
    }
  stream >> Rowna;
  if (Rowna!='=')
    {
      cerr << "Blad skladni: Brak znaku ''=''" << endl;
      stream.setstate(ios::failbit);
      return stream;
    }
  stream >> wa.Wynik;
  if (cin.fail())
    {
      cerr << "Blad skladni wyrazenia. Niepoprawny symbol wyniku" << endl;
      cin.ignore(10000,'\n');
    }
  return stream;
} // operator >>

Symbol operator + (Symbol Arg1, Symbol Arg2)
{
  return Dodaj(Arg1,Arg2);
}

Symbol operator - (Symbol Arg1)
{
  return PrzeciwnyDodawania(Arg1);
}

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

Symbol operator * (Symbol Arg1, Symbol Arg2)
{
  return Mnozenie(Arg1,Arg2);
}

Symbol operator ~ (Symbol Arg1)      //przeciazenie odwrotnego
{
  return OdwrotnyMnozenia(Arg1);
}

Symbol operator / (Symbol Arg1, Symbol Arg2)
{
  if (Arg2==e) return jablko;           //dzielenie przez "0"
  return Arg1*~Arg2;
}

/************************************************************************/
/* Kalkulator - funkcja oblicza prawidłowy wynik równania               */
/* Argumenty:   WyrAlg &wa - wprowadzone wyrażenie algebraiczne         */
/* PRE:         wa musi byc zainicjowane                                */
/* POST:        funkcja zwraca "Symbol" jako wynik działania            */
/*              algebraicznego                                          */
/************************************************************************/
Symbol Kalkulator(const WyrAlg &wa)
{
  switch (wa.Op)
    {
    case '+': return wa.Arg1+wa.Arg2; break;
    case '-': return wa.Arg1-wa.Arg2; break;
    case '*': return wa.Arg1*wa.Arg2; break;
    case '/': return wa.Arg1/wa.Arg2; break;
    default: cerr<< "Nie powinienies tego widziec!" << endl; return z; break;
    }
  return z;
}

/***********************************************************************/
/* Sprawdzian - funckja obsługująca wyrażenie algebraiczne             */
/* Argumenty:   wa - stuktura do której wczytywane są elementy         */
/*                   wyrazenia algebraicznego                          */
/*              stat - struktura zawierająca dane statystyczne         */
/* PRE:         stat musi byc zainicjowane                             */
/* POST:        funkcja wczytuje wyrażenie algebraiczne ze standardoweg*/
/*              wejścia i zapisuje je do stukruty wa lub zwraca        */
/*              odpowiedni komunikat o błędzie, sprawdza różnież       */
/*              poprawność wprowadzonego wyniku, zmienia odpowiednie   */
/*              dane statystyczne                                      */
/***********************************************************************/
void Sprawdzian(WyrAlg &wa, Staty &stat)
{
  Symbol wynik;

  ++ stat.CalkowitaLiczbaWyrazen;
  cin >> wa;
  if (cin.fail()) ++stat.BlednaSkladnia;
  else
    {
      cout << "Wczytano wyrazenie: " << wa << endl;
      wynik=Kalkulator(wa);
      if (wynik==z) cerr << "Niepoprawne wyrazenie w pamieci" << endl;
      if (wa.Wynik!=wynik)
    {
      cout << "Wynik niepoprawny. Wlasciwy wynik to: " << wynik << endl;
      ++stat.NiepoprawnyWynik;
    }
      else
    {
      cout << "Wynik poprawny" << endl;
      ++stat.PoprawneWyniki;
    }
    }
} //Sprawdzian

/**************************************************************************/
/* Statystyka - funkcja wyświelta statstykę sprawdzianu                   */
/* PRE:         stats musi być zainicjowane                               */
/* POST:        funkcja wyświetla na standardowym wyjściu statystykę      */
/**************************************************************************/
void Statystyka (const Staty &stats)
{
  int PoprWyrazenia=stats.CalkowitaLiczbaWyrazen-stats.BlednaSkladnia;
  cout << "Statystyka: " << endl;
  cout << "Ilosc wszytskich wyrazen: " << stats.CalkowitaLiczbaWyrazen
       << endl;
  cout << "Ilosc poprawnie zapisanych wyrazen: "
       << PoprWyrazenia
       << endl;
  cout << "Ilosc wyrazen z poprawnym wynikiem: " << stats.PoprawneWyniki
       << endl;
  cout << "Procentowo ilosc poprawnych wynikow: "
       << (static_cast<double>(stats.PoprawneWyniki)/PoprWyrazenia)*100 << "%\n";
}

int main()
{
  WyrAlg wa;
  Staty stat;
  char Znak;

  cout << "Start sprawdzianu z artymetyki:" << endl;
  cout << "Wprowadzaj wyrazenia liniami, znaki i symbole oddzielone spacjami"
       << endl << endl;

  InicjujStaty(stat);

  while ((Znak=getc(stdin))!=EOF)   //ctrl+D = EOF w linuxie
    {
      ungetc(Znak,stdin);
      Sprawdzian(wa,stat);
      cin.clear();
      cin.ignore(10000,'\n');
    }

  Statystyka(stat);         //wyświetlenie statystyki


}