warum lässt sich folgender Code nicht übersetzen ?????

class A {};
class B: public A {};

int main(void)
{
B* pB = new B;
A* pA = pB; // OK
A** ppA = &pB; <- Hier ist das Problem ?
}

Ich bekomme folende Fehler:
MSVC 8.0: error C2440: 'initializing' : cannot convert from 'B **__w64 ' to 'A **'
gcc 3.3.3: cannot convert `B**' to `A**' in initialization

Grüße,
Philipp

(btw, "A** ppA = &pA;" ist übrigens erlaubt, falls du es unbedingt brauchst)

Weshalb spielt die Polymorphie eine Rolle ?

und warum die Objektgröße ? Wie Du schreibst, in einer Ebene geht es (da ist die Objektgröße ja kein Problem) und dann kommt ja nur der Pointer hinzu und Pointer sind immer gleich groß, egal wo sie hinzeigen....

Kannst Du das mal eventuell in einem konstruierten Beispiel zeigen, wo es Probelme mit der Polymorphie / Objekgröße geben würde (wenn der obige Code funktionieren würde) ? Danke !!

Und was genau verbirgt sich hinter Deinem "etc" ?

class base
{
public:
  // ...
};

class a : public base
{
public:
  // ...
};

class b : public base
{
public:
  // ...
};

// ...

base* ptr = new a;
b* ptr_2_b = ptr; // wäre falsch und ist daher nicht möglich

ein zeiger auf eine basisklasse kann auch auf eine abgeleitete klasse zeigen. aber nicht umgekehrt. denn es gibt meistens mehrere abgeleitete klassen. woher soll der compiler dann wissen auf welchen typ der zeiger wirklich zeigt.

schau dir mal dynamic_cast an

base* ptr = new a;
b* ptr_2_b = ptr;

was hat das mit der frage zu tun?

ok, alles klar.....wo ist der Zusammenhang mit dem oben genannten Problem ?? Ich habe nur Pointer vom Typ der Basisklasse...

Die Frage war, WARUM geht es nicht. Das es nicht geht ist klar und wie ich es (für mein Problem hier) umgehen kann, auch.

Aber mir ist nicht klar, warum der Compiler das nicht automatisch erkennt.
Weil:

B* pB = new B;
A* pA = pB;

A** ppA1 = &pA; <- geht, ist ein pointer auf einen A pointer, der auf ein B zeigt
A** ppA2 = &pB; <- geht nicht, soll ein pointer sein, der auf einen B pointer zeigt, der auf ein B zeigt.

Dabei kann aber ein b pointer auf ein B einem A pointer zugewiesen werden....

und das zweite (mit den doppelpointern) hat mit dem ersten doch nix zu tun!?

Aber ich hoffe das CStoll seinen Beitrag etwas erläutert. Er scheint verstanden zu haben, um was es geht.

also die frage war warum das nicht geht:

B* b = new B;
A** = &b;

ganz einfach, weil das auch nicht geht:

float* blub = new float;
int** pi = &blub;

wenn du einen pointer auf eine abgeleitete klasse in einen pointer auf eine basisklasse umcastest, kann es sein, dass der pointer dabei verändert werden muss (damit er auch wirklich auf das in der abgeleiteten klasse enthaltene objekt der basisklasse zeigt).

B* b = new B;
A** a = &b;

wäre das möglich, würde in so einem fall *a auf das falsche objekt zeigen.

SRY: ich sollte mal etwas genauer lesen...

also die frage war warum das nicht geht:

B* b = new B;
A** = &b;

ganz einfach, weil das auch nicht geht:

float* blub = new float;
int** pi = &blub;

...

Also Deine Erklärungsversuche in allen Ehren, aber die hilft hier nicht weiter.
DAS

float* blub = new float;
int** pi = &blub;

geht nicht, weil auch

int* blub = new float;

nicht geht => weil int und float keine polymorphen Typen sind.

Gruß,

Simon2.

Wohlgemerkt, das B ja ein A ist !

class A {};
class B: public A {};

B* pB = new B;
A* pA = new A;
A* pAB = pB;

Geht:
A** ppA1 = &pA;
logisch, da pA ein pointer vom Typ A* (auf ein A ist) und man mit einem A** darauf zeigen kann. Typprüfung nachvollziehbar

A** ppA1 = &pAB;
logisch, da pAB ein pointer vom Typ A* (auf ein B ist) und man mit einem A** darauf zeigen kann. Typprüfung nachvollziehbar.

