Dotaz: Dědičnost

[Jardík]

Když mě to programování nedá spát Mám problém s dědičností. Mám třídu Widget. Od této třídy mám odvozenu třídu Container. Třída container obsahuje metodu addWidget( Widget *childWidget ). Problém je, že v této metodě nemohu přistupovat k chráněným proměnným třídy Widget. Tj. následující kód hází chybu:

void Container::addWidget( Widget *childWidget )
{
	if(childWidget->m_pParent == 0)
	{
		// ...
	} else {
		// ...
	}
}

Výstup kompilátoru:

./Toolkit/Widget.h: In member function ‘void Toolkit::Container::addWidget(Toolkit::Widget*)’:
./Toolkit/Widget.h:31: error: ‘Toolkit::Widget* Toolkit::Widget::m_pParent’ is protected
./Toolkit/Container.cpp:35: error: within this context
./Toolkit/Widget.h:30: error: ‘GtkWidget* Toolkit::Widget::m_pWidget’ is protected
./Toolkit/Container.cpp:43: error: within this context
./Toolkit/Widget.h:31: error: ‘Toolkit::Widget* Toolkit::Widget::m_pParent’ is protected
./Toolkit/Container.cpp:45: error: within this context

Odpovědi

[Boris]

Imho stačí změnit v deklaraci třídy Widget proměnnou
private Widget * m_pParent;
na
protected Widget * m_pParent;

[Jardík]

Bohužel to tak mám. Zajímavé je, že když to přetypuji na Container*, tak k nim přistupovat můžu, ale to je docela prasárna.

[podlesh]

Přistupovat přímo k fieldům je prasárna samo o sobě. Já bych tam dal nějakou metodu getParent().

[Michal Kubeček]

Berte to tak, že protected vám umožňuje přístup k prvkům rodiče z metod potomka, ale to se týká jen téže instance. Kromě toho mají metody třídy přístup ke všem prvkům jiných instancí téže třídy podle stejných pravidel jako ke svým vlastním, ale to se netýká jiných instancí rodičovské třídy. Takže

class B {
private:
  int x;
protected:
  int y;
public:
  int z;
  const B& operator = (const B& s);
};

class D : public B {
public:
  const D& operator = (const D& s);
  const D& operator = (const B& s);
};

const B& operator = (const B& s);
{
  x = s.x // OK
  y = s.y // OK
  z = s.z // OK
  return *this;
}

const D& operator = (const D& s);
{
  x = s.x // OK
  y = s.y // OK
  z = s.z // chyba (na obou stranách)
  return *this;
}

const D& operator = (const B& s);
{
  x = s.x // OK
  y = s.y // chyba (na pravé straně)
  z = s.z // chyba (na obou stranách)
  return *this;
}

[Jardík]

class B {
private:
  int x;
protected:
  int y;
public:
  int z;
  const B& operator = (const B& s);
};

class D : public B {
public:
  const D& operator = (const D& s);
  const D& operator = (const B& s);
};

const B& B::operator = (const B& s);
{
  x = s.x // OK
  y = s.y // OK
  z = s.z // OK
  return *this;
}

const D& D::operator = (const D& s);
{
  //tohle se mi nezdá
  //podle mě je chyba v x=s.x (private)
  x = s.x // OK
  y = s.y // OK
  z = s.z // chyba (na obou stranách)
  return *this;
}

const D& D::operator = (const B& s);
{
  // dle toho, co jste říkal by měla být chyba
  // v x=s.x a y=s.y, ne v z=s.z
  x = s.x // OK
  y = s.y // chyba (na pravé straně)
  z = s.z // chyba (na obou stranách)
  return *this;
}

To je docela naprd. Potřebuji totiž nutně nastavit tu chráněnou proměnnou a zároveň nechci, aby byla public. Kdybych si napsal chráněnou metodu třídy Widget, mohl bych ji pak zavolat? Vyzkouším to.

[Michal Kubeček]

V tom zdrojáku máte samozřejmě pravdu, zapomněl jsem, co bylo nahoře, a dole jsem psal, jako bych to měl obráceně (tj. x public, y protected a z private).

Co se vašeho problému týká, nejjednodušší asi bude použít friend deklaraci.

[Jardík]

Tak jsem narazil na další problém. V konstruktoru třídy Widget volám virtuální metodu create(). Tuto metodu má i odvozená třída Label. Problém je v tom, že se vždy zavolá metoda create() třídy Widget. Asi by se neměly volat virtuální metody z konstruktoru, že?

[Michal Kubeček]

Volat je sice můžete, ale nebude fungovat run-time binding. Podrobnější vysvětlení najdete např. v Eckelovi, první díl, kapitola 15, celý mechanismus je tam popsán poměrně podrobně. V podstatě jde o to, že ve chvíli, kdy je prováděn kód konstruktoru, není ještě k dispozici ta část tabulky virtuálních metod, která odpovídá potomkům právě vytvářené třídy.

[Jardík]

Ještě jedna věc. Pokud bych učinil Widget přátelskou třídou třídy Container, zavolala by se virtuální metoda třídy Container?:

class Widget{
protected:
  virtual void nejakaVirtualniFce();
public:
  void nejakaFce();
}

class Container{
public:
  friend class Widget;
protected:
  virtual void nejakaVirtualniFce();
}

void Widget::nejakaFce()
{
  nejakaVirtualniFce();
}

[Michal Kubeček]

Ne, to samozřejmě ne. Deklarace friend pouze umožňuje přístup k protected a private prvkům instance dané třídy, ale volat metodu jiné třídy (aniž by byla použita konkrétní instance) můžete jen tehdy, je-li ta metoda static.

[Jardík]

A toto učinit lze?:

class Widget{
  ..
};

class Container: public Widget{
public:
  friend class Widget;
};

Jestli ne, tak to všechno, co jsem tři dny psal můžu leda tak vyhodit.

[Michal Kubeček]

Ano, znamená to, že metody třídy Widget budou moci přistupovat k prvkům instancí třídy Container stejně jako metody této třídy. Ale samozřejmě jen u instancí této třídy. Takže asi takto:

class Widget {
  virtual ~Widget() {}
  void f();
};

class Container: public: Widget {
private:
  int x;
public:
  virtual ~Container() {}
  friend class Widget;
};

void Widget::f()
{
  Container* pc = new Container;
  pc->x = 0; // OK
  Widget* pw = new Widget;
  pw->x = 0; // chyba

  if (typeid(*this) == typeid(Container) {
    x = 0; // chyba
    this->x = 0; // chyba
    pc = dynamic_cast<Container*>(this);
    pc->x = 0; // OK
  }
}

[Jardík]

Skvěle. Už to začínám pobírat . Teď už jen poslední dotaz ohledně toho přetypování. Proč dynamic_cast<Container*>(this)? Jak se to liší od (Container*)(this)?

[Michal Kubeček]

Když to trochu zjednoduším, jde o to, že dynamic_cast<T*>(p) umožňuje přetypovat pouze pokud

• T je void
• T je rodič typu *p
• T je potomek typu *p (compile-time kontrola) a *p je instance typu T nebo některého jejího potomka (run-time kontrola); to ale pouze za předpokladu, že dědičnost je polymorfní, tj. ty třídy mají aspoň jednu virtuální metodu

Analogicky lze použít dynamic_cast i pro reference.

[Michal Kubeček]

Nebo jednoduše: dynamic_cast je bezpečnější v tom, že snižuje riziko, že přetypujete pointer na něco, čím není.