Les Références De Fonction

Alors je viens de travailler avec des pointeurs de fonction et je me suis souvenu que vous pourriez faire ceci:

void Foo()
{
}

int main()
{
    void(& func)() = Foo;

    func(); //::Foo();
}

L'avantage évident étant que les références référence valide les objets (sauf s'ils sont mal utilisés), ou des fonctions dans ce cas.

L'inconvénient majeur étant que vous ne pouvez pas stocker un tableau de références et ne pouvez pas les utiliser pour la fonction de membre de pointeurs (au moins autant que j'en puis dire).

Ma question: personne ne les utiliser (c'est à dire, fonction des références, pas pointeurs de fonction), et si oui, dans quelles circonstances avez-vous trouvé utile/utile?

Le seul endroit où je peux les voir être utile au large de la chauve-souris est la liaison d'une référence à une certaine fonction lors de l'utilisation de compilation conditionnelle.

J'ai toujours utiliser des références quand je n'acceptent pas les pointeurs null. Si vous utilisez les pointeurs, vous devriez vérifier si l'une (ou assurez-vous) le pointeur est null, avant de l'utiliser.
Probablement, vous pouvez utiliser std::reference_wrapper pour utiliser la référence dans le conteneur. De cette façon, vous obtenez tout le parti reference a et pouvez l'utiliser comme une valeur.

OriginalL'auteur GlobalKiller | 2009-01-26

c++

13

J'ai utilisé avant d'ajouter la personnalisation à des classes en les passant au constructeur comme le modèle de stratégie

Idem ici, mais j'ai utilisé boost::function place. C'est plus souple 🙂
Votre contribution est appréciée.
Stimuler la solution est plus souple, mais La solution que j'ai donné est bon dans le code incorporé où boost généraux, sur le code compilé. Est prohibitif.
Je suis en train d'essayer d'essayer de déclarer une propriété de classe qui peut se référer à une fonction au moment de l'exécution. Il me semble que u a réussi même si je n'ai pas compris ur réponse. Veuillez étendu ur réponse avec des exemples de code. Merci!

OriginalL'auteur Robert Gould
12

Je pense que votre exemple d'utilisation est assez bonne. Parce que si vous voulez utiliser un simple pointeur de fonction, et vous appliquez ensuite l'adresse de l'opérateur, vous obtiendrez l'adresse du pointeur de fonction. À l'aide d'une référence à la fonction va faire que l'on attend, en ce qu'elle renvoie un pointeur sur la fonction elle-même.

Je ne peux pas penser à de nombreux exemples. En gardant les références de fonction, comme vous le soulignez, a d'horribles conséquences. Un autre éventuellement indésirables conséquence est que, si tenus en tant que membre, vos objets seront incessibles si vous n'écrivez pas votre propre opérateur= et de s'abstenir d'essayer de ré-attribuer la fonction de référence.

Je pense que la plupart des utilisations de la fonction de références implicites, à l'instar de la plupart des utilisations du tableau des références bien que beaucoup plus, lorsque vous accepter des arguments par référence:
```
template<typename T>
void do_something(T const& t) { ... }
```
Tout en acceptant les tableaux par référence a l'avantage de ne pas perdre leurs informations de taille, l'acceptation de fonctions par référence explicitement, ne semble pas être un avantage (au moins autant que je peux voir). Je suppose que l'existence de références de fonction est largement justifié par la vision idéaliste d'une référence comme une alias-nom d'un objet ou d'une fonction, en collaboration avec le fait qu'il permet le passage de fonctions à ces modèles qui acceptent leur argument par référence.

Je serais probablement éviter de les utiliser si je n'aurais pas besoin d'eux, inévitablement. Constante des pointeurs de fonction également de la non-reassignable callables, et sera probablement éviter les confusions lorsque d'autres programmeurs, qui, éventuellement, ne sont pas très familier avec cette langue de niches, de lire votre code. Vaut la peine de noter que Vandervoorde & Josuttis vous conseillons également de les éviter pour réduire les risques de confusion (dans leur livre " C++ Templates - Le Guide Complet).

Pointeurs de fonction ont également un autre avantage dans la mesure où elles peuvent être faites à un aspect différent du commun des appels de fonction: (*mafonction)(bar);
aib. eh bien, la même chose est vraie pour la fonction des références. vous pouvez même le faire (**************mafonction)(bar); il fonctionne toujours, en raison de la conversion implicite de la fonction à la fonction de pointeur 🙂 même si je suis d'accord ça a l'air drôle
Hmm c'est vrai, je ne pense pas que. Vous pouvez le faire avec des fonctions classiques.

OriginalL'auteur Johannes Schaub - litb

Références de fonction, à la différence des pointeurs de fonction, de le rendre plus difficile pour les créer à partir d'une source invalide. Ceci est utile si vous faites un wrapper autour d'une bibliothèque C - le code C++ peut prendre une fonction de rappel par référence et passez le pointeur de la bibliothèque C si la lbrary exige que le passé pointeur ne doit pas être NULL.

C'est aussi un moyen pratique d'attribuer une fonction, surtout en C++11 avec le nouveau mot clé auto:

#include <iostream>
#include <typeinfo>

void f(int i, char c)
{
    std::cout << i << ' ' << c << std::endl;
}

int main()
{
    std::cout << typeid(f).name() << std::endl; //FvicE
    f(0, '1');

    void (*pf)(int, char) (&f); //ugly
    std::cout << typeid(pf).name() << std::endl; //PFvicE
    (*pf)(2, '3');
    pf(4, '5'); //works, but I don't recommend it

    void (&rf)(int, char) (f); //still ugly
    std::cout << typeid(rf).name() << std::endl; //FvicE
    rf(6, '7');

    auto &af (f); //pretty, but only works in C++11
    std::cout << typeid(af).name() << std::endl; //FvicE, same as above
    af(8, '9');
}

Bonne réponse, également très utile avec des lambdas et le référencement lambda fonctions.

OriginalL'auteur LB--

2

en outre à l'utilisation de la stratégie (comme l'a souligné Robert Gould), je freqently les utiliser au point d'entrée (modèle) métaprogrammation. Une fonction de référence peut facilement être repris par un paramètre de modèle; à partir de ce point, il peut être passé à travers plusieurs couches de (métaprogrammation) modèles. Bien sûr, cela vaut pour un pointeur de fonction en tant que bien, mais la référence est un alias et donc communique l'intention plus clairement.

