Comment faites-vous passer boost::bind objets à une fonction?

J'ai un one-dimensional fonction minimizer. Maintenant que je suis de passage il pointeurs de fonction. Toutefois, de nombreuses fonctions de plusieurs paramètres, dont certains sont détenus fixe. J'ai mis en place cette aide de foncteurs comme

template <class T>
minimize(T &f) {
}

Functor f(param1, param2);
minimize<Functor>(f);

Cependant, le foncteur définition a beaucoup de crud. Boost::bind semble plus propre. De sorte que je pouvais faire:

minimize(boost:bind(f,_1,param1,param2))

Cependant, je ne suis pas sûr que mon minimize déclaration voudrais, comme l'utilisation de boost::bind. Ce type d'objet est boost::bind? Est-il un modèle simple pour ce qui évite le passe-partout de foncteurs mais permet à plusieurs de liaison de paramètre?

OriginalL'auteur Tristan | 2009-06-25

  1. 17

    Vous pouvez simplement utiliser boost::function. Je pense que boost::bind possède son propre type de retour, mais qui est compatible avec boost::function. Utilisation typique est de faire un typedef pour la fonction:

    typedef boost::function<bool(std::string)> MyTestFunction;

    et puis vous pouvez passer n'importe quel fonction compatible avec boost::bind:

    bool SomeFunction(int i, std::string s) { return true; }
MyTestFunction f = boost::bind(SomeFunction, 42, _1);
f("and then call it.");

    J'espère que c'est ce que vous voulez.

    Il travaille également avec des méthodes en passant par le this pointeur pour l'appel de la deuxième paramètre à boost::bind.

    OriginalL'auteur OregonGhost

  2. 4

    Je voudrais définir réduire() de cette façon:

    minimize(boost::function< return_type(param_type1,param_type2,param_type3,...)> f)
{
    ...
}

    Vous pouvez ensuite appeler à minimiser() comme ceci:

    minimize(boost::bind(&class::function,actual_object,_1,_2,_3,...));

    OriginalL'auteur J. Polfer

  3. 3

    Modifier le paramètre à une valeur de paramètre. Les objets de fonction sont intentionnellement poids léger, et boost::bind est certainement, spécialement conçu pour s'adapter à l'intérieur de l'espace de quelques octets à l'aide de boost::compressed_pair et ce n'est pas. 

    template <class T>
void minimize(T f) {
}

    Ensuite, vous pouvez transmettre le résultat de boost::bind. Rappelez-vous que boost::bind est en fait un modèle de fonction qui retourne un objet de type. Donc, avoir minimize non-const paramètre de référence ne pouvait pas fonctionner.

    OriginalL'auteur Johannes Schaub - litb

  4. 1

    Tout d'abord, vous prenez votre argument de modèle comme une référence à la non-const, de sorte que le temporaire returend par boost::bind de ne pas se lier à elle. De sorte que vous pouvez l'utiliser comme:

    template <class T>
T::result_type minimize(const T &f) {
}

    Mais si vous voulais l'utiliser avec votre Foncteurs ainsi, elles devraient avoir un const operator(). Alors peut-être que par valeur, c'est mieux:

     template <class T>
 T::result_type minimize(T f) {
 }

    Je crois avoir le retour se fera T::result_type force un T à un boost::function (plutôt que de la complexité du type de lier les retours), mais je ne suis pas à 100%

    OriginalL'auteur Todd Gardner