Table of Contents

1. Polimorfizam
2. Pitanje
3. Odgovor
4. Jednostavan primjer
5. Virtualne metode
6. Implementacija polimorfizma
7. Kovarijantni povratni tip
8. Funkciju je dovoljno deklarirati virtualnom samo u baznoj klasi
9. Operator dosega :: zaobilazi virtualni mehanizam
10. Virtualni destruktor
11. Čista virtualna funkcija i apstraktna klasa
12. override, C++2011
13. final, C++11
14. Polimorfizam i spremnici
15. Polimorfno ponašanje dobivamo ako spremamo pokazivače
16. Pametni pokazivači osiguravaju polimorfno ponašanje i automatsku dealokaciju
17. Polimorfizam i kreiranje objekta nepoznatog tipa
18. Kloniranje
19. Novi konstruktor SmartPointer klase
20. Oblikovni obrasci (Design Patterns)
21. Obrasci se obično dijele u tri grupe
22. Prototype

Polimorfizam

Marko Živković
2026

Bazirano na prezentaciji prof. Mladena Juraka, 2019.

Pitanje

Prerađivanjem metode iz bazne klase u proširenoj klasi želimo nasljediti sučelje metode i promijeniti implementaciju.

class Window{
public:
    void resize(int x, int y) {
    std::cout << "Window::resize"  << std::endl;
    // ....
}
// .....
};

class SimpleDialog : public Window{
public:
    void resize(int x, int y) {
    Window::resize(x,y);   // Neka bazna klasa napravi svoj dio posla ...
    std::cout << "SimpleDialog::resize"  << std::endl;
    // ....
}
// .....
};

Funkcija update() je klijent klase Window. Kako uzima referencu na Window može raditi sa svakom klasom koja je izvedena iz klase Window.

void update(Window& obj)
{
    // ...
    int x=80, y=170;
    //
    obj.resize(x,y);
    // ...
}

Koja će metoda resize() biti pozvana kada update() dobije SimpleDialog objekt?

SimpleDialog dialog;
update(dialog);

Odgovor

Bit će pozvana metoda resize() iz klase Window!

Da bi se funkcija update() zaista ponašala polimorfno, ona bi morala pozvati verziju metode resize() implementiranu u klasi SimpleDialog. Bez toga ne može adekvatno promijeniti dimenziju SimpleDialog prozora.

Da bismo postigli polimorfno ponašanje moramo izmijeniti baznu klasu Window. U njoj funkciju resize() trebamo proglasiti virtualnom:

class Window{
public:
    virtual void resize(int x, int y) {
        std::cout << "Window::resize"  << std::endl;
        // ....
    }
    // .....
};

Kada se virtualna metoda poziva kroz pokazivač ili referencu na baznu klasu poziva se verzija metode iz klase koja je određena dinamičkim tipom pokazivača, odnosno reference.

Sada se u kodu

SimpleDialog dialog;
update(dialog);    // zove SimpleDialog::resize()

na referenci dialog zove metoda update() iz klase SimpleDialog.

Napomena

Polimorfizam je termin koji označava primjenu jednog te istog koda na različite vrste objekata. Objekti moraju pripadati istoj hijerarhiji klasa, a postiže se kroz mehanizam virtualnih funkcija. Polimorfno se mogu ponašati samo klase koje definiraju barem jednu virtualnu funkciju te se stoga takve klase nazivaju polimornim klasama.

Jednostavan primjer

Bazna klasa

class Base{
public:
    virtual void f(){ cout << "Base::f()\n"; }
    void g(){ cout << "Base::g()\n"; }
    virtual void h(){ cout << "Base::h()\n"; }
};

Izvedena klasa

class Derived : public Base{
public:
    virtual void f(){ cout << "Derived::f()\n"; }
    void g(){ cout << "Derived::g()\n"; }
    void z(){ cout << "Derived::z()\n"; }
};

Jednostavan primjer, poziv

void client(Base * pb){
    pb->f();
    pb->g();
    pb->h();
//  pb->z(); - daje grešku pri kompilaciju
}

int main() {
    Derived d;
    client(&d);
}

Rezultat

Derived::f()
Base::g()
Base::h()

Funkcija f() je virtualna i prerađena je u izvedenoj bazi te dobivamo prerađenu verziju metode.
Funkcija g() nije virtualna i premda je prerađena u izvedenoj klasi dobivamo verziju metode iz bazne klase.
Funkcija h() je virtualna ali nije prerađena je u izvedenoj klasi te dobivamo metodu iz bazne klase.
Funkcija z() ne postoji u baznoj klasi i stoga ju klijent ne može pozvati.

Virtualne metode

Kada je funkcija članica bazne klase označena virtual onda se mijenja način na koji se funkcija poziva ako poziv ide kroz pokazivač ili referencu. Ako se statički i dinamički tip pokazivača ili reference razlikuju, onda će biti pozvana verzija virtualne funkcije iz klase koja odgovara dinamičkom tipu.
Dinamički tip neke reference ili pokazivača nije poznat za vrijeme kompilacije i stoga se odluka koja će verzija virtualne funkcije biti pozvana ne može donijeti tijekom kompilacije: ona se donosi za vrijeme izvršavanja programa i taj se proces naziva dinamičko vezanje (eng. dynamic binding).
Metodu činimo virtualnom u baznoj klasi kada je želimo redefinirati u proširenim klasama i kada želimo da implementacija iz proširene klase bude korištena u metodama koje su klijenti bazne klase (kroz pokazivače i reference). Oznaka virtual znači da proširena klasa nasljeđuje samo sučelje (deklaraciju) funkcije, ali može supstituirati vlastitu implementaciju.

Napomena

Objekti nemaju dinamički tip. Kada funkciju zovemo na objektu (na primjer, A a; a.f()) tada nema nikakve razlike između virtualne i nevirtualne funkcije. Uvijek se zove funkcija A::f().

Implementacija polimorfizma

Za svaku klasu koja sadrži barem jednu virtualnu funkciju prevodilac kreira virtualnu tabelu klase koja sadrži pokazivače na virtualne funkcije klase. Nevirtualne funkcije klase ne ulaze u tu tabelu. Virtualna tabela je jedna za sve instance (objekte) dane klase.
U svaku instancu klase prevodilac stavlja pokazivač na virtualnu tabelu klase vtp (virtual table pointer). Radi se o jednom pokazivaču, neovisno o tome koliko ima virtualnih funkcija u klasi. Prisustvo virtualne funkcije u klasi povećava stoga svaku instancu klase za jedan pokazivač. K tome se još stavlja "skriveni kod" u konstruktor koji inicijalizira vtp pokazivač.
Kada treba pozvati virtualnu funkciju prvo se dohvati pokazivač na virtualnu tabelu (vtp) koji sadrži svaki objekt. On je određen tipom objekta i stoga se selekcija virtualne metode vrši prema dinamičkom tipu. Odgovarajuću metodu prevodilac selektira računanjem offset-a u virtualnoj tabeli (koji se zna za vrijeme kompilacije) i zatim se funkcija poziva kroz njen pokazivač.

Implementacija polimorfizma, primjer

class Base{
    public:
        virtual int f(int);
        virtual void g(int);
        int h();
    private:
        int a;
};

class Derived : public Base {
    public:
        virtual int f(int);
        virtual void w(int);
    private:
        int b;
};

Kovarijantni povratni tip

Reimplementacija virtualne funkcije u proširenoj klasi mora imati isti broj i tip parametara te isti povratni tip kao i funkcija u baznoj klasi. To pravilo ima jednu iznimku. Ako virtualna funkcija u baznoj klasi vraća pokazivač ili referencu na baznu klasu, onda njena prerađena verzija u proširenoj klasi može vratiti pokazivač ili referencu na proširenu klasu.

Bazna klasa - metoda `window()` vraća referencu na baznu klasu

class Window{
    public:
        // .....
        virtual Window& window(){
         // Vraća referencu na Window
         // ...
            return *this;
        }
};

Izvedena klasa - metoda `window()` vraća referencu na izvedenu klasu

class SimpleDialog : public Window{
    public:
        // .....
        virtual SimpleDialog& window(){
         // O.K. Vraća referencu na SimpleDialog a ne Window
         // ...
            return *this;
        }
};

Funkciju je dovoljno deklarirati virtualnom samo u baznoj klasi

Prerađene verzije funkcije su automatski virtualne.

class Window{
  public:
      virtual void resize(int x, int y) {
        // Ovdje je deklaracija virtual bitna
        // ....
      }
      // .....
};

class SimpleDialog : public Window{
  public:
      void resize(int x, int y) {
          // Ovdje je deklaracija virtual nije potrebna
          // i stavlja se samo kao informacija
          // ....
      }
      // .....
};

Operator dosega :: zaobilazi virtualni mehanizam

Virtualni mehanizam se može zaobići pomoću operatora dosega. Tako na primjer u metodi update možemo pomoću obj.Window::resize(x,y); pozvati metodu resize iz bazne klase neovisno o dinamičkom tipu reference obj. Analogno vrijedi za poziv kroz pokazivače.

void update(Window& obj)
{
    // ...
    int x=80, y=170;
    //
    obj.Window::resize(x,y); // Poništava virtualni mehanizam
                             // i uvijek zove metodu iz bazne klase ...
}

Napomene

Konstruktori nikad nisu virtualni: to ne bi imalo smisla jer dok se konstruktor izvršava objekt još nije kompletan i njegov dinamički tip nije poznat.
Operator pridruživanja se može učiniti virtualnim, ali to nije korisno.
Ako virtualna funkcija ima defaultne parametre i pozvana je kroz pokazivač ili referencu koriste se defaultni parametri prema statičkom tipu pokazivača ili reference. Stoga prerađena funkcija mora zadržati defaultne vrijednosti bazne funkcije, inače ponašanje može biti neočekivano.

Virtualni destruktor

Čak ako i nemamo potrebe za destruktorom u baznoj klasi trebamo definirati virtualni destruktor ako želimo da klasa služi kao baza za definiciju proširenih klasa.

Bazna klasa bez virtualnog destruktora

struct A {
    A(double x=0.0, double y=0.0, double z=0.0)
    { coo[0]=x; coo[1]=y; coo[2]=z; }

    inline double mean(){
        // ....
    }
    double coo[3];
    ~A(){ std::cout << "~A()"<<std::endl; }  // nevirtualni konstruktor
};

Izvedena klasa

struct B :  A // javno nasljeđivanje (default)
{
    B(double x=0.0, double y=0.0, double z=0.0, const std::string& _name="B") :
                         A(x,y,z), name(_name) {}
    std::string get_name() { return name; }
    ~B(){ std::cout << "~B()"<<std::endl; }
    std::string name;
};

Gubitak memorije

int main()
{
    A *pa = new B(3,6,3);
    // ...
    std::cout << pa->mean() << std::endl;
    delete pa;  // Gubitak memorije: pozvan je samo destruktor klase A
    return 0;
}

Ovdje smo (u naredbi delete pa;) kroz pokazivač čiji je statički tip jednak baznom tipu pozvali nevirtualni destruktor bazne klase. Posljedica toga je da se izvršila destrukcija samo baznog dijela objekta.

Kada destruktor definiramo virtualnim onda se zove destruktor prema dinamičkom tipu objekta — dakle, destruktor izvedene klase. Prevodilac nakon destrukcije izvedenog dijela klase automatski poziva i destruktor baznog dijela i objekt će biti potpuno uništen.

Čista virtualna funkcija i apstraktna klasa

U baznoj klasi ponekad nemamo pravu implementaciju za neku od virtualnih funkcija. U tom slučaju funkciju možemo deklarirati kao čistu virtualnu funkciju tako što ćemo ju izjednačiti s nulom. Na primjer,

virtual void resize(int x, int y) = 0;

Tom deklaracijom kažemo da funkcija nema implementaciju; nju će dati proširene klase. Klasa koja ima barem jednu čistu virtualnu funkciju nazivamo apstraktna klasa. Prevodilac neće dozvoliti instanciranje objekata apstraktne klase. Njena uloga je da služi kao bazna klasa za hijerarhiju klasa koja će biti izvedena iz nje i stoga možemo koristiti samo pokazivače i reference na apstraktnu klasu.

Apstraktna klasa, primjer

class Base{
    public:
        virtual void f() const = 0; // čista virtualna funkcija
        virtual void g() const = 0; // čista virtualna funkcija
};
// konkretna klasa daje implementaciju čistim virtualnim
// funkcijama
class Derived : public Base{
    public:
        void f() const { /*  implementacija */ }
        void g() const { /*  implementacija */ }
};

// klijent bazne klase. Može uzeti samo referencu ili pokazivač na
// Base.
void process(Base const & obj)
{
    obj.f();
    obj.g();
}

int main(){
    Base obj;     // greška - apstraktna klasa
    Derived obj;  // o.k.
    process(obj); // o.k.
}

override, C++2011

Kod prerađivanja virtualne bazne funkcije lako je pogriješiti kao u sljedećem primjeru:

struct Base{
    virtual void f() ;
};
struct Derived : Base{
    void f(int);  // prerađujemo f() ali, greška!
                  // Base::f() ne uzima parametar int.
};