Pour donner un exemple: lors de la rédaction d'un générique de commande système de répartition d'une application, un grand nombre de différentes opérations doivent être, a annoncé que les commandes. On peut utiliser un simple "générateur de fonction" en tant que front-end pour le code client. En coulisses, ce générateur de fonction ramasse la véritable signature de fonction en tant que paramètre du modèle, dérive (par modèle de métaprogrammation) le paramètre effectif et le type de retour de valeurs et, éventuellement, choisit la spécialisation de stocker un "memento" et "annuler foncteur". Ces foncteurs peuvent être stockées soit en tant que pointeurs de fonction en interne, ou à l'aide de boost ou de tr1 ou C++11 de la fonction des objets. De cette façon, il est possible de construire un type de coffre-fort invocation de commande et "annuler".

Je serais intéressé d'avoir un oeil sur le code du système que vous avez décrit, s'il est disponible quelque part 🙂
Intéressant mais trop abstrait pour comprendre sans un exemple de code à vue, sauf si vous êtes un très avancée programmeur.
cela n'a rien à voir avec le fait d'être un "débutant". Il a à voir avec l'abstraction. Certaines choses sont mieux dit dans un paragraphe de résumé de texte, que de cracher 300 lignes de béton de code. Qu'est-ce exactement dans la description ci-dessus est-ce que vous ne comprenez pas?

OriginalL'auteur Ichthyo
1

J'ai utilisé dans un système de plug-in, où plug-in Dll peut être chargé/déchargé au moment de l'exécution. Je chercher des symboles dans chaque DLL, et les jetèrent à des pointeurs de fonction.

La question est au sujet de la fonction références, et l'OP dit explicitement qu'ils ne s'intéressent pas à utilise des pointeurs de fonction (bien qu'il semble qu'ils l'ont édité que dans l'après ça).
Il s'avère que les OP édité la question de rendre explicite déclaration après que j'ai posté cette réponse: stackoverflow.com/posts/480248/revisions

OriginalL'auteur Ates Goral

Vous devez vous connecter pour publier un commentaire.