Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
08.04.2005, 14:01 Uhr
~doppler
Gast

Hi,
hat jemand Erfahrungen damit, die operatoren new und new[] selbst zu definieren? Ich möchte eigentlich einen operator new, der sich genauso verhält wie der Standard-Operator, aber eben ein private-member einer Klasse ist. Ist es richtig, dazu einfach im private-Abschnitt zu schreiben

C++:

void* operator new(size_t s) {
return malloc(s);
};
void* operator new[](size_t s) {
return malloc(s);
};

oder kann man irgendwie die globalen Operatoren benutzen (z.B. using ::new oder so)?

Was ist, wenn man neue new-Operatoren hat und dann von der Klasse ableitet? Muss man dann in der abgeleiteten Klasse die Operatoren wieder selbst private machen oder weiß das der Compiler automatisch?

Hintergrund ist, dass ich einen Poiter-Typ habe, der mitzählt, wieviele dieser Pointer auf ein Objekt zeigen, und sobald keiner mehr darauf zeigt, das Objekt löscht. Wenn ich dann irgendwo aus Versehen auf die Idee komme, new aufzurufen, kann natürlich alles kaputt gehen. Andererseits muss man natürlich Pointer des neuen Typs erzeugen können und benötigt dafür das Standard-new.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
08.04.2005, 14:04 Uhr
0xdeadbeef
Gott
(Operator)

C++:

void *operator new(size_t s) { return ::operator new(s); }

Aber ich denke, in deinem Fall wäre der einfachere Weg, die Konstruktoren private zu machen.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 08.04.2005 um 14:07 Uhr von 0xdeadbeef editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
08.04.2005, 14:14 Uhr
~doppler
Gast

Danke, das ist ja einfacher als gedacht.

Das Problem bei private Konstruktoren ist, dass ich keine abgeleiteten Klassen erstellen kann, und bei protected können die abgeleiteten Klassen selbst wieder public Kostruktoren zur Verfügung stellen. Deshalb auch der zweite Teil der Frage, ob einmal new im private Block für alle abgeleiteten Klassen ausreicht.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

003
08.04.2005, 14:15 Uhr
0xdeadbeef
Gott
(Operator)

Ne, das reicht nicht aus.

Ne Singleton-Pattern ist in C++ nicht wirklich umsetzbar, tut mir leid. Allerdings gilt das effektiv für alle objektorientierten Sprachen - zur Not könnte jemand, der mehrere Instanzen haben will, die Klasse halt für jede Instanz neu ableiten.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 08.04.2005 um 14:17 Uhr von 0xdeadbeef editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

004
08.04.2005, 15:34 Uhr
(un)wissender
Niveauwart

Zitat von 0xdeadbeef:

Ne Singleton-Pattern ist in C++ nicht wirklich umsetzbar, tut mir leid.

Ist mir neu, warum das? Ich habe das schon x-mal gemacht und du sagt mir, dass es nicht gehen würde?
--
Wer früher stirbt ist länger tot.

Dieser Post wurde am 08.04.2005 um 15:34 Uhr von (un)wissender editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

005
08.04.2005, 16:21 Uhr
~doppler
Gast

Erstmal danke für das Stichwort Singleton-Pattern, das Konzept war mir neu.

Eigentlich wollte ich aber sowas programmieren wie:
"Es gibt keine Objekte vom Typ Klasse*, außer innerhalb eines Objekts vom Typ neuer_pointer_typ<Klasse>."

Inzwischen ist mir aber klar, dass das nicht geht, weil man immer eine abgeleitete Klasse erzeugen kann, in der eine Funktion return this; enthält.

Naja, immerhin muss man dann nurnoch darauf achten, nirgends return this; zu schreiben, denn zumindest auf meinem System lässt sich das folgende nicht übersetzen

C++:

#include <iostream>

class A {
private:
    void* operator new(size_t s) {return ::operator new(s);};
};

class B : public A {

};

int main() {
    B* b = new B();

    return 0;
};

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

006
08.04.2005, 16:25 Uhr
0xdeadbeef
Gott
(Operator)

Mit Singleton-Pattern meinte ich etwas wie

C++:

class singleton { ... };
class mein_konkretes_singleton : public singleton { ... }; // <-- das hier soll dann automatisch ein singleton sein

...und das dürfte dann doch schwierig umzusetzen sein.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

007
08.04.2005, 16:26 Uhr
Th

Zitat:

Eigentlich wollte ich aber sowas programmieren wie:
"Es gibt keine Objekte vom Typ Klasse*, außer innerhalb eines Objekts vom Typ neuer_pointer_typ<Klasse>."

Doch das ginge schon, wenn der Konstruktor privat ist, also keine Ableitung mehr möglich ist (quasi final) und man dann einen friend definiert, welcher dann das Objekt erzeugt. Dann müßte man aber mit Referenzen bzw. Pointern arbeiten, da ja keine Kopien erzeugt werden können (von außen).

Zu beefy:

es geht, wenn man dem singleton den Namen der Klasse übergibt, also

C++:

template<class T> class singleton { public: T* Instance(); };
class mein_konkretes_singleton : public singleton<mein_konkrets_singleton> { ... };

Dieser Post wurde am 08.04.2005 um 16:31 Uhr von Th editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

008
08.04.2005, 16:47 Uhr
~doppler
Gast

Zitat:

So hatte ich mir das gedacht, aber es ist in meinem Fall sehr wichtig, dass man abgeleitete Klassen erzeugen kann (und auch deren Objekte). Ich hätte nur gern diese pointer-Geschichten einmal in einer Basis-Klasse erledigt.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

009
08.04.2005, 16:51 Uhr
virtual
Sexiest Bit alive
(Operator)

Zitat von 0xdeadbeef:

Mit Singleton-Pattern meinte ich etwas wie

C++:

class singleton { ... };
class mein_konkretes_singleton : public singleton { ... }; // <-- das hier soll dann automatisch ein singleton sein

...und das dürfte dann doch schwierig umzusetzen sein.

Nee, geht natürlich nicht, weil der Defaultctor public ist, wenn man nichts weiter macht. Aber man kann sich die Sache durch Template dennoch vereinfachen, so daß man das Singleton-spezielle nur einmal schreibt und ansonsten ableitet und genau zwei weitere Zeilen in der Abgeleiteten Klasse braucht:

C++:

template<class S>
class singleton {

private:
    singleton& operator = (const singleton&);
    singleton(const singleton&);

protected:
    singleton() { }

public:
    static S& the_instance() {
        static S instance;
        return instance;
    }

};

class my_singleton: public singleton<my_singleton> {
    my_singleton() { }                   // Verhindert, daß ctor aufrufbar ist...
    friend singleton<my_singleton>; // Aber template solls dürfen
};

int main() {
    my_singleton& the_singleton =  my_singleton::the_instance();
    my_singleton x; // Geht nicht
    my_singleton y = the_singleton; // Geht nicht
}

Witzig finde ich den Code deshalb, weil die Ableitung schon ein wenig von hinten durch die Brust ins Auge zu sein scheint, aber letztlich genau das macht, was man will und darüberhinaus legal ist.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: