元组类型的模板重载(元组,对)

Question

我试图提供相同模板化函数的两个版本,一个用于任何可以像a一样的tuple东西,也就是说,tuple_size和它一起使用的东西std::get.我不在乎它是否得到std::arrays,只要它得到元组和对.编写通用版本没有问题,但我似乎无法使用类似元组的版本.

// 1
template <typename T>
A func(T&& t) { /* ... */ }

// 2
template <typename TupleType,
          std::size_t Size=std::tuple_size<std::decay_t<TupleType>>::value>
B func(TupleType&& tup) { /* ... */ }

用例子:

int main() {
    int i;
    std::vector<int> v;
    auto t = std::make_tuple(1, 2.0, 'a');
    auto p = std::make_tuple(1, 2.0);

    A a = func(i); // calls 1
    a = func(v); // calls 1

    B b = func(t); // ambiguous, should call 2
    b = func(p); // ambiguous, should call 2
}

我知道我可以为元组写一些重载,但这是很多写,并且会产生一个中间体pair.我不想丢失对原始对的引用,因为这只是一个转发功能.

template <typename... Ts>
B func(std::tuple<Ts...>& tup) { }

template <typename... Ts>
B func(const std::tuple<Ts...>& tup) { }

template <typename... Ts>
B func(std::tuple<Ts...>&& tup) { }

无论如何,我可以main通过一个通用的转发功能以我想要的方式进行上述调用吗？

更新:这些函数的返回类型不同.应该首先包括,我过于简单了.

Answer 1

template <typename T, typename U = void>
struct is_tuple_like : std::false_type {};

template <typename T>
struct is_tuple_like<T, decltype((void)std::get<0>(std::declval<T>()), (void)std::tuple_size<T>::value)> : std::true_type {};

template <typename T, std::enable_if_t<!is_tuple_like<std::decay_t<T>>{}, int> = 0>
A func(T&& t)
{
    return {};
}

template <typename TupleType, std::enable_if_t<is_tuple_like<std::decay_t<TupleType>>{}, int> = 0>
B func(TupleType&& tup)
{
    return {};
}

DEMO

带标签调度的替代解决方案:

template <typename T>
A _func(T&& t, std::false_type)
{
    return {};
}

template <typename TupleType>
B _func(TupleType&& tup, std::true_type)
{
    return {};
}

template <typename TupleOrNot>
auto func(TupleOrNot&& t)
{
    return _func(std::forward<TupleOrNot>(t), is_tuple_like<std::decay_t<TupleOrNot>>{});
}

演示2