Ich habe eine Klasse Kopf , die eine Liste mit Positionen hat.

class Kopf {

   public:
        std::list<Position*>   m_pobPosition;

};

Und dann habe ich eine andere Klasse- UnterKopf
[code]
class UnterKopf :public Kopf
{

public:
std::list<UnterPosition*> m_pobPosition;

};

Jetzt möchte ich den Zeiger , der auf diese Liste >Position> zeigt
umbiegen . Er soll zeigen auf die Liste <UnterPosition>.

Mein Problem ist , ich weiß nicht wie ich den Zeiger , der auf die Liste <Position> zeigt zurückbekomme .

Danke.

LG, Rixa

Hallo,...

Du solltest deine Frage nochmal so formulieren das man sie eindeutig verstehen kann.

Jetzt aber mehrere Anmerkungen vielleicht ist darin auch deine Frage beantwortet:
a) Membervariablen sollte man nicht public deklarieren
b) Du kannst keinen Container eines Types in einen eines anderen Types konvertieren, nur kopieren.
c) Du kannst einen Zeiger auf eine Basisklasse in einen der entsprechenden Unterklasse mittels dynamic_cast konvertieren, sofern das Objekt dahinter tatsächlich einen damit kompatiblen Typ entspricht.
d) Dir ist hoffentlich bewusst das du mit der definition der Liste in der abgeleiteten Klasse die gleichnamige in der Basisklasse überdeckst.
e) Mit Polymorphie hast du dich hoffentlich schonmal beschäftigt. Du kannst in eine Liste mit Zeigern auf die Basisklasse auch Objekte der abgeleiteten speichern.

cu André

std::list<Position> *   m_pobPosition;
//statt
std::list<Position*>   m_pobPosition;

wenn du m_pobPosition auf die liste mit den UnterPositionen zeigen lassen willst, das geht nicht.

vielleicht willst du auch etwas anderes und ich verstehe dich nicht.

Ich versuch's nochmals.
1 *
Kopf ---- > KopfItem <---- pobPosition
| |
| |
Unterkopf UnterkopfItem <---- pobUnterposition

Ich habe eine Basisklasse : Kopf
Diese Basisklasse hat eine Collection: pobPosition , die Objekte vom Typ KopfItem beinhaltet.

Dann habe ich eine Klasse Unterkopf , die hat eine Collection: pobUnterposition, duie Objekte der Klasse: UnterkopfItem beinhaltet.

Die Klasse: Unterkopf ist von der Klasse: Kopf abgeleitet. Die Klasse UnterkopfItem ist von der Klasse : KopfItem abgeleitet.

Ich möchte , ( ich denke , dass das geht ) den Zeiger , mit dem der Kopf auf seine Collection :pobPositionen zeigt , holen und ihn auf die Collection
pobUnterposition zeigen lassen.

Viele Grüße, Rixa

1 *
Kopf ---- > KopfItem Das ist die: <---- pobPosition
| | Diese Strichle bedeutetn : Ableitung
| 1 * |
Unterkopf ---- > UnterkopfItem Das ist die: <---- pobUnterposition

Ich habe also 2 Klassen:
Unterkopf ist abgeleitet vom Kopf
Unterkopitem vom Kopfitem.

Kopf hat eine Collection pobPosition , die Objekte der Klasse: KopfItem beinhaltet.
Unterkopf hat eine Collection pobUnterposition , die Objekte der Klasse: UnterkopfItem beinhaltet.

Danke.

Grüße, Rixa

Ich möchte , ( ich denke , dass das geht ) den Zeiger , mit dem der Kopf auf seine Collection :pobPositionen zeigt , holen und ihn auf die Collection
pobUnterposition zeigen lassen.

Welcher Zeiger denn?
Namen sind Schall und Ruach und lenken in diesem Falle nur ab, ich versuch noch mal, das Ganze zu ordnen:

class ItemA { /* ... */ };
class ItemB : public ItemA { /* ... */ };

class A { public: std::list<ItemA*> m_a; };
class B : public A { public: std::list<ItemB*> m_b; };

was nun? welches Problem soll glöst werden?

Hallo Camper,

Ich möchte jetzt dass die Klasse A auf die Elemente der Collection
std::list<ItemB*> m_b zugreifen kann.

Normaleweise kann sie das nicht , aber wenn ich der Klasse A sagen kann ,
du hast jetzt die Collection m_b und nicht m_a dann müsste es gehen .
Aber wie ?

Viele Grüße ,Rixa

Ich möchte jetzt dass die Klasse A auf die Elemente der Collection
std::list<ItemB*> m_b zugreifen kann.

m_b von welchem Objekt vom Typ B?

m_b von welchem Objekt vom Typ B?

ja. Ich benutze deine Dekl. die m_b Liste hängt am Objkt der Klasse B.

Ich möchte aber , dass Objekt der Klasse A sie kennt .

Rixa

ja. Ich benutze deine Dekl. die m_b Liste hängt am Objkt der Klasse B.

Ich möchte aber , dass Objekt der Klasse A sie kennt.

Dann musst du sie zur Membervariable der Klasse A machen..

Dann musst du sie zur Membervariable der Klasse A machen..

Das kann ich nicht . Die Basisklasse gehört zur Fremdimplementation.

Grüße , Rixa

da kann ich Badestrand absolut recht geben.

Falls du dich jetzt dazu entscheiden willst aus der Liste nen Zeiger
auf eine Liste zu machen und den in dem Konstruktor von Unterkopf
umbiegen willst, kriegst du allerdings auch Probleme.

class Kopf { 

protected: 
    std::list<Position*>*   m_pobPosition; 

};

class UnterKopf : public Kopf {
public: 
    UnterKopf();

private:
    std::list<UnterPosition*> m_upobPosition; 

}; 

UnterKopf::UnterKopf(){
    m_pobPosition = &m_upobPosition; // Das geht leider nicht
}

http://www.research.att.com/~bs/bs_faq2.html#conversion

Ich wollte dich nur schonmal vorwarnen
Ich glaub auf sowas wolltest du eigentlich hinaus.
Sowas kann man wohl mit Templates (solange es nicht virtual ist) umgehen.
Wenn du eigentlich darauf hinaus wolltest, sag Bescheid, ich kuck morgen
(äh, heute abend) wieder rein.

btw: Soll Unterkopf denn auch ne Position-Liste haben oder nur eine
Unterposition-Liste?

Gruß,
CSpille

vielen Dank ! Ja , genau so wollte ich es machen.

Hmm, schade das es nicht geht.

Viele Grüße, Rixa