std::function fails to distinguish overloaded functions

by

It’s obvious to us which function you intend to be chosen, but the compiler has to follow the rules of C++ not use clever leaps of logic (or even not so clever ones, as in simple cases like this!)

The relevant constructor of std::function is:

template<class F> function(F f);

which is a template that accepts any type.

The C++14 standard does constrain the template (since LWG DR 2132) so that it:

shall not participate in overload resolution unless f is Callable (20.9.12.2) for argument types ArgTypes... and return type R.

which means that the compiler will only allow the constructor to be called when Functor is compatible with the call signature of the std::function (which is void(int, int) in your example). In theory that should mean that void add(A, A) is not a viable argument and so “obviously” you intended to use void add(int, int).

However, the compiler can’t test the “f is Callable for argument types …” constraint until it knows the type of f, which means it needs to have already disambiguated between void add(int, int) and void add(A, A) before it can apply the constraint that would allow it to reject one of those functions!

So there’s a chicken and egg situation, which unfortunately means that you need to help the compiler out by specifying exactly which overload of add you want to use, and then the compiler can apply the constraint and (rather redundantly) decide that it is an acceptable argument for the constructor.

It is conceivable that we could change C++ so that in cases like this all the overloaded functions are tested against the constraint (so we don’t need to know which one to test before testing it) and if only one is viable then use that one, but that’s not how C++ works.

More Related Contents:

  1. std::function vs template
  2. Isn’t the template argument (the signature) of std::function part of its type?
  3. Vector of std::function with different signatures
  4. Overloaded lambdas in C++ and differences between clang and gcc
  5. How to directly bind a member function to an std::function in Visual Studio 11?
  6. Comparing std::functions for equality?
  7. how to avoid static member function when using gsl with c++
  8. std::function and std::bind: what are they, and when should they be used?
  9. Using `std::function` to call non-void function
  10. Overload resolution: assignment of empty braces
  11. What is the purpose of std::function and how to use it?
  12. Using ‘void’ template arguments in C++
  13. What are Aggregates and PODs and how/why are they special?
  14. When should I use std::thread::detach?
  15. Why is `std::move` named `std::move`?
  16. How to check if a std::thread is still running?
  17. What exactly is std::atomic?
  18. Passing a std::array of unknown size to a function
  19. Outputting Date and Time in C++ using std::chrono
  20. What’s a use case for overloading member functions on reference qualifiers?
  21. What are the differences between -std=c++11 and -std=gnu++11?
  22. Setting vector elements in range-based for loop [duplicate]
  23. what is the best modern c++ approach to construct and manipulate a 2d array [closed]
  24. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  25. Is C++11’s long long really at least 64 bits?
  26. Can compiler generate std::move for a last use of lvalue automatically?
  27. C function pointers with C++11 lambdas
  28. How to update GCC in MinGW on Windows?
  29. Difference between std::function and a standard function pointer? [duplicate]
  30. Overloading on R-value references and code duplication

Leave a Comment