std::tuple-like 的命名要求？ [复制]

我正在为std::tuple，并意识到我可以让它工作std::pair and std::array同样，这三个类实现std::tuple_size and std::get。这在任何地方都是“标准化的”吗？有没有 ”std::allocator_traits“但是对于类似 std::tuple 的类而不是类似 std::allocator 的类？

目前我这样做是为了检查一个类是否是“类元组”：

#include <type_traits>
#include <cstddef>
#include <utility>
#include <tuple>

namespace is_tuple {
    namespace detail {
        // T* exists for incomplete types, but not sizeof(T)
        template<class T, ::std::size_t = sizeof(T)>
        ::std::true_type is_complete_type_impl(T*);

        ::std::false_type is_complete_type_impl(...);

        template<class T>
        struct is_complete_type : decltype(
            is_complete_type_impl(::std::declval<T*>())
        ) {};
    }

    template<class T>
    struct is_tuple : detail::is_complete_type<::std::tuple_size<T>>::type {};
}

这可能有一些误报（尽管我不认为有）

这些是我对“类似元组”类型、类型的“要求”T和一个类型的对象T called t:

1. std::tuple_size<T>是一个完整的类型
2. std::tuple_size<T>::value is a static constexpr const std::size_t（称为N)
3. std::get<I>(t)对所有人返回非空I in [0, N)

（这是正确和完整的吗？我还实施了检查std::get，但代码太长，无法发布）

另外，除了专门化之外，是否有更好的方法来指定类型是否“类似元组”std::tuple_size<T>（可能类似于 iterator_tag ）

这在任何地方都是“标准化的”吗？

如果你指的是哈希算法，那么（就像很多事情一样）已经有一个完整的解决方案boost.

boost is of course, arguably more standardised and certainly more portable than the various implementations of the c++ standard itself.¹

#include <boost/functional/hash.hpp>
#include <tuple>
#include <utility>
#include <array>
#include <string>
#include <iostream>

template<class T>
std::size_t hashit(T const& x)
{
    using x_type = std::decay_t<T>;
    return boost::hash<x_type>()(x);
}

template<class T>
std::size_t hashit2(T const& x)
{
    using boost::hash_value;
    return hash_value(x);
}

int main()
{
    using namespace std::literals;

    std::cout << hashit(std::make_tuple(1, 2, 5, "foo"s)) << '\n';
    std::cout << hashit2(std::make_tuple(1, 2, 5, "foo"s)) << '\n';

    std::cout << '\n';

    std::cout << hashit(std::make_pair(1.0, 2.0)) << '\n';
    std::cout << hashit2(std::make_pair(1.0, 2.0)) << '\n';

    std::cout << '\n';

    std::cout << hashit(std::array<int, 3>{4, 5, 6}) << '\n';
    std::cout << hashit2(std::array<int, 3>{4, 5, 6}) << '\n';
}

¹ This will be seen by many as a controversial statement. It is nonetheless empirically true.