kurwywyjebane

/***********************************************************/
/* Iloczyn klas a konwersja dynamiczna i funkcje wirtualne */
/***********************************************************/

#include <iostream>
using namespace std;

class Obiekt {
 public:
  Obiekt()
  {}

  virtual ~Obiekt()
  {}

  enum {_GDI_,_OpenGL_,_DirectX_};
  virtual void Rysuj(int srodowisko) = 0;
};

class Kolo : public Obiekt {
 public:
  Kolo()
  {}

  void Rysuj(int srodowisko)
  {
   cout << "rysuje obiekt kola w srodowisku ";
   switch (srodowisko) {
    case _GDI_: cout << "GDI" << endl; break;
    case _OpenGL_: cout << "OpenGL" << endl; break;
    case _DirectX_: cout << "DirectX" << endl; break;
   }
  }
};

class Sfera : public Obiekt {
 public:
  Sfera()
  {}

  void Rysuj(int srodowisko)
  {
   cout << "rysuje obiekt sfery w srodowisku ";
   switch (srodowisko) {
    case _GDI_: cout << "GDI - operacja bledna!" << endl; break;
    case _OpenGL_: cout << "OpenGL" << endl; break;
    case _DirectX_: cout << "DirectX" << endl; break;
   }
  }
};

class Linia : public Obiekt {
 public:
  Linia()
  {}

  void Rysuj(int srodowisko)
  {
   cout << "rysuje obiekt linii w srodowisku ";
   switch (srodowisko) {
    case _GDI_: cout << "GDI" << endl; break;
    case _OpenGL_: cout << "OpenGL" << endl; break;
    case _DirectX_: cout << "DirectX" << endl; break;
   }
  }
};

class Forma {
 public:
  Forma()
  {}

  virtual ~Forma()
  {}

  virtual void Rysuj() = 0;
};

class Srodowisko {
 public:
  Srodowisko()
  {}

  virtual ~Srodowisko()
  {}

  virtual void Rysuj(Obiekt *obiekt) = 0;
  virtual Forma *Ujmij(Obiekt *obiekt) = 0;
};

class GDI : public Srodowisko {
 public:

  class FormaKola : public Forma {
    Kolo *kolo_;
    GDI *gdi_;
   public:
    FormaKola(Kolo *kolo, GDI *gdi):
     kolo_(kolo), gdi_(gdi)
    {}
    void Rysuj()
    {
     cout << "rysuje obiekt kola w srodowisku GDI" << endl;
    }
  };

  class FormaLinii : public Forma {
    Linia *linia_;
    GDI *gdi_;
   public:
    FormaLinii(Linia *linia, GDI *gdi):
     linia_(linia), gdi_(gdi)
    {}
    void Rysuj()
    {
     cout << "rysuje obiekt linii w srodowisku GDI" << endl;
    }
  };

 public:
  GDI()
  {}

  Forma *Ujmij(Obiekt *obiekt)
  {
   Kolo *kolo = dynamic_cast<Kolo*>(obiekt);
   if (kolo!=NULL) return new FormaKola(kolo,this);
   else {
    Sfera *sfera = dynamic_cast<Sfera*>(obiekt);
    if (sfera!=NULL) { cout << "blad: rysowanie obiektow 3D w srodowisku GDI jest niemozliwe!" << endl; return NULL; }
    else {
     Linia *linia = dynamic_cast<Linia*>(obiekt);
     if (linia!=NULL) return new FormaLinii(linia,this);
     else { cout << "blad: nieznany typ obiektu!" << endl; return NULL; }
    }
   }
  }

  void Rysuj(Obiekt *obiekt)
  {
   Kolo *kolo = dynamic_cast<Kolo*>(obiekt);
   if (kolo!=NULL) rysuj_kolo(kolo);
   else {
    Sfera *sfera = dynamic_cast<Sfera*>(obiekt);
    if (sfera!=NULL) rysuj_sfere(sfera);
    else {
     Linia *linia = dynamic_cast<Linia*>(obiekt);
     if (linia!=NULL) rysuj_linie(linia);
     else cout << "blad: nieznany typ obiektu!" << endl;
    }
   }
  }

