Che cos'è un delegato C ++?

Qual è l'idea generale di un delegato in C ++? Cosa sono, come vengono utilizzati e a cosa servono?

Mi piacerebbe prima conoscerli in un modo "scatola nera", ma anche un po 'di informazioni sull'intestino di queste cose sarebbe eccezionale.

Questo non è C ++ nella sua forma più pura o pulita, ma noto che la base di codice in cui lavoro li ha in abbondanza. Spero di capirli abbastanza, quindi posso semplicemente usarli e non dover approfondire l'orribile orribile modello annidato.

Questi due articoli di The Code Project spiegano cosa intendo, ma non in modo particolarmente succinto:

• Puntatori di funzioni membro e delegati C ++ più veloci possibili

• I delegati C ++ incredibilmente veloci

Hai un numero incredibile di scelte per raggiungere i delegati in C ++. Ecco quelli che mi sono venuti in mente.

Opzione 1: funzioni:

Un oggetto funzione può essere creato implementando 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);

Opzione 2: espressioni lambda (solo C ++ 11 )

// 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);

Opzione 3: puntatori a funzione

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

Opzione 4: puntatore alle funzioni membro (soluzione più veloce)

Vedi Delegato C ++ veloce (su The Code Project ).

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);

Opzione 5: std :: function

(o boost::functionse la tua libreria standard non la supporta). È più lento, ma è il più flessibile.

#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

Opzione 6: associazione (usando std :: bind )

Consente di impostare alcuni parametri in anticipo, ad esempio è utile chiamare una funzione membro.

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

Opzione 7: modelli

Accetta qualsiasi cosa purché corrisponda all'elenco degli argomenti.

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

Un delegato è una classe che avvolge un puntatore o un riferimento a un'istanza di oggetto, un metodo membro della classe di quell'oggetto da chiamare su quell'istanza di oggetto e fornisce un metodo per attivare quella chiamata.

Ecco un esempio:

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 );
}

La necessità di implementazioni di delegati C ++ è un imbarazzo di lunga durata per la comunità C ++. Ogni programmatore C ++ vorrebbe averli, quindi alla fine li usano nonostante i fatti che:

1. std::function() utilizza le operazioni heap (ed è fuori portata per una seria programmazione integrata).

2. Tutte le altre implementazioni fanno concessioni verso la portabilità o la conformità standard a livelli maggiori o minori (si prega di verificare ispezionando le varie implementazioni dei delegati qui e su codeproject). Devo ancora vedere un'implementazione che non utilizza reinterpret_casts selvaggi, "prototipi" di classe nidificati che si spera producano puntatori a funzioni della stessa dimensione di quelli passati dall'utente, trucchi del compilatore come prima dichiarazione in avanti, quindi digitazione e poi dichiarazione di nuovo, questa volta ereditando da un'altra classe o simili tecniche ombrose. Sebbene sia un grande risultato per gli implementatori che l'hanno costruito, è ancora una triste testimonianza dell'evoluzione del C ++.

3. Solo raramente viene sottolineato che ora oltre 3 revisioni C ++ standard, i delegati non venivano indirizzati correttamente. (O la mancanza di funzionalità linguistiche che consentono implementazioni dirette dei delegati.)

4. Con il modo in cui le funzioni lambda C ++ 11 sono definite dallo standard (ogni lambda ha un tipo anonimo e diverso), la situazione è migliorata solo in alcuni casi d'uso. Ma per il caso d'uso dell'uso dei delegati nelle API della libreria (DLL), i lambda da soli non sono ancora utilizzabili. La tecnica comune qui è prima impacchettare lambda in una funzione std :: e poi passarlo attraverso l'API.

Molto semplicemente, un delegato fornisce funzionalità per il funzionamento di un puntatore a funzione. Esistono molte limitazioni dei puntatori a funzione in C ++. Un delegato usa un po 'di cattiveria dietro le quinte per creare una funzione-puntatore-tipo-classe di classe modello che funziona nel modo desiderato.

vale a dire: puoi impostarli in modo che puntino a una determinata funzione e puoi passarli in giro e chiamarli quando e dove vuoi.

Ci sono alcuni ottimi esempi qui:

• http://www.codeproject.com/Articles/7150/Member-Function-Pointers-and-the-Fastest-Possible
• http://www.codeproject.com/Articles/11015/The-Impossibly-Fast-C-Delegates
• http://www.codeproject.com/Articles/13287/Fast-C-Delegate

Un'opzione per i delegati in C ++ che non è altrimenti menzionata qui è quella di farlo in stile C usando una funzione ptr e un argomento di contesto. Questo è probabilmente lo stesso modello che molti che fanno questa domanda stanno cercando di evitare. Tuttavia, il modello è portatile, efficiente ed è utilizzabile nel codice incorporato e nel kernel.

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);
    ...

Equivalente di Windows Runtime di un oggetto funzione in C ++ standard. Si può usare l'intera funzione come parametro (in realtà si tratta di un puntatore a funzione). Viene utilizzato principalmente in combinazione con eventi. Il delegato rappresenta un contratto che i gestori di eventi adempiono molto. Facilita come può funzionare un puntatore a funzione.