Comment std::bind fonctionne avec les fonctions de membre

Quand vous dites "le premier argument est une référence" vous avez sûrement voulu dire "le premier argument est un pointeur": le & opérateur prend l'adresse d'un objet, ce qui donne un pointeur.

Avant de répondre à cette question, nous allons brièvement du recul et de regarder votre première utilisation de std::bind() lorsque vous utilisez

std::bind(my_divide, 2, 2)

vous fournir une fonction. Lorsqu'une fonction est votée il se désintègre en un pointeur. L'expression ci-dessus est équivalent à celui-ci, prenant explicitement l'adresse

std::bind(&my_divide, 2, 2)

Le premier argument de std::bind() est un objet de déterminer comment appeler une fonction. Dans le cas ci-dessus, il est un pointeur de fonction de type double(*)(double, double). Tout autre objet appelable, avec un appel de fonction de l'opérateur, trop.

Depuis les fonctions membres sont tout à fait commun, std::bind() fournit un soutien pour faire face avec le pointeur de fonctions membres. Lorsque vous utilisez &print_sum vous simplement obtenir un pointeur vers une fonction membre, c'est à dire, une entité de type void (Foo::*)(int, int). Alors que les noms de fonction implicitement à la carie de pointeurs de fonctions, c'est à dire, la & peut être omis, ce n'est pas vrai pour les fonctions membres (ou membres de données, d'ailleurs): pour obtenir un pointeur vers une fonction membre, il est nécessaire d'utiliser le &.

Noter qu'un pointeur de membre est spécifique à un class mais il peut être utilisé avec n'importe quel objet de la classe. C'est, il est indépendant de tout objet particulier. C++ n'est pas un moyen direct d'obtenir une fonction de membre directement liée à un objet (je pense en C#, vous pouvez obtenir des fonctions directement liée à un objet à l'aide d'un objet par un nom de membre; toutefois, il est de 10 ans depuis la dernière fois que j'ai programmé un peu de C#).

En interne, std::bind() détecte qu'un pointeur vers une fonction membre est passé et, plus vraisemblablement, il se transforme en un callable objets, par exemple, par l'utilisation std::mem_fn() avec son premier argument. Depuis un non-static fonction membre a besoin d'un objet, le premier argument de la résolution de l'objet appelable est soit une référence ou un [smart] pointeur vers un objet de la classe appropriée.

Utiliser un pointeur vers une fonction membre d'un objet est nécessaire. Lors de l'utilisation d'un pointeur de membre avec std::bind() le deuxième argument de std::bind() en conséquence besoin de spécifier quand l'objet est à venir. Dans votre exemple

std::bind(&Foo::print_sum, &foo, 95, _1)

l'résultant objet appelable utilise &foo, c'est à dire, un pointeur vers foo (de type Foo*) que l'objet. std::bind() est assez intelligent pour utiliser quoi que ce soit qui ressemble à un pointeur, rien convertibles à une référence du type approprié (comme std::reference_wrapper<Foo>), ou [copier] d'un objet, de l'objet, lorsque le premier argument est un pointeur sur membre.

Je soupçonne que vous n'avez jamais vu un pointeur sur membre - sinon, il serait tout à fait clair. Voici un exemple simple:

#include <iostream>

struct Foo {
    int value;
    void f() { std::cout << "f(" << this->value << ")\n"; }
    void g() { std::cout << "g(" << this->value << ")\n"; }
};

void apply(Foo* foo1, Foo* foo2, void (Foo::*fun)()) {
    (foo1->*fun)();  //call fun on the object foo1
    (foo2->*fun)();  //call fun on the object foo2
}

int main() {
    Foo foo1{1};
    Foo foo2{2};

    apply(&foo1, &foo2, &Foo::f);
    apply(&foo1, &foo2, &Foo::g);
}

La fonction apply() obtient tout simplement deux pointeurs vers Foo objets, et un pointeur vers une fonction membre. Il appelle la fonction membre a souligné avec chacun des objets. Ce drôle de ->* opérateur demande un pointeur sur un membre à un pointeur vers un objet. Il y a aussi un .* opérateur qui applique un pointeur sur un membre d'un objet (ou, comme ils se comportent comme des objets, une référence à un objet). Depuis un pointeur vers une fonction membre a besoin d'un objet, il est nécessaire d'utiliser cet opérateur qui demande un objet. En interne, std::bind() organise le même.

Quand apply() est appelée avec les deux pointeurs et &Foo::f il se comporte exactement de la même manière que si le membre f() serait appelée sur les objets respectifs. De même, lors de l'appel de apply() avec les deux pointeurs et &Foo::g il se comporte exactement de la même manière que si le membre g() serait appelée sur les objets respectifs (la sémantique du comportement est le même, mais le compilateur est susceptible d'avoir un temps beaucoup plus difficile inline fonctions et échoue généralement lorsque les pointeurs vers les membres sont impliqués).

OriginalL'auteur Dietmar Kühl