std::bind de fonction membre de classe

J'ai ce code:

#include <iostream>
#include <functional>

struct Foo
{
        int get(int n) { return 5+n; }
};

int main()
{
        Foo foo;
        auto L = std::bind(&Foo::get, &foo, 3);

        std::cout << L() << std::endl;

        return 0;
}

Semble que cela:

auto L = std::bind(&Foo::get, &foo, 3);

est equivalento:

auto L = std::bind(&Foo::get, foo, 3);

Pourquoi?

Il n'est pas. On se lie à un pointeur, l'autre se lie à un copier.
Pour ce que ça vaut, vous pouvez également passer un pointeur intelligent (tout type qui implémente operator-> retour d'un foo*) comme deuxième argument. Essayez avec un std::shared_ptr.
dupliquer:stackoverflow.com/questions/15264003/... Bien que j'aime les deux réponses...

OriginalL'auteur Gian Lorenzo Meocci | 2013-04-15

  1. 14

    std::bind() accepte ses arguments en valeur. Cela signifie que, dans le premier cas, vous êtes de passage à un pointeur en valeur, résultant dans la copie d'un pointeur. Dans le second cas, vous êtes de passage à un objet de type foo en valeur, résultant en une copie d'un objet de type Foo.

    En conséquence, dans le second cas, l'évaluation de l'expression L() causes de la fonction de membre de get() être invoquée sur un copie de l'objet d'origine foo, qui peut ou peut ne pas être ce que vous voulez.

    Cet exemple illustre la différence (oubliez la violation de la Règle de Trois, Règle des Cinq, c'est juste à des fins d'illustration):

    #include <iostream>
#include <functional>

struct Foo
{
    int _x;

    Foo(int x) : _x(x) { }

    Foo(Foo const& f) : _x(f._x)
    {
        std::cout << "Foo(Foo const&)" << std::endl;
    }

    int get(int n) { return _x + n; }
};

int main()
{
   Foo foo1(42);

   std::cout << "=== FIRST CALL ===" << std::endl;
   auto L1 = std::bind(&Foo::get, foo1, 3);
   foo1._x = 1729;
   std::cout << L1() << std::endl; //Prints 45

   Foo foo2(42);

   std::cout << "=== SECOND CALL ===" << std::endl;
   auto L2 = std::bind(&Foo::get, &foo2, 3);
   foo2._x = 1729;
   std::cout << L2() << std::endl; //Prints 1732
}

    Live.

    Si, pour une raison quelconque, vous ne souhaitez pas utiliser le pointeur de la forme, vous pouvez utiliser std::ref() pour prévenir une copie de l'argument d'être créé:

    auto L = std::bind(&Foo::get, std::ref(foo), 3);

    OriginalL'auteur Andy Prowl

  2. 4

    Ils ne sont pas les mêmes. Le générique de la fonction liant std::bind copies c'est des arguments. Dans le cas de std::bind(&Foo::get,&foo,3), le pointeur est copié, mais lorsque vous appelez l'objet lié, il s'applique toujours à l'origine foo objet. Dans std::bind(&Foo::get,foo,3) l'objet foo est copié, et de l'appeler plus tard s'applique à la limite de la copie, et non pas à l'objet d'origine.

    Vous pouvez tester cela en utilisant une fonction membre qui accède à l'état interne de l'objet, de lier l'objet dans les deux sens, changement de l'objet d'origine et de voir comment les résultats diffèrent.

    OriginalL'auteur David Rodríguez - dribeas