 |
C++Talk.NET C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Axel Panning Guest
|
Posted: Thu Oct 07, 2004 8:56 am Post subject: verschachtelung von Klassen |
|
|
Hallo,
class Blub{
public:
Blub(){ myvalue=1; }
~Blub(){ }
int myvalue;
Blub myblub;
};
int main(int argc, char* argv[]){
Blub dummy;
return 0;
}
das Beispiel funktioniert nicht. Leuchtet mir auch ein, da sich das Ding
rekursiv immer wieder selbst instanzieren würde (richtig?). Lösung wäre
'myblub' als Typ 'Blub*' zu deklarieren. Gibt es einen anderen Weg? Geht
mir eigentlich nur darum, daß man die Pointer wieder aufräumen muss, was
ich leider oft vergesse. Darum arbeite ich ungern mit wilden Heap-Daten
die ich irgendwo ins Objekten "hinhänge" udn später wieder zusammen
kratzen muss.
Gruß Axel
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
 |
Daniel Weber Guest
|
Posted: Thu Oct 07, 2004 9:35 am Post subject: Re: verschachtelung von Klassen |
|
|
Axel Panning wrote:
| Quote: | Lösung wäre 'myblub' als Typ 'Blub*' zu deklarieren.
Gibt es einen anderen Weg?
|
Nein, sonst kämst Du beim instaziieren nie zu einem Ende, weil Blub ja
immer wieder ein neues Blub-Objekt enthält. Nur mit Pointern kannst Du
irgendwann NULL zuweisen und aufhören.
Bye,
Daniel
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
 |
Rolf Magnus Guest
|
Posted: Thu Oct 07, 2004 10:28 am Post subject: Re: verschachtelung von Klassen |
|
|
Axel Panning wrote:
| Quote: | Hallo,
class Blub{
public:
Blub(){ myvalue=1; }
~Blub(){ }
int myvalue;
Blub myblub;
};
int main(int argc, char* argv[]){
Blub dummy;
return 0;
}
das Beispiel funktioniert nicht. Leuchtet mir auch ein, da sich das Ding
rekursiv immer wieder selbst instanzieren würde (richtig?).
|
Ja. Ein Blub enhält ein Blub, welches wieder ein Blub enthält, in dem ein
Blub steckt, das ... und immer so weiter. Das Objekt bräuchte unendlich
viel Speicher.
| Quote: | Lösung wäre 'myblub' als Typ 'Blub*' zu deklarieren. Gibt es einen anderen
Weg?
|
Was genau willst du denn damit erreichen? Daß die obige Datenstruktur so
keinen Sinn ergibt, hast du ja selbst bemerkt.
| Quote: | Geht mir eigentlich nur darum, daß man die Pointer wieder aufräumen muss,
was ich leider oft vergesse.
|
Wieso? Beim Schreiben des Destruktors schaut man, was man aufräumen muß und
macht das dort dann alles.
| Quote: | Darum arbeite ich ungern mit wilden Heap-Daten die ich irgendwo ins
Objekten "hinhänge" udn später wieder zusammen kratzen muss.
|
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
 |
Axel Panning Guest
|
Posted: Thu Oct 07, 2004 10:58 am Post subject: Re: verschachtelung von Klassen |
|
|
| Quote: | Lösung wäre 'myblub' als Typ 'Blub*' zu deklarieren. Gibt es einen anderen
Weg?
Was genau willst du denn damit erreichen? Daß die obige Datenstruktur so
keinen Sinn ergibt, hast du ja selbst bemerkt.
|
Das konkrete Problem ist/war folgendes:
Ich hab eine Klasse
struct MPoint{
int x;
int y;
};
class MArea::public vector<MPoint>{
/---
noch so einiges...
---/
MArea convexHull;
MArea edge;
};
Die 'convexeHull' enthält wie man sich denken kann alle Punkte der
convexen Hülle. Ich könnte auch einfach ein vector<int> machen wo ich
einfach nur die Positionen der convexen Hülle spreichere. Analog dazu
halt der 'edge', der alle Punkte des Randes behinhaltet. Hmm werd die
Datenstrukturen wohl übedenken müssen...
evtl. so:
class MSimpleArea::public vector<MPoint>{
/---
noch so einiges...
---/
};
class MAdvancedArea::public MSimpleArea{
MSimpleArea convexHull;
MSimpleArea edge;
};
hätte ja sein können, daß es eine einfachere Lösung gibt... ;)
| Quote: | Geht mir eigentlich nur darum, daß man die Pointer wieder aufräumen muss,
was ich leider oft vergesse.
Wieso? Beim Schreiben des Destruktors schaut man, was man aufräumen muß und
macht das dort dann alles.
Ja sicher, wie gesagt, ich "vergesse" meistens was. Und dann geht die |
Suche los, was da den Speicher so voll stopft. Deshalb hab ich mir
angewöhnt: Solange nur geht auf dem Stack arbeiten. Heap nur wenn
unbedingt nötig... ob das nun sinnvoll ist mag ich nicht zu beurteilen.
Solange nicht unnötig riesige Datenmengen dauernd neu allokiert werden
müssen sollte das doch nicht so falsch sein oder?
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
 |
