Hi Leuts, folgende Frage: Ich habe zwei Klassen 8DBL425 und DBL800). Sie unterschieden sich lediglich im Aufbau einiger Mehtoden, haben aber nach aussen hin die gleichen Methoden mit gleichen Parametern und gleichen Rückgabewerten. Nun möchte ich zur Laufzeit eine Variable erzeugen, entweder von der einen Klasse doer von der anderen. Das entscheidet sich erst zur Laufzeit! Dazu möchte ich aber ein und denselben Pointer benutzen. Aber wie rufe ich dann die Methoden auf, da ich ja erst zur Laufzeit weiss von welchem Typ der Pointer ist ? Hintergrund ist folgender: Über die serielle Schnittstelle kommuniziere ich mit einem Messgerät. Dieses Protokoll wurde aber einmal geändert, weshalb ich hier zwei unterschiedliche Protokolle einhalten muss, entweder das eine oder das andere. Wie mache ich sowas am besten ? Greets Karlheinz
Beide Klassen verwenden die gleiche Basisklasse, alle relevanten von Dir aufzurufenden Methoden sind virtuelle Methoden, Also;
1 | basisklasse
|
2 | {
|
3 | virtual int machwas() = 0; |
4 | };
|
5 | |
6 | klasse1 : public basisklasse |
7 | {
|
8 | virtual int machwas() { return 1;}; |
9 | };
|
10 | |
11 | klasse2 : public basisklasse |
12 | {
|
13 | virtual int machwas() { return 2;}; |
14 | };
|
15 | |
16 | |
17 | basisklasse* p; |
18 | int x; |
19 | |
20 | p = (basisklasse *) new klasse1; |
21 | |
22 | x = p->machwas(); |
23 | |
24 | // x ist 1
|
25 | |
26 | p = (basisklasse *) new klasse2; |
27 | |
28 | x = p->machwas(); |
29 | |
30 | // x ist 2
|
Statt des C-Typecasts "(basisklasse *)" sollte ein geeigneteres C++-Konstrukt verwendet werden, reinterpret_cast oder dergleichen.
class Kommunikator { public: Kommunikator(int param1, int param2) { ... // Hier könnte man das tun, was beide Klassen // gemeinsam haben } virtual ~Kommunikator() { ... } virtual void tueDies(void)=0; virtual void tueDas(void)=0; } class Protokoll1Kommunikator : public Kommunikator { public: Protokoll1Kommunikator(int param1, int param2, int param3) :Kommunikator (param1, param2) { // Mit param1 und 2 wird der Konstruktor von // Kommunikator aufgerufen ... // Konstruktor von Protokoll 1 } ~Protokoll1Kommunikator() { ... } void tueDies(void) { ... // Wie Protokoll 1 dies tut. } void tueDas(void) { ... // Wie Protokoll 1 das tut. } private: void ganzgeheim() { ... // Etwas ganz Geheimes das nur Protokoll 1 macht } } class Protokoll2Kommunikator : public Kommunikator { public: // Konstruktor wie oben void tueDies(void) { ... // Wie Protokoll 2 dies tut. } void tueDas(void) { ... // Wie Protokoll 2 das tut. } ~Protokoll2Kommunikator() { ... } } void main() { int protokoll; ... Kommunikator* k; if(protokol==1) k = new Protokoll1Kommunikator(a,b,c); else if(protokol==2) k = new Protokoll2Kommunikator(...); ... k->tueDies(); k->tueDas(); ... }
@Rufus: Beim Casten eines Objekt-Zeigers auf einen Basisklassen-Zeiger ist gar kein cast nötig, das geschieht implizit.
Schön ausgedrückt, aber natürlich trotzdem richtig =8^)
Also da gibt es ganz kluge Leute, die haben vor nicht langer Zeit Designpatterns aufgeschrieben, wenn sich bei mir jemand um eine Stelle als Programmierer bewirbt kommt die Frage nach Kenntnis von Designpatterns: Ich empfehle: "Entwurfsmuster" von Gamma/Helm/Johnson/Vlissides Adison-Weseley ISBN 3-8273-1862-9 Orginal ist auf Englisch, ist auch besser. Dort findet man Fabrik und abstrakte Fabrik Warum das Rad neu erfinden...
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.