Foncteur C++ (C++ 98) avec plusieurs constructeurs?

Question

Est-il possible de créer un foncteur avec plusieurs constructeurs? Je veux être capable d'utiliser le foncteur de différentes manières, en initialisant ses différents membres de différentes façons, tout dépendant du constructeur utilisé pour le configurer initialement.

Mais existe-t-il une solution plus élégante que celle que je propose ici en utilisant des foncteurs avec plusieurs constructeurs?

Ce niveau de réutilisation supplémentaire jouerait très bien dans l'interpréteur de protocole de fil de communication que j'écris. Un fil particulier (ou un sous-ensemble de fils) dans une ligne de communication peut souvent servir à des fins différentes, en fonction du protocole spécifique utilisé. J'aimerais donc pouvoir créer un petit ensemble de foncteurs adaptables, dans des paramètres raisonnables, plutôt que de devoir créer un grand nombre de foncteurs très spécifiques, dont chacun a relativement peu d'adaptabilité. Le petit ensemble de foncteurs hautement adaptables serait ensuite utilisé, un à la fois, en tant que paramètre pour une fonction de gabarit dans une autre classe, laquelle fonction peut lire ou écrire des données selon les "règles" incorporées dans le paramètre fonctor utilisé pour appeler cette fonction de modèle.

Mon but est de rendre le code aussi générique que possible, pour permettre l'utilisation de nombreuses permutations de protocoles et de sous-protocoles avec le même code de base.

Answer 1

Je ne suis pas sûr de comprendre votre question. Une réponse directe est: oui vous pouvez, vous pouvez même surcharger l'opérateur().

class MyFunctor { 
public: 
    MyFunctor(int a) : a(a), b(0.0) {} 
    MyFunctor(double b) : a(0), b(b) {} 

    int operator()(int c) const { return a + c; } 
    double operator()(double c) const { return b + c; } 
private: 
    int a; 
    double b; 
}; 

MyFunctor fromInt(2); 
MyFunctor fromDouble(2.1); 

std::cout << fromInt(3) << std::endl; // Print 5 
std::cout << fromInt(3.1) << std::endl; // Print 3.1 

std::cout << fromDouble(2) << std::endl; // Print 2 
std::cout << fromDouble(2.2) << std::endl; // Print 4.3 

Cependant, je pense que ce violent le Single responsibility principle. Une meilleure solution pourrait être de créer plusieurs petits foncteurs et de choisir le meilleur en utilisant une usine. Ceci évolue probablement mieux, puisque si vous voulez ajouter une nouvelle capacité à votre code, par exemple. pour les chaînes, vous pouvez simplement créer un nouveau fichier dans lequel il y a une nouvelle classe MyFunctorString et une nouvelle surcharge à createFunctor (std :: string). Vous pouvez facilement tester cette nouvelle classe, et vous n'avez pas à vous soucier des interactions entre les différentes surcharges. Par exemple, la première fois que j'ai écrit le code pour MyFunctor, j'ai oublié d'initialiser tous les membres à 0, ce qui conduit à des résultats indéfinis.