[C++] variable Klassen

Computer: Software & Programmierung Programmierung allgemein
#1

Hallo,

ich komm grad einfach nicht drauf…
wenn ich Klassen haben, die alle die gleichen Methoden haben, wie setze ich mal diese, mal jene ein

Ich hab mir schonw as überlegt in der Art:

void\* klasse;
if (soundso)
{
 klasse = new Klasse1();
}
else
{
 klasse = new Klasse2();
}
klasse-\>tuWas();

allerdings frag ich mich grad ob ich dann nicht unweigerlich Probleme beim „delete klasse;“ kriege. Der Compiler weiss ja nicht, was er da jetzt freigeben soll.

Wie macht man sowas?
Es kann ja kaum das hier die gute Lösung sein (wenn sie überhaupt funktioniert):

if (soundso)
{
 delete (Klasse1\*)klasse;
}
else
{
 delete (Klasse2\*)klasse;
}

Bitte helft mir :smile:

Das is doch auch sowas ähnliches wie function-pointer im C oder? das hab ich auch noch nie so ganz verstanden, wie man das macht, könnt ihr mir das grad auch noch schnell erklären , danke :smile:

Bruno

#2

Hallo,

kannst Du so etwas nicht irgendwie umgehen? Ist meiner Meinung nach kein sauberes Design eines Programms.

Sollte doch prinzipiell auch mit Hilfe einer abstrakten Basisklasse realisierbar sein.

Dirk

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

#3

kannst Du so etwas nicht irgendwie umgehen? Ist meiner Meinung
nach kein sauberes Design eines Programms.
Sollte doch prinzipiell auch mit Hilfe einer abstrakten
Basisklasse realisierbar sein.

Äh ja ok, ich kann von mir aus auch noch eine Klasse schreiben von der die beiden abgeleitet sind… machts das einfacher?

bruno

#4

Moin,

wenn ich Klassen haben, die alle die gleichen Methoden haben,
wie setze ich mal diese, mal jene ein

Ein Interface, bzw. eine abstrakte Basisklasse.

Thorsten

#5

void* klasse;

Ja natürlich. In der abstakten Basisklasse definierst Du

...
void tuWas() = 0;
...

Sind Klasse1 und Klasse2 von dieser abstrakten Klasse abgeleitet, so müssen sie

tuWas

implementieren.

Du kannst dann deinen Code einfach so kompilieren, ohne Dich um Funktionspointer kümmern zu müssen.

Dein Code könnte dann etwa so aussehen:

if (soundso)
{
 klasse = new Klasse1();
}
else
{
 klasse = new Klasse2();
}
klasse-\>tuWas();

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

#6

Hallo Bruno,

Erstelle ein Basisklasse, von dann die anderen abgeleitet
werden. Die gemeinsam genutzten Funktionen sind als virtuelle
Funktionen zu erstellen. Wenn Du dann einen Zeiger auf eine
abgeleitete Klasse hast, weiß der Compiler, welche der Methoden
er aufrufen muß. Das gleiche gilt für den delete Operator.

Gruß Patrick

#7

und wie sieht es mit dem Zerstören des Objektes aus? Wird dann auch der richtige Destruktor nämlich der von entweder Klasse1 oder Klasse2 aufgerufen?

Bruno

#8

und wie sieht es mit dem Zerstören des Objektes aus? Wird dann
auch der richtige Destruktor nämlich der von entweder Klasse1
oder Klasse2 aufgerufen?

Bruno

Natürlich. Du solltest Dich vielleicht noch mal etwas näher mit Objektorientierung und Polymorphismus beschäftigen :wink:

Dirk

#9

Die gemeinsam genutzten Funktionen sind als virtuelle
Funktionen zu erstellen.

Hi,

das sollten dann aber keine kleinen Schnipsel sein, die dann massenhaft in Schleifen o.ä. aufgerufen werden. (elementweise Operationen auf Vektoren oder ähnliches). Das wird elend langsam. Für sowas sollte man das Design neu überdenken.

Ciao Lutz

#10

Hi
Ich experimentiere schon länger mit dem, was du „variable Klassen“ nennst. Versuch’s doch mal so:

void* klasse = NULL;

klasse = realloc( klasse,sizeof( klasse_1 ) );

…dann

klasse_1* Zeiger = ( klasse_1* )klasse;

…und dann

Zeiger -> TuWas();

…und wenn du es wieder freigeben willst:

klasse = realloc( klasse,0 );

Funktioniert recht gut!
Außerdem finde ich, daß das ein wirklich geniales Programmdesign ist und die Standardtechniken bei weitem übertrifft. Mit Hilfe dieser Grundlage kann man in weiterführenden System ganz neue Programmlogiken aufbauen, die sich wesentlich effizienter programmieren und verwalten lassen.

Florian

#11

Hi
Ich experimentiere schon länger mit dem, was du „variable
Klassen“ nennst. Versuch’s doch mal so:

void* klasse = NULL;

klasse = realloc( klasse,sizeof( klasse_1 ) );

…dann

klasse_1* Zeiger = ( klasse_1* )klasse;

…und dann

Zeiger -> TuWas();

…und wenn du es wieder freigeben willst:

klasse = realloc( klasse,0 );

Funktioniert recht gut!
Außerdem finde ich, daß das ein wirklich geniales
Programmdesign ist und die Standardtechniken bei weitem
übertrifft.

Aua,
das ist extrem schlechter Programmierstil, da Du damit die Typüberprüfung, die in C++ eingebaut ist, und einen Vorteil zu C darstellt, vollständig ausschaltest. Wenn Du sowas überhaupt benutzt, dann nur, wenn es wirklich notwendig ist und dann auch gut gekapselt, damit Fehler in diesem „gesetzlosen“ Gebiet sehr schnell eingegrenzt werden können.

Für etwas konformere Tricks: http://oonumerics.org/blitz++

Ciao Lutz

#12

Aua,
das ist extrem schlechter Programmierstil, da Du damit die
Typüberprüfung, die in C++ eingebaut ist, und einen Vorteil zu
C darstellt, vollständig ausschaltest. Wenn Du sowas überhaupt
benutzt, dann nur, wenn es wirklich notwendig ist und dann
auch gut gekapselt, damit Fehler in diesem „gesetzlosen“
Gebiet sehr schnell eingegrenzt werden können.

…da hast du was falsch verstanden, glaube ich: Das, was ich da an Quelltext geschrieben habe, ist sozusagen nur das Vorgeplänkel. Du benutzt nämlich dann im eigentlichen Rest des Programms, wenn du die allokierten Variablen nutzen willst, den Nicht - void - Zeiger, der auf dieselbe Adresse wie der void Zeiger zeigt.
Der Vorteil in diesem Stil liegt darin, daß man über nur einen Zeiger ( void* ) eine ganze „Allokationsstruktur“ bauen kann. Der Vorteil ist nicht gleich einsehbar: Man ist dadurch in der Lage ausgesprochen dynamisch zu programmieren. Z.B. ist man in der Lage eine Dateiverarbeitung zu schreiben, die sofort mit allen Typen, egal wie dynamisch sie gebaut sind, sofort fertig zu werden, ohne das man noch größeren Programmieraufwand hätte.

Florian