Mislili smo da prerađujemo funkciju void f() iz Base, ali smo je samo sakrili novom funkcijom u Derived. Za prevodilac to nije greška, premda najčešće jest.

U standardu C++11 možemo izraziti namjeru prerađivanja virtualne funkcije pomoću override. U tom slučaju gornja situacija završava greškom pri kompilaciji.

struct Base{
  virtual void f(int) const;
  virtual void g();
  void h();
};

struct Derived : Base{
  void f(int) const override; // ok: f odgovara f iz bazne klase
  void g(int) override;       // greška: Base nema g(int)
  void h() override;          // greška: h nije virtualna
  void k() override;          // greška: B nema funkciju k()

};

Sada prevodilac javlja grešku u tri slučaja u kojima funkcija ne prerađuje virtualnu funkciju iz bazne klase.

override dolazi na kraj deklaracije funkcije.

final, C++11

Ako želimo zabraniti (daljnje) prerađivanje virtualne funkcije možemo je proglasiti finalnom pomoću final. Ključna riječ final dolazi na kraju deklaracije. Primjer:

class Base{
    public:
        virtual void f() const;
        void g();
};

class Derived : public Base{
    public:
        void f() const final; // zabranjujemo daljnje prerađivanje
        void g() final;       // greška final se može primijeniti samo
                              // na virtualnu funkciju
};

class D2 : public Derived{
    public:
        void f() const;  // greška: prerađujemo finalnu funkciju
};

final se može primijeniti samo na virtualnu funkciju i ne ponavlja se u definiciji fukcije izvan klase.

Ako želimo spriječiti proširivanje neke klase možemo je deklarirati kao final. Ključna riječ final dolazi iza imena klase, a ispred eventualne derivacijske liste (dvotočke).

class  A {
  // ...
};

class B final : public A{
  // ...
};

class C : public B { // greška, ne možemo proširivati B
  // ...
};

Polimorfizam i spremnici

Stablo nasljeđivanja:

class A {
   public:
      virtual void name() const {  std::cout << "class A" << std::endl; }
};

class B : public A
{
   public:
      virtual void name() const {  std::cout << "class B" << std::endl; }
};

Koja će metoda biti pozvana?

int main()
{
    std::vector<A>  vec_A;
    A a;
    B b;
    vec_A.push_back(a);
    vec_A.push_back(b);

    vec_A[0].name();
    vec_A[1].name();
}

Kako se objekti predaju spremnicima kopiranjem doći će do izrezivanja baznog podobjekta u naredbi vec_A.push_back(b); Stoga će uvijek biti pozvana metoda name() iz bazne klase.
Kako se objekti ne ponašaju polimorfno u spremnicima trebamo raditi s pokazivačima.

Polimorfno ponašanje dobivamo ako spremamo pokazivače

int main()
{
    std::vector<A*> vec_pA;

    A a;
    B b;

    vec_pA.push_back(&a);
    vec_pA.push_back(&b);

    vec_pA[0]->name();
    vec_pA[1]->name();
}

Sada se ispravno poziva metoda prema dinamičkom tipu pokazivača.
Ponovo se javlja problem dealokacije memorije (ako je dinamički alociramo)! Izlaz je u korištenju pametnih pokazivača, na primjer unique_ptr<A>.

Pametni pokazivači osiguravaju polimorfno ponašanje i automatsku dealokaciju

U spremnik treba umjesto golih pokazivača spremati pametne pokazivače.

Sljedeći kod sada funkcionira korektno i virtualna funkcija bit će pozvana prema svojem dinamičkom tipu:

#include <iostream>
#include <memory>
#include <vector>

class A {
   public:
      virtual void name() const {  std::cout << "class A" << std::endl; }
};

class B : public A
{
   public:
      virtual void name() const {  std::cout << "class B" << std::endl; }
};

int main()
{
    std::vector<std::unique_ptr<A>> vec;
    vec.push_back(std::unique_ptr<A>(new A()));
    vec.push_back(std::unique_ptr<A>(new B()));

    vec[0]->name();  // ispisuje class A
    vec[1]->name();  // ispisuje class B

    return 0;
}

Polimorfizam i kreiranje objekta nepoznatog tipa

Problem

Pametni pokazivač funkcionira samo s dinamički alociranim objektima. Sljedeći kod završava greškom:

B bb;
SmartPointer<B> spbb(&bb);

Zašto?

Rješenje

