根据 std::tuple 的大小更改函数的返回类型答案

【问题标题】：Change a function's return type based on size of std::tuple根据 std::tuple 的大小更改函数的返回类型
【发布时间】：2021-08-22 01:10:23
【问题描述】：

问题

以下是我面临的问题的简化、人为示例。本质上，我需要一个可以容纳任意数量的项目并在需要时返回这些项目的对象。

template<typename... Ts>
class Foo {
public:
    Foo(Ts... args) :
        mArgs{std::forward<Ts>(args)} {
    }

    std::tuple<Ts...> getArgs() const {
        return mArgs;
    }

private:
    std::tuple<Ts...> mArgs;
};

这在 args > 1 时工作正常。

Foo<int, int> f{1, 2};
auto result = f.getArgs(); // result is a tuple containing two ints.

但是，如果 args == 1，我宁愿不从 getArgs 获取元组。

Foo<int> f{1};
auto result = f.getArgs(); // result is a tuple, but I want it to be an int.

问题

有没有办法，也许使用 SFINAE，来定义另一个在 args == 1 时使用的 getArgs 函数？类似的东西（这显然是非常错误的）：

template<typename = std::enable_if_t<std::tuple_size_v<Ts...> == 1>>
??? getArgs() const {
    return mArgs;
}

这有几个明显的问题：

我不确定std::tuple_size_v<Ts...> 是否会起作用。
我不知道新的返回类型是什么。也许std::tuple_element 在这里有用。

【问题讨论】：

你是要std::conditional_t吗？

标签： c++ overloading sfinae return-type variadic

【解决方案1】：

您实际上可以通过对给定类型集的部分特化来做到这一点。不需要 SFINAE。以下是使用 int 示例的方法：

#include <stdio.h>
#include <tuple>

template<typename... Ts>
struct storage {
    typedef std::tuple<Ts...> type;
};

template<typename T>
struct storage<T> {
    typedef T type;
};

template<typename... Ts>
class Foo {
public:
    Foo(Ts... args) :
        mArgs{std::forward<Ts>(args)...} {
    }

    typename storage<Ts...>::type getArgs() const {
        return mArgs;
    }

private:
    typename storage<Ts...>::type mArgs;
};

int main(int argc, char **argv)
{
    Foo<int, int> f1{1, 2};
    Foo<int> f2{1};

    std::tuple<int, int> args1 = f1.getArgs();
    printf("args1 = (%d, %d)\n", std::get<0>(args1), std::get<1>(args1));
    int args2 = f2.getArgs();
    printf("args2 = %d\n", args2);

    return 0;
}

【讨论】：

不应该将第二个storage 制作成T` 上更通用的模板，而不是专门的int？
好点@RemyLebeau，这确实是一个更好的解决方案。我会更新答案。

【解决方案2】：

另一种方法：使用sizeof...(T) == 1 来确定是否只使用了一种类型。然后使用auto 返回类型和if constexpr 完成剩下的工作。


template<typename... T>
class Foo {
public:
    Foo(T&&... t)
        : mArgs{std::forward<T>(t)...} {
        
    }
    
    auto getArgs() const {
        if constexpr (sizeof...(T) == 1) {
            return std::get<0>(mArgs);
        } else {
            return mArgs;
        }
    }
  
private:
    std::tuple<T...> mArgs;
};

示例用法：

auto foo_i = Foo{11};
auto foo_c = Foo{'c'};
auto foo_ic = Foo{11, 'c'};

int i2 = foo_i.getArgs();
char c2 = foo_c.getArgs();
std::tuple<int, char> ic2 = foo_ic.getArgs();

Live Demo

【讨论】：