Falk Tannhäuser Guest
|
Posted: Thu Oct 07, 2004 11:59 am Post subject: Re: verschachtelung von Klassen |
|
|
Axel Panning wrote:
| Quote: | class Blub{
public:
Blub(){ myvalue=1; }
~Blub(){ }
int myvalue;
Blub myblub;
};
int main(int argc, char* argv[]){
Blub dummy;
return 0;
}
das Beispiel funktioniert nicht. Leuchtet mir auch ein, da sich das Ding
rekursiv immer wieder selbst instanzieren würde (richtig?). Lösung wäre
'myblub' als Typ 'Blub*' zu deklarieren.
|
In diesem Fall sollte dieser Zeiger im Konstruktor initialisiert werden:
Blub() myvalue(1), myblub(0) {}
oder vielleicht besser
Blub(Blub* b = 0) myvalue(1), myblub(b) {}
womit sowas wie
Blub dummy(new Blub(new Blub(new Blub)));
ginge.
Natürlich darf dann das passende 'delete' im Destruktor nicht fehlen:
~Blub() { delete myblub; }
| Quote: | Gibt es einen anderen Weg? Geht
mir eigentlich nur darum, daß man die Pointer wieder aufräumen muss, was
ich leider oft vergesse. Darum arbeite ich ungern mit wilden Heap-Daten
die ich irgendwo ins Objekten "hinhänge" udn später wieder zusammen
kratzen muss.
|
Wenn das ganze wie oben beschrieben gelöst wird, sollten sich solche
Probleme vermeiden lassen. Hilfreich dafür ist es allerdings, wenn
'myblub' 'private' gemacht wird und nur über die dafür vorgesehenen
Memberfunktionen manipuliert wird, damit nicht jeder hergelaufene Eumel
diesen Zeiger unkontrolliert umbiegen kann und dabei vergisst, das
alte Objekt freizugeben. (Dieser Rat gilt im allgemeinen für alle
Membervariablen...)
Man könnte auch std::auto_ptr<Blub> anstelle von Blub* verwenden -
umbiegen dann per 'reset', und der Destruktor wird automatisch
aufgerufen.
Außerdem wäre zu überlegen, ob du die Blub-Objekte nicht lieber
in einen Container (z.B. std::list<Blub>) stecken willst, anstatt
eine Art von verketteter Liste von Hand zu programmieren.
MfG
Falk
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
 |
