Was ist ein C++-Delegat?

Question 1

Was ist die allgemeine Idee eines Delegaten in C++? Was sind sie, wie werden sie verwendet und wofür werden sie verwendet?

Ich würde sie gerne zuerst auf „Black Box“-Weise kennenlernen, aber ein paar Informationen über die Eingeweide dieser Dinge wären auch großartig.

Dies ist nicht C++ in seiner reinsten oder saubersten Form, aber ich stelle fest, dass die Codebasis, an der ich arbeite, sie in Hülle und Fülle enthält. Ich hoffe, sie genug zu verstehen, damit ich sie einfach verwenden kann und mich nicht in die schreckliche Schrecklichkeit verschachtelter Vorlagen vertiefen muss.

Diese zwei Das Code-Projekt Artikel erklären, was ich meine, aber nicht besonders prägnant:

Question 2

Sie haben eine unglaubliche Anzahl von Möglichkeiten, um Delegates in C++ zu erreichen. Hier sind die, die mir in den Sinn gekommen sind.

Option 1: Funktoren:

Ein Funktionsobjekt kann durch Implementieren erstellt werden operator()

struct Functor
{
     // Normal class/struct members

     int operator()(double d) // Arbitrary return types and parameter list
     {
          return (int) d + 1;
     }
};

// Use:
Functor f;
int i = f(3.14);

Option 2: Lambda-Ausdrücke (C++11 nur)

// Syntax is roughly: [capture](parameter list) -> return type {block}
// Some shortcuts exist
auto func = [](int i) -> double { return 2*i/1.15; };
double d = func(1);

Option 3: Funktionszeiger

int f(double d) { ... }
typedef int (*MyFuncT) (double d);
MyFuncT fp = &f;
int a = fp(3.14);

Option 4: Zeiger auf Elementfunktionen (schnellste Lösung)

Sehen Schneller C++-Delegierter (An Das Code-Projekt).

struct DelegateList
{
     int f1(double d) { }
     int f2(double d) { }
};

typedef int (DelegateList::* DelegateType)(double d);

DelegateType d = &DelegateList::f1;
DelegateList list;
int a = (list.*d)(3.14);

Möglichkeit 5: std::Funktion

(oder boost::function wenn Ihre Standardbibliothek dies nicht unterstützt). Es ist langsamer, aber am flexibelsten.

#include <functional>
std::function<int(double)> f = [can be set to about anything in this answer]
// Usually more useful as a parameter to another functions

Option 6: Bindung (mit std::bind)

Ermöglicht das Einstellen einiger Parameter im Voraus, z. B. zum bequemen Aufrufen einer Member-Funktion.

struct MyClass
{
    int DoStuff(double d); // actually a DoStuff(MyClass* this, double d)
};

std::function<int(double d)> f = std::bind(&MyClass::DoStuff, this, std::placeholders::_1);
// auto f = std::bind(...); in C++11

Option 7: Vorlagen

Akzeptiere alles, solange es mit der Argumentliste übereinstimmt.

template <class FunctionT>
int DoSomething(FunctionT func)
{
    return func(3.14);
}

Question 3

Ein Delegat ist eine Klasse, die einen Zeiger oder eine Referenz auf eine Objektinstanz umschließt, eine Mitgliedsmethode der Klasse dieses Objekts, die für diese Objektinstanz aufgerufen werden soll, und eine Methode bereitstellt, um diesen Aufruf auszulösen.

Hier ist ein Beispiel:

template <class T>
class CCallback
{
public:
    typedef void (T::*fn)( int anArg );

    CCallback(T& trg, fn op)
        : m_rTarget(trg)
        , m_Operation(op)
    {
    }

    void Execute( int in )
    {
        (m_rTarget.*m_Operation)( in );
    }

private:

    CCallback();
    CCallback( const CCallback& );

    T& m_rTarget;
    fn m_Operation;

};

class A
{
public:
    virtual void Fn( int i )
    {
    }
};


int main( int /*argc*/, char * /*argv*/ )
{
    A a;
    CCallback<A> cbk( a, &A::Fn );
    cbk.Execute( 3 );
}

Question 4

