Wie kann es sein nützlich, um eine überlastung der "function call" - Betreiber?

Vor kurzem habe ich entdeckt, dass in C++ können Sie die überlastung der "function call" - Betreibers, in einer seltsamen Art und Weise, in dem Sie haben zu schreiben, sind zwei paar Klammern zu tun:

class A { 
  int n;
public: 
  void operator ()() const; 
};

Und dann diese Art der Nutzung:

A a;
a();

Wann ist dies nützlich?

Lesen Sie über die Funktion von Objekten. en.wikipedia.org/wiki/Function_object

InformationsquelleAutor lurks | 2010-02-28

c++function-object functor operator-overloading

27

Diese können verwendet werden, um "funktoren", Objekte, die handeln, wie Funktionen:
```
class Multiplier {
public:
    Multiplier(int m): multiplier(m) {}
    int operator()(int x) { return multiplier * x; }
private:
    int multiplier;
};

Multiplier m(5);
cout << m(4) << endl;
```
Den oben genannten Drucke 20. Der Wikipedia-Artikel weiter oben verlinkt gibt weitere wesentliche Beispiele.

Und der Hauptgrund, warum Sie wollen würde, funktoren ist, um höherwertige Funktionen in C++.
Sie könnten erweitern Sie diese um, zum Beispiel, multiplizieren Sie mit m das erste mal Sie es nennen, multipliziert mit m+1 das zweite mal, usw. Normale Funktionen können nicht speichern Sie alle Status-Informationen zwischen aufrufen, aber funktoren können.
Auch können Sie immer mit statischen Variablen in einer Funktion zu geben es Staat (oder globals - Schauer). Aber beide sind sehr hässlich und fehleranfällig. (Ich würde verwenden einen Funktor statt .. aber es ist möglich)

InformationsquelleAutor Greg Hewgill
17

Gibt es wenig mehr als eine syntaktische gewinnen in die Verwendung von operator (), bis Sie anfangen, templates zu verwenden. Aber bei der Verwendung von Vorlagen, die Sie behandeln können reelle Funktionen und funktoren (Klassen fungieren als Funktionen) auf die gleiche Weise.
```
class scaled_sine
{
    explicit scaled_sine( float _m ) : m(_m) {}
    float operator()(float x) const { return sin(m*x); }
    float m;
};

template<typename T>
float evaluate_at( float x, const T& fn )
{
   return fn(x);
}

evaluate_at( 1.0, cos );
evaluate_at( 1.0, scaled_sine(3.0) );
```
Ja; Funktion-wie die Dinge wirklich sind sehr nützlich, wenn Sie genug schwache Typisierung. C++ hat noch nicht, aber Vorlagen müssen.

InformationsquelleAutor Michael Anderson
5

Einen Algorithmus implementiert, die eine Vorlage verwenden, egal ob das Ding genannt wird, ist eine Funktion oder Funktor, Sie kümmert sich um die syntax. Entweder standard (z.B. for_each()) oder Ihre eigenen. Und funktoren können einen Status haben, und tun alle möglichen Dinge, die, wenn Sie aufgerufen werden. Funktionen können nur im Zustand mit eine statische lokale variable oder Globale Variablen.

InformationsquelleAutor paul
1

Wenn du eine Klasse kapselt eine Funktion Zeiger, das könnte die Nutzung noch deutlicher.

InformationsquelleAutor Reed Copsey
1

Kann der compiler auch die inline-funktors und die Funktion aufrufen. Es können keine inline-Funktion Zeiger, jedoch. Auf diese Weise, mit dem Aufruf der Funktion Bediener kann deutlich die performance verbessern, wenn es verwendet wird, zum Beispiel mit der standard C++ Bibliothek für algorithmen.

InformationsquelleAutor fintux

Beispielsweise für die Implementierung von Generatoren:

//generator
struct Generator {
    int c = 0;

    virtual int operator()() {
        return c++;
    }
};

int sum(int n) {
    Generator g;

    int res = 0;
    for( int i = 0; i < n; i++ ) {
        res += g();
    }

    return res;
}

InformationsquelleAutor Quonux

0

Sehe ich Potenzial, um noch eine exotische Nutzung:

Angenommen, Sie haben Objekt unbekannten Typs und deklarieren eine andere variable des gleichen Typs, wie diese:
```
 auto c=decltype(a*b)(123);
```
Wenn solche Muster ausgiebig genutzt, decltype geworden, sehr ärgerlich.
Dieser Fall kann auftreten, wenn einige smart-Art-system, das automatisch erfinden Ergebnistyp von Funktionen und Operatoren, basierend auf die Typen der Argumente.

Nun, wenn jede Spezialisierung für jeden Typ von diesem Typ-system ausgestattet mit
Magie-definition von operator() wie diese:
```
template<????> class Num<???>{
    //specific implementation here
    constexpr auto operator()(auto...p){return Num(p...);}
}
```
decltype() nicht mehr benötigt, können Sie einfach schreiben:
```
auto c=(a*b)(123);
```
Da operator() des Objektes leitet an den Konstruktor seiner eigenen Typ.

InformationsquelleAutor Lexey

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.