Why is std::function not equality comparable?

by

Why is std::function not equality comparable?

std::function is a wrapper for arbitrary callable types, so in order to implement equality comparison at all, you’d have to require that all callable types be equality-comparible, placing a burden on anyone implementing a function object. Even then, you’d get a narrow concept of equality, as equivalent functions would compare unequal if (for example) they were constructed by binding arguments in a different order. I believe it’s impossible to test for equivalence in the general case.

What is the “possible hole in the type system?”

I would guess this means it’s easier to delete the operators, and know for certain that using them will never give valid code, than to prove there’s no possibility of unwanted implicit conversions occurring in some previously undiscovered corner case.

How is it different from std::shared_ptr?

std::shared_ptr has well-defined equality semantics; two pointers are equal if and only if they are either both empty, or both non-empty and pointing to the same object.

More Related Contents:

  1. Using generic std::function objects with member functions in one class
  2. Optimization code for a debug function (c++11 with templates) [closed]
  3. What is the usefulness of `enable_shared_from_this`?
  4. Sorting zipped (locked) containers in C++ using boost or the STL
  5. How to convert a lambda to an std::function using templates
  6. Is this behavior of vector::resize(size_type n) under C++11 and Boost.Container correct?
  7. Meaning of = delete after function declaration
  8. Should I use std::function or a function pointer in C++?
  9. Why can’t clang with libc++ in c++0x mode link this boost::program_options example?
  10. C++ – Why is boost::hash_combine the best way to combine hash-values?
  11. when g++ static link pthread, cause Segmentation fault, why?
  12. Why user-defined move-constructor disables the implicit copy-constructor?
  13. std::bind a bound function
  14. Which Boost features overlap with C++11?
  15. Is it possible to std::move objects out of functions? (C++11)
  16. Inferring the call signature of a lambda or arbitrary callable for “make_function”
  17. Doing a static_assert that a template type is another template
  18. How does weak_ptr work?
  19. Using vector as a buffer without initializing it on resize()
  20. Function returning a lambda expression
  21. Using boost thread and a non-static class function
  22. Where is shared_ptr?
  23. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  24. C++11 equivalent to boost shared_mutex
  25. C++ Function Callbacks: Cannot convert from a member function to a function signature
  26. Difference between C++11 std::bind and boost::bind
  27. Comparing 3 modern c++ ways to convert integral values to strings
  28. Why the initializer of std::function has to be CopyConstructible?
  29. Why can’t C++11 move a noncopyable functor to a std::function?
  30. Using Boost adaptors with C++11 lambdas

Leave a Comment