staging.inyokaproject.org

C++: Problem mit Rückgabeweren

Status: Ungelöst | Ubuntu-Version: Xubuntu 14.04 (Trusty Tahr)
Antworten |

Dakuan

Avatar von Dakuan

Anmeldungsdatum:
2. November 2004

Beiträge: 6532

Ich habe da in einem Programm ein Panel mit recht vielen Eingabemöglichkeiten. Das meiste ist Text, aber es sind auch einige Integer Werte dabei. Für die Abfrage der Werte möchte ich trotzdem ein einheitliches Interface haben.

Da wollte ich mal wieder besonders schlau sein, und dachte das der Compiler dass schon über die Signatur erkennen würde. Aber leider gehört bei C++ der Rückgabewert nicht zur Signatur.

Die betreffenden Funktionen sehen etwa so aus:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
const char * gw_setup::t_value( int code ) {
    switch( code ) {
        case GPT_PRE:   return d_prefix->value();
        case GPT_SUF:   return d_suffix->value();
        ...
    }
    return NULL;
}

int gw_setup::i_value( int code ) {
    switch( code ) {
        case GPI_DMOD:  return d_mode->value();
        ...
    }
    return -1;
}

Sieht jemand eine Möglichkeit, das Problem irgendwie eleganter zu lösen, außer die Integer Werte in Text zu konvertieren?

rklm Team-Icon

Projektleitung

Anmeldungsdatum:
16. Oktober 2011

Beiträge: 13242

Bin mir nicht sicher, dass ich Deinen Fall richtig verstanden habe: ist gw_setup die Klasse des Panels? Wir wissen ja auch wenig über die Benutzung des Panels, aber wenn es ein Dialog mit einen Knopf für "OK" oder "Submit" hat, dann würde ich in dem Moment ein Objekt zurückliefern, dass alle Eingaben enthält.

Wenn es so etwas nicht gibt und zu beliebigen Zeitpunkten (also nicht beim "Abschicken") auf die Werte zugreifen willst, dann geht vielleicht auch etwas mit Template-Spezialisierung. Ich habe es allerdings noch nicht hinbekommen. Dabei bin ich allerdings via dieses auf interessanten Lesestoff gestoßen. ☺

So ganz bin ich mir auch noch nicht einig mit mir, ob Dein Ansatz generell so gutes Design ist: Du definierst ja Konstanten für die einzelnen Wert, die aber bereits mit festen Namen erreichbar sind. Das wirkt irgendwie schief. Und ich würde auch anstatt "NULL" zurück zu geben, lieber eine Exception werfen, denn ein falscher Aufrufparameter ist ein Programmierfehler.

rklm Team-Icon

Projektleitung

Anmeldungsdatum:
16. Oktober 2011

Beiträge: 13242

Ha! Zu früh gepostet:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>

using namespace std;

class Foo {
  int a;
  const char* b;
public:
  Foo() : a(195), b("Hello world!") {}
  void test() { cout << "test(" << a << ":" << b << ")" << endl; }

  template<typename T, int C> T access();
};


template<> int Foo::access<int,1>() { return a; }
template<> const char* Foo::access<const char*,2>() { return b; }

int main() {
  cout << "start" << endl;

  Foo f;
  f.test();
  cout << "int value: " << f.access<int,1>() << endl;
  cout << "char value: " << f.access<const char*,2>() << endl;

  return 0;
}

Sieht dann so aus:

1
2
3
4
5
$ g++ -std=c++11 -Wall special.cpp && ./a.out
start
test(195:Hello world!)
int value: 195
char value: Hello world!

☺

rklm Team-Icon

Projektleitung

Anmeldungsdatum:
16. Oktober 2011

Beiträge: 13242

rklm schrieb:

So ganz bin ich mir auch noch nicht einig mit mir, ob Dein Ansatz generell so gutes Design ist: Du definierst ja Konstanten für die einzelnen Wert, die aber bereits mit festen Namen erreichbar sind. Das wirkt irgendwie schief. Und ich würde auch anstatt "NULL" zurück zu geben, lieber eine Exception werfen, denn ein falscher Aufrufparameter ist ein Programmierfehler.