 private:

  void rysuj_kolo(Kolo *kolo)
  {
   cout << "rysuje obiekt kola w srodoiwsku GDI" << endl;
  }

  void rysuj_sfere(Sfera *sfera)
  {
   cout << "blad: nie moge rysowac obiektu sfery w srodowisku GDI!" << endl;
  }

  void rysuj_linie(Linia *linia)
  {
   cout << "rysuje obiekt linii w srodoiwsku GDI" << endl;
  }
};

class OpenGL : public Srodowisko {
 public:

  class FormaKola : public Forma {
    Kolo *kolo_;
    OpenGL *opengl_;
   public:
    FormaKola(Kolo *kolo, OpenGL *gdi):
     kolo_(kolo), opengl_(gdi)
    {}
    void Rysuj()
    {
     cout << "rysuje obiekt kola w srodowisku OpenGL" << endl;
    }
  };

  class FormaSfery : public Forma {
    Sfera *sfera_;
    OpenGL *opengl_;
   public:
    FormaSfery(Sfera *sfera, OpenGL *gdi):
     sfera_(sfera), opengl_(gdi)
    {}
    void Rysuj()
    {
     cout << "rysuje obiekt sfery w srodowisku OpenGL" << endl;
    }
  };

  class FormaLinii : public Forma {
    Linia *linia_;
    OpenGL *opengl_;
   public:
    FormaLinii(Linia *linia, OpenGL *gdi):
     linia_(linia), opengl_(gdi)
    {}
    void Rysuj()
    {
     cout << "rysuje obiekt linii w srodowisku OpenGL" << endl;
    }
  };

 public:
  OpenGL()
  {}

  Forma *Ujmij(Obiekt *obiekt)
  {
   Kolo *kolo = dynamic_cast<Kolo*>(obiekt);
   if (kolo!=NULL) return new FormaKola(kolo,this);
   else {
    Sfera *sfera = dynamic_cast<Sfera*>(obiekt);
    if (sfera!=NULL) return new FormaSfery(sfera,this);
    else {
     Linia *linia = dynamic_cast<Linia*>(obiekt);
     if (linia!=NULL) return new FormaLinii(linia,this);
     else { cout << "blad: nieznany typ obiektu!" << endl; return NULL; }
    }
   }
  }

  void Rysuj(Obiekt *obiekt)
  {
   Kolo *kolo = dynamic_cast<Kolo*>(obiekt);
   if (kolo!=NULL) rysuj_kolo(kolo);
   else {
    Sfera *sfera = dynamic_cast<Sfera*>(obiekt);
    if (sfera!=NULL) rysuj_sfere(sfera);
    else {
     Linia *linia = dynamic_cast<Linia*>(obiekt);
     if (linia!=NULL) rysuj_linie(linia);
     else cout << "blad: nieznany typ obiektu!" << endl;
    }
   }
  }

 private:

  void rysuj_kolo(Kolo *kolo)
  {
   cout << "rysuje obiekt kola w srodoiwsku OpenGL" << endl;
  }

  void rysuj_sfere(Sfera *sfera)
  {
   cout << "rysuje obiekt sfery w srodoiwsku OpenGL" << endl;
  }

  void rysuj_linie(Linia *linia)
  {
   cout << "rysuje obiekt linii w srodoiwsku OpenGL" << endl;
  }
};

class DirectX : public Srodowisko {
 public:

  class FormaKola : public Forma {
    Kolo *kolo_;
    DirectX *directx_;
   public:
    FormaKola(Kolo *kolo, DirectX *gdi):
     kolo_(kolo), directx_(gdi)
    {}
    void Rysuj()
    {
     cout << "rysuje obiekt kola w srodowisku DirectX" << endl;
    }
  };