Da bismo riješili taj problem SmartPointer treba imati konstruktor koji će umjesto pokazivača na dinamički alocirani objekt dobiti kao argument referencu na objekt:

SmartPointer(const T & t);

Taj konstruktor treba lokalno dinamički alocirati kopiju objekta i držati pokazivač na nju. Pri izlasku iz dosega dinamički alocirana kopija objekta bit će dealocirana. Ostaje nam još osigurati polimorfno ponašanje.

To znači da pametni pokazivač koji drži pokazivač statičkog tipa T treba korektno dinamički alocirati objekt svakog tipa koji proširuje T. Drugim riječima, moramo korektno dinamički locirati objekt nepoznatog tipa.

Kloniranje

Tu smo se susreli s problemom konstrukcije objekta čiji nam tip nije poznat ali za koji znamo da proširuje danu baznu klasu.

On se rješava tako što se u svakoj klasi u lancu nasljeđivanja definira virtualna funkcija koja dinamički alocira objekt tipa klase i vraća pokazivač na njega. Tu ćemo funkciju zvati clone().

class A {
  public:
     // ...
     virtual void name() const {  std::cout << "class A" << std::endl; }
     virtual A* clone() const { return new A(*this); } // Kloniraj objekt
};

class B : public A
{
  public:
     // ...
     virtual void name() const {  std::cout << "class B" << std::endl; }
     virtual B* clone() const { return  new B(*this); }  // Kloniraj objekt
};

Nova klasa SmartPointer je sada dana ovdje:

Novi konstruktor `SmartPointer` klase

U našoj implementaciji pametnog pokativača na bazi brojanja referenci (SmartPointer) dodajemo novi konstruktor koji uzima objekt i klonira ga:

template <class T>
class SmartPointer{
  public:
    SmartPointer(T *p) : ptr(p), cnt(new int(1)) {}
      // Novi konstruktor
    SmartPointer(const T &t) : ptr(t.clone()), cnt(new int(1)) {}
     // ...
  private:
    T     * ptr;
    int   * cnt;
};

Problem je riješen uz dva ograničenja:

Klase koje želimo koristiti polimorfno moraju se znati klonirati;
Korisnik mora znati da SmartPointer klasi ne smije dati adresu objekta koji nije dinamički alociran. Umjesto adrese u toj situaciji treba SmartPointer klasi predati objekt.

Novi konstruktor `SmartPointer` klase, korištenje

A* pa = new A();
SmartPointer<A> spa(pa);   // Dinamički alociran objekt

B* pb = new B();
SmartPointer<A> spb(pb);   // Dinamički alociran objekt

B bb;
SmartPointer<A> spbb(bb);  // Statički objekt

std::vector< SmartPointer<A> > vect_A;

vect_A.push_back(spa);
vect_A.push_back(spb);
vect_A.push_back(spbb);

vect_A[0]->name();   // daje "class A"
vect_A[1]->name();   // daje "class B"
vect_A[2]->name();   // daje "class B"

// Dealokacija se provodi automatski

slide 2/22

Polimorfizam

Pitanje

Odgovor

Jednostavan primjer

Bazna klasa

Izvedena klasa

Jednostavan primjer, poziv

Rezultat

Virtualne metode

Implementacija polimorfizma

Implementacija polimorfizma, primjer

Kovarijantni povratni tip

Bazna klasa - metoda window() vraća referencu na baznu klasu

Izvedena klasa - metoda window() vraća referencu na izvedenu klasu

Funkciju je dovoljno deklarirati virtualnom samo u baznoj klasi

Operator dosega :: zaobilazi virtualni mehanizam

Napomene

Virtualni destruktor

Bazna klasa bez virtualnog destruktora

Izvedena klasa

Gubitak memorije

Čista virtualna funkcija i apstraktna klasa

Apstraktna klasa, primjer

override, C++2011

final, C++11

Polimorfizam i spremnici

Polimorfno ponašanje dobivamo ako spremamo pokazivače

Pametni pokazivači osiguravaju polimorfno ponašanje i automatsku dealokaciju

Polimorfizam i kreiranje objekta nepoznatog tipa

Problem

Rješenje

Kloniranje

Novi konstruktor SmartPointer klase

Problem je riješen uz dva ograničenja:

Novi konstruktor SmartPointer klase, korištenje

Bazna klasa - metoda `window()` vraća referencu na baznu klasu

Izvedena klasa - metoda `window()` vraća referencu na izvedenu klasu

Novi konstruktor `SmartPointer` klase

Novi konstruktor `SmartPointer` klase, korištenje