Jaky je rozdíl v tom když volám potomka/předka(dědičnost) – C / C++ – Fórum – Programujte.com

Mám následující program:

#include <iostream>
using namespace std;
class Medved{
protected:
int delka;
int vaha;
public:
Medved(int vaha, int delka){
this->vaha = vaha;
this->delka = delka;
}
virtual float kolikKrmit(){
return vaha/10+1/delka;
}
};
class Medvide:public Medved{
private:
int vek;
public:
Medvide(int vaha, int delka, int vek):Medved(vaha,delka){
this->vek = vek;
}
float kolikKrmit(){
return vaha/10+1/delka+vek;
}
};
int main () {
Medved* pokus = new Medvide(50,150,3); // a o tohle mi jde, je nějaký rozdíl kdybych tam napsal Medvide*pokus=new...
cout << "Potrebuje " << pokus->kolikKrmit() << " kg zradla" << endl;
delete pokus;
system("PAUSE");
return 0;
}

Stane se ěnco podstatného když vytvářim objekt pomocí předka/potomka? Je to ukázkový příkald půlsemestrálky, jen si nevím rady, proč je tam ten Medved,a co by se stalo kdyybch tam dosadil Medvide.
Díky za vysvětlení

Polymorfismus ... to je ten důvod, proč je tam Medved a není tam Medvide.

Jde v kostce o toto: řekněme, že máš ty svoje medvědy a chceš s nimi v programu pracovat. Můžeš si udělat různé třídy a mít třeba pole medvědů, pole medvíďat, pole medvědic atd. Vždycky ale budeš muset pracovat s tím daným polem a danou třídou, takže budeš separátně procházet medvědy, medvíďata, medvědice atd. S největší pravděpodobností budou mít skoro všechny funkce stejné, a to je nejlepší nasadit pilíř OOP a to polymorfismus :smile1: .

Jde vlastně o to, že vytvoříš základní třídu (v tvém případě Medved), kde definuješ společné rozhraní (funkce) a tyto funkce označíš klíčovým slovem virtual. Potom vytvoříš dceřinou třídu (v tvém případě Medvide), která bude od této dědit a všechny odlišnosti (jinak pracující funkce z toho rozhraní) si implementuje sama a samozřejmě je označíš klíčovým slovem virtual (v tvém příkladě jde o funkci kolikKrmit()). Následně můžeš vytvořit jedno pole (nebo jinou datovou strukturu) typu Medved a jednotlivé položky inicializovat instancemi jednotlivých tříd (Medved, Medvide, Medvedice, atd.) a potom, když budeš volat funkce z toho společného rozhraní, tak se budou volat implementace z jednotlivých (instanci odpovídajících) tříd. Neboli v tvém případě máš sice proměnnou typu Medved, ale inicializuješ jí jako Medvide, takze po zavolání kolikKrmit() se volá implementace z třídy Medvide. Neboli překladač udělá polovinu práce za tebe :smile1: .

A k tvému problému, pokud ti to překladač nebere (ale měl by), tak použij přetypování:

Medved* pokus = (Medved*) new Medvide(50,150,3); 

virtual float kolikKrmit()

{

	if (bJevtom) return(3 * (vaha/10+1/delka));

	else return(Medved::kolikKrmit());

} 

Díky za tak obsáhlou odpověď, trochu jsem to přelouskal, a asi vím co jsi mě tím chtěl anznačit. Já jsem právě dumal, že i když jsem tam dal: Medved* pokus = new Medvide(50,150,3) nebo Medvide* pokus = new Medvide(50,150,3) , tak to vypsalo úplně tu stejnou věc, říkal sjem si proč to tam je teda ten Medvěd(jestli to má nějakou úlohu). A až teď jsem vlastně pochopil že to má určitou spojitost s tím polymorifsmem. Ještě jednou díky za vysvětlení