Using std::bind with member function, use object pointer or not for this argument?

by

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) when f is a pointer to a member function of a class T and t1 is an object of type T or a reference to an object of type T or a reference to an object of a type derived from T;

— ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a class T and t1 is not one of the types described in the previous item;

— t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is an object of type T or a reference to an object of type T or a reference to an object of a type derived from T;

— (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1 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).

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]
  3. Why would the behavior of std::memcpy be undefined for objects that are not TriviallyCopyable?
  4. Is the size of std::array defined by standard
  5. Capturing a reference by reference in a C++11 lambda
  6. Do I really need to implement user-provided constructor for const objects?
  7. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  8. Is std::abs(0u) ill-formed?
  9. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  10. What does the void() in decltype(void()) mean exactly?
  11. Can the point-of-instantiation be delayed until the end of the translation unit?
  12. Can C++ code be valid in both C++03 and C++11 but do different things?
  13. What is the value category of the operands of C++ operators when unspecified?
  14. How can an incomplete type be used as a template parameter to vector here?
  15. Is a constexpr array necessarily odr-used when subscripted?
  16. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  17. Is left-shifting (
  18. Is writing to &str[0] buffer (of a std:string) well-defined behaviour in C++11?
  19. Classes with both template and non-template conversion operators in the condition of switch statement
  20. reinterpret_cast between char* and std::uint8_t* – safe?
  21. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  22. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  23. Calling an explicit constructor with a braced-init list: ambiguous or not?
  24. Can we apply content not explicitly cited from the normative references to the C++ standard?
  25. Calling delete on NULL pointers – C++03 vs C++11
  26. std::tuple memory alignment
  27. Rvalues, lvalues and formal definitions
  28. What is use of the ref-qualifier `const &&`?
  29. memcpy/memmove to a union member, does this set the ‘active’ member?
  30. Overload resolution with ref-qualifiers

Leave a Comment