Das Problem, was ich hier sehe, ist folgendes: Du willst einen Zugang definieren, der einen int als Schlüssel benutzt, um beliebige Werte uniform zuzugreifen, aber sie haben nicht alle denselben Typ. Man muss also pro Schlüssel sowieso den Typ wissen und kann die Werte gerade nicht uniform zugreifen. Du müsstest da schon deutlich mehr Aufwand treiben, z.B. eine Wrapper-Klasse definieren, die dann bei entsprechenden Typumwandlungen Fehler liefert usw. Das erscheint mir allerdings extrem aufwändig.

Warum definierst Du nicht einfach Zugriffsmethoden für jedes Feld - oder machst die Felder gleich öffentlich?

Dakuan

(Themenstarter)
Avatar von Dakuan

Anmeldungsdatum:
2. November 2004

Beiträge: 6532

So ganz bin ich mir auch noch nicht einig mit mir, ob Dein Ansatz generell so gutes Design ist:

Dazu kann ich wenig sagen. Die meisten Bücher behandeln ja nur die Grundlagen von C++. Wie man an größere Projekte rangeht wird selten erwähnt. Und die Autoren von "Entwurfsmuster ..." schreiben selbst, das dieses Buch für C++ eher wenig geeignet ist. Mir bleibt also nur "trial and error".

ist gw_setup die Klasse des Panels?

Ja, ich habe das ausgelagert weil es wegen des Umfangs im Hauptprogramm zu unübersichtlich wurde. Das sind Textfelder, Buttons und Spinner. Bei jeder Änderung wird ein Callback gemacht und das Hauptprogramm entscheidet dann ob und wer weiter informiert werden muss.

Warum definierst Du nicht einfach Zugriffsmethoden für jedes Feld - oder machst die Felder gleich öffentlich?

Die Zugriffsmethoden liefert ja das Toolkit. Aber öffentlich? Ich weiss nicht, da müssten dann ausser dem Hauptprogramm noch 3 weitere Klassen alle Elemente des Panels kennen. Ursprünglich wollte ich einfach nur Text Zeiger weiter reichen.

Wahrscheinlich ist es dann doch besser, wenn ich auch die Integer Werte in ein Textformat bringe.

rklm Team-Icon

Projektleitung

Anmeldungsdatum:
16. Oktober 2011

Beiträge: 13242

Dakuan schrieb:

So ganz bin ich mir auch noch nicht einig mit mir, ob Dein Ansatz generell so gutes Design ist:

Dazu kann ich wenig sagen. Die meisten Bücher behandeln ja nur die Grundlagen von C++. Wie man an größere Projekte rangeht wird selten erwähnt. Und die Autoren von "Entwurfsmuster ..." schreiben selbst, das dieses Buch für C++ eher wenig geeignet ist. Mir bleibt also nur "trial and error".

Naja, wir sind ja auch noch da. 😉

ist gw_setup die Klasse des Panels?

Ja, ich habe das ausgelagert weil es wegen des Umfangs im Hauptprogramm zu unübersichtlich wurde. Das sind Textfelder, Buttons und Spinner. Bei jeder Änderung wird ein Callback gemacht und das Hauptprogramm entscheidet dann ob und wer weiter informiert werden muss.

Du wirst dann doch einen Callback pro Feld definieren. Der weiß dann doch, auf welchen Wert er zugreifen muss. Ich verstehe immer noch nicht, was der Zweck der neuen Zugriffsmethoden sein soll.

Die Zugriffsmethoden liefert ja das Toolkit.

Wofür brauchst Du denn dann noch die anderen Methoden?

Wahrscheinlich ist es dann doch besser, wenn ich auch die Integer Werte in ein Textformat bringe.

Das würde ich bei meinem aktuellen Stand des Verständnisses weder bejahen noch verneinen.

Dakuan

(Themenstarter)
Avatar von Dakuan

Anmeldungsdatum:
2. November 2004

Beiträge: 6532

Warum habe ich immer Probleme, mich verständlich auszudrücken ...

Also die Einstellungen betreffen 2 Objekte, die einander nicht kennen. Ein 3. Objekt erzeugt standard Einstellungen, die aber vom Benutzer geändert werden können.

Wenn dann ein neuer Programmlauf gestartet wird, werden die aktuellen Angaben vom Hauptprogramm nur noch abgefragt und ein Zähler hochgezählt.

