Y a-t-il des pointeurs de la fonction en C #?

Les délégués sont essentiellement des pointeurs de fonction, mais avec des capacités de multidiffusion supplémentaires intégrées. Vous pouvez donc affecter plusieurs fonctions au même délégué et elles seront toutes appelées en séquence lorsque le délégué est appelé.

Les délégués ont également des interfaces asynchrones intégrées et disposent de CO / Contra de variance lors de l'attribution de nouvelles fonctions à un délégué (et, dans .NET 4, lors de la transmission des délégués)

Un délégué est similaire à un pointeur de fonction d'une certaine manière, mais il est en fait plus proche d'une interface avec une seule fonction associée à un moyen d'enregistrer des gestionnaires et d'un mécanisme de répartition multidiffusion.

Donc, c'est beaucoup plus qu'un pointeur de fonction.

pas dans le sens classique C / C ++, no. Mais le concept est quelque peu similaire - .NET introduit le concept de Délégués Pour gérer les situations où vous avez besoin d'une variable pour invoquer une méthode sur. Les délégués ne peuvent pas être "Twiddled" avec comme des pointeurs et il y a de type Sécurité intégrée.

Si vous utilisez des pointeurs de fonction de style C «correctement», les concepts sont similaires. Mais il semble y avoir beaucoup de code hérité qui fait des manipulations amusantes des pointeurs de jupe autour de la sécurité de type ou de ce qui n'est pas.

Comme d'autres l'ont dit, vous voudrez utiliser des délégués pour des situations de C # que vous auriez utilisé des pointeurs de fonction pour en C ++. Les délégués sont conceptuellement similaires aux pointeurs de la fonction, mais beaucoup plus agréables à utiliser, car ils encapsulent non seulement la fonction, mais également l'objet "recevant" qui sera "Ceci" de l'invocation.

Notez que le CLR a le concept de pointeurs de fonction. Si vous deviez examiner de près la façon dont le compilateur C # génère un code qui construit des délégués, vous verriez qu'il effectue une référence gérée à une fonction et transmet celle à un constructeur de délégué. Il n'y a pas de fonctionnalité de langue dans C # qui vous permet d'obtenir au pointeur de la fonction "nu" et de le manipuler directement.

Cependant, étant donné que le concept existe dans le CLR, il est théoriquement possible qu'une version future de C # puisse prendre en charge les pointeurs de fonction comme concept de première classe dans un code dangereux, tout comme nous prenons en charge les pointeurs de données dans un code dangereux. Ce que nous ferons dans ce cas, c'est (1) suivre la signature du pointeur de fonction que le type de pointeur et (2) le code d'émetteur qui utilise «calli» (appelez l'indirection du pointeur) CIL OPCODE.

Cela augmenterait l'efficacité de certains scénarios interopest obscur dans lesquels nous devons actuellement faire passer de nombreux cerceaux, construire des instances de délégués uniquement afin que le marshaller puisse obtenir au pointeur de la fonction. Si nous pouvions éviter de nécessiter la dépense de la construction de délégués et d'aller directement au pointeur de la fonction, les scénarios interopers maintenant rares pourraient devenir moins chers.

Cependant, je ne voudrais pas tenir mon souffle à attendre cette fonctionnalité si j'étais toi. Nous avons le prototypé et cela fonctionne assez bien, mais je ne pense pas que la demande soit là pour justifier de l'ajouter à une langue générale comme c # à ce moment-là.

C # a quelque chose comme un pointeur de fonction, qui est un délégué d'appel. Eh bien ... Je ne peux pas vraiment vous donner une réponse théorique à la différence entre eux. Mais je peux vous donner une différence de mise en oeuvre de code entre les pointeurs de fonctions C # délégués VS C ++.

C # p> xxx pré>

ceci compilerait facilement en C #. P>

C ++ p>

#include <iostream>
#include <vector>

class A
{
public:
    A() {}
    virtual void operator()() { std::cout << "A is called"; }
};

class B : A
{
public:
    B(std::vector<int>& vec):vec_(vec){}
    void operator()() { vec_.clear(); std::cout << "B is called" << std::endl; }

private:
    std::vector<int>& vec_;
};

int main() 
{
    std::vector<int> tmpVec;
    for (int i = 0; i < 10; ++i)
    {
        tmpVec.push_back(i);
    }
    B* b = new B(tmpVec);
    A* a = (A*)b;

    std::cout << "Current vec size: " << tmpVec.size() << std::endl;

    (*a)();

    std::cout << "Current vec size: " << tmpVec.size() << std::endl;

    delete b;

    return 0;
}

En plus de la réponse de N00BKEFKA, je dois vous faire savoir qu'il existe des pointeurs de fonction membre en C ++ et il n'est pas nécessaire de définir une nouvelle classe du tout.

Voici comment pointer sur Intlist .clear , où INTLIST est une instance de std :: vecteur , puis invoquez cette fonction sans définir de nouvelle classe du tout: xxx

mais bien sûr que les délégués C # sont les meilleurs selon toutes les autres réponses ici.