Qu'est-ce qu'un délégué C ++?

Quelle est l'idée générale d'un délégué en C ++? Quels sont-ils, comment sont-ils utilisés et à quoi servent-ils?

J'aimerais d'abord en apprendre davantage sur eux dans une «boîte noire», mais un peu d'informations sur les tripes de ces choses serait également très bien.

Ce n'est pas du C ++ à l'état pur ou le plus propre, mais je remarque que la base de code sur laquelle je travaille en a en abondance. J'espère les comprendre suffisamment pour pouvoir les utiliser et ne pas avoir à me plonger dans l'horrible horrible modèle imbriqué.

Ces deux articles de The Code Project expliquent ce que je veux dire, mais pas particulièrement succinctement:

• Pointeurs de fonction membre et délégués C ++ les plus rapides possibles

• Les délégués C ++ incroyablement rapides

Vous avez un nombre incroyable de choix pour obtenir des délégués en C ++. Voici ceux qui me sont venus à l'esprit.

Option 1: foncteurs:

Un objet fonction peut être créé en implémentant 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: expressions lambda ( C ++ 11 uniquement)

// 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: pointeurs de fonction

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

Option 4: pointeur vers les fonctions membres (solution la plus rapide)

Voir Délégué Fast C ++ (sur 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);

Option 5: std :: fonction

(ou boost::functionsi votre bibliothèque standard ne le prend pas en charge). C'est plus lent, mais c'est le plus flexible.

#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: liaison (en utilisant std :: bind )

Permet de définir certains paramètres à l'avance, pratique pour appeler une fonction membre par exemple.

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: modèles

Acceptez n'importe quoi tant qu'il correspond à la liste d'arguments.

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

Un délégué est une classe qui encapsule un pointeur ou une référence vers une instance d'objet, une méthode membre de la classe de cet objet à appeler sur cette instance d'objet et fournit une méthode pour déclencher cet appel.

Voici un exemple:

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

Le besoin d'implémentations de délégués C ++ est un embarras durable pour la communauté C ++. Tous les programmeurs C ++ aimeraient les avoir, donc ils les utilisent finalement malgré les faits que:

1. std::function() utilise des opérations de tas (et est hors de portée pour une programmation embarquée sérieuse).

2. Toutes les autres implémentations font des concessions soit sur la portabilité, soit sur la conformité standard à des degrés plus ou moins élevés (veuillez vérifier en inspectant les différentes implémentations de délégués ici et sur codeproject). Je n'ai pas encore vu d'implémentation qui n'utilise pas de reinterpret_casts sauvages, des "prototypes" de classe imbriquée qui, espérons-le, produisent des pointeurs de fonction de la même taille que celle transmise par l'utilisateur, des astuces de compilateur comme first forward declare, puis typedef puis déclarez à nouveau, cette fois héritant d'une autre classe ou de techniques louches similaires. Bien que ce soit une grande réussite pour les implémenteurs qui ont construit cela, c'est toujours un triste témoignage sur la façon dont le C ++ évolue.

3. Il est rarement souligné que maintenant, sur 3 révisions standard C ++, les délégués n'étaient pas correctement adressés. (Ou le manque de fonctionnalités de langage permettant des implémentations de délégué simples.)

4. Avec la façon dont les fonctions lambda C ++ 11 sont définies par la norme (chaque lambda a un type anonyme et différent), la situation ne s'est améliorée que dans certains cas d'utilisation. Mais pour le cas d'utilisation de l'utilisation de délégués dans les API de bibliothèque (DLL), les lambdas seuls ne sont toujours pas utilisables. La technique courante ici consiste à emballer d'abord le lambda dans une fonction std ::, puis à le transmettre à travers l'API.

Très simplement, un délégué fournit des fonctionnalités sur la façon dont un pointeur de fonction DEVRAIT fonctionner. Il existe de nombreuses limitations des pointeurs de fonction en C ++. Un délégué utilise une certaine méchanceté de modèle dans les coulisses pour créer un objet de type pointeur de fonction de classe de modèle qui fonctionne comme vous le souhaitez.

c'est-à-dire - vous pouvez les configurer pour qu'ils pointent sur une fonction donnée et vous pouvez les faire circuler et les appeler quand et où vous le souhaitez.

Il y a de très bons exemples ici:

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

Une option pour les délégués en C ++ qui n'est pas mentionnée autrement ici est de le faire en style C en utilisant une fonction ptr et un argument de contexte. C'est probablement le même schéma que beaucoup de personnes qui posent cette question essaient d'éviter. Mais, le modèle est portable, efficace et utilisable dans le code embarqué et du noyau.

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

Windows Runtime équivalent d'un objet fonction en C ++ standard. On peut utiliser toute la fonction comme paramètre (en fait c'est un pointeur de fonction). Il est principalement utilisé en conjonction avec des événements. Le délégué représente un contrat que les gestionnaires d'événements remplissent beaucoup. Cela facilite le fonctionnement d'un pointeur de fonction.