#include<iostream>
using namespace std;

class Vector
{
private:
	int x,y,z;
public:
	Vector(int a,int b,int c)
	{
		x=a;
		y=b;
		z=c;
	}
	Vector& operator+=(const Vector& v)
	{
		x+=v.x;
		y+=v.y;
		z+=v.z;
		return *this;
	}
	friend ostream& operator<<(ostream &os,const Vector& v)
	{
		os<<v.x<<" "<<v.y<<" "<<v.z;
		return os;
	}
	virtual void test()
	{
		cout<<"Basisklasse!"<<endl;
	}
};

class Abg:public Vector
{
public:
	Abg(int a,int b,int c):Vector(a,b,c) {}
	void test()
	{
		cout<<"Abgeleitete Klasse!"<<endl;
	}
};

int main()
{
    Vector *vptr=&Vector(10,20,30);
    Abg *aptr=&Abg(1,2,3);
    vptr=aptr;
    vptr->test();
    return 0;
}

Wie kann ich aptr auf die Basisklasse Vector zeigen lassen?

Meine 2.Frage:

Gelegentlich findet man solche Anweisungen

if(i>2580000L)

Was genau besagt das L hinter der Konstanten?

Wie kann ich aptr auf die Basisklasse Vector zeigen lassen?

gar nicht aber du kannst vptr auf ein Abg zeigen lassen was auch viel sinnvoller ist

vptr=new Abg(1,2,3);
 vptr->test();
 delete vptr;

K

Wie kann ich aptr auf die Basisklasse Vector zeigen lassen?

bluecode schrieb:

1. nein

Passend bedeutet wohl irgendwas anderes.

Aber um auf die erste Frage zurückzukommen, sollten wir erstmal deine Fehler ansprechen.

Vector *vptr=&Vector(10,20,30);
    Abg *aptr=&Abg(1,2,3);

Das ist gar nicht gut. Evtl. solltest du dir mal die Warnungen deines Compilers genauer anschaun. Der GCC sagt hier zB folgendes

warning: taking address of temporary

Und genau das sind Vector(10,20,30) und Abg(1,2,3), temporäre Objekte. Dh sie werden erzeugt und sofort wieder zerstört, nachdem sie als rvalue nicht mehr benötigt werden. Deine Zeiger existieren aber weiter, nur verweisen sie auf totes Fleisch. Sie sind so nicht benutzbar.
Entweder du erzeugst deine Objekte dynamisch oder du erzeugst die Objekte mit automatischem Speicher, was ich immer vorziehen würde sofern es keine guten Gründe dagegen gibt.

Vector v(10,20,30);
Abg a(1,2,3);

Jetzt haben wir schon mal zwei Objekte die solange verfügabr sind, bis der Gültigkeitsbereich verlassen wird. Du kannst jederzeit Zeiger darauf erzeugen.

Vector* vptr = &v;
Abg* aptr = &a;

Bedenke aber, es sind immer noch zwei verschiedene Objekte. Die Zeiger verweisen somit auch auf unterschiedliche Objekte.
Willst du nun einen Verweis auf die Basisklasse, dann ist das ziemlich trivial. Der Compiler kann sowas nämlich implizit durchführen, sofern public Vererbung vorliegt. Da es in C++ aber solch schöne Sachen wie Referenzen gibt, verwenden wir diese und keine Zeiger.

Vector& a_base = a;

Über a_base kannst du jetzt auf das Bisisklassenobjekt von a zugreifen.

Hab noch ein paar Probleme:

Evtl. solltest du dir mal die Warnungen deines Compilers genauer anschaun

Visual C++ 6 gibt keine Warnung dafür aus.

Vector *vptr=&Vector(10,20,30);
    Abg *aptr=&Abg(1,2,3);

Warum handelt es sich denn hierbei um temporäre Objekte und nicht um ganz normale lokale Objekte?

Willst du nun einen Verweis auf die Basisklasse, dann ist das ziemlich trivial. Der Compiler kann sowas nämlich implizit durchführen, sofern public Vererbung vorliegt

Meinst du ich kann einfach aptr=vptr schreiben?
Dann bekomme ich aber folgende Fehlermeldung:

error C2440: '=' : 'class Vector *' kann nicht in 'class Abg *' konvertiert werden

Über a_base kannst du jetzt auf das Bisisklassenobjekt von a zugreifen.

Hab das jetzt so gemacht:

#include<iostream>
using namespace std;

