Почему этот вызов перегруженной функции неоднозначен?

Question

Почему этот конструктор называется двусмысленным?

#include <functional> 

class A { 
    std::function<int(void)> f_; 
    std::function<float(void)> g_; 
public: 
    A(std::function<int(void)> f) { f_ = f; } 
    A(std::function<float(void)> g) { g_ = g; } 
    ~A() {} 
}; 

int main() 
{ 
    A a([](){ return (int)1; }); 
    return 0; 
} 

Обратите внимание на тип.

Есть ли способ рассказать компилятору, какой конструктор перегружен для использования?

Answer 1

Потому что то, что вы проходите, не соответствует типам, поэтому мы входим в последовательности преобразования, чтобы найти перегрузку для использования. Обе версии функции могут быть неявно созданы из лямбда-объекта, который возвращает int. Таким образом, компилятор не может решить, что выбрать для создания; хотя кажется интуитивно очевидным, что правила на C++ не позволяют этого.

Edit:

Написано экспромтом, но я думаю, что это может сделать трюк:

template < typename Fun > 
typename std::enable_if<std::is_same<typename std::result_of<Fun()>::type, int>::value>::type f(Fun f) ... 


template < typename Fun > 
typename std::enable_if<std::is_same<typename std::result_of<Fun()>::type, double>::value>::type f(Fun f) ... 

и т.д ... Или вы можете использовать тег диспетчеризацию:

template < typename Fun, typename Tag > 
struct caller; 

template < typename T > tag {}; 

template < typename Fun > 
struct caller<Fun, tag<int>> { static void call(Fun f) { f(); } }; 

// etc... 

template < typename Fun > 
void f(Fun fun) { caller<Fun, typename std::result_of<Fun()>>::call(fun); } 

Answer 2

Это дефект в стандарте. См DR 2132:

Рассмотрим следующий пример:

#include <functional> 

void f(std::function<void()>) {} 
void f(std::function<void(int)>) {} 

int main() { 
    f([]{}); 
    f([](int){}); 
} 

Призывы е в магистральный неоднозначны. По-видимому, потому, что конверсионные последовательности до std::function от лямбда составляют . Стандарт указывает, что объект функции, присвоенный std::function ", должен быть обратимся (20.8.11.2) для типов аргументов ArgTypes и типа возврата R." Он не говорит, что если это не случай, конструктор не входит в набор перегрузки.

Попробуйте использовать указатель на функцию в качестве аргумента вместо:

A(int f()) { f_ = f; } 
A(float g()) { g_ = g; } 

Answer 3

template<class F, 
    class R=std::result_of_t<F&()>, 
    std::enable_if_t<std::is_convertible<R,int>{}&&(!std::is_convertible<R,float>{}||std::is_integral<R>{}),int> =0 
> 
A(F&&f):A(std::function<int()>(std::forward<F>(f))){} 
template<class F, 
    class R=std::result_of_t<F&()>, 
    std::enable_if_t<std::is_convertible<R,float>{}&&(!std::is_convertible<R,int>{}||std::is_floating_point<R>{}, int> =0 
> 
A(F&&f):A(std::function<float()>(std::forward<F>(f))){} 
A(std::function<int()> f) { f_ = f; } 
A(std::function<float()> g) { g_ = g; } 

Здесь мы неоднозначные случаи, и отправку интегральных к перегрузке INT, и не плавающий к поплавку один.

Случаи, когда они конвертируются в оба, но ни с плавающей точкой, ни с интегралом, остаются двусмысленными. Как и должно быть.

Предложение sfina может быть сложным. Если он не работает, замените:

std::enable_if_t<std::is_convertible<R,float>{}&&(!std::is_convertible<R,int>{}||std::is_floating_point<R>{}, int> =0 

С

class=std::enable_if_t<std::is_convertible<R,float>{}&&(!std::is_convertible<R,int>{}||std::is_floating_point<R>{}> 

и аналогичные для других CTOR. Это может работать в MSVC например.

Полный по тегу диспетчеризации может потребоваться для MSVC, из-за отсутствие экспрессии SFINAE в 2015 году