#include <iostream>

using namespace std;

class A{

public: 
	 void myfunk(){cout<<"Klasse A";};

};

class B:public A
{
public:

	void myfunk(){cout<<"Klasse B";};

};

int main()
{

B objekt;

objekt.myfunk(); // Es wird myfunk von B aufgerufen 

}

void rateMal(A *rate)
{
    rate->myfunk();
}

Es gibt wohl nur hier Probleme.
Wenn ich ein B Objekt übergebe, wird immer noch Klasse A aufgerufen.
Liegt das nur daran dass C performant ist und der Compiler keine Zeit hat sich anzuschauen dass eigentlich ein B Objekt übergeben wurde.

Und wenn ich virtual verwende sage ich dem Compiler er soll doch bitte nochmal genauer hinschaun Denn ich bin ja der Programmierer und weiß dass ich die gleiche Funktion in einer abgeleiteten Klasse nochmal verwende . So is es doch .

Wenn ich ein B Objekt übergebe, wird immer noch Klasse A aufgerufen.
Liegt das nur daran dass C performant ist und der Compiler keine Zeit hat sich anzuschauen dass eigentlich ein B Objekt übergeben wurde.

Du übergibst hier kein B Objekt, sondern einen Zeiger auf ein A. Der Grund warum nun die Methode von A aufgerufen wird ist, dass die Methode nicht virtual ist...

Obwohl ich kein virtual verwende wird es richtig aufgerufen.
Eigentlich sollte doch myfunk aus A aufgerufen werden oder.

Erinnerst Du Dich noch an die Grundschulzeit, als Dir das Fragezeichen beigebracht wurde?

Du gehst mir so auf die Nerven.

P.I.-Zeiger

Was meinst Du damit?

PI-Zeiger

Sag bloß, du kennst keine P.I. Zeiger?

Sonst hätte ich wohl nicht gefragt.

314159265358979 schrieb:

Die speichern einen Funktionszeiger + Objektzeiger in 1 Byte rein und damit kann man virtual calls direkt machen, sogar mit weniger Speicherverbrauch als mit normalen Zeigern.

Der Text bietet leider keine Referenz und auch nichts, nach dem man googeln könnte, wenn man wissen wollte, was das sein soll bzw wie es funktioniert.

Virtuelle Methoden funkionieren so:

Für die dynamische Bindung wird zuerst im referenzierten Objekt der virtuelle Methoden-Zeiger auf die VMT(entsprechend der Klasse) ausgewertet, anschließend wird aus dieser die Adresse der virtuellen Methode verwendet. Da sagst du nich' dem Compiler, er soll nochmal genau nachschaun' was du willst.

Und was ist ein virtueller Methodenzeiger? :p

Da du so ein erfahrener und erfolgreicher Software-Entwickler bist, hast du die überaus große Ehre, das zu präsentieren.

Ein virtueller Methodenzeiger ist ein vom Compiler erzeugter (also interner) Funktionszeiger, der je virtueller Methode jedes Objektes diesen zur Verfügung gestellt wird.

Meinst du die vtable?!

VMT <-> Virtual Method Table.

Das er zur Laufzeit erzeugt wird, bedeutet im Endeffekt, dass der Programmierer keinerlei Kontakt mit ihm hat und ihn nicht Kontrollieren kann.
Der Zeiger existiert nur vorübergehend, um die Relationen in den Stammbäumen der Klassen im Bezug auf Virtuelle Methoden korrekt auszugleichen.
Du, Pi, hast auch schon mal versucht das nachzubauen.

Ja, vtalble - so nennt Sie der Compiler.

Undefined reference to 'vtable for MyClass::~Myclass()'

oder so ähnlich, das hat ich schon öfter.

Und wie wird der erzeugt? Durch irgend einen Kobold oder so?

Ja. Ein 2cm großer Kobold namens Grämlin sitzt in deinem PC und kackt Methodenzeiger.

Nein, ohne witz mal. Ich glaub(weiß es aber nicht), der Zeiger wird vom Compiler erzeugt, und zeigt anfangs auf die Basisklassenmethode.

Du meinst wohl Gremlin.
Wie auch immer, lies dir besser nochmal deinen Wiki-Artikel durch, das mit dem zur Laufzeit erzeugten, virtuellen Zeiger ist Unfug

Hast wohl recht...

void funktion(Base* ptr)
{
     //do something
}

main()
{
// Der Compiler sollte doch erkennen dass eine abgeleitete KLasse uebergeben wird
funktion (& DerivedClass ) ;
}

Der Compiler sieht doch welcher Typ uebergeben wird.

Wenn er die Funktion kompiliert, dann weiß der Compiler nur, dass ein Base* übergeben wird. Die Funktion könnte zur Laufzeit aus einer Bibliothek aus aufgerufen werden oder sonstwas, wo der Compiler nichtmal theoretisch den Quellcode des Aufrufs kennen könnte...

Allerdings sind moderne Compiler sehr schlau und werden, wenn angebracht, entsprechende Optimierungen anwenden, wenn sie den Typ des übergebene Objektes zur Laufzeit bestimmen können. Das sind aber nur Optmierungen, die in manchen Fällen möglich sind und ändert nichts am Prinzip der Polymorphie...