class Vector
{
private:
	int x,y,z;
public:
	Vector(int a,int b,int c)
	{
		x=a;
		y=b;
		z=c;
	}
	Vector& operator+=(const Vector& v)
	{
		x+=v.x;
		y+=v.y;
		z+=v.z;
		return *this;
	}
	friend ostream& operator<<(ostream &os,const Vector& v)
	{
		os<<v.x<<" "<<v.y<<" "<<v.z;
		return os;
	}
	virtual void test()
	{
		cout<<"Basisklasse!"<<endl;
	}
};

class Abg:public Vector
{
public:
	Abg(int a,int b,int c):Vector(a,b,c) {}
	void test()
	{
		cout<<"Abgeleitete Klasse!"<<endl;
	}
};

Vector v(10,20,30);
Abg a(1,2,3);

int main()
{
	Vector* vptr = &v;
	Abg* aptr = &a;
	aptr=vptr;
	Vector& a_base=a;
	a_base.test();
	return 0;
}

Allerdings wird, wenn ich die Methode test() aufrufe, trotzdem die Methode der abgeleiteten Klasse aufgerugen, trotz virtual-Deklaration.

EDIT

Allerdings wird, wenn ich die Methode test() aufrufe, trotzdem die Methode der abgeleiteten Klasse aufgerugen, trotz virtual-Deklaration.

Jetzt verstehe ich erst was du willst. In diese Richtung geht's nicht so einfach.
So gehts ( habe aber noch nie gesehen dass das jemand absichtlich macht )

Vector vv= a; // slicing
    vv.test();   // Vector.test() wird aufgerufen

//aptr=vptr; // nicht erlaubt

Hmm..

Warum steht dann in der Literatur:

"Ein Zeiger (oder eine Referenz), der auf ein Objekt einer abgeleiteten Klasse weist, kann in einen Zeiger auf ein Objekt der Basisklasse umgewandelt werden. Dies entspricht der Standardkonvertierung, die auch ohne explizite Typumwandlung erlaubt ist."

Visual C++ 6 gibt keine Warnung dafür aus.

Visual C++ 6 ist ja auch kein Compiler. Und dass der darin enthaltene Compiler (MSC) nicht mehr ganz taufrisch ist, da gabs auch schon genügend Beiträge zu. Vielleicht hilft auch, wenn das Warnlevel einfach ganz rauf gesetzt wird.

AJ_Styles schrieb:

Vector *vptr=&Vector(10,20,30);
    Abg *aptr=&Abg(1,2,3);

Warum handelt es sich denn hierbei um temporäre Objekte und nicht um ganz normale lokale Objekte?

Um lokale Objekte handelt es sich trotzdem, nur die Lebensdauer ist eine andere als "normal" erzeugte Variablen/Objekte. Die Lebensdauer endet dann, wenn die Anweisung vollständig abgearbeitet ist. Und wie ich bereits sagte, bedeutet dies praktisch, dass das temporäre Objekt zerstört werden kann, wenn es als rvalue nicht mehr gebraucht wird.

AJ_Styles schrieb:

Meinst du ich kann einfach aptr=vptr schreiben?
Dann bekomme ich aber folgende Fehlermeldung:

error C2440: '=' : 'class Vector *' kann nicht in 'class Abg *' konvertiert werden

Nein. Implizit funktioniert das nur in eine Richtung, nämlich von unten nach oben, dh von abgeleiteter Klasse zur Basisklasse. Für die andere Richtung musst du schon mehr machen. Dann brauchst du einen Cast.

aptr = static_cast<Abg*>(vptr);

Das solltest du aber nur machen, wenn du dir wirklich sicher bist, dass du einen Basisklassenzeiger auf das abgeleitete Objekt (Abg) hast. Ansonsten schaust du dir mal dynamic_cast an. Oder noch besser, du überlegst dir erstmal, ob du diesen Downcast überhaupst brauchst oder nicht doch eine elegantere Lösung findest.

AJ_Styles schrieb:

Hab das jetzt so gemacht:
[...]

Der Code ist bis auf das angesprochene aptr=vptr ok. Globale Variablen wollen wir aber nur im äussersten Notfall. Und solch einer liegt hier nicht vor. Also definieren wir v und a in der main Funktion.

AJ_Styles schrieb:

Allerdings wird, wenn ich die Methode test() aufrufe, trotzdem die Methode der abgeleiteten Klasse aufgerugen, trotz virtual-Deklaration.

Was völlig normal ist, virtual verdeckt nicht sondern überschreibt.

Ich habe noch Probleme mit einigen Formulierungen:

Um noch mal auf meine Literaturquelle zurückzukommen:

"Ein Zeiger (oder eine Referenz), der auf ein Objekt einer abgeleiteten Klasse weist, kann in einen Zeiger auf ein Objekt der Basisklasse umgewandelt werden. Dies entspricht der Standardkonvertierung, die auch ohne explizite Typumwandlung erlaubt ist."

Aber genau das funktioniert ja nicht. aptr, der Zeiger auf die abgeleitete Klasse kann nicht in vptr, einen Zeiger auf die Basisklasse umgewandelt werden?!

Das solltest du aber nur machen, wenn du dir wirklich sicher bist, dass du einen Basisklassenzeiger auf das abgeleitete Objekt (Abg) hast. Ansonsten schaust du dir mal dynamic_cast an. Oder noch besser, du überlegst dir erstmal, ob du diesen Downcast überhaupst brauchst oder nicht doch eine elegantere Lösung findest.

Wieso spricht man in diesem Zusammenhang von einem Downcast? Upcast wäre doch logischer, da man einen Zeiger einer abgeleitete Klasse auf eine Basisklasse zeigen lässt.

"Ein Zeiger (oder eine Referenz), der auf ein Objekt einer abgeleiteten Klasse weist, kann in einen Zeiger auf ein Objekt der Basisklasse umgewandelt werden. Dies entspricht der Standardkonvertierung, die auch ohne explizite Typumwandlung erlaubt ist."

Aber genau das funktioniert ja nicht. aptr, der Zeiger auf die abgeleitete Klasse kann nicht in vptr, einen Zeiger auf die Basisklasse umgewandelt werden?!

Du wandelst nicht aptr in vptr um sondern

aptr=vptr; // nicht erlaubt

wandelt vptr in aptr um. ( aus vptr soll ein aptr werden )

"Ein Zeiger (oder eine Referenz), der auf ein Objekt einer abgeleiteten Klasse weist, kann in einen Zeiger auf ein Objekt der Basisklasse umgewandelt werden. Dies entspricht der Standardkonvertierung, die auch ohne explizite Typumwandlung erlaubt ist."

Aber genau das funktioniert ja nicht. aptr, der Zeiger auf die abgeleitete Klasse kann nicht in vptr, einen Zeiger auf die Basisklasse umgewandelt werden?!

Das solltest du aber nur machen, wenn du dir wirklich sicher bist, dass du einen Basisklassenzeiger auf das abgeleitete Objekt (Abg) hast. Ansonsten schaust du dir mal dynamic_cast an. Oder noch besser, du überlegst dir erstmal, ob du diesen Downcast überhaupst brauchst oder nicht doch eine elegantere Lösung findest.

Wieso spricht man in diesem Zusammenhang von einem Downcast? Upcast wäre doch logischer, da man einen Zeiger einer abgeleitete Klasse auf eine Basisklasse zeigen lässt.

Ich glaube, du hast noch einige Probleme mit dem Verständnis, was zu was umgewandelt wird.

a = b;
 <--

Links steht das Ziel, muss ein sogenannter lvalue sein. Und rechts steht die Quelle, also der rvalue. (wobei b trotzdem auch ein lvalue sein kann)
Sollte also b nicht direkt a zugewiesen werden können, muss eine Umwandlung von Typ(b) nach Typ(a) erfolgen.

Wenn da also steht

vptr = aptr;

dann wird aptr zu vptr umgewandelt, also der Zeiger der abgeleiteten Klasse in einen Zeiger der der Basisklasse.

Wenn da also steht

vptr = aptr;

dann wird aptr zu vptr umgewandelt, also der Zeiger der abgeleiteten Klasse in einen Zeiger der Basisklasse.

Aber wieso kann ich, nach obiger Typumwandlung, aptr trotzdem nicht auf eine Instanz der Basisklasse zeigen lassen, wo aptr doch nun ein Basisklassenzeiger sein sollte?

aptr=&v //Fehler

Und wieso wird, wenn ich jetzt über vptr die Methode test() aufrufe, die Methode der abgeleiteten Klasse aufgerufen? Ich denke, ich habe aptr in vptr umgewandelt und nicht umgekehrt (was ja auch ohne expliziten cast nicht gehen würde)?

Ich denke, ich habe aptr in vptr umgewandelt

Du hast überhaupt nichts umgewandelt ( im sinne von Verändert ).
Ein Zeiger vom typ der Basisklasse zeigt jetzt auf ein Object der abgeleiteten Klasse. Umgekehrt ist das nicht möglich ein Zeiger vom Typ einer Abgeleiteten Klasse kann ( ohne expliziten cast ) nicht auf ein Object vom typ der Basisklasse zeigen. Das kann ja auch nicht sein da der Basisklasse ja Attibute der abgeleiteten Klasse fehlen könnten, eine abgeleitete Klasse erbt aber immer alle Attribute der Basisklasse also ist auch kein cast notwendig.

Und wieso wird, wenn ich jetzt über vptr die Methode test() aufrufe, die Methode der abgeleiteten Klasse aufgerufen?

Der einzige Sinn von Polymorphie ist es ja, dass über einem Zeiger vom typ der Basisklasse eben auf die virtuellen Methoden der konkreten (abgeleiteten) Klasse zugegriffen wird (late binding).
Kurt

Aber wieso kann ich, nach obiger Typumwandlung, aptr trotzdem nicht auf eine Instanz der Basisklasse zeigen lassen, wo aptr doch nun ein Basisklassenzeiger sein sollte?

Nein, aptr ist kein Basisklassenzeiger. Ich erinnere dich nochmal an die Deklaration

Abg* aptr

AJ_Styles schrieb:

Und wieso wird, wenn ich jetzt über vptr die Methode test() aufrufe, die Methode der abgeleiteten Klasse aufgerufen?

Das hab ich dir doch schon beantwortet.

virtual verdeckt nicht sondern überschreibt

Die Funktion ist nunmal virtuell. Wenn du also willst, dass die Funktion der Basisklasse aufgerufen wird, dann musst du auch ein Objekt der Basisklasse instanzieren.

Vielleicht solltest du dir das ganze mal etwas bildlich vorstellen.

----------------------------------------
|              Abg Objekt              |
|--------------------------------------|
| Vector     | vtable     | Abg only   |
|------------|------------|------------|
| x          | test()     | ctor       |
| y          |            | ...        |
| z          |            |            |
| ctor       |            |            |
| ...        |            |            |
----------------------------------------

Du instanzierst also ein Objekt des Typs Abg. Dieses kannst du dir bildlich wie mein ASCII-Art vorstellen. Da wäre der Teil der Basisklasse (Vector), die vtable und der Teil der in Abg noch hinzugekommen ist (Abg only). In der vtable werden die Adressen der virtuellen Funktionen abgespeichert. Hat deine Klasse keine virtuellen Funktionen, so kann der Teil auch wegfallen. Bei der Instanzierung wird dort also die Adresse von Abg::test abgelegt.
Wenn du jetzt einen Zeiger auf dieses Objekt hast (Abg*) und wandelst diesen in einen Zeiger der Basisklasse um (Vector*), dann zeigt dieser auf den Vector Teil. Rufst du jetzt test() auf, sieht der Compiler, dass es eine virtuelle Funktion ist (so hast du diese ja schliesslich in Vector deklariert) und schaut dementsprechend in die vtable. Dort steht immer noch Abg::test und diese Funktion ruft er dann auch auf.
Und genau darin liegt ja auch der Witz von virtual, du hast also eine Referenz oder einen Zeiger auf die Basisklasse, es wird aber trotzdem die Funktion des eigentlich instanzierten Objektes, nämlich der abgeleiteten Klasse, aufgerufen.

Also eine Zusammenfassung:

Wenn ich schreibe

aptr=vptr

;

Ich möchte, dass mein Zeiger aptr (der auf eine abgeleitete Klasse zeigt) auf das Objekt zeigt, dessen Adresse in vptr gespeichert ist (in diesem Fall also eine Instanz der Basisklasse Vektor).Da beide Typen nicht kompatibel sind, muss vptr zuvor per static_cast in ein Zeiger auf die abgeleitete Klasse umgewandelt werden. Der Cast ist notwendig, da sich in der abgeleiteten Klasse ja andere (zusätzliche) Elemente als in der Basisklasse befinden können.
Umgekehrt ist kein cast nötig, da der Compiler dies implizit durchführen kann (sofern public-Vererbung vorliegt).

Kann man das so stehen lassen?

Das mit der virtuellen Tabelle und der späten Bindung wurde auch sehr gut erklärt.

Eine Sache wundert mich dennoch:

Wenn du jetzt einen Zeiger auf dieses Objekt hast (Abg*) und wandelst diesen in einen Zeiger der Basisklasse um (Vector*), dann zeigt dieser auf den Vector Teil.

Das heisst eigentlich zeigt der Pointer gar nicht auf eine Instanz der Basisklasse, sondern vielmehr auf den Vector-Teil im abgeleiteten Objekt?