【问题标题】:How to use C++ template magic in order to pattern match on type如何使用 C++ 模板魔法来对类型进行模式匹配
【发布时间】:2019-03-26 08:05:47
【问题描述】:

希望所有typename T 都只有一个包装器,它支持结构化绑定,例如通过tuple_size 和tuple_element 没有运行时开销(contexprs,SFINAE)。有一个函数 encode 接受 T obj 作为参数,并使用更具体的参数和类型参数调用 encode_impl。

文章https://playfulprogramming.blogspot.com/2016/12/serializing-structs-with-c17-structured.html 使用了一堆arity 函数来达到相同的结果。但据我了解,元组提供了std::tuple_size,这是可以利用的。

#include <tuple>
#include <utility>


class Aa {
    public:
        Aa(int a1_, int a2_): a1(a1_), a2(a2_) {}

        template<std::size_t N>
        decltype(auto) get() const {
            if constexpr (N == 0) return a1;
            else if constexpr (N == 1) return a2;
        }

    private:
        int a1;
        int a2;
};

class Bb {
    public:
        Bb(Aa a_, int b_): a(a_), b(b_) {}

        template<std::size_t N>
        decltype(auto) get() const {
            if constexpr (N == 0) return a;
            else if constexpr (N == 1) return b;
        }

    private:
        Aa a;
        int b;

};

namespace std {
    // Aa
    template<>
    struct tuple_size<Aa> : std::integral_constant<std::size_t, 2> {};

    template<std::size_t N>
    struct tuple_element<N, Aa> {
        using type = decltype(std::declval<Aa>().get<N>());
    };

    // Bb
    template<>
    struct tuple_size<Bb> : std::integral_constant<std::size_t, 2> {};

    template<std::size_t N>
    struct tuple_element<N, Bb> {
        using type = decltype(std::declval<Bb>().get<N>());
    };
}

template <size_t N>
using size = std::integral_constant<size_t, N>;

template<typename T>
void encode(T t) {
    encode_impl<?std::tuple_size<T>?()>(T t, ?std::tuple_size<T>);
}

template<?>
encode_impl(T t, ?) {
    std::cout << "It works";
}

解决问题的期望是理解必须用于编译代码 sn-p 的符号。现在你可以在很多地方看到?。

如果无法使用std::tuple_size,那么欢迎使用替代解决方案。文章中用于类的 Arity 函数不起作用,但这是一个有点不同的问题。

【问题讨论】:

标签: c++


【解决方案1】:

您是问如何将some_type::get&lt;i&gt;() 的返回值作为函数的参数应用?

在我的脑海中你会写encode和encode_impl这样的东西:

template<typename T>
void encode(T const& t, std::ostream& os)
{
  encode_impl(t, os, std::make_index_sequence<std::tuple_size<T>::value>{ });
}

template
<typename T, std::size_t... I>
void encode_impl(T const& t, std::ostream& os, std::index_sequence<I...> const)
{
  constexpr auto last = sizeof...(I) - 1;
  os << "{ ";
  [[maybe_unused]] int const temp[] = 
    { ((os << t.template get<I>() << (I != last ? ", " : " ")), 0)... };
  os << "}" << std::endl;
}

encode_impl 中这个看起来很恶心的包扩展使用逗号运算符来强制评估其左侧操作数并丢弃结果,然后评估文字 0 并将其存储在虚拟数组 temp 中。包扩展用于初始化数组,以便以正确的顺序(从左到右)评估参数。

更新: 好的,所以我认为您想要的是进行自己的类型特征测试is_tuple_like,如果T 是“类似元组”的类型,则返回true,这只要求表达式std::tuple_size&lt;T&gt;::value 格式正确并且表达式@987654334 @ 格式正确。从那里您可以编写一个函数来打印“类似元组”类型的元素,如果这些元素中的任何一个是类似元组的,则递归地打印它们的元素。这是我想出的:

template
<
  typename T,
  typename tp_enabled =
    std::void_t
    <
      decltype(std::tuple_size<T>::value),
      decltype(std::declval<T&>().template get<std::size_t(0)>())
    >
>
constexpr auto
is_tuple_like(int const)noexcept->bool
{
  return true;
}

template
<typename T, typename tp_arg>
constexpr auto
is_tuple_like(tp_arg const)noexcept->bool
{
  return false;
}

template<typename T>
auto encode(T const& t, std::ostream& os)->
std::enable_if_t<is_tuple_like<T>(0)>
{
  encode_impl(t, os, std::make_index_sequence<std::tuple_size<T>::value>{ });
  os << std::endl;
}

template
<bool is_last, typename T>
auto
encode_one(T const& t, std::ostream& os)->
std::enable_if_t<!is_tuple_like<T>(0)>
{
  os << t << (is_last ? " " : ", ");
}

template
<bool is_last, typename T>
auto
encode_one(T const& t, std::ostream& os)->
std::enable_if_t<is_tuple_like<T>(0)>
{
  encode_impl(t, os, std::make_index_sequence<std::tuple_size<T>::value>{ });
  os << (is_last ? " " : ", ");
}

