Przeciążanie operatorów

0

Witam. Mam problem z przeciążaniem operatorów. Otóż utknąłem w martwym punkcie. Mam napisać program (w C++), który działa na typie enum. Program sprawdza czy podane na wejściu np. a+b równa się np. c w odpowiednio przygotowanej wcześniej tabeli. Mój problem dotyczy tego, iż po prostu nie wiem czy robię to dobrze oraz nie wiem w jaki sposób program ma sprawdzać czy wynik wpisanego działania równa się wartości w tabelce np. dodawania. Na razie mam coś takiego:
dzialania.hh

#include <iostream> /*deklaracja bibliotek*/
#include <iomanip>

#ifndef DZIALANIA_HH
#define DZIALANIA_HH

enum Symbol { e, a, b, c, d , error};
char *Bufor = new char(2);

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

 
extern int testuj(Symbol x, Symbol y, char OperatorDzialania);

#endif

main.cpp

#include <iostream> /*deklaracja bibliotek*/
#include <iomanip>
#include <cstdlib>
#include <string>

using namespace std;
enum Symbol { e, a, b, c, d , error};
int testuj(Symbol x, Symbol y, char OperatorDzialania, int i);

int main() /*funkcja glowna programu*/
{	
	int i=1;
	srand(time (NULL));/*start maszyny losujacej*/
	Symbol x=a, y=a;
	char OperatorDzialania='+';
    cout << endl << "Wyrazenia arytmetyczne nalezy wprowadzac w formie:"
    << endl;
    cout << "    symbol(brak spacji)operator(brak spacji)symbol" << endl;
    cout << "Symbolami sa litery: a, b, c, d, e." << endl << endl;  
    testuj(x, y, OperatorDzialania, i);/*wywolanie funkcji testujacej uzytkownika*/
    return 0;
}

test_dzialan.cpp

#include <iostream> /*deklaracja bibliotek*/
#include <iomanip>
#include <cstdlib>
#include <string>
#include "dzialania.hh"

using namespace std;
struct Pytanie {
  char    OperatorDzialania;
  Symbol  WynikDzialania;
};


#define ILOSC_PYTAN   10  /* te pytania można pozmieniać, byleby tylko były*/

Pytanie  ZbiorPytan[ILOSC_PYTAN] = {
             { '+', a }, { '-', c }, { '+', e }, { '-', d }, { '+', b },
             { '-', a }, { '+', c }, { '-', e }, { '+', d }, { '-', b }
          };
      
        
istream & operator >> (istream & StrmWej, Symbol & WczytSym)
{
  Symbol TabSymboli[] = {a, b, c, d, e};
  char ZnakSymbolu;
  
  StrmWej >> ZnakSymbolu;

  if (!(ZnakSymbolu >= 'a' && ZnakSymbolu <= 'e')) // sprawdzanie czy liczba
  {      					   // spelnia warunki
    WczytSym = error;
	*Bufor = ZnakSymbolu;
	return StrmWej;
  }
  
  WczytSym = TabSymboli[ZnakSymbolu-'a'];
  return StrmWej;
}

ostream & operator << (ostream & StrmWy, Symbol Znak)
{                                            // wypisywanie na strumieniu
  StrmWy << "eabcd"[Znak];                   // symboli zamiast liczb
  return StrmWy;
}    

Symbol operator << (Symbol Arg, int Przesuniecie)
{
  for (; Przesuniecie > 0; --Przesuniecie) {
   switch (Arg) {
    case e: Arg = a;
    case a: Arg = b;
    case b: Arg = c;
    case c: Arg = d;
    case d: Arg = e;
    case error: Arg = error;
   }
  }
  return Arg;
}

Symbol ZnajdzElementOdwrotny(Symbol x)  /* tutaj też mam problem, nie wiem czy program dobrze liczy w myśl zasady
                                                                   a - b = a + (-b) */
{
  Symbol y = e;
  do
  {
    if ( x + y == e ) return y;
    y = y << 1;
  } while ( y != e );
}

Symbol operator + (Symbol y, Symbol x)
{
  return Dodawanie[x][y];
}

Symbol operator - (Symbol y, Symbol x)
{
  return y + ZnajdzElementOdwrotny(x);
}

Symbol operator * (Symbol y, Symbol x)
{
	return Mnozenie[x][y];
}

Symbol operator / (Symbol y, Symbol x)
{
	if(y==e || x==e)
	{
		return error;
	}
	else
	return (x/y);
}
	

