#include <iostream>
#include <string>
#include <map>
#include <cstdlib>

using namespace std;

map<string, double> tablica;

// x + 4 * (23 - e1)

class Izraz {
public:
  virtual double vrednost() const = 0;
  virtual Izraz* klon() const = 0;
  virtual ~Izraz() {

  }
};

class Konstanta : public Izraz {
public:
  Konstanta(double c)
    :_c(c)
  {}
  double vrednost() const {
    return _c;
  }
  Izraz* klon() const {
    return new Konstanta(*this);
  }
private:
  double _c;
};

class Promenljiva : public Izraz {
public:
  Promenljiva(string ime)
    :_ime(ime)
  {}
  double vrednost() const {
    if (tablica.count(_ime))
      return tablica[_ime];
    else {
      cerr << "Nedefinisana promenljiva " << _ime << endl;
      exit(EXIT_FAILURE);
    }
  }
  Izraz* klon() const {
    return new Promenljiva(*this);
  }
private:
  string _ime;
};

class BinOperator : public Izraz {
public:
  BinOperator(Izraz* levi, Izraz* desni)
    :_levi(levi->klon()), _desni(desni->klon())
  {}
  ~BinOperator () {
    delete _levi;
    delete _desni;
  }
  BinOperator(const BinOperator& z) {
    _levi = z._levi->klon();
    _desni = z._desni->klon();
  }
  BinOperator& operator=(const BinOperator& z) {
    if (this != &z) {
      delete _levi;
      delete _desni;
      _levi = z._levi->klon();
      _desni = z._desni->klon();
    }
    return *this;
  }
protected:  
  Izraz* _levi;
  Izraz* _desni;
};

class Zbir : public BinOperator {
public:
  Zbir(Izraz* i1, Izraz* i2)
    :BinOperator(i1, i2)
  {}
  double vrednost() const {
    return _levi->vrednost() + _desni->vrednost();
  }
  Izraz* klon() const {
    return new Zbir(*this);
  }
};

class Razlika : public BinOperator {
public:
  Razlika(Izraz* i1, Izraz* i2)
    :BinOperator(i1, i2)
  {}
  double vrednost() const {
    return _levi->vrednost() - _desni->vrednost();
  }
  Izraz* klon() const {
    return new Razlika(*this);
  }
};

class Proizvod : public BinOperator {
public:
  Proizvod(Izraz* i1, Izraz* i2)
    :BinOperator(i1, i2)
  {}
  double vrednost() const {
    return _levi->vrednost() * _desni->vrednost();
  }
  Izraz* klon() const {
    return new Proizvod(*this);
  }
};

class Kolicnik : public BinOperator {
public:
  Kolicnik(Izraz* i1, Izraz* i2)
    :BinOperator(i1, i2)
  {}
  double vrednost() const {
    return _levi->vrednost() / _desni->vrednost();
  }
  Izraz* klon() const {
    return new Kolicnik(*this);
  }
};

int main() {
  Izraz* i1 = new Konstanta(3.14);
  Izraz* i2 = new Promenljiva("x");

  tablica["x"] = 101;

  cout << i1->vrednost() << endl;
  cout << i2->vrednost() << endl;

  tablica["x"] = 102;
  tablica["y"] = 0;

  cout << i1->vrednost() << endl;
  cout << i2->vrednost() << endl;

  Izraz *i3 = new Promenljiva("y");
  Izraz *i4 = new Konstanta(1);

  Izraz *z = new Zbir(i1, i2);
  Izraz *r = new Razlika(i3, i4);

  Izraz *i = new Proizvod(z, r);

  cout << i->vrednost() << endl;

  delete i1;
  delete i2;
  delete i3;
  delete i4;
  delete z;
  delete r;
  delete i;

  return 0;
}