angenommen ich habe eine Klasse

class C
{
    ...
public:
    void a_1();
     ...
    void a_m();

    void b_1();
    ...
    void b_n();
};

dessen Interface mir zu fett ist. Ich würde dem nun gerne begegnen, indem ich b_1,...,b_n per Delegaten auslagere, also

class B
{
    ...
public:
    void b_1();
    ...
    void b_n();
};

und

class C
{
    B* b;
    ...
public:
    void a_1();
     ...
    void a_m();

    void b_1() { b->b_1(); }
    ...
    void b_n() { b->b_n(); }
};

Irgendwie ist die Klasse C so aber nicht wirklich übersichtlicher geworden (zumindest der Header, der Sourcecode wahrscheinlich schon).

Von daher die Frage: Gibt es eine andere Möglichkeit mittels Delegaten das Interface von C übersichtlicher zu bekommen? So ist es ja genau dasselbe wie vorher, wenn man die Definition von b_1,...,b_n noch in den Source-Code packt.

Ansonsten ist vielleicht das Pimpl-Idiom etwas...

Ansonsten ist vielleicht das Pimpl-Idiom etwas...

Für das Interface? Kaum.

Du könntest C von B erben lassen - wenn du die Konsequenzen überblickst, und wenn diese Beziehung sinnvoll ist. Ansonsten könntest du in C eine Memberfunktion einführen, die einen Zeiger auf ein B-Objekt zurückgibt.

class B
{
private:
 int n;
public:
 int GetN() const {return n;}
 void SetN(int _n) {n = _n;}
};

class C : public B
{
 public:
  int GetN_and_one() const {return GetN() + 1;}
};

int main()
{
 C test;
 test.getN();
 test.getN_and_one();
}

oder hab ich dich falsch verstanden?

bb

edit: oh - hatte vergessen, den tab zu aktualisieren, bevor ich geschrieben hab... sry ><

Du könntest C von B erben lassen - wenn du die Konsequenzen überblickst, und wenn diese Beziehung sinnvoll ist. Ansonsten könntest du in C eine Memberfunktion einführen, die einen Zeiger auf ein B-Objekt zurückgibt.

Mir ging es darum, ob es neben diesen beiden Möglichkeiten noch eine andere gibt. Vererbung würde ich lieber vermeiden (da die Klassenhierarchie in dem Fall, den ich vor Augen habe, schon kompliziert genug ist). Und ein Zeiger auf ein B-Objekt hat ja den Nachteil, dass ich dann

C c;
c.b()->b_1();

statt

C c;
c.b_1();

schreiben müsste (wobei b() den Zeiger auf das B-Objekt liefere). Ich dachte an ein Konstrukt, dass mir erlaubt alle member functions eines Delegaten B der Klasse C zu member functions von C zu machen, ohne dass ich die einzeln ins Interface von C schreiben muss, also

class C
{
    B* b;
    ...
public:
    void a_1();
     ...
    void a_m();

    use interface of B;    // die Zeile nur so, dass C++ das versteht
};

Ansonsten musst du halt b public machen, dann geht das:

C c;
c.b->b_1();

oder wenn eine Referenz speicherst:

C c;
c.b.b_1();

Das ist aber nur zu empfehlen, wenn du wirklich keine Vor/Nachbedingugen hast. Ansonsten kannst du dir ja eine Schnittstelle für B basteln, der dir die Aufrufe wrappt und du so im Nachhinein immernoch relativ leicht eine Vor/Nachbedingung einfügen kannst. (Kommt dann auf das gleiche raus, wie alles in C zu wrappen, ausser, dass es ein wenig aufgeräumter ist.)

B& b = c.b();

b.b_1();
b.b_2();
b.b_n();

Meinst du vielleicht "der Delegierte"? Oder meinst du das englische "delegate" (der Abgeordnete/Abgesandte/Bevollmächtigte/...)? Oder "delegieren" (ich delegiere, du delegierst, der Vorgang des Delegierens)?

Es ist nicht meine Absicht dich zurechtzuweisen oder zu beleidigen, ich denke nur dass du genauer verstanden wirst wenn du Wörter verwendest die es a) auch gibt und die b) gebräuchlich sind bzw. allgemein verstanden werden.

Oder aber du gehst zum Reißbrett und schaust ob wirklich alles Teil des Klasseninterfaces sein muss, oder ob nicht einiges sinnvoll in normale Funktionen ausgelagert werden kann, oder ob nicht doch eine Komposition das Richtige ist.

Was soll "Delegaten" für ein Wort sein? Vielleicht Plural (bzw. 2. Fall Singular) von "Delegat"? Wenn ja, was soll "Delegat" für ein Wort sein?