Rolf Magnus Guest
|
Posted: Thu Oct 07, 2004 12:09 pm Post subject: Re: verschachtelung von Klassen |
|
|
Axel Panning wrote:
| Quote: |
Lösung wäre 'myblub' als Typ 'Blub*' zu deklarieren. Gibt es einen
anderen Weg?
Was genau willst du denn damit erreichen? Daß die obige Datenstruktur so
keinen Sinn ergibt, hast du ja selbst bemerkt.
Das konkrete Problem ist/war folgendes:
Ich hab eine Klasse
struct MPoint{
int x;
int y;
};
class MArea::public vector<MPoint>{
/---
noch so einiges...
---/
MArea convexHull;
MArea edge;
};
Die 'convexeHull' enthält wie man sich denken kann alle Punkte der
convexen Hülle.
|
Der konzeptzionelle Fehler hier ist, daß die konvexe Hülle hier wieder
rekursiv weitere konvexe Hüllen hätte.
| Quote: | Ich könnte auch einfach ein vector<int> machen wo ich
einfach nur die Positionen der convexen Hülle spreichere. Analog dazu
halt der 'edge', der alle Punkte des Randes behinhaltet. Hmm werd die
Datenstrukturen wohl übedenken müssen...
evtl. so:
class MSimpleArea::public vector<MPoint>{
/---
noch so einiges...
---/
};
class MAdvancedArea::public MSimpleArea{
MSimpleArea convexHull;
MSimpleArea edge;
};
|
So etwas in der Art scheint mir auch sinnvoll. Evtl. könntest du ja das
MSimpleArea, von dem du ableistest, statt dessen auch zu einem Member
machen.
| Quote: | hätte ja sein können, daß es eine einfachere Lösung gibt... ;)
Geht mir eigentlich nur darum, daß man die Pointer wieder aufräumen muss,
was ich leider oft vergesse.
Wieso? Beim Schreiben des Destruktors schaut man, was man aufräumen muß
und macht das dort dann alles.
Ja sicher, wie gesagt, ich "vergesse" meistens was. Und dann geht die
Suche los, was da den Speicher so voll stopft. Deshalb hab ich mir
angewöhnt: Solange nur geht auf dem Stack arbeiten. Heap nur wenn
unbedingt nötig... ob das nun sinnvoll ist mag ich nicht zu beurteilen.
|
Naja, vieles kann man ja gerade mit den Standardcontainern machen. Die
kapseln die dynamischen Speichergeschichten dann weg.
| Quote: | Solange nicht unnötig riesige Datenmengen dauernd neu allokiert werden
müssen sollte das doch nicht so falsch sein oder?
|
Durchaus. Wenn's geht, ist es keine schlechte Idee, auf dynamischen Speicher
zu verzichten oder irgendwelche Klassen zu verwenden, die sich schon selbst
drum kümmern.
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
 |
Falk Tannhäuser Guest
|
Posted: Thu Oct 07, 2004 12:20 pm Post subject: Re: verschachtelung von Klassen |
|
|
Axel Panning wrote:
| Quote: | Das konkrete Problem ist/war folgendes:
Ich hab eine Klasse
struct MPoint{
int x;
int y;
};
class MArea::public vector<MPoint>{
/---
noch so einiges...
---/
MArea convexHull;
MArea edge;
};
|
Warum eigentlich überhaupt diese Vererbung? Täte es nicht einfach
class MArea
{
std::vector<MPoint> contents;
std::vector<MPoint> convexHull;
std::vector<MPoint> edge;
public:
MPoint& operator[](std::size_t index) { return contents[index]; }
MPoint const& operator[](std::size_t index) const { return contents[index]; }
// ... der ganze Rest
// Auch andere gewünschte 'std::vector'-ähnliche Operationen könnten bei Bedarf
// implementiert und an 'contents' delegiert werden, z.B.
typedef std::vector<MPoint>::iterator iterator;
typedef std::vector<MPoint>::const_iterator const_iterator;
iterator begin() { return contents.begin(); }
const_iterator begin() const { return contents.begin(); }
// usw.
};
MfG
Falk
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
 |
Axel Panning Guest
|
Posted: Thu Oct 07, 2004 12:41 pm Post subject: Re: verschachtelung von Klassen |
|
|
Falk Tannhäuser wrote:
| Quote: | Axel Panning wrote:
Das konkrete Problem ist/war folgendes:
Ich hab eine Klasse
struct MPoint{
int x;
int y;
};
class MArea::public vector<MPoint>{
MArea convexHull;
MArea edge;
};
Warum eigentlich überhaupt diese Vererbung? Täte es nicht einfach
class MArea
{
std::vector<MPoint> contents;
std::vector<MPoint> convexHull;
std::vector<MPoint> edge;
public:
MPoint& operator[](std::size_t index) { return contents[index]; }
MPoint const& operator[](std::size_t index) const { return
contents[index]; }
// ... der ganze Rest
// Auch andere gewünschte 'std::vector'-ähnliche Operationen könnten
bei Bedarf
// implementiert und an 'contents' delegiert werden, z.B.
typedef std::vector<MPoint>::iterator iterator;
typedef std::vector<MPoint>::const_iterator const_iterator;
iterator begin() { return contents.begin(); }
const_iterator begin() const { return contents.begin(); }
// usw.
};
wäre sicherlich auch eine variante. aber hinter |
| Quote: | /---
noch so einiges...
---/
|
verbirgt sich halt noch so einiges, was das ganze imho sinnvoll macht
oder zumindest unkomplizierter. werd aber nochmal drüber nachdenken
ob es sein muss.
danke (auch allen anderen) für die tipps.
axel
--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
|
|
| Back to top |
|
 |
|
|
You cannot post new topics in this forum You cannot reply to topics in this forum You cannot edit your posts in this forum You cannot delete your posts in this forum You cannot vote in polls in this forum
|
|