En passant de l'opérateur en tant que paramètre

Je veux avoir une fonction qui prend la valeur 2 bool vars (comme une table de vérité)

par exemple:

depuis

T | F : T

puis 

myfunc('t', 'f', ||);  /*defined as: bool myfunc(char lv, char rv, ????)*/

doit retourner vrai;

comment puis-je passer le troisième paramètre?
(Je sais, c'est possible de le passer comme un char*, mais alors je vais avoir un autre tableau pour comparer opérateur de chaîne, puis faire l'opération qui est quelque chose que je voudrais éviter)

Est-il possible de passer d'un opérateur comme ^(XOR) ou ||(OU) ou &&(ET), etc dans une fonction/méthode?

Merci d'avance

InformationsquelleAutor nacho4d | 2010-12-25
  1. 26

    Définir:

    bool myfunc(char lv, char rv, boost::function<bool(bool,bool)> func);

    si vous avez le coup de pouce, ou 

    bool myfunc(char lv, char rv, std::function<bool(bool,bool)> func);

    si vous avez le C++0x compilateur, ou

    template<class Func> bool myfunc(char lv, char rv, Func func);

    Si vous voulez qu'il soit un modèle. Ensuite, vous pouvez appeler le:

    myfunc('t', 'f', std::logical_or<bool>());
    • +1 pour l'utilisation de la plaine ol' STL prédicats!
    • Juste pensé qu'il serait utile d'inclure un lien vers plus d'objets de fonction comme std::logical_or cplusplus.com/reference/std/functional
    InformationsquelleAutor ybungalobill
  2. 5

    @ybungalobill posté un C++ bonne réponse et vous devez vous en tenir à elle. Si vous souhaitez passer des opérateurs, des fonctions ne fonctionneront pas, mais des macros de faire le travail:

    #define MYFUNC(lv, rv, op) ....

//Call it like this
MYFUNC('t', 'f', ||);

    Être prudent, les macros sont mal.

    InformationsquelleAutor Karel Petranek
  3. 2

    Ce que vous pouvez faire est de définir le proxy opérateurs qui retournent des types spécifiques.

    namespace detail {
    class or {
        bool operator()(bool a, bool b) {
            return a || b;
        }
    };
    class and {
        bool operator()(bool a, bool b) {
            return a && b;
        }
    };
    //etc
    class X {
        or operator||(X x) const { return or(); }
        and operator&&(X x) const { return and(); }
    };
};
const detail::X boolean;
template<typename T> bool myfunc(bool a, bool b, T t) {
     return t(a, b);
}
//and/or
bool myfunc(bool a, bool b, std::function<bool (bool, bool)> func) {
    return func(a, b);
}
//example
bool result = myfunc(a, b, boolean || boolean);

    Vous pouvez si désespérée de la chaîne cet effet à l'aide de modèles de passe complexes, des expressions logiques.

    Aussi, l'opérateur XOR est au niveau du bit, pas de logique, bien que la différence est réaliste rien.

    Cependant, il ya une raison que les lambdas existent dans C++0x et c'est parce que ce genre de chose à plat suce en C++03.

    • Corrigez-moi si je me trompe, mais n'est-ce pas surcharger operator|| et operator&& mal?
    • Aucune - pourquoi serait-il? Ce n'est pas différent de la _1 et etc dans boost::bind.
    • Désolé... ne pas voir que ceux qui étaient à l'intérieur de classes 😛 Pensais que vous étiez en rupture de court-circuit de la sémantique pour chaque expression contenant && ou ||!
    • La surcharge operator|| et operator&& est mal (parce que ces surcharges sont plus paresseux et d'évaluer leurs paramètres dans l'ordre non défini), sauf s'ils sont utilisés pour l'expression de modèles (où ce n'est pas grave), comme dans ce cas.
    InformationsquelleAutor Puppy
  4. -1

    Il est difficile d'être réalisé. En C++, la fonction, le paramètre besoin d'un memroy adresse pour trouver son objet, mais l'opérateur est décidé au moment de la compilation. L'opérateur ne sera pas un objet. Ainsi, vous pouvez penser au sujet de MACRO pour terminer votre tâche.

    • Ce n'est pas vrai. STL foncteurs ne sont généralement pas des pointeurs de fonction.
    • Je pense que STL foncteurs est aussi un objet, il dispose également d'une adresse de mémoire à envoyer en paramètre de la fonction.
    • c'est hors de propos. Vous peut surcharge des opérateurs et de les transmettre à des fonctions. Il se trouve que cela ne peut être fait (pour de bonnes raisons) avec pré-définis opérateurs de type intégré. Donc en passant les opérateurs de fonctions fonctionne bien mais pas dans ce cas très particulier (sauf si vous utilisez l'astuce illustrée par DeadMG, puis il fonctionne même pour ce cas).
    • Merci pour Konrad. Je ne sais pas ce. Et je veux savoir que: surcharge de l'opérateur -> créer une classe de RTTI d'infos supplémentaires pour l'opérateur, donc, pour le compilateur, ce n'est pas un opérateur par défaut(compilateur faire avec par défaut le code binaire). la surcharge de paramètre de compilation de référence de RTTI de savoir comment opérateur poignée de son action. de sorte qu'il peut passer la référence, et par défaut de l'opérateur ne peut pas passer. Est-il juste?(Je ne suis pas très bonne en anglais. Désolé.)
    InformationsquelleAutor erinus