  class FormaSfery : public Forma {
    Sfera *sfera_;
    DirectX *directx_;
   public:
    FormaSfery(Sfera *sfera, DirectX *gdi):
     sfera_(sfera), directx_(gdi)
    {}
    void Rysuj()
    {
     cout << "rysuje obiekt sfery w srodowisku DirectX" << endl;
    }
  };

  class FormaLinii : public Forma {
    Linia *linia_;
    DirectX *directx_;
   public:
    FormaLinii(Linia *linia, DirectX *gdi):
     linia_(linia), directx_(gdi)
    {}
    void Rysuj()
    {
     cout << "rysuje obiekt linii w srodowisku DirectX" << endl;
    }
  };

 public:
  DirectX()
  {}

  Forma *Ujmij(Obiekt *obiekt)
  {
   Kolo *kolo = dynamic_cast<Kolo*>(obiekt);
   if (kolo!=NULL) return new FormaKola(kolo,this);
   else {
    Sfera *sfera = dynamic_cast<Sfera*>(obiekt);
    if (sfera!=NULL) return new FormaSfery(sfera,this);
    else {
     Linia *linia = dynamic_cast<Linia*>(obiekt);
     if (linia!=NULL) return new FormaLinii(linia,this);
     else { cout << "blad: nieznany typ obiektu!" << endl; return NULL; }
    }
   }
  }

  void Rysuj(Obiekt *obiekt)
  {
   Kolo *kolo = dynamic_cast<Kolo*>(obiekt);
   if (kolo!=NULL) rysuj_kolo(kolo);
   else {
    Sfera *sfera = dynamic_cast<Sfera*>(obiekt);
    if (sfera!=NULL) rysuj_sfere(sfera);
    else {
     Linia *linia = dynamic_cast<Linia*>(obiekt);
     if (linia!=NULL) rysuj_linie(linia);
     else cout << "blad: nieznany typ obiektu!" << endl;
    }
   }
  }

 private:

  void rysuj_kolo(Kolo *kolo)
  {
   cout << "rysuje obiekt kola w srodoiwsku DirectX" << endl;
  }

  void rysuj_sfere(Sfera *sfera)
  {
   cout << "rysuje obiekt sfery w srodoiwsku DirectX" << endl;
  }

  void rysuj_linie(Linia *linia)
  {
   cout << "rysuje obiekt linii w srodoiwsku DirectX" << endl;
  }
};

void RysujWszystkie1(Obiekt *obiekty[],int N)
{
 int srodowisko = Obiekt::_GDI_;

 cout << "Implementacja pierwsza->" << endl;
 for (int i=0; i<N; i++)
 obiekty[i]->Rysuj(srodowisko);
}

void RysujWszystkie2(Obiekt *obiekty[],int N)
{
 Srodowisko *srodowisko = new GDI;

 cout << "Implementacja druga->" << endl;
 for (int i=0; i<N; i++)
 srodowisko->Rysuj(obiekty[i]);

 delete srodowisko;
}

void RysujWszystkie3(Obiekt *obiekty[],int N)
{
 Srodowisko *srodowisko = new GDI;

 cout << "Implementacja trzecia->" << endl;
 for (int i=0; i<N; i++) {
  Forma *forma = srodowisko->Ujmij(obiekty[i]);
  if (forma!=NULL) {
   forma->Rysuj();
   delete forma;
  }
 }

 delete srodowisko;
}

int main()
{
 Obiekt *obiekty[] = { new Kolo, new Sfera, new Linia };
 int N = sizeof obiekty/sizeof(Obiekt *);

 RysujWszystkie1(obiekty, N);
 cout << endl;

 RysujWszystkie2(obiekty, N);
 cout << endl;

 RysujWszystkie3(obiekty, N);
 cout << endl;

 return 0;
}