c++ - 获取模板函数/通用 lambda 的唯一返回类型

Question

有没有办法在不指定参数类型的情况下获取模板函数/泛型 lambda 的返回类型？

template<class F>
struct unique_result_of {
    using type = std::result_of_t<F( *any valid parameter combination that F can be called upon* )>;
}

auto f = [](auto x, auto y, int z) -> int {};
auto g = [](double x, auto y) -> float {};

using return_type_f = typename unique_result_of<decltype(f)>::type; // should be int
using return_type_g = typename unique_result_of<decltype(g)>::type; // should be float

当然，只有当由同一模板函数名称生成的所有函数都具有唯一的返回类型时，这才有效。

Answer 1

您给出的示例将适用于以下内容，但有一些注意事项，如下所述

#include<type_traits>
#include<utility>

struct ubiq
{
    template<typename T>
    constexpr operator T&() const;
};

template<size_t>
ubiq make_ubiq();

struct broken_t;

template<typename T>
static constexpr bool is_broken_v = std::is_same_v<T, broken_t>;

template<typename T, size_t I0, size_t... I>
auto call(std::index_sequence<I0, I...>)
    -> decltype(std::declval<T>()(make_ubiq<I0>(), make_ubiq<I>()...));

template<typename T>
auto call(std::index_sequence<>) -> decltype(std::declval<T>()());

template<typename T, size_t... I>
auto call(std::index_sequence<I...>) -> broken_t;

template<typename T, size_t N>
using call_t = decltype(call<T>(std::make_index_sequence<N>{}));

template<typename Void, typename...>
struct collapse
{
    using type = broken_t;  
};

template<typename T>
struct collapse<std::enable_if_t<!is_broken_v<T>>, T>
{
    using type = T;  
};

template<typename T, typename... Ts>
struct collapse<std::enable_if_t<!is_broken_v<T>>, T, broken_t, Ts...> :
    collapse<void, T, Ts...> {};

template<typename... Ts>
struct collapse<void, broken_t, Ts...> :
    collapse<void, Ts...> {};

template<typename T, typename... Ts>
struct collapse<std::enable_if_t<!is_broken_v<T>>, T, T, Ts...> :
    collapse<void, T, Ts...> {};

template<typename... Ts>
using collapse_t = typename collapse<void, Ts...>::type;

template<typename, typename>
struct unique_call;

template<typename T, size_t... Ns>
struct unique_call<T, std::index_sequence<Ns...>>
{
    using type = collapse_t<call_t<T, Ns>...>;
};

template<typename T, size_t N = 10>
using unique_call_t = typename unique_call<T, std::make_index_sequence<N>>::type;

以下断言通过

auto f = [](auto x, auto y, int z) -> int {return 42;};
auto g = [](double x, auto y) -> float {return 4.2;};

static_assert(std::is_same_v<int, unique_call_t<decltype(f)>>);
static_assert(std::is_same_v<float, unique_call_t<decltype(g)>>);

Live

它的工作方式是“扫描”一个类型并查看是否可以使用任意数量的参数来调用它。参数的上限必须预先指定，但实际上如果有人给我超过十个参数的东西，我会假装它根本不存在 :D

然后检查可能的返回类型集，如果那里有不同的类型，或者如果没有，则结果类型将为 broken_t。

struct S
{
    int operator()(int);
    float operator()(float);
};
struct U {};

static_assert(std::is_same_v<broken_t, unique_call_t<S>>);  // passes
static_assert(std::is_same_v<broken_t, unique_call_t<U>>);  // passes

注意事项

此方法无法区分不存在的 operator() 和为相同参数计数重载的操作符。以下类型将被视为只有 int operator()()。

struct S
{
    int operator()();
    int operator()(int);
    float operator()(float);
};
static_assert(std::is_same_v<int, unique_call_t<S>>);  // passes!??

我还没有想出可以做到这一点的方法。

另一个问题是模板

template<typename T, std::enable_if_t<std::is_integral<T>>* = nullptr>
int operator()(T);

由于我们作弊并创建了 ubiq 类型并将其用作参数的占位符，因此它不能很好地与模板一起使用，T 将不是一个整数在这种情况下。