template
<typename T, std::size_t... I>
void encode_impl(T const& t, std::ostream& os, std::index_sequence<I...> const)
{
  constexpr auto last = sizeof...(I) - 1;
  os << "{ ";
  [[maybe_unused]] int const temp[] =
    { (encode_one<I == last>(t.template get<I>(), os), 0)... };
  os << "}";
}

int main () {
    auto a = Aa(1, 1);
    encode(a, std::cout);
    auto b = Bb(a, 1);
    encode(b, std::cout);
    return 0;
}

输出:

{ 1, 1 }
{ { 1, 1 }, 1 }

更新 2:所以上面的 is_tuple_like 实现在 GCC 和最新版本的 Clang (8.0.0) 上编译得很好,但无法在 Clang 7.0.0 上编译,所以这里有一个适用于 Clang 的版本7.0.0 它使用变量模板而不是函数模板:

#include <tuple>
#include <utility>
#include <iostream>

class Aa {
    public:
        Aa(int a1_, int a2_): a1(a1_), a2(a2_) {}

        template<std::size_t N>
        decltype(auto) get() const {
            if constexpr (N == 0) return a1;
            else if constexpr (N == 1) return a2;
        }

    private:
        int a1;
        int a2;
};

class Bb {
    public:
        Bb(Aa a_, int b_): a(a_), b(b_) {}

        template<std::size_t N>
        decltype(auto) get() const {
            if constexpr (N == 0) return a;
            else if constexpr (N == 1) return b;
        }

    private:
        Aa a;
        int b;
};


namespace std {
    // Aa
    template<>
    struct tuple_size<Aa> : std::integral_constant<std::size_t, 2> {};

    template<std::size_t N>
    struct tuple_element<N, Aa> {
        using type = decltype(std::declval<Aa>().get<N>());
    };

    // Bb
    template<>
    struct tuple_size<Bb> : std::integral_constant<std::size_t, 2> {};

    template<std::size_t N>
    struct tuple_element<N, Bb> {
        using type = decltype(std::declval<Bb>().get<N>());
    };
}

template
<typename T, typename tp_enabled = std::void_t<>>
constexpr bool is_tuple_like = false;

template
<typename T>
constexpr bool 
is_tuple_like
<
  T, 
  std::void_t
  <
    decltype(std::tuple_size<T>::value),
    decltype(std::declval<T&>().template get<std::size_t(0)>())
  >
> = true;

template<typename T>
auto encode(T const& t, std::ostream& os)->
std::enable_if_t<is_tuple_like<T>>
{
  encode_impl(t, os, std::make_index_sequence<std::tuple_size<T>::value>{ });
  os << std::endl;
}

template
<bool is_last, typename T>
auto
encode_one(T const& t, std::ostream& os)->
std::enable_if_t<!is_tuple_like<T>>
{
  os << t << (is_last ? " " : ", ");
}

template
<bool is_last, typename T>
auto
encode_one(T const& t, std::ostream& os)->
std::enable_if_t<is_tuple_like<T>>
{
  encode_impl(t, os, std::make_index_sequence<std::tuple_size<T>::value>{ });
  os << (is_last ? " " : ", ");
}

template
<typename T, std::size_t... I>
void encode_impl(T const& t, std::ostream& os, std::index_sequence<I...> const)
{
  constexpr auto last = sizeof...(I) - 1;
  os << "{ ";
  [[maybe_unused]] int const temp[] =
    { (encode_one<I == last>(t.template get<I>(), os), 0)... };
  os << "}";
}

int main () {
    auto a = Aa(1, 1);
    encode(a, std::cout);
    auto b = Bb(a, 1);
    encode(b, std::cout);
    return 0;
}

【讨论】:

  • 实际上,我想在文章中使用与print_struct 相同的样式,例如接受size&lt;2&gt; 作为第三个参数。关于您的代码 sn-p,有一个 error: template argument for non-type template parameter must be an expression encode_impl(t, os, std::make_index_sequence&lt;std::tuple_size&lt;T&gt;&gt;{ }); Clang 版本是 Apple LLVM version 10.0.0 (clang-1000.10.44.4) 这是我尝试在 pastebin 上编译的代码
  • 啊,我忘记了std::tuple_size&lt;t&gt;之后的::value,它现在应该编译了。我也在向后打印每个元素。但我也意识到我的答案是不完整的,因为它没有解决包含子结构的结构,即Bb 我很快就会添加到它。
  • 我尝试编译一个code,收到一个error。它一定是某个地方的拼写错误,导致错误显示tuple_size&lt;int&gt; 调用肯定是无效的。不过可能是我复制粘贴错了。
  • 您的 pastebin 中的代码在 GCC 8.3 和 Clang 8.0(使用的编译器资源管理器)上编译得很好,但是我在 Clang 7.0 上遇到了同样的错误,所以我做了一些挖掘,这确实是一个在某些情况下,早期版本的 Clang 无法使用函数模板正确处理表达式 SFINAE 的错误。让我看看我是否不能制作适用于 Clang 7.0 的不同版本的 is_tuple_like
猜你喜欢
  • 1970-01-01
  • 2013-04-10
  • 1970-01-01
  • 1970-01-01
  • 2015-04-14
  • 1970-01-01
  • 2021-02-09
  • 1970-01-01
  • 2013-04-26
相关资源
最近更新 更多