 |
C++Talk.NET
C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Michael Sabo
Guest
|
 Posted: Sat Feb 25, 2006 2:05 pm Post subject: dynamische / statische Objekte |
 |
|
Hallo zusammen,
manchmal könnte es doch durchaus Sinn machen, innerhalb einer Klasse zu
wissen ob diese dynamisch oder statisch instanziiert wurde (z.B. für einen
automatischen Aufruf von delete).
So viel ich weiss, sollte ja sowas egal sein und ist nicht sprachlich
vorgesehen. Aber gibt es trotzdem Möglichkeiten an diese Information zu
gelangen?
Dachte da z.B. an eine "geheime" Methode oder Objektattriut (sowas wäre
allerdings bestimmt herstellerspezifisch). Habe zuerst gedacht, sowas könnte
man mit einer globalen Variablen und Critical Sections lösen. So könnte der
Operator new die Variable setzen und bei Aufruf des Konstruktors dieser
prüfen ob diese gesetzt ist. Aber denke das dies so doch nicht gehen kann,
denn sobald der Operator new ausgeführt wurde, im Konstruktor nun nicht
gewusst wird
- wird nun das neue dynamische Objekt nun initialisiert
- oder legt ein anderer Thread nur ein neues statisches Objekt an und die
Thread-Umschaltung war nun gerade zufälligerweise zwischen dem Aufruf von
Operator new und dem Kostruktor
Für irgendwelche Anregungen bin ich euch sehr dankbar!
Mfg
Michael
--
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 |
|
 |
Stefan Reuther
Guest
|
| Posted: Sun Feb 26, 2006 12:06 am Post subject: Re: dynamische / statische Objekte |
|
|
Michael Sabo wrote:
| Quote: | manchmal könnte es doch durchaus Sinn machen, innerhalb einer Klasse zu
wissen ob diese dynamisch oder statisch instanziiert wurde (z.B. für einen
automatischen Aufruf von delete).
So viel ich weiss, sollte ja sowas egal sein und ist nicht sprachlich
vorgesehen. Aber gibt es trotzdem Möglichkeiten an diese Information zu
gelangen?
Dachte da z.B. an eine "geheime" Methode oder Objektattriut (sowas wäre
allerdings bestimmt herstellerspezifisch).
|
Du kannst oftmals einfach feststellen, in welchem Segment (data / bss /
stack oder eben heap) ein Objekt liegt, indem du dir vom Linker die
Startadressen geben lässt und vergleichst. Das geht logischerweise auf
jedem System anders. Das hilft dir aber auch nicht, wenn dein Objekt auf
dem Stack eines Threads liegt, der vom Heap allokiert wurde.
| Quote: | Habe zuerst gedacht, sowas könnte man mit einer globalen Variablen und
Critical Sections lösen. So könnte der Operator new die Variable setzen
und bei Aufruf des Konstruktors dieser prüfen ob diese gesetzt ist.
Aber denke das dies so doch nicht gehen kann, denn sobald der Operator
new ausgeführt wurde, im Konstruktor nun nicht gewusst wird
- wird nun das neue dynamische Objekt nun initialisiert
- oder legt ein anderer Thread nur ein neues statisches Objekt an und die
Thread-Umschaltung war nun gerade zufälligerweise zwischen dem Aufruf von
Operator new und dem Kostruktor
|
Genau. Auch zu bedenken wäre: was ist, wenn ein Objekt einer
abgeleiteten Klasse allokiert wird? Und die verschärfte Version: was,
wenn dein Objekt Teil einer abgeleiteten Klasse ist, die mehrere
Subobjekte dieses Typs hat? (class A1:B; class A2:B; class C:A1,A2).
Was, wenn ein Array auf dem Heap allokiert wird?
Meiner Meinung nach kann sowas nicht (zuverlässig) funktionieren. Du
kannst höchstens den Zugriff auf den Konstruktor einschränken, und somit
alle Objekte über eine Factory-Funktion erstellen.
Eine weitere Möglichkeit wäre, das Wissen über die Platzierung explizit
zu übergeben.
Und die Kombination aus beidem wäre
class Foo {
bool on_heap;
void* operator new(std::size_t x)
{ return ::operator new(x); }
Foo(bool on_heap)
: on_heap(on_heap)
{ }
public:
Foo()
: on_heap(false)
{ }
static Foo* create()
{ return new Foo(true); }
};
Du musst halt dann alle Objekte per Factory-Funktion anlegen.
Stefan
--
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 |
|
|
Heinz Ozwirk
Guest
|
| Posted: Sun Feb 26, 2006 4:13 am Post subject: Re: dynamische / statische Objekte |
|
|
"Michael Sabo" <Michael.Sabo (AT) gmx (DOT) de> schrieb im Newsbeitrag
news:44001dd5$0$13596$9b4e6d93 (AT) newsread2 (DOT) arcor-online.net...
| Quote: | Hallo zusammen,
manchmal könnte es doch durchaus Sinn machen, innerhalb einer Klasse zu
wissen ob diese dynamisch oder statisch instanziiert wurde (z.B. für einen
automatischen Aufruf von delete).
So viel ich weiss, sollte ja sowas egal sein und ist nicht sprachlich
vorgesehen. Aber gibt es trotzdem Möglichkeiten an diese Information zu
gelangen?
Dachte da z.B. an eine "geheime" Methode oder Objektattriut (sowas wäre
allerdings bestimmt herstellerspezifisch). Habe zuerst gedacht, sowas
könnte man mit einer globalen Variablen und Critical Sections lösen. So
könnte der Operator new die Variable setzen und bei Aufruf des
Konstruktors dieser prüfen ob diese gesetzt ist. Aber denke das dies so
doch nicht gehen kann, denn sobald der Operator new ausgeführt wurde, im
Konstruktor nun nicht gewusst wird
- wird nun das neue dynamische Objekt nun initialisiert
- oder legt ein anderer Thread nur ein neues statisches Objekt an und die
Thread-Umschaltung war nun gerade zufälligerweise zwischen dem Aufruf von
Operator new und dem Kostruktor
Für irgendwelche Anregungen bin ich euch sehr dankbar!
|
Nur eine Idee:
Leite von deiner Klasse zwei weitere ab. Die eine bekommt einen privaten
Destruktor. Instanzen dieser Klasse können nicht "auf dem Stack" abgelegt
werden. Die zweite Klasse bekommt einen privaten operator new, der nicht
einmal implementiert werden muss. Instanzen dieser Klasse können nicht mit
new erzeugt werden. Die Konstruktoren der abgeleiteten Klassen
initialisieren die Basisklasse mit einem Parameter, der angibt, dass eine
Instanz einer abgeleiteten Klasse erzeugt wird, und ob sie mit new erzeugt
wurde oder nicht. Die entsprechenden Konstruktoren sind in der Basisklasse
protected. Jede Instanz der Klasse weiß dann ob sie "normal" erzeugt wurde
und nicht weiß wie, oder ob eine abgeleitete Klasse instanziiert wurde und
dadurch auch bekannt ist wie.
Das ganze muss man zwar noch etwas verschönern, vielleicht mit einer
Destroy-Methode für die Instanzen auf dem Heap und mit Copy-Constructor und
Zuweisungsoperator, die wissen wie sie mit den unterschiedlich erzeugten
Instanzen umzugehen haben. Man kann auch irgendeine abstrakte Methode zur
Basisklasse hinzufügen, so dass man Instanzen der Basisklasse gar nicht erst
erzeugen kann, aber dann kann man solche Klassen nur noch als Pointer oder
Referenz an Funktionen übergeben und als Rückgabewerte kommen sie überhaupt
nicht in Frage. Aber was da sinnvoll ist, hängt davon ab, was man eigentlich
erreichen will.
Kleines Beispiel:
// ----------
#include <iostream>
#include <string>
class SomeClass
{
protected:
std::string how;
public:
SomeClass(): how("Keine Ahnung")
{}
virtual ~SomeClass()
{}
void foo()
{
std::cout << how << std::endl;
}
};
class NotOnHeap: public SomeClass
{
public:
NotOnHeap()
{
how = "Nicht mit new";
}
private:
void* operator new(size_t);
};
class NotOnStack: public SomeClass
{
public:
NotOnStack()
{
how = "Mit new";
}
private:
~NotOnStack()
{}
};
void foo(SomeClass sc)
{
sc.foo();
}
int main()
{
NotOnHeap noh;
NotOnStack* nos = new NotOnStack;
SomeClass* sc = nos;
foo(noh);
foo(*nos);
foo(*sc);
delete sc;
}
// ----------
HTH
Heinz
--
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 |
|
|
Michael Sabo
Guest
|
| Posted: Sun Feb 26, 2006 11:06 pm Post subject: Re: dynamische / statische Objekte |
|
|
| Quote: | Nur eine Idee:
Leite von deiner Klasse zwei weitere ab. Die eine bekommt einen privaten
Destruktor. Instanzen dieser Klasse können nicht "auf dem Stack" abgelegt
werden. Die zweite Klasse bekommt einen privaten operator new, der nicht
einmal implementiert werden muss. Instanzen dieser Klasse können nicht mit
new erzeugt werden. Die Konstruktoren der abgeleiteten Klassen
initialisieren die Basisklasse mit einem Parameter, der angibt, dass eine
Instanz einer abgeleiteten Klasse erzeugt wird, und ob sie mit new erzeugt
wurde oder nicht. Die entsprechenden Konstruktoren sind in der Basisklasse
protected. Jede Instanz der Klasse weiß dann ob sie "normal" erzeugt wurde
und nicht weiß wie, oder ob eine abgeleitete Klasse instanziiert wurde und
dadurch auch bekannt ist wie.
|
Dieser Weg bin habe ich auch schon evaluiert. Funktionieren tut sie schon.
Was mir nur ein wenig daran störte, ist der damit verbundene Aufwand.
- 2 Klassen ableiten
- Evtl. viele längliche Konstruktoren nochmals definieren (rufen jedoch
natürlich nur noch die Basisklasse auf)
- 2 x Operator new und delete implementieren (public/private)
Wär halt schön wenn es eine einfachere Lösung gäbe...
Mfg
Michael
--
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 |
|
|
Ralf Westram
Guest
|
| Posted: Mon Feb 27, 2006 1:06 am Post subject: Re: dynamische / statische Objekte |
|
|
Am Sat, 25 Feb 2006 10:05:35 +0100 schrieb Michael Sabo:
| Quote: | Habe zuerst gedacht, sowas könnte
man mit einer globalen Variablen und Critical Sections lösen. So könnte der
Operator new die Variable setzen und bei Aufruf des Konstruktors dieser
prüfen ob diese gesetzt ist. Aber denke das dies so doch nicht gehen kann,
denn sobald der Operator new ausgeführt wurde, im Konstruktor nun nicht
gewusst wird
- wird nun das neue dynamische Objekt nun initialisiert
- oder legt ein anderer Thread nur ein neues statisches Objekt an und die
Thread-Umschaltung war nun gerade zufälligerweise zwischen dem Aufruf von
Operator new und dem Kostruktor
|
Ich denke, man könnte es schon auf die Art lösen, allerdings nicht mit
einem globalen Flag, sondern einem globalen Pointer, der auf den
Speicherbereich zeigt, der gerade von Deinem operator new erzeugt wurde.
Dem ungünstigen Fall, daß mehrere dynamische Objekte gleichzeitig in
verschiedenen Threads erzeugt werden, könntest Du dadurch begegnen, daß Du
das noch uninitialisierte Objekt dazu verwendest, einen Zeiger auf das
nächste Objekt abzulegen, welches ebenfalls gerade initialisiert wird.
Ralf
--
48% sind von mir. Der Rest sind Quotes nehm' ich an..
--
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 |
|
|
Martin Kaul
Guest
|
| Posted: Mon Feb 27, 2006 9:06 am Post subject: Re: dynamische / statische Objekte |
|
|
Michael Sabo wrote:
| Quote: | Hallo zusammen,
manchmal könnte es doch durchaus Sinn machen, innerhalb einer Klasse zu
wissen ob diese dynamisch oder statisch instanziiert wurde (z.B. für einen
automatischen Aufruf von delete).
So viel ich weiss, sollte ja sowas egal sein und ist nicht sprachlich
vorgesehen. Aber gibt es trotzdem Möglichkeiten an diese Information zu
gelangen?
Du kannst den "operator new" für deine Klasse überschreiben und dort ein |
Flag setzen, welches definiert, dass die Instanz dynamisch erzeugt wurde.
-----------------
#include <iostream>
class A
{
static bool with_operator_new_;
bool dynamic_instance_;
int x_;
public:
A( int x )
: dynamic_instance_( with_operator_new_ )
, x_( x )
{
std::cout << "A::A() dynamic=" << dynamic_instance_ << std::endl;
with_operator_new_ = false;
}
~A()
{
std::cout << "A::~A()" << std::endl;
}
void *operator new( size_t size )
{
std::cout << "A::operator new(" << size << ")" << std::endl;
with_operator_new_ = true;
return ::malloc( size );
}
};
bool A::with_operator_new_ = false;
-----------------
Der Code:
{
A obja( 1 );
}
A *obja_ptr = new A( 2 );
delete obja_ptr;
gibt dann folgende Ausgabe:
A::A() dynamic=0
A::~A()
A::operator new(
A::A() dynamic=1
A::~A()
Bei Multithreading muss A::with_operator_new_ abgesichert werden, dass
ist dann aber Thema einer anderen Gruppe...
tschaule
Martin
--
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 |
|
|
Michael Sabo
Guest
|
| Posted: Wed Mar 01, 2006 12:06 am Post subject: Re: dynamische / statische Objekte |
|
|
| Quote: | Ich denke, man könnte es schon auf die Art lösen, allerdings nicht mit
einem globalen Flag, sondern einem globalen Pointer, der auf den
Speicherbereich zeigt, der gerade von Deinem operator new erzeugt wurde.
|
Stimmt. Diesen kann ich im Konstruktor mit this vergleichen und weiss
dadurch ob der Konstruktor unmittelbar nach new aufgerufen wurde oder ob ein
anderer Thread gerade ein statisches Objekt anlegt. Falls ein anderer Thread
auch ein dynamisches Objekt anlegen will, würd ich eher sagen, soll dieser
einfach kurz warten (while pointer!=NULL;), bis dieser im Konstruktor wieder
zurückgesetzt wird.
(Müssen halt alles atomare Vergleiche und Exchange-Funktionen sein. Gibts
aber unter Windows und auf anderen BS bestimmt auch. Ist auch bestimmt
schnell als Critical Sections)
Könnte klappen. Muss ich mal ausprobieren. Hätte ich auch selbst drauf
kommen können. Aber irgendwann kann man nicht mehr um die "Ecke" denken...
;-)
Michael
--
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 |
|
|
Michael Sabo
Guest
|
| Posted: Wed Mar 01, 2006 12:06 am Post subject: Re: dynamische / statische Objekte |
|
|
| Quote: | #include <iostream
class A
{
static bool with_operator_new_;
bool dynamic_instance_;
int x_;
public:
A( int x )
: dynamic_instance_( with_operator_new_ )
, x_( x )
{
std::cout << "A::A() dynamic=" << dynamic_instance_ << std::endl;
with_operator_new_ = false;
}
~A()
{
std::cout << "A::~A()" << std::endl;
}
void *operator new( size_t size )
{
std::cout << "A::operator new(" << size << ")" << std::endl;
with_operator_new_ = true;
return ::malloc( size );
}
};
bool A::with_operator_new_ = false;
|
Auch keine schlechte Idee. Aber bei Multithreading könnte es glaube ich
schwierig werden dies "sicher" zu machen...
Mfg
Michael
--
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 |
|
|
Martin Kaul
Guest
|
| Posted: Wed Mar 01, 2006 6:06 am Post subject: Re: dynamische / statische Objekte |
|
|
Michael Sabo wrote:
| Quote: | #include <iostream
class A
{
static bool with_operator_new_;
bool dynamic_instance_;
int x_;
public:
A( int x )
: dynamic_instance_( with_operator_new_ )
, x_( x )
{
std::cout << "A::A() dynamic=" << dynamic_instance_ << std::endl;
with_operator_new_ = false;
}
~A()
{
std::cout << "A::~A()" << std::endl;
}
void *operator new( size_t size )
{
std::cout << "A::operator new(" << size << ")" << std::endl;
with_operator_new_ = true;
return ::malloc( size );
}
};
bool A::with_operator_new_ = false;
Auch keine schlechte Idee. Aber bei Multithreading könnte es glaube ich
schwierig werden dies "sicher" zu machen...
|
Hmm, der Konstruktor und operator new müssten dann in ner
Critical-Section sein, damit nicht gleichzeitig mit dem Erzeugen eines
statischen Objektes der operator new von einem anderen Thread
aufgerufen wird. Beim Konstruktor von A wird die Critical-Section im
Konstruktor der Basisklasse von A gestartet und am Ende des Konstruktors
von A beendet (Nicht getestet - nur aus der Hüfte geschossen).
Bei dynamischen Objekten müsste über ne Sempahore vielleicht abgesichert
sein, dass nach einem new auf jeden Fall erst der Konstruktor drankommt,
bevor ein zweites new drankommt.
Ich bin jetzt nicht so der Standard-Freak aber ich denke doch, dass in
C++ nach jedem new der Konstruktor auf jeden Fall aufgerufen wird.
tschaule
Martin
--
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 |
|
|
Martin Kaul
Guest
|
| Posted: Wed Mar 01, 2006 6:06 am Post subject: Re: dynamische / statische Objekte |
|
|
Michael Sabo wrote:
| Quote: | Ich denke, man könnte es schon auf die Art lösen, allerdings nicht mit
einem globalen Flag, sondern einem globalen Pointer, der auf den
Speicherbereich zeigt, der gerade von Deinem operator new erzeugt wurde.
Stimmt. Diesen kann ich im Konstruktor mit this vergleichen und weiss
dadurch ob der Konstruktor unmittelbar nach new aufgerufen wurde oder ob ein
anderer Thread gerade ein statisches Objekt anlegt. Falls ein anderer Thread
auch ein dynamisches Objekt anlegen will, würd ich eher sagen, soll dieser
einfach kurz warten (while pointer!=NULL;), bis dieser im Konstruktor wieder
zurückgesetzt wird.
|
Wobei - ist in C++ definiert, dass der Pointer vom operator new auch dem
this Pointer der Instanz entspricht?
Vor allem bei Klassen mit virtuellen Methoden muss ja vor dem
eigentlichen Objekt noch die VTable stehen und der Platz wird von new
zusätzlich mit angelegt, d.h. eventuell (und dann auch noch je nach
Compiler & Plattform unterschiedlich) zeigt this nicht auf den Begin des
Speicherbereiches der mit new angelegt wurde, sondern auf das Ende der
VTable.
tschaule
Martin
--
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 |
|
|
Michael Sabo
Guest
|
| Posted: Wed Mar 01, 2006 6:06 pm Post subject: Re: dynamische / statische Objekte |
|
|
| Quote: | Wobei - ist in C++ definiert, dass der Pointer vom operator new auch dem
this Pointer der Instanz entspricht?
|
Würde jetzt zwar nicht die Hand für alle Compiler und Plattformen ins Feuer
legen. Aber ich hätte gesagt schon. Dass noch ein Offset wegen der vtable
dazuaddiert werden muss beim Zugriff auf ein Element weiss er ja.
Michael
--
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 |
|
|
kanze
Guest
|
| Posted: Fri Mar 03, 2006 10:06 am Post subject: Re: dynamische / statische Objekte |
|
|
Martin Kaul wrote:
| Quote: | Michael Sabo wrote:
Ich denke, man könnte es schon auf die Art lösen, allerdings
nicht mit einem globalen Flag, sondern einem globalen
Pointer, der auf den Speicherbereich zeigt, der gerade von
Deinem operator new erzeugt wurde.
Stimmt. Diesen kann ich im Konstruktor mit this vergleichen
und weiss dadurch ob der Konstruktor unmittelbar nach new
aufgerufen wurde oder ob ein anderer Thread gerade ein
statisches Objekt anlegt. Falls ein anderer Thread auch ein
dynamisches Objekt anlegen will, würd ich eher sagen, soll
dieser einfach kurz warten (while pointer!=NULL;), bis
dieser im Konstruktor wieder zurückgesetzt wird.
Wobei - ist in C++ definiert, dass der Pointer vom operator
new auch dem this Pointer der Instanz entspricht?
|
Überhaupt nicht. Ich kenne sogar keine Implementierung, wo es
immer der Fall ist. Diese Aussage gilt nur, wenn überhaupt, für
die meist abgeleitete Klasse.
| Quote: | Vor allem bei Klassen mit virtuellen Methoden muss ja vor dem
eigentlichen Objekt noch die VTable stehen und der Platz wird
von new zusätzlich mit angelegt, d.h. eventuell (und dann auch
noch je nach Compiler & Plattform unterschiedlich) zeigt this
nicht auf den Begin des Speicherbereiches der mit new angelegt
wurde, sondern auf das Ende der VTable.
|
Zuerst steht nur einem VPtr, und nicht die ganze Tabelle, im
Objekt. Dazu kann es auch an einer beliebigen Stelle im Objekt
vorkommen; ich glaube schon gesehen zu haben, dass es am Ende
der Basisklasse vorkommt.
Im Fall von virtueller Ableitung ist das Problem noch
komplizierter; typischerweise hängt die Stelle der virtuellen
Basisklasse von der meist abgeleiteten Klasse ab, was man im
Constructor nicht kennen kann.
Was man eventuell machen kann, ist Anfangs- und Endadresse
speichern, und überprüfen, ob this zwischen den Beiden liegt.
(Dazu müss man std::less, etc. benutzen, und nicht < u.s.w.)
--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
--
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 |
|
|
Michael Sabo
Guest
|
| Posted: Sat Mar 04, 2006 1:39 pm Post subject: Re: dynamische / statische Objekte |
|
|
| Quote: | Was man eventuell machen kann, ist Anfangs- und Endadresse
speichern, und überprüfen, ob this zwischen den Beiden liegt.
(Dazu müss man std::less, etc. benutzen, und nicht < u.s.w.)
|
Jetzt hast Du mir das Wort aus dem Munde genommen. Jetzt wollte ich gerade
das gleiche Posten! 
Bei der Implementierung ist mir doch aufgefallen, dass die absolute
Anfangsadresse von malloc (des Objektes) und der this-Pointer meines
eigentliches Objektes nur im trivialen Fall identisch ist. Hab das dann auch
so gelöst, in dem ich abfrage ob this zwischen der Anfangs- und der
End-Adresse liegt.
Nur ich habe keine std::less benötigt!?
Allerdings habe ich InterlockedExchange (für die Windows-Leute bzw. allg.
lock cmpxchg) vorsichtshalber verwendet damit der Vergleich aus einem
anderen Thread nicht zufälligerweise den alten Wert bereits ausgelesen hat
bevor der andere noch dazu kam diesen zu aktualisieren.
Mfg
Michael
--
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
|
|
FAQ
Search
Memberlist
Usergroups
Register
Profile
Log in to check your private messages
Log in