Mal sehen, ob ich nachher noch etwas Zeit zum grübeln finde.

rklm Team-Icon

Projektleitung

Anmeldungsdatum:
16. Oktober 2011

Beiträge: 13242

Dakuan schrieb:

Warum habe ich immer Probleme, mich verständlich auszudrücken ...

Vielleicht liegt es ja auch an mir.

Also die Einstellungen betreffen 2 Objekte, die einander nicht kennen. Ein 3. Objekt erzeugt standard Einstellungen, die aber vom Benutzer geändert werden können.

Dann kannst Du doch in jedem Event-Handler die entsprechenden Felder im jeweiligen Objekt aktualisieren, oder?

Wenn dann ein neuer Programmlauf gestartet wird, werden die aktuellen Angaben vom Hauptprogramm nur noch abgefragt und ein Zähler hochgezählt.

Oder Du machst es so, dass das Panel eine Methode bekommt, die die aktuellen Werte in den übergebenen Objekten setzt. Oder eine Methode pro Objekt, das zu konfigurieren ist.

In dem ganzen Szenario ist mir aber immer noch nicht klar, welchen Zweck die Indizierung per int haben soll.

ChickenLipsRfun2eat Team-Icon

Anmeldungsdatum:
6. Dezember 2009

Beiträge: 12067

Hallo!

Ich vermute nach dem Lesen hier, du suchst so etwas wie Qt mit dem QVariant bietet? Also eine Containerklasse, der alle Werte enthalten kann und somit als universeller Rückgabetyp fungiert?

Problem dabei ist, dass du die entsprechenden Werte dann später wieder "umcasten" musst, wenn du int/bool/char brauchst.

Oder habe ich das völlig falsch verstanden?

Dakuan

(Themenstarter)
Avatar von Dakuan

Anmeldungsdatum:
2. November 2004

Beiträge: 6532

Vielleicht liegt es ja auch an mir.

Auch möglich, aber wenn mir das öfters passiert, kann das auch an meiner Denkweise oder nach japanischer Ansicht, an meiner Blutgruppe liegen 😉

In dem ganzen Szenario ist mir aber immer noch nicht klar, welchen Zweck die Indizierung per int haben soll.

Das sind eigentlich Zähler bzw. Einsteller für Min. und Max. Werte für einen Dateinamen Generator. Da bieten sich im FLTK Toolkit die bereits erwähnten Spinner an.

Dann kannst Du doch in jedem Event-Handler die entsprechenden Felder im jeweiligen Objekt aktualisieren, oder?

Das ist im FLTK Toolkit recht aufwändig, da ich für jedes verwendete Widget eine abgeleitete Klasse bauen muss bzw. dem vorhandenen Event-Handler einen eigenen vorschalten muss. Und wenn eine Änderung an 2 andere Objekte weiter gemeldet werden muss, stehe ich wieder auf dem Schlauch oder der Event Handler muss alle beteiligten Objekte kennen, was ich eigentlich vermeiden wollte.

Ich bin mir da nicht ganz sicher, weil ich die verschiedenen Design Konzepte nicht wirklich kenne (habe nur oberflächlich darüber gelesen), aber das was ich da gerade mache könnte ansatzweise Ähnlichkeit mit dem Observer Modell haben.

@ChickenLipsRfun2eat

Problem dabei ist, dass du die entsprechenden Werte dann später wieder "umcasten" musst, wenn du int/bool/char brauchst.

Aufgrund vorheriger Diskussionen hast Du sicherlich schon vermutet, das mir Qt etwas zu Umfangreich ist. Aber wenn ich sowiso "umcasten" muss. könnte ich auch generell mit void* arbeiten. Damit kann man alles hinzaubern.

Möglicherweise könnte ich die Funktionen so ändern, das ein Zeiger auf den Rückgabewert übergeben wird. Das währe dann wahrscheinlich wieder Teil der Signatur. Da muss ich aber erstmal sehen, wie das auf der Seite des Aufrufers aussieht.

rklm Team-Icon

Projektleitung

Anmeldungsdatum:
16. Oktober 2011

Beiträge: 13242

ChickenLipsRfun2eat schrieb:

Ich vermute nach dem Lesen hier, du suchst so etwas wie Qt mit dem QVariant bietet? Also eine Containerklasse, der alle Werte enthalten kann und somit als universeller Rückgabetyp fungiert?

Problem dabei ist, dass du die entsprechenden Werte dann später wieder "umcasten" musst, wenn du int/bool/char brauchst.

Eben, das grundsätzliche Problem wird nur verlagert.

Dakuan schrieb:

Auch möglich, aber wenn mir das öfters passiert, kann das auch an meiner Denkweise oder nach japanischer Ansicht, an meiner Blutgruppe liegen 😉

Oha... In meiner Beobachtung wird in vielen Themen nach einer speziellen Lösung gefragt. Während das den sportlichen Ehrgeiz weckt, eine solche Lösung zu bauen (siehe den Ansatz mit Templates weiter oben), kann man ohne Angabe des größeren Ziels nicht wissen, ob die Lösung auch sinnvoll ist. Ich weiß immer gerne, was die Leute erreichen wollen. Ein typisches Szenario ist die Frage nach "Wie mache ich X mit sed? Ich habe schon 1000 Sachen probiert, aber es klappt nicht." Dann erfährt man, was eigentlich gemacht werden soll und stellt fest, das ganze ließe sich mit awk in einer Zeile lösen, weil das Werkzeug für dieses Problem viel geeigneter ist.

In dem ganzen Szenario ist mir aber immer noch nicht klar, welchen Zweck die Indizierung per int haben soll.

Das sind eigentlich Zähler bzw. Einsteller für Min. und Max. Werte für einen Dateinamen Generator. Da bieten sich im FLTK Toolkit die bereits erwähnten Spinner an.

Nein, das meine ich nicht. Die Spinner sind ja zum Eingeben der Werte da - kein Problem hier. Aber Du hast in Deinen ursprünglichen Zugriffsmethoden im ersten Posting ein Argument code vorgesehen, das das Feld auswählt ("indiziert"). Darum ging es mir. Der Sinn erschließt sich mir noch nicht - vermutlich weil mir Kontext fehlt.

Ich bin mir da nicht ganz sicher, weil ich die verschiedenen Design Konzepte nicht wirklich kenne (habe nur oberflächlich darüber gelesen), aber das was ich da gerade mache könnte ansatzweise Ähnlichkeit mit dem Observer Modell haben.

Ich denke, das ist generell MVC, und wir überlegen gerade wie der Controller das Modell ändern soll.

@ChickenLipsRfun2eat

Aufgrund vorheriger Diskussionen hast Du sicherlich schon vermutet, das mir Qt etwas zu Umfangreich ist. Aber wenn ich sowiso "umcasten" muss. könnte ich auch generell mit void* arbeiten. Damit kann man alles hinzaubern.

Nur, dass Dir dann Typinformationen fehlen. ☺ Dafür bräuchte es so einen Wrapper. Aber ich verstehe immer noch nicht, warum dieser einheitliche Zugriff per numerischem Index überhaupt benötigt wird. Da wäre es halt sinnvoll zu erfahren, wofür Du das brauchst.

Dakuan

(Themenstarter)
Avatar von Dakuan

Anmeldungsdatum:
2. November 2004

Beiträge: 6532

Aber Du hast in Deinen ursprünglichen Zugriffsmethoden im ersten Posting ein Argument code vorgesehen, das das Feld auswählt ("indiziert"). Darum ging es mir. Der Sinn erschließt sich mir noch nicht - vermutlich weil mir Kontext fehlt.

Also eigentlich bin ich auf der Suche nach einem neuen Konzept für meine Programme und probiere neue Dinge aus. In diesem Fall passiert folgendes: Alle Widgets im Panel benutzen (mit einer Ausnahme) die selbe lokale Callback Funktion. Der einzige Unterschied ist der übergebene Code Wert, der angibt wo sich etwas geändert hat. Das Panel macht dann seinerseits ein Callback an das Hauptprogramm und gibt diesen Code weiter.

Das Hauptprogramm kann dann mit diesem Code die aktuellen Werte abholen, falls diese sofort verarbeitet werden müssen. Aber die Hauptaktivität startet erst, wenn der "Run" Button gedrückt wurde. Dann müssen noch einige andere Werte aktuell abgefragt werden. Mit 2 Ausnahmen sind das alles Strings.

Inspiriert zu dieser Vorgehensweise wurde ich durch 2 Klassen des FLTK-Toolkits, hauptsächlich Fl_Tree. Da wird sogar nur mitgeteilt, das ein Ereignis stattgefunden hat und der Grund muss extra erfragt werden.

Die Frage nach dem Sinn stellt sich mir erstmal so nicht. Mich interessiert hauptsächlich ob es besser funktioniert als das was ich bisher ausprobiert habe. Ausgelagert habe ich das Panel, weil die Textfelder teilweise sehr groß sind, und ich daher überlege, die in einem Bereich anzuordnen, der horizontal und vertikal gescrollt werden kann. Und wenn das funktioniert, möchte ich das auch in anderen Programmen einsetzen.

rklm Team-Icon

Projektleitung

Anmeldungsdatum:
16. Oktober 2011

Beiträge: 13242

Dakuan schrieb:

Also eigentlich bin ich auf der Suche nach einem neuen Konzept für meine Programme und probiere neue Dinge aus. In diesem Fall passiert folgendes: Alle Widgets im Panel benutzen (mit einer Ausnahme) die selbe lokale Callback Funktion. Der einzige Unterschied ist der übergebene Code Wert, der angibt wo sich etwas geändert hat. Das Panel macht dann seinerseits ein Callback an das Hauptprogramm und gibt diesen Code weiter.

Wie wird der Wert für code ermittelt? Ich kenne mich mit FLTK leider nicht aus, aber Du wirst doch vermutlich pro Widget einen Event-Handler definieren, der als erstes den Wert für code ermittelt und dann die "lokale Callback Funktion" aufruft, oder?

Und was macht dann diese "lokale Callback Funktion"?

Die Frage nach dem Sinn stellt sich mir erstmal so nicht. Mich interessiert hauptsächlich ob es besser funktioniert als das was ich bisher ausprobiert habe.

? Das ist doch die Sinnfrage.

Dakuan

(Themenstarter)
Avatar von Dakuan

Anmeldungsdatum:
2. November 2004

Beiträge: 6532

Wie wird der Wert für code ermittelt? Ich kenne mich mit FLTK leider nicht aus, aber Du wirst doch vermutlich pro Widget einen Event-Handler definieren,..

In FLTK hat jedes Widget einen eingebauten Event-Handler (int Fl_Widget::handle ( int event ). Einen eigenen Handler vorschalten kann man aber auch, wenn man z.B. Tastenkombinationen abfangen will. Im Manual steht dazu:

You normally don't call this method directly, but instead let FLTK do it when the user interacts with the widget.

When implemented in a widget, this function must return 0 if the widget does not use the event or 1 otherwise.

Most of the time, you want to call the inherited handle() method in your overridden method so that you don't short-circuit events that you don't handle. In this last case you should return the callee retval.

Der Rückgabewert der Callback Funktion kann bei der Initialisierung übergeben werden:

1
2
3
4
// Normalfall
widget->callback( callback_funktion, this );
// oder
widget->callback( callback_funktion, (void*)code );

Und was macht dann diese "lokale Callback Funktion"?

Vielleicht kann man das am Code besser sehen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void gw_setup::do_callback( int info ) { // callback panel -> Besitzer
    if( callback_pt )
        callback_pt( this, (void*)info );
}

//-----------------------------------------------------------------------------
//      local callback function
void gw_setup::panel_cb( Fl_Widget * w, void * u ) {
    gw_setup * parent = (gw_setup*)w->parent();
    parent->do_callback( (int)u );
}

//-----------------------------------------------------------------------------
//      Callback function for the mode selector.
void gw_setup::mode_cb( Fl_Widget * w, void * u ) {
    Fl_Check_Button * btn = (Fl_Check_Button*)w;
    gw_setup * gws = (gw_setup*)u;
    int val = btn->value();

    if( val == 0 )  // change 1->0
        gws->inc_start(); // incrementiere Startwert für nächste Aktion
    gws->do_callback( btn->value() == 0 ? GPN_SINGLE0 : GPN_SINGLE1 );
}

rklm Team-Icon

Projektleitung

Anmeldungsdatum:
16. Oktober 2011

Beiträge: 13242

Dakuan schrieb:

Wie wird der Wert für code ermittelt? Ich kenne mich mit FLTK leider nicht aus, aber Du wirst doch vermutlich pro Widget einen Event-Handler definieren,..

Also, die Antwort auf die Frage ist: man übergibt den Wert für code beim Setzen des Callbacks für ein Widget (s.u.).

Der Rückgabewert der Callback Funktion kann bei der Initialisierung übergeben werden:

Du meinst nicht den Rückgabewert sondern ein Argument (user data), das die Callback-Funktion beim Aufruf übergeben bekommt. Das scheint mir ein wenig aus der prozeduralen Welt zu kommen: da definiert man dann eine Funktion, die zusätzliche Daten bekommt, um das Verhalten zu steuern. In einer objektorientierten Sprache würde ich da eher eine Objektreferenz bzw. -zeiger erwarten.

Und was macht dann diese "lokale Callback Funktion"?

Vielleicht kann man das am Code besser sehen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void gw_setup::do_callback( int info ) { // callback panel -> Besitzer
    if( callback_pt )
        callback_pt( this, (void*)info );
}

//-----------------------------------------------------------------------------
//      local callback function
void gw_setup::panel_cb( Fl_Widget * w, void * u ) {
    gw_setup * parent = (gw_setup*)w->parent();
    parent->do_callback( (int)u );
}

//-----------------------------------------------------------------------------
//      Callback function for the mode selector.
void gw_setup::mode_cb( Fl_Widget * w, void * u ) {
    Fl_Check_Button * btn = (Fl_Check_Button*)w;
    gw_setup * gws = (gw_setup*)u;
    int val = btn->value();

    if( val == 0 )  // change 1->0
        gws->inc_start(); // incrementiere Startwert für nächste Aktion
    gws->do_callback( btn->value() == 0 ? GPN_SINGLE0 : GPN_SINGLE1 );
}

Wenn ich das richtig sehe, zeigst Du hier nur die Mechanik, um letztendlich an gw_setup::callback_pt zu delegieren. Das erklärt aber noch nicht, was die eigentliche Arbeit ist, die dort verrichtet wird. Darum ging es mir eigentlich. Ich versuche immer erst auf einer abstrakteren Ebene zu verstehen, was das Ziel ist bzw. welche Aufgabe erledigt wird.

Du scheinst mir hier mit gw_setup::callback_pt auch noch einen zusätzlichen Callback-Mechanismus zu dem von FLTK eingeführt zu haben. Ohne jetzt schon alle Details zu durchschauen, würde ich das vermutlich anders machen. Ich würde ein Interface für ein Proxy-Objekt und dann mehrere implementierende Klassen definieren, die alle relevanten Daten enthalten, mit denen es die nötige Arbeit im Callback-Fall erledigen kann. Dann würde ich einen simplen Adapter definieren, der von FL_Callback an die Arbeitsmethode des Proxy-Objektes delegiert. Ins Unreine geschrieben:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class FlCallback {
public:
  virtual void callback(Fl_Widget *widget) = 0;
  static void adapter(Fl_Widget *widget, void *flCb);
};

void FlCallback::adapter(Fl_Widget *widget, void *flCb) {
  if ( flCb ) { 
    ((FlCallback*) flCb)->callback(widget);
  }
}

...

class Cb1 : public FlCallback {
  void callback(Fl_Widget *w) {
    ...
  }
};

...

class SomeWidget : ... {
  FlCallback *cb;

  SomeWidget() : cb(new Cb1(this, ...)) {
    widget->callback(&FlCallback::adapter, cb);
  }

  ~SomeWidget() {
    delete cb;
  }
};

Vielleicht kann man das noch eleganter machen. Aber so schon kann man z.B. bei Deinem gw_setup::panel_cb bereits in die Callback-Klasse den Zeiger auf den Parent packen (sofern der sich nicht ändern kann), so dass dann die Auflösung nicht immer wieder gemacht werden muss. Ein anderer Vorteil ist, dass man Zustand im Callback-Objekt über Aufrufe hinweg zwischenspeichern kann (z.B. einen Zähler der Aufrufe oder den Zeitstempel des letzten Aufrufes etc.).

Antworten |