wie realisieren?

roN

Hallo,

ich habe eine Frage, ich habe mehrere Kommunikationsklassen, mit versch. implemntierungen, aber beide haben dieselben Funktionen. Dann hab' ich eine 'Masterklasse' welche entscheidet, in welcher Instanz die Funktion ausgeführt wereden soll. Alles klar? Die Hauptanwendung setzt eine Eigenschaft der Masterklasse, damit diese weiss, in welche Instanz sie 'abbiegen' soll.
Schema:

HA: Hauptanwendung
A: Instanz der Kommunikationsklasse A
B: Instanz der Kommunikationsklasse B
MK: Instanz Masterklasse

THA::THA()
{
MK->Interface=A;
}

TMK::TMK()
{
if (this->Interface)
  A->WriteData();
else
  B->WriteData();
}

wie realisier ich das am besten? Ich habe Datentype, welche ich überall benutze definiert und TA und TB haben noch zusätzliche, verschiedene, in THA nicht vorhandene Eigenschaften/Methoden.
Wie soll ich das am besten realisieren?
TA und TB von TMK ableiten? dann muss ich ja TMK.h in TA und TB includen und um die Instanzen in TMK zu erstellen, muss ich TA.h und TB.h in TMK includen, was doch auch nicht gut ist. ... Vorschläge? Danke!

C++ Forumbot

Dieser Thread wurde von Moderator/in Jansen aus dem Forum Borland C++ Builder (VCL/CLX) in das Forum C++ verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Ich würde das State(Zustand) DesignPattern vorschlagen

roN

hm, wo finde ich Infos darüber?
kennst du gewisse pages' mein Buch meint sagt mir nichts dazu...
mal sehen... *google*

PuppetMaster2k

Hier gibts das was du suchst und mehr: http://home.earthlink.net/~huston2/dp/patterns.html

nillable

http://de.wikipedia.org/wiki/Zustand_(Entwurfsmuster)
Buch: http://www.amazon.de/exec/obidos/ASIN/3827321999/qid=1118665855/sr=2-1/ref=sr_2_11_1/302-1028164-3236043

Hier ein Beispiel:

#include <iostream>

using namespace std;

class StateOfMaster
{
    public:
        virtual void foo() const = 0;
};

class StateA : public StateOfMaster
{
    public:
        void foo() const
        {
            cout << "A: foo" << endl;
        }
};

class StateB : public StateOfMaster
{
    public:
        void foo() const
        {
            cout << "B: foo" << endl;
        }
};

class Master
{
    public:
        Master(StateOfMaster *initialState) : _currentState(initialState)
        {}

        void foo() const
        {
            _currentState->foo();
        }

        void setState(StateOfMaster *state)
        {
            _currentState = state;
        }
    private:
        StateOfMaster *_currentState;        
};

int main()
{
    StateA a;    
    StateB b;

    Master m(&a);    
    m.foo();

    m.setState(&b);
    m.foo();

    cin.get();
}

Oft gewährt man den Zuständen auch Zugriff auf ihren "Master", damit sie sich bei Bedarf selbst austauschen können.