Geht nicht:
A** ppA2 = &pB;
weil pB ein pointer vom Typ B* (auf ein B ist) und man mit einem A** nicht darauf zeigen kann, weil:
man mit einem pointer vom Typ B* nur auf ein B zeigen kann, nicht aber auf ein A (da das die Elternklasse ist). Man kann einem pointer vom Typ B* nicht einen pointer vom Typ A* zuweisen (außer mit dynamic_cast oder static_cast).

Ist das so richtig verstanden ?

Die Typen A* und B* haben sogesehen rein garnichts miteinander gemeinsam.

jo, das war es auch, was mein beispiel mit dem int und dem float aussagen sollte. das beispiel war nur von mir leider "etwas ungut" (saublöd) gewählt^^ sry dafür

Endlich, ok das ist eine wirklich gute und verständliche Begründung. Jetzt ist alles klar ! Danke !

Das mit Objektgröße/Polymorphie hat mich so wie oben gepostet etwas irritiert.

PS. bleibt immer noch die Frage, warum man C++ nicht so definiert hat, dass es aus dem Zusammenhang A<->B auch den Zusammenhang A*<->B* erkennen kann....aber das wäre wohl ein anderer Post

Was für ein Schwachsinn !!! Natürlich kann ich einem pointer vom Typ B* einem pointer vom Typ A* zuweisen, mach ich oben ja sogar ! Immer noch ein Rätzel...

meinst du einem pointer vom typ B* einen poiner vom typ A* zuweisen oder umgekehrt?
falls ersteres:
nein, nicht ohne cast

PhilippMaurer schrieb:

bleibt immer noch die Frage, warum man C++ nicht so definiert hat, dass es aus dem Zusammenhang A<->B auch den Zusammenhang A*<->B* erkennen kann....aber das wäre wohl ein anderer Post

was sollte das:

A** ppA = &pB;

deiner meinung nach tun?

A** -> A* -> A (geht in C++)
A** -> A* -> B (geht in C++)

A** -> B* -> B (geht nicht in C++)

A** ppA = &pB;

einem zeiger auf ein A* wird die adresse eines B* zugewiesen. wie soll das funktionieren? ein B* zeigt ja nicht auf ein objekt vom typ A!?
ein B* kann lediglich in ein A* umgewandelt werden. das bedeutet nicht, dass ein B* ein A* ist. nachdem ein B* kein A* ist, wie soll also einem A** die adresse eines B* zugewiesen werde können!?

das ist keine frage der definition von C++, sondern es ist einfach nicht möglich/sinnvoll.

denk dir einfach folgendes:
nehmen wir an deine B objekte sehen im speicher so aus

___________
|         |
|    B    |
| _______ |
| |     | |
| |  A  | |
| |_____| |
|_________|

ein B* würde auf den beginn des B objektes zeigen. wandelst du den zeiger in einen A* um, dann zeigt das ergebnis auf das A in dem B. der wert des zeigers ist ein anderer. wenn du jetzt einem A** die adresse eines B* zuweisen würdest, dann würde der A** auf einen wert zeigen der nicht auf das A, sondern auf das B zeigt.

Einen Pointer auf einen B Pointer der auf ein B zeigt, aber vom Typ A**. Da A die Elternklasse von B ist, wären folgende "Zeigerketten" für mich logisch einwandfrei:

A** -> A* -> A (geht in C++)
A** -> A* -> B (geht in C++)

A** -> B* -> B (geht nicht in C++)

Hier liegt ein Denkfehler schon beim einfachen Zeiger vor.
Ein B* zeigt immer nur auf ein B und ein A* immer nur auf ein A aber niemals auf ein B. Da A die Basisklasse von B ist, kann ein A* auf ein A-Objekt zeigen, dass das Basisklassensubobjekt eines B-Objektes ist - aber auch dann zeigt unser A* nur auf das A-Subobjekt.
Wenn die Adresse eines B bekannt ist, so lässt sich damit die Adresse das A-Subobjektes in diesem B ermitteln - und C++ ist freundlich genug, das Ganze als implizite Konvertierung zuzulassen - diese Tatsache sagt aber nichts über die Pointerobjekte selbst aus. Wenn ein A** auf ein B* zeigen könnte, setzte das voraus, dass ein B*-Objekt identisch mit einem A*-Objekt ist - aber der innere Aufbau von Pointern ist (nahezu) völlig unbestimmt. Ganz nebenbei muss die Adresse eines Basisklassensubobjektes nicht mit der das vollständigen Objektes übereinstimmen - bei Mehrfachvererbung ist das offensichtlich, aber auch bei Einfachvererbung gibt es diesbezüglich keine Beschränkungen.