Question

我想为类模板的内部类提供结构化绑定。如何为该内部类专门研究std::tuple_size？

我不能对数据成员使用结构化绑定，因为内部类可能是与该功能不兼容的类型。因此，我需要提供类似元组的结构化绑定。为了向内部类提供这样的功能，我需要在std::tuple_size中部分专门化namespace std。问题是我得到了参数（外部类的）T的非推断上下文。

我知道我可以将内部类放在全局名称空间中，从而解决每个问题，但是有什么方法可以使内部类保持相同的结果？

#include <tuple>

template<typename T>
class Collection
{
    public:
        struct Element
        {
            int id;
            T actual_element;
        };

    //...
};


namespace std 
{
    template<typename T>
    struct tuple_size<typename Collection<T>::Element> // Error! Non-deduced context
        : std::integral_constant<std::size_t, 2> {};
}



//Collection iterators...

int main()
{
    Collection<int> collection;

    for (auto & [id, element] : collection) //what I'd like to achieve
        //do some stuff...
}

Answer 1

在这种情况下，您不必提供绑定：Element已经可以分解：

struct Element { int i, j; };
auto [i, j] = Element{2, 3}; // ok

但是，假设Element实际上更复杂并且需要自定义绑定，那么是的-您将需要将其删除。但是，不需要位于全局名称空间中。可能在其他地方：

namespace detail {
    template <typename T> struct Element { ... };
}

template<typename T>
class Collection
{
    public:
        using Element = detail::Element<T>;
        friend Element;
        // ...
};

到那时，专门化绑定很简单。正如您所指出的那样，^†毫无办法，因为专心研究Collection<T>::Element是一个不可推论的上下文。

^†简短的新语言功能，使您可以选择加入类主体本身内的结构化绑定。为此P1096有这样的论文，但是在发表时被拒绝了。这并不是说一项新提案不能做得更好。

Answer 2

我不认为以下解决方案是该问题最优雅（或根本优雅）的解决方案。但是，它通过为此非常特定的目的使用/利用 C++20 概念来实现为模板类 Element 的内部类 Collection 添加结构绑定支持。

鉴于 get 成员函数也可以声明为自由函数，可以使用以下模式为不能/不能修改的内部类（例如，遗留，第 3 方）。应该相应地调整这个概念。

在线试用

代码：

#include <concepts>
#include <tuple>

struct Hack
{};

template< typename T >
concept CollectionElement = requires
{
   typename T::type;
   { T::hack } -> std::same_as< const Hack& >;
};

namespace std
{
  template< ::CollectionElement T >
  class tuple_size< T > : public integral_constant< size_t, 2 >
  {};

  template< ::CollectionElement T >
  struct tuple_element< 0u, T >
  {
      using type = int;
  };

  template< ::CollectionElement T >
  struct tuple_element< 1u, T >
  {
      using type = typename T::type;
  };
}

template<typename T>
class Collection
{
    public:

        struct Element
        {
            static constexpr Hack hack = {};
            using type = T;

            template< std::size_t I >
            std::tuple_element_t< I, Element >& get() &
            {
                if constexpr (I == 0u) return id;
                if constexpr (I == 1u) return actual_element;
            }

            template< std::size_t I >
            const std::tuple_element_t< I, Element >& get() const&
            {
                if constexpr (I == 0u) return id;
                if constexpr (I == 1u) return actual_element;
            }

            template< std::size_t I >
            std::tuple_element_t< I, Element >& get() &&
            {
                if constexpr (I == 0u) return id;
                if constexpr (I == 1u) return actual_element;
            }

            template< std::size_t I >
            const std::tuple_element_t< I, Element >& get() const&&
            {
                if constexpr (I == 0u) return id;
                if constexpr (I == 1u) return actual_element;
            }
            
            int id;
            T actual_element;
        };

    //...
};

int main()
{
    Collection< int >::Element test
    {
        .id = 3,
        .actual_element = 5
    };

    auto& [id, element] = test;
    id = 7;
    element = 9;
    
    return id + element; // returns 16
}

一般原则：

#include <concepts>
#include <tuple>

template< typename T >
struct Outer
{
    using value_type = T;

    struct Inner
    {
        using value_type = typename Outer::value_type;

        int m_first  = {};
        int m_second = {};
    };
};

namespace std
{
  template< typename T >
  requires(std::same_as< T, typename ::Outer< typename T::value_type >::Inner >)
  class tuple_size< T > : public integral_constant< size_t, 2 >
  {};

  template< typename T >
  requires(std::same_as< T, typename ::Outer< typename T::value_type >::Inner >)
  struct tuple_element< 0u, T >
  {
      using type = int;
  };

  template< typename T >
  requires(std::same_as< T, typename ::Outer< typename T::value_type >::Inner >)
  struct tuple_element< 1u, T >
  {
      using type = int;
  };
}

template< std::size_t I, typename T >
requires(std::same_as< T, typename Outer< typename T::value_type >::Inner >)
[[nodiscard]]
inline std::tuple_element_t< I, T >& get(T& src)
{
    if constexpr (I == 0u)
    {
        return src.m_first;
    }
    if constexpr (I == 1u)
    {
        return src.m_second;
    }
}

template< std::size_t I, typename T >
requires(std::same_as< T, typename Outer< typename T::value_type >::Inner >)
[[nodiscard]]
inline const std::tuple_element_t< I, T >& get(const T& src)
{
    if constexpr (I == 0u)
    {
        return src.m_first;
    }
    if constexpr (I == 1u)
    {
        return src.m_second;
    }
}

template< std::size_t I, typename T >
requires(std::same_as< T, typename Outer< typename T::value_type >::Inner >)
[[nodiscard]]
inline std::tuple_element_t< I, T >&& get(T&& src)
{
    if constexpr (I == 0u)
    {
        return src.m_first;
    }
    if constexpr (I == 1u)
    {
        return src.m_second;
    }
}

template< std::size_t I, typename T >
requires(std::same_as< T, typename Outer< typename T::value_type >::Inner >)
[[nodiscard]]
inline const std::tuple_element_t< I, T >&& get(const T&& src)
{
    if constexpr (I == 0u)
    {
        return src.m_first;
    }
    if constexpr (I == 1u)
    {
        return src.m_second;
    }
}

int main()
{
    Outer< int >::Inner ref;
    auto& [f, s] = ref;
    f = 3; s = 5;
    
    return ref.m_first + ref.m_second;
}

类模板的内部类的类似元组的结构化绑定

2 个答案: