Почему конструктор в этом коде C++ неоднозначен и как я могу это исправить?

Question

В приведенном ниже коде компилятор не может определить, какой конструктор я хочу использовать. Почему и как мне это исправить? ( Живой пример)

#include <tuple>
#include <functional>
#include <iostream>

template<typename data_type, typename eval_type, typename Type1, typename Type2>
class A
{
public:
    using a_type = std::tuple<Type1, Type2>;
    using b_type = std::tuple<std::size_t,std::size_t>;

    inline explicit constexpr A(const std::function<data_type(a_type)>& Initializer,
        const std::function<eval_type(data_type)>& Evaluator,
        const Type1& elem1, const Type2& elem2)
    {
        std::cout << "idx_type" << std::endl;
    }
    inline explicit constexpr A(const std::function<data_type(b_type)>& Initializer,
        const std::function<eval_type(data_type)>& Evaluator,
        const Type1& elem1, const Type2& elem2)
    {
        std::cout << "point_type" << std::endl;
    }
};

int main()
{
    int a = 1;
    long long b = 2;
    auto c = A<double, double, long long, int>{
        [](std::tuple<long long,int> p)->double { return 1.0*std::get<0>(p) / std::get<1>(p); },
        [](double d)->double { return d; }, b,a
        };

    return 0;
}

Answer 1

Причина этого не в том, что лямбда не std::function и поэтому компилятор пытается создать его, используя пятую перегрузку конструктора. Проблема в том, что оба ваших A конструкторы могут быть использованы из-за этого преобразования и по той причине, что std::tuple<long long,int> а также std::tuple<std::size_t,std::size_t> конструируемые друг от друга делает это неоднозначным для компилятора, какой конструктор выбрать.

То, что вы могли сделать, явно приведено к желаемому std::function (MCVE из @PasserBy используется в комментариях), вот так:

#include <tuple>
#include <functional>
#include <iostream>

template<typename data_type, typename Type1, typename Type2>
class A
{
public:
    using a_type = std::tuple<Type1, Type2>;
    using b_type = std::tuple<std::size_t,std::size_t>;

    A(const std::function<data_type(a_type)>&)
    {
        std::cout << "idx_type" << std::endl;
    }
    A(const std::function<data_type(b_type)>&)
    {
        std::cout << "point_type" << std::endl;
    }
};

int main()
{
    std::function<double(std::tuple<long long, int>)> func = [](auto p) -> double { return 1; };
    auto c = A<double, long long, int>{
        func
    };
}

Answer 2

Как упомянул @SombreroChicken, std::function<R(Args...)> имеет конструктор, который позволяет любой вызываемый объект c инициализировать его, пока c(Args...) действует и возвращает что-то конвертируемое в R,

Чтобы исправить это, вы можете использовать некоторые машины SFINAE

#include <tuple>
#include <functional>
#include <iostream>
#include <type_traits>

template<typename data_type, typename Type1, typename Type2>
class A
{
    template<typename T>
    struct tag
    {
        operator T();
    };

public:
    using a_type = std::tuple<Type1, Type2>;
    using b_type = std::tuple<std::size_t,std::size_t>;

    template<typename C, std::enable_if_t<std::is_invocable_v<C, tag<b_type>>>* = nullptr>
    A(C&& initializer)
    {
        std::cout << "size_t" << std::endl;
    }

    template<typename C, std::enable_if_t<std::is_invocable_v<C, tag<a_type>>>* = nullptr>
    A(C&& initializer)
    {
        std::cout << "other" << std::endl;
    }
};

int main()
{
    auto c = A<double, long long, int>{
        [](std::tuple<long long, int> p) -> double { return 1; }
    };

    auto c2 = A<double, long long, int>{
        [](std::tuple<std::size_t, std::size_t>) -> double { return 2; }  
    };
}

Жить

Здесь мы отключаем конструктор, если вызываемый может быть вызван с b_type или же a_type соответственно. Дополнительная косвенность через tag есть ли отключить преобразование между кортежами разных типов