Using std::bind with member function, use object pointer or not for this argument?
Solution 1
Both are correct. 20.8.9.1.2 forwards to 20.8.2 to describe the requirements and the effect of your call to bind
. 20.8.2 is:
20.8.2 Requirements [func.require]
1 Define INVOKE
(f, t1, t2, ..., tN)
as follows:—
(t1.*f)(t2, ..., tN)
whenf
is a pointer to a member function of a classT
andt1
is an object of typeT
or a reference to an object of typeT
or a reference to an object of a type derived fromT
;—
((*t1).*f)(t2, ..., tN)
whenf
is a pointer to a member function of a classT
andt1
is not one of the types described in the previous item;—
t1.*f
whenN == 1
andf
is a pointer to member data of a classT
andt1
is an object of typeT
or a reference to an object of typeT
or a reference to an object of a type derived fromT
;—
(*t1).*f
whenN == 1
andf
is a pointer to member data of a classT
andt1
is not one of the types described in the previous item;—
f(t1, t2, ..., tN)
in all other cases.
The first two options allow both a reference and a pointer.
The important thing to notice here is that the wording does not limit you to plain pointers. You could use a std::shared_ptr
or some other smart pointer to keep your instance alive while bound and it would still work with std::bind
as t1
is dereferenced, no matter what it is (given, of course, that it's possible).
Solution 2
To add to the correct answer (that both forms are allowed).
I think of the two binding options in analogy with function argument declaration, which may be "passed by value" or "passed by reference".
In the case of f1
(aka passing my_foo
"by value") the result doesn't "see" any changes made to my_foo
past the binding point. This may not be desired especially if my_foo
evolves. "By value" binding has an additional "cost" of (several) calls to a copy constructor.
Some programmer dude
Abusing programming instead of drugs. Worked with most of everything from airport systems to temperature sensors. Recently slipped on a banana-peel and ended up with my own software/programming contracting firm. And I don't do chat.
Updated on October 17, 2020Comments
-
Some programmer dude over 3 years
When using
std::bind
to bind a member function, the first argument is the objectsthis
pointer. However it works passing the object both as a pointer and not.See for example the following program:
#include <iostream> #include <functional> struct foo { void bar(int v) { std::cout << "foo::bar - " << v << '\n'; } }; int main() { foo my_foo; auto f1 = std::bind(&foo::bar, my_foo, 1); auto f2 = std::bind(&foo::bar, &my_foo, 2); f1(); f2(); }
Both clang and GCC compiles this without complaints, and the result works for both binds:
foo::bar - 1 foo::bar - 2
I have been trying to wrap my head around the specification (section 20.8.9) but it's one of the places where it's far from clear to me.
Should only one be correct, or are both correct?
-
Mike Lui over 8 yearsOnly the second (passing a pointer) method worked for me when my instance was a static variable.The first way caused each bind to act as if it was given another instance; that is, if f1 and f2 were run in succession, both bound using the first way, then the side effects of f1 on the static instance did not show when f2 was called
-
Mike Lui over 8 yearsAh I see now that I was copying my static instance to a new instance when I didn't pass a pointer. This is what I get for not following the rule of five