Cvičení 7

Dědičnost. Runtime polymorfizmus. Slicing.

Úloha

Knihovna

• obsahuje seznam titulů

• každý titul může být:

  • Kniha: název, autor, počet stran
  • Časopis: název, autor, rok, číslo
  • CD: název, autor, názvy skladeb

• vypsat všechny informace o všech titulech autora

• kolik je v knihovně knih od daného autora

• nedělat konzolové rozhraní, stačí naplnit data v kódu a provést akci

Hierarchie tříd

• všechny tituly mají některé vlastnosti a operace společné

Dědičnost

class Base{
  int dataBase;
public:
  Base(int data):dataBase(data){}
  virtual void method(){
    cout << dataBase << endl;
  }
};
class Derived : public Base {
  string dataDerived;
public:
  Derived(int dataBase, string dataDerived):
    Base(dataBase), dataDerived(dataDerived){ }

  void method() override{
    Base::method();
    cout << dataDerived << endl;
  }
};
Derived d(1, "x"); d.method();

Virtuální volání

Volání metody odvozené třídy přes ukazatel na předka

#include<memory>
class Base{
  virtual void method() = 0;
  ...
};

class Derived : public Base{
  void method() override {
     ...
  }
};
unique_ptr<Base> b
  = make_unique<Derived>();

b->method();

Virtuální volání

Base b;
Derived d;

Nepolymorfní vektor

vector<Base> vec_base;

Slicing

vector<Base> vec_base;
vec_base.push_back(Derived());

Base b = Derived();

Zákaz kopírování

class Base{
  Base(const Base&) = delete;
  Base& operator=(const Base&) = delete;
public:
  Base(){}
  ...
};

Abstraktní předek

• žádné interface, žádné abstract
• metody které musejí být předefinovány jsou =0 (čistě virtuální)
• třída, která obsahuje čistě virtuální metody, je abstraktní

class Base{
  virtual void method() = 0;
  ...
};

class Derived : public Base{
  void method() override {
    ...
  }
};

Polymorfní vektor

vector<unique_ptr<Base> > vec_ptr_base;

Kopírování

Z unique_ptr nelze tvořit kopii:

void m(unique_ptr<Base> p){
  unique_ptr<Base> p2 = p; 
}

void m(unique_ptr<Base> p){
  unique_ptr<Base> p2 =
    make_unique<Base>(p); 
}

Klonování

class Base{
public:
  virtual unique_ptr<Base> clone() const = 0;
};
class Derived : public Base{
public:
  unique_ptr<Base> clone() const override{
    return make_unique<Book>(*this);
  }
};
void m(unique_ptr<Base> p){
  unique_ptr<Base> p2 = p->clone();
}

Virtuální destruktor

• unique_ptr<Base> automaticky odalokuje objekt.
• ale je nutné zařídit, aby se zavolal správný destruktor pro Derived.
• destruktor také musí být virtuální

class Base{
  virtual ~Base(){}
};
class Derived : public Base{
};


unique_ptr<Base> p = make_unique<Derived>();

Test na typ

Jak zjistit, zda je objekt daného typu?

Base* b = ...
Derived* d = dynamic_cast<Derived*>(b);
if(d){
  ...
}

Při použití na reference nelze vrátit nullptr:

Base& b = ...
Derived& d = dynamic_cast<Derived&>(b);