int testuj(Symbol x, Symbol y, char OperatorDzialania, int i)
{
	int licznik=1;
	Symbol wynik;
	i=( rand() % 10 ) + 0;
	while(licznik<=ILOSC_PYTAN) /*petla while odliczajaca ilosc pytan*/
	{
	cout << "Podaj operacje ";
	if(ZbiorPytan[i].OperatorDzialania=='+')
	{
		cout << "dodawania";
	}
		if(ZbiorPytan[i].OperatorDzialania=='-')
	{
		cout << "odejmowania";
	}
		if(ZbiorPytan[i].OperatorDzialania=='*')
	{
		cout << "mnozenia";
	}
		if(ZbiorPytan[i].OperatorDzialania=='/')
	{
		cout << "dzielenia";
	}
	cout << " ktorej wynikiem jest: " << ZbiorPytan[i].WynikDzialania << endl;
    cout << "Twoja odpowiedz: " << endl;
	cin >> x >> OperatorDzialania >> y;
	if(x == error)
	{
	  cerr << "*** Bledny symbol. Wprowadzono: '" << Bufor << "'" << endl;
	  cerr << "*** Dopuszczalne znaki symbolu to: 'a', 'b', 'c', 'd', "
	    << "'e'." << endl << "Sprobuj jeszcze raz." << endl;
	  continue;
	}
	if(y == error)
	{
	  cerr << "*** Bledny symbol. Wprowadzono: '" << Bufor << "'" << endl;
	  cerr << "*** Dopuszczalne znaki symbolu to: 'a', 'b', 'c', 'd', "
	    << "'e'." << endl << "Sprobuj jeszcze raz." << endl;
	  continue;
	}
	switch(OperatorDzialania)                   /* główny zgryz*/
	{
		case '+':
		wynik = x+y;
		if((wynik) == Dodawanie[x][y])
	{
		cout << "Dobrze";
		i=( rand() % 10 ) + 0;
	};break;
	case '-':
	wynik = x-y;
	if((wynik) == Dodawanie[x][y])
	{
		cout << "Dobrze";
		i=( rand() % 10 ) + 0;
	};break;
	case '*':
	wynik = x*y;
	if((wynik) == Mnozenie[x][y])
	{
		cout << "Dobrze";
		i=( rand() % 10 ) + 0;
	}; break;
	case '/':
	wynik = x/y;
	if((wynik) == Mnozenie[x][y])
	{
		cout << "Dobrze";
		i=( rand() % 10 ) + 0;
	}; break;
	}
	licznik++;
	}
	return 0;
	}

Poczytałem trochę o przeciążeniach w Symfonii C++ i w internecie ale jakoś nie znalazłem rozwiązania swojego problemu(większość przykładów jest na klasach, których jeszcze nie miałem). Dzięki za pomoc i sugestie : )

0
if(x+y==Dodawanie[x][y]) // dobrze
0

Trochę go pozmieniałem wg Waszych sugestii.
test_dzialan.cpp

#include <iostream> /*deklaracja bibliotek*/
#include <iomanip>
#include <cstdlib>
#include <string>
#include "dzialania.hh"

using namespace std;
struct Pytanie {
  char    OperatorDzialania;
  Symbol  WynikDzialania;
};


#define ILOSC_PYTAN   10

Pytanie  ZbiorPytan[ILOSC_PYTAN] = {
             { '+', a }, { '-', c }, { '+', e }, { '-', d }, { '+', b },
             { '-', a }, { '+', c }, { '-', e }, { '+', d }, { '-', b }
          };
      
        
istream & operator >> (istream & StrmWej, Symbol & WczytSym)
{
  Symbol TabSymboli[] = {a, b, c, d, e};
  char ZnakSymbolu;
  
  StrmWej >> ZnakSymbolu;

  if (!(ZnakSymbolu >= 'a' && ZnakSymbolu <= 'e')) // sprawdzanie czy liczba
  {      					   // spelnia warunki
    WczytSym = error;
	*Bufor = ZnakSymbolu;
	return StrmWej;
  }
  
  WczytSym = TabSymboli[ZnakSymbolu-'a'];
  return StrmWej;
}

ostream & operator << (ostream & StrmWy, Symbol Znak)
{                                            // wypisywanie na strumieniu
  StrmWy << "eabcd"[Znak];                   // symboli zamiast liczb
  return StrmWy;
}    

Symbol operator + (Symbol x, Symbol y)
{
  return Dodawanie[x][y];
}