Meinst du vielleicht "der Delegierte"? Oder meinst du das englische "delegate" (der Abgeordnete/Abgesandte/Bevollmächtigte/...)? Oder "delegieren" (ich delegiere, du delegierst, der Vorgang des Delegierens)?

Es ist nicht meine Absicht dich zurechtzuweisen oder zu beleidigen, ich denke nur dass du genauer verstanden wirst wenn du Wörter verwendest die es a) auch gibt und die b) gebräuchlich sind bzw. allgemein verstanden werden.

Hiermit soll gemeint sein, was in "Design Patterns" auf S. 20 unter "Delegation" beschrieben ist: "... a receiving object delegates operations to its delegate". Delegat ist meine Eindeutschung von "delegate". Falls es eine andere Übersetzung gibt, lasst mich es wissen.

Hiermit soll gemeint sein, was in "Design Patterns" auf S. 20 unter "Delegation" beschrieben ist: "... a receiving object delegates operations to its delegate". Delegat ist meine Eindeutschung von "delegate". Falls es eine andere Übersetzung gibt, lasst mich es wissen.

http://dict.leo.org/ende?lang=de&search=delegate

Grüssli

hustbaer schrieb:

Was soll "Delegaten" für ein Wort sein? Vielleicht Plural (bzw. 2. Fall Singular) von "Delegat"? Wenn ja, was soll "Delegat" für ein Wort sein?

Meinst du vielleicht "der Delegierte"? Oder meinst du das englische "delegate" (der Abgeordnete/Abgesandte/Bevollmächtigte/...)? Oder "delegieren" (ich delegiere, du delegierst, der Vorgang des Delegierens)?

Es ist nicht meine Absicht dich zurechtzuweisen oder zu beleidigen, ich denke nur dass du genauer verstanden wirst wenn du Wörter verwendest die es a) auch gibt und die b) gebräuchlich sind bzw. allgemein verstanden werden.

Hiermit soll gemeint sein, was in "Design Patterns" auf S. 20 unter "Delegation" beschrieben ist: "... a receiving object delegates operations to its delegate". Delegat ist meine Eindeutschung von "delegate". Falls es eine andere Übersetzung gibt, lasst mich es wissen.

Übersetzung des englischen Worts ist ja nicht schwer zu finden. Übersetzung des Fachausdruckes kann ich dir keine anbieten. Verwende doch einfach das englische Wort, so wie es unter Programmierern üblich ist. Man sagt auch "callback" oder "exception" - solche Ausdrücke werden selten übersetzt. Wenn du eine Übersetzung kennst die breitflächig verstanden wird kannst du sie gerne verwenden (auch wenn ich es persönlich nicht tun würde). Aber auf Zwang einfach alles ins Deutsche zu übersetzen oder - noch schlimmer - "einzudeutschen" indem man ein nicht-deutsches Wort deutsch dekliniert... finde ich nicht gut.

Ich dachte an ein Konstrukt, dass mir erlaubt alle member functions eines Delegaten B der Klasse C zu member functions von C zu machen, ohne dass ich die einzeln ins Interface von C schreiben muss, also

class C
{
    B* b;
    ...
public:
    void a_1();
     ...
    void a_m();

    use interface of B;    // die Zeile nur so, dass C++ das versteht
};

So etwas gibt es, soweit ich weiß, nur in Delphi und nur für Interfaces (implements). In C++ kannst du aber, wenn du nicht dynamic_cast<> benutzt, sondern das dynamische Dispatching selbst implementierst (z.B. mit QueryInterface()), etwas ähnliches erreichen.

In C++ kannst du aber, wenn du nicht dynamic_cast<> benutzt, sondern das dynamische Dispatching selbst implementierst (z.B. mit QueryInterface()), etwas ähnliches erreichen.

Kennt jemand eine Website, auf der erklärt wird, was QueryInterface ist und wie es funktioniert? Per Google habe ich nichts erhellendes finden können.

audacia schrieb:

In C++ kannst du aber, wenn du nicht dynamic_cast<> benutzt, sondern das dynamische Dispatching selbst implementierst (z.B. mit QueryInterface()), etwas ähnliches erreichen.

Kennt jemand eine Website, auf der erklärt wird, was QueryInterface ist und wie es funktioniert? Per Google habe ich nichts erhellendes finden können.

http://msdn.microsoft.com/en-us/library/ms682521(VS.85).aspx

Soweit ich das aber sehe, ging es vorher aber eher um dynamisches Dispatching:
http://en.wikipedia.org/wiki/Dynamic_dispatch