C++使用std::enable_if创建最多10个参数的std::元组专业化

Question

我想创建一个元组，该元组最多可以专门化10个参数，类似于std:：pair是专门化两个参数的方式。

即tuple<int,float,bool>将具有成员first()、second()和third()

这是我迄今为止的尝试：

#pragma once
#include <tuple>
#include <type_traits>
template<typename... Types>
struct tuple : std::tuple<Types...> {
using std::tuple<Types...>::tuple;
static constexpr size_t size = sizeof...(Types);
template<size_t N>
using elem_n = std::tuple_element_t<N, std::tuple<Types...>>;
template<size_t N>
const elem_n<N>& get() const { return std::get<N>(*this); }
template<size_t N>
elem_n<N>& get() { return std::get<N>(*this); }
template<bool F = false> std::enable_if_t< (size >= 1) || F, const elem_n<0>&> first() const { return get<0>(); }
template<bool F = false> std::enable_if_t< (size >= 2) || F, const elem_n<1>&> second() const { return get<1>(); }
template<bool F = false> std::enable_if_t< (size >= 3) || F, const elem_n<2>&> third() const { return get<2>(); }
template<bool F = false> std::enable_if_t< (size >= 4) || F, const elem_n<3>&> fourth() const { return get<3>(); }
template<bool F = false> std::enable_if_t< (size >= 5) || F, const elem_n<4>&> fith() const { return get<4>(); }
template<bool F = false> std::enable_if_t< (size >= 6) || F, const elem_n<5>&> sixth() const { return get<5>(); }
template<bool F = false> std::enable_if_t< (size >= 7) || F, const elem_n<6>&> seventh() const { return get<6>(); }
template<bool F = false> std::enable_if_t< (size >= 8) || F, const elem_n<7>&> eighth() const { return get<7>(); }
template<bool F = false> std::enable_if_t< (size >= 9) || F, const elem_n<8>&> ninth() const { return get<8>(); }
template<bool F = false> std::enable_if_t< (size >= 10) || F, const elem_n<9>&> tenth() const { return get<9>(); }
template<bool F = false> std::enable_if_t< (size >= 1) || F, elem_n<0>&> first() { return get<0>(); }
template<bool F = false> std::enable_if_t< (size >= 2) || F, elem_n<1>&> second() { return get<1>(); }
template<bool F = false> std::enable_if_t< (size >= 3) || F, elem_n<2>&> third() { return get<2>(); }
template<bool F = false> std::enable_if_t< (size >= 4) || F, elem_n<3>&> fourth() { return get<3>(); }
template<bool F = false> std::enable_if_t< (size >= 5) || F, elem_n<4>&> fith() { return get<4>(); }
template<bool F = false> std::enable_if_t< (size >= 6) || F, elem_n<5>&> sixth() { return get<5>(); }
template<bool F = false> std::enable_if_t< (size >= 7) || F, elem_n<6>&> seventh() { return get<6>(); }
template<bool F = false> std::enable_if_t< (size >= 8) || F, elem_n<7>&> eighth() { return get<7>(); }
template<bool F = false> std::enable_if_t< (size >= 9) || F, elem_n<8>&> ninth() { return get<8>(); }
template<bool F = false> std::enable_if_t< (size >= 1) || F, elem_n<9>&> tenth() { return get<9>(); }
};

我也尝试过：

template<size_t N>
using elem_n = std::conditional_t<(size >= N), std::tuple_element_t<N, std::tuple<Types...>>, void>;

但是当使用进行测试时

using my_tripple = tuple<int, std::string, float>;
my_tripple a;
a.first() = 6;
a.second() = "hello";
a.third() = 0.1f;

我得到编译错误：

/usr/include/c++/9/tuple:1303: error: static assertion failed: tuple index is in range
1303 |       static_assert(__i < tuple_size<tuple<>>::value,
|                     ~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~

从fourth()到tenth()

error: no type named ‘type’ in ‘struct std::tuple_element<3, std::tuple<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, float> >’
26 |     template<bool F = false> std::enable_if_t< (size >= 4) || F, const elem_n<3>&> fourth() const { return get<3>(); }
|                                                                                    ^~~~~~

这与问题c++有关。使用std:：enable_if有条件地将getter添加到可变变体模板中，但其解决方案在这里不起作用。

感谢

Answer 1

您为second()、third()使用默认模板参数的方法是正确的，但您错过的是，您需要使get<>的模板参数依赖于默认模板参数，因此直到模板实例化时才会得到解决，如果从未使用过，则永远不会得到解决。除非它依赖于模板参数，否则它会在声明时得到解析，并且由于给定的原因而失败。

仅使用second()的简短示例。third()、fourth()等将以相同的方式声明，使用size_t n=2、size_t n=3等：

#include <tuple>
template<typename... Types>
struct tuple : std::tuple<Types...> {
using std::tuple<Types...>::tuple;
static constexpr size_t size = sizeof...(Types);
template<size_t N>
using elem_n = std::tuple_element_t<N, std::tuple<Types...>>;
template<size_t N>
const elem_n<N>& get() const { return std::get<N>(*this); }
template<size_t N>
elem_n<N>& get() { return std::get<N>(*this); }
template<size_t n=1> auto second() const { return get<n>(); }
};
tuple<int> foo;
tuple<int, float> bar;
float foobar()
{
return bar.second();  // compiles, foo.first() would be a compilation error
}

在foo的情况下，由于除非显式调用second()，否则get<1>实际上永远不存在，因此不存在编译错误。