Symbol operator * (Symbol x, Symbol y)
{
  return Mnozenie[x][y];
}

Symbol operator - (Symbol x, Symbol y)  // na podstawie tabelki
{
  if(y == a)
	y = b;
  else if(y == b)
    y = a;
  else if(y == c)
    y = d;
  else if(y == d)
    y = c;
	
  return Dodawanie[x][y];
}

Symbol operator / (Symbol x, Symbol y)
{
  if(y == a)
	y = b;
  else if(y == b)
    y = a;
	
  return Mnozenie[x][y];
}
	

int testuj(Symbol x, Symbol y, char OperatorDzialania, int i)
{
	int licznik=1;
	Symbol wynik;
	i=( rand() % 10 ) + 0;
	while(licznik<=ILOSC_PYTAN) /*petla while odliczajaca ilosc pytan*/
	{
	cout << "Podaj operacje ";
	if(ZbiorPytan[i].OperatorDzialania=='+')
	{
		cout << "dodawania";
	}
		if(ZbiorPytan[i].OperatorDzialania=='-')
	{
		cout << "odejmowania";
	}
		if(ZbiorPytan[i].OperatorDzialania=='*')
	{
		cout << "mnozenia";
	}
		if(ZbiorPytan[i].OperatorDzialania=='/')
	{
		cout << "dzielenia";
	}
	cout << " ktorej wynikiem jest: " << ZbiorPytan[i].WynikDzialania << endl;
    cout << "Twoja odpowiedz: " << endl;
	cin >> x >> OperatorDzialania >> y;
	if(x == error)
	{
	  cerr << "*** Bledny symbol. Wprowadzono: '" << Bufor << "'" << endl;
	  cerr << "*** Dopuszczalne znaki symbolu to: 'a', 'b', 'c', 'd', "
	    << "'e'." << endl << "Sprobuj jeszcze raz." << endl;
	  continue;
	}
	if(y == error)
	{
	  cerr << "*** Bledny symbol. Wprowadzono: '" << Bufor << "'" << endl;
	  cerr << "*** Dopuszczalne znaki symbolu to: 'a', 'b', 'c', 'd', "
	    << "'e'." << endl << "Sprobuj jeszcze raz." << endl;
	  continue;
	}
	if(OperatorDzialania != '+' && OperatorDzialania != '-' 
	&& OperatorDzialania != '*' && OperatorDzialania != '/')
	{
	  cerr << "*** Bledny operator. Jako operator wprowadzono znak '"
	    << OperatorDzialania << "'." << endl;
	  cerr << "*** Dopuszczalne znaki operatorow to: '+' '-' '/' '*'" 
	    << endl << endl;
	  continue;
	}
    if(OperatorDzialania == '/' && y == e)
	{
	  cerr << "*** Niedozwolona operacja. Proba dzielenia przez przez"
        << endl;
      cerr << "*** element neutralny operacji dodawania." << endl;
	  continue;
	}
	
	switch(OperatorDzialania)
	{
		case '+':
			if(x+y == Dodawanie[x][y])
				{
					cout << "Dobrze\n";
					i=( rand() % 10 ) + 0;
				}
			else
				{
					cout << "Zle\n";
				}
					break;
		case '-':
			if((x-y) == Dodawanie[x][y])
				{
					cout << "Dobrze\n";
					i=( rand() % 10 ) + 0;
				}
			else
				{
					cout << "Zle\n";
				}
				break;
		case '*':
			if((x*y) == Mnozenie[x][y])
				{
					cout << "Dobrze\n";
					i=( rand() % 10 ) + 0;
				} 
			else
				{
					cout << "Zle\n";
				}
				break;
		case '/':
			if((x/y) == Mnozenie[x][y])
				{
				cout << "Dobrze\n";
				i=( rand() % 10 ) + 0;
				}
			else
				{
					cout << "Zle\n";
				} 
				break;
		default:
				{
				cout << "Nieznane polecenie.\n" ;
				};
				break;
	}
	licznik++;
	}
	return 0;
	}

Tylko, że teraz nie rozpoznaje działań i dla np. dodawania uznaje za prawdziwe jakiekolwiek odejmowanie : P

EDIT Dobra mam, musiałem zmienić tak, żeby sprawdzał czy odp. użytkownika zgadza się z odpowiedzią, która jest w części pytań a nie z tabelką i działa. jak będę miał jeszcze jakieś problemy to się zgłoszę. Dzięki : )

1 użytkowników online, w tym zalogowanych: 0, gości: 1