Je souhaite créer de nombreuses fonctions avec les mêmes paramètres, par exemple:
#define INT_OPERATION(name) const int name (const int a, const int b)
INT_OPERATION(add) { return (a + b); }
INT_OPERATION(subtract) {return (a - b); }
4 Réponses :
Si votre principale préoccupation est de pouvoir "modifier facilement les types des paramètres", il est simple de les écrire en tant que modèles afin que vous ne devez jamais modifier les types des paramètres:
template <typename T1, typename T2>
auto add (const T1 &a, const T2 &b) -> decltype(a + b) {
return (a + b);
}
Je ne pense pas que OP voulait changer de paramètre en premier lieu, mais les opérations.
Il essaie d'éviter la cuillère. Regardez l'exemple macro qu'il a donné.
Oui, le modèle requis est pour une binop et "Ajouter" est l'un des arguments.
@Jrok Il a dit: «Je suis capable de modifier facilement les types des paramètres une fois pour modifier toutes les fonctions». C'est une façon de ne jamais modifier les types des paramètres.
Toujours ignore complètement la question principale qui est "Je souhaite créer de nombreuses fonctions avec les mêmes paramètres, par exemple:", un peu comme une personne qui demande "Je suis affamé, avez-vous de la nourriture" et réponds "non, mais prenez cette assiette manger ce que vous avez fini par ".
@kfsone La façon dont je lis est "Je souhaite créer de nombreuses fonctions avec les mêmes paramètres, mais pour pouvoir modifier facilement les types des paramètres de toutes les fonctions que je veux conserver la plaque chauffante au même endroit". Ainsi, la résolution de la "nécessité de modifier les types de paramètres", le problème évite la nécessité d'éviter la chaudière.
Si celles-ci étaient des fonctions membres, vous pouvez déclarer leur type commun ( Typedef const int fn (int, int) code>), déclarez les fonctions de membre à l'intérieur de la classe à l'aide de ce type: Fn add, subtract;
Une fonction puis renvoyer une fonction ayant ce type: p> ( Dès que vous placez un ensemble de La même procédure présente des limitations similaires lors de l'utilisation des outils de programmation générique. Vous Typedef code> ed. Seule le type d'une fonction. Il est donc valable de dire: () code> après Ajouter code> Vous déclarerez une fonction renvoyant une fonction simple qui n'est pas valide C ++) P> Sur les types génériques h2>
const int add(int const a, int const b) {
return a + b;
}
Peut-être quelque chose comme ça:
#include <iostream>
#include <functional>
typedef std::function<int(int, int)> IntFunction;
IntFunction add = [](int a, int b) {return a + b;};
IntFunction substract = [](int a, int b) {return a - b;};
int main(int, char**) {
std::cout << add(1, 2) << std::endl;
std::cout << substract(1, 2) << std::endl;
return 0;
}
Pourquoi ne pas utiliser de modèles?
Je ne sais pas quelle est la motivation derrière ce besoin. Pouvenir
std :: plus etstd :: moins ,std :: moins , etc. Servir vos besoins?On dirait que ce sont juste pour des raisons explicatives de le garder simple.
Un peu connexe: Stackoverflow.com/questions/4022984/... < / a>
@Rsahu Oui, comme l'a dit Kfsone, ce sont simplement pour la démonstration du problème.