Rozwazmy nastepujaca definicje klasy Expr (reprezentujacej wyrazenia z
jedna zmienna)

class Expr
{
  protected:

  public:

	 Expr(void) {};
 virtual ~Expr(void) {};

 virtual int isConstant(void) = 0  ;     // Czy to jest wyrazenie stale
 virtual int calcValue(int xValue=0) = 0 ; // Oblicz wartosc wyrazenia
                                  // dla wartosci zmiennej x rownej xValue

 virtual void print() = 0 ;          // Wydrukuj wyrazenie   
} ;

Zdefiniuj nastepujace podklasy Expr:

class ExprConst : public Expr  // Stala calkowita (atrybut: wartosc)
class ExprVar : public Expr    // Zmienna 
class ExprBin : public Expr    // Operacja dwuargumentowa 
class ExprSum : public ExprBin    // Suma dwoch wyrazen
class ExprProd : public ExprBin   // Iloczyn dwoch wyrazen 

tak by implementowaly metody zdefiniowane w klasie Expr, a wiec
konstruktory, destruktory, obliczanie wartosci wyrazenia oraz jego
drukowanie.

W klasie ExprBin nalezy zaimplementowac te metody, ktore sa wspolne
dla wszystkich operacji dwuargumentowych (tu: dla sumy i iloczynu)

Metoda print ma uwzgledniac fakt, ze mnozenie ma wiekszy priorytet 
niz dodawanie. Calosc powinna sie dac latwo rozszerzyc o kolejne konstrukcje 
na wyrazeniach (np. odejmowanie, potegowanie)


Uwaga: mozesz rozszerzyc klase Expr o nowe atrybuty i metody.

Przykladowy fragment kodu uzywajacy opisanych klas:

  //----------------------------------------------------------

  Expr *e, *e1, *e2 ;

  e2 = new ExprConst(2) ;
  e = new ExprProd(e2,new ExprConst(*e2)) ;
  e -> print() ;
  cout <<  " = " << e->calcValue()  << '\n' ;
  delete e ;

  //----------------------------------------------------------

  e1 = new ExprSum(new ExprConst(2), new ExprConst(2)) ;
  e1 -> print() ;
  cout <<  " = " << e1->calcValue()  << '\n' ;

  e = new ExprProd(new ExprConst(2), e1) ;
  e -> print() ;
  cout <<  " = " << e->calcValue()  << '\n' ;
  delete e ;

  //----------------------------------------------------------

  e1 = new ExprProd(new ExprConst(2), new ExprConst(2)) ;
  e = new ExprSum(e1, new ExprConst(2)) ;
  e -> print() ;
  cout <<  " = " << e->calcValue()  << '\n' ;
  delete e ;

  //----------------------------------------------------------

  e = new ExprProd(new ExprVar, new ExprVar) ;
  e -> print() ;
    cout <<  " = " << e->calcValue(2)  << "  (x=2)" << '\n' ;
  delete e ;

  //----------------------------------------------------------

I wynik jego dzialania:

2 * 2 = 4
2 + 2 = 4
2 * (2 + 2) = 8
2 * 2 + 2 = 6
x * x = 4  (x=2)