Die Notwendigkeit von C++-Delegatimplementierungen ist eine lang anhaltende Verlegenheit für die C++-Community. Jeder C++-Programmierer würde sie gerne haben, also verwenden sie sie schließlich trotz der Tatsachen, dass:

std::function() verwendet Heap-Operationen (und ist für ernsthafte eingebettete Programmierung unerreichbar).
Alle anderen Implementierungen machen Zugeständnisse in Richtung Portabilität oder Standardkonformität in größerem oder geringerem Maße (bitte überprüfen Sie dies, indem Sie die verschiedenen Delegiertenimplementierungen hier und auf codeproject überprüfen). Ich habe noch keine Implementierung gesehen, die keine wilden reinterpret_casts verwendet, verschachtelte Klassen “Prototypen”, die hoffentlich Funktionszeiger der gleichen Größe wie die vom Benutzer übergebenen erzeugen, Compiler-Tricks wie zuerst vorwärts deklarieren, dann typedef und dann erneut deklarieren, diesmal von einer anderen Klasse oder ähnlichen zwielichtigen Techniken erben. Obwohl es eine großartige Leistung für die Implementierer ist, die das gebaut haben, ist es immer noch ein trauriges Zeugnis dafür, wie sich C++ entwickelt.

Nur selten wird darauf hingewiesen, dass seit über 3 C++-Standardrevisionen Delegaten nicht richtig angesprochen wurden. (Oder das Fehlen von Sprachfeatures, die eine unkomplizierte Delegiertenimplementierung ermöglichen.)
Mit der Art und Weise, wie C++11-Lambda-Funktionen vom Standard definiert werden (jedes Lambda hat einen anonymen, anderen Typ), hat sich die Situation nur in einigen Anwendungsfällen verbessert. Aber für den Anwendungsfall der Verwendung von Delegaten in (DLL-)Bibliotheks-APIs, Lambdas allein sind immer noch nicht nutzbar. Die übliche Technik hier besteht darin, das Lambda zuerst in eine std::function zu packen und es dann über die API zu übergeben.

Question 5

Ganz einfach, ein Delegat bietet Funktionen dafür, wie ein Funktionszeiger funktionieren SOLLTE. Es gibt viele Einschränkungen für Funktionszeiger in C++. Ein Delegat verwendet hinter den Kulissen ein bösartiges Template, um ein funktionszeigerartiges Ding der Template-Klasse zu erstellen, das so funktioniert, wie Sie es vielleicht möchten.

dh – Sie können sie so einstellen, dass sie auf eine bestimmte Funktion zeigen, und Sie können sie herumreichen und anrufen, wann und wo immer Sie möchten.

Hier gibt es einige sehr gute Beispiele:

http://www.codeproject.com/Articles/13287/Fast-C-Delegate

Question 6

Eine Option für Delegaten in C++, die hier nicht anderweitig erwähnt wird, besteht darin, dies im C-Stil mit einer Funktion ptr und einem Kontextargument zu tun. Dies ist wahrscheinlich das gleiche Muster, das viele, die diese Frage stellen, zu vermeiden versuchen. Das Muster ist jedoch portabel, effizient und kann in eingebettetem und Kernel-Code verwendet werden.

class SomeClass
{
    in someMember;
    int SomeFunc( int);

    static void EventFunc( void* this__, int a, int b, int c)
    {
        SomeClass* this_ = static_cast< SomeClass*>( this__);

        this_->SomeFunc( a );
        this_->someMember = b + c;
    }
};

void ScheduleEvent( void (*delegateFunc)( void*, int, int, int), void* delegateContext);

    ...
    SomeClass* someObject = new SomeObject();
    ...
    ScheduleEvent( SomeClass::EventFunc, someObject);
    ...

Question 7

Windows-Runtime-Äquivalent eines Funktionsobjekts in Standard-C++. Man kann die ganze Funktion als Parameter verwenden (eigentlich ist das ein Funktionszeiger). Es wird hauptsächlich in Verbindung mit Veranstaltungen verwendet. Der Delegat stellt einen Vertrag dar, den Ereignishandler weitgehend erfüllen. Es erleichtert, wie ein Funktionszeiger arbeiten kann.