Comment définir une macro qui définit une fonction qui s'appelle elle-même?

C'est un bon exemple pour des fonctions d'ordre supérieur, qui sont des fonctions prenant une autre fonction comme argument. Dans ce cas, la fonction doit être appelée sur chaque élément.

Celui-ci définit un ordre supérieur d'appel de fonction f sur chaque élément. Il nécessite de C++11 pour les variadic templates (args...). Si vous n'avez pas de C++11 est disponible, vous pouvez supprimer le typename ...Args et de travailler avec fixe les types d'argument dans la fonction de signature.

template<typename Delegates, typename Function, typename... Args>
void callOnAll(Delegates delegates, Function f, Args... args) {
    for (int i = 0; i < delegates.size(); i++)
        f(delegates[i], args...);
}

Maintenant, vous pouvez appeler à l'aide de cette syntaxe:

callOnAll(delegates, std::mem_fun<void,Delegate>(&Delegate::doSomething), 42);

La std::mem_fun chose crée un temporaire de la fonction de l'objet pour la fonction de membre que vous souhaitez appeler pour chaque délégué. Vous pouvez également appliquer d'autres fonctions, en prenant un pointeur comme premier argument. Par exemple, cette petite fonction lambda (également que depuis C++11):

callOnAll(delegates, [](Delegate *d){
    d->doSomething(42);
});

qui est à peu près la même chose, juste une autre syntaxe.

Voir un exemple ici:

• http://ideone.com/jrozqr (std::mem_fun)
• http://ideone.com/vOI4me (fonction lambda)

---

Une version légèrement différente de ce code utilise une gamme de base au lieu de indexées en fonction de boucle, qui semble beaucoup plus propre (nécessite également de C++11):

template<typename Delegates, typename Function, typename... Args>
void callOnAll(Delegates delegates, Function f, Args... args) {
    for(auto d : delegates)
        f(d, args...);
}

---

Pour votre information, il y a std::for_each, ce qui fait à peu près ce que vous voulez, mais de manière un peu plus fonctionnel, comme il ne prend pas des paramètres de la fonction par elle-même, mais vous fournir une fonction lambda /foncteur qui prend seulement un pointeur vers une instance. Comparer le code suivant à l'un au-dessus de la fonction lambda:

std::for_each(delegates.begin(), delegates.end(), [](Delegate *d){
    d->doSomething(42);
});

La seule différence est que nous avons à passer .begin() et .end() itérateurs, au lieu d'une seule instance de conteneur, comme delegates. Cependant, il y a beaucoup d'autres algorithmes définis dans la bibliothèque standard qui valent le coup d'oeil!!!

OriginalL'auteur leemes

Dans C, il existe variadic argument des macros, ce qui serait très pratique ici, je suppose. Ils ne sont normalement pas partie du C++ (subtile différence), bien que la plupart des compilateurs de les mettre en œuvre ne pas les limiter à C.

En C++, vous êtes mieux de toucher les modèles, en particulier avec les variadic templates en C++11 (et de transfert parfait), mais je vais essayer d'utiliser le préprocesseur, pour le plaisir et profit hum...

Si nous voulons un réel C++03 préprocesseur solution, alors nous avons fait appel à Boost.Préprocesseur. Le botteur réel est le Préprocesseur de la Séquence: on peut (en théorie*) la liste des éléments qui peuvent être manipulée à volonté, ce qui nous obtient assez proche pour le confort de variadic macros.

Mais avant de nous plonger dans y, on doit remarquer que les noms des arguments sont tout à fait sans importance, et que seule leur type est vraiment important.

Je propose donc la syntaxe suivante:

CALL_ON_ALL(dosomething, (int)(bool))
//(int)(bool) is a preprocessor sequence in Boost.Preprocessor

Les entrailles sont un peu plus subtil, et je ne suis pas sûr de les obtenir à droite sur le premier essai, il doit probablement quelque chose comme:

#define CALL_ON_ALL(Name_, Args_)                                               \
void Name_ ( BOOST_PP_ENUM( BOOST_PP_SEQ_SIZE(Args_), ARG_ENUM, Args_) ) {  \
for (size_t i = 0, max = delegates.size(); i != max; ++i) {             \
delegates[i]->                                                      \
Name_ ( BOOST_PP_ENUM_PARAMS( BOOST_PP_SEQ_SIZE(Args_), arg );  \
}                                                                       \
}
#define ARG_ENUM(z, n, data)                                                    \
BOOST_PP_SEQ_ELEM(data, n) BOOST_PP_CAT(arg, n)

Remarque: la complexité n'est pas trop terrible, il y a N appels à BOOST_PP_SEQ_ELEM qui est elle-même linéaire, conduisant à une équation du second degré de complexité. Je ne pouvais pas trouver un BOOST_PP_SEQ_* macro qui pourrait énumérer les arguments et place des virgules entre eux.

*Dans la pratique, il y a une démo avec près d'une centaine d'éléments dans les docs, espérons que ça suffit 😉

OriginalL'auteur Matthieu M.