Pretty-print std :: tuple

Question

这是我之前关于漂亮印刷STL容器的问题的后续行动,为此我们设法开发了一个非常优雅且完全通用的解决方案.

---

在下一步中,我想std::tuple<Args...>使用可变参数模板包含漂亮打印(因此这是严格的C++ 11).因为std::pair<S,T>,我只是说

std::ostream & operator<<(std::ostream & o, const std::pair<S,T> & p)
{
  return o << "(" << p.first << ", " << p.second << ")";
}

打印元组的类似结构是什么？

我已经尝试了各种模板参数堆栈解包,传递索引并使用SFINAE来发现我何时处于最后一个元素,但没有成功.我不会用破碎的代码给你带来负担; 问题描述有希望直截了当.基本上,我想要以下行为:

auto a = std::make_tuple(5, "Hello", -0.1);
std::cout << a << std::endl; // prints: (5, "Hello", -0.1)

与前一个问题包含相同级别的通用性(char/wchar_t,pair delimiters)的加分点!

Answer 1

耶,指数〜

namespace aux{
template<std::size_t...> struct seq{};

template<std::size_t N, std::size_t... Is>
struct gen_seq : gen_seq<N-1, N-1, Is...>{};

template<std::size_t... Is>
struct gen_seq<0, Is...> : seq<Is...>{};

template<class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple(std::basic_ostream<Ch,Tr>& os, Tuple const& t, seq<Is...>){
  using swallow = int[];
  (void)swallow{0, (void(os << (Is == 0? "" : ", ") << std::get<Is>(t)), 0)...};
}
} // aux::

template<class Ch, class Tr, class... Args>
auto operator<<(std::basic_ostream<Ch, Tr>& os, std::tuple<Args...> const& t)
    -> std::basic_ostream<Ch, Tr>&
{
  os << "(";
  aux::print_tuple(os, t, aux::gen_seq<sizeof...(Args)>());
  return os << ")";
}

Ideone上的实例.

对于分隔符,只需添加这些部分特化:

// Delimiters for tuple
template<class... Args>
struct delimiters<std::tuple<Args...>, char> {
  static const delimiters_values<char> values;
};

template<class... Args>
const delimiters_values<char> delimiters<std::tuple<Args...>, char>::values = { "(", ", ", ")" };

template<class... Args>
struct delimiters<std::tuple<Args...>, wchar_t> {
  static const delimiters_values<wchar_t> values;
};

template<class... Args>
const delimiters_values<wchar_t> delimiters<std::tuple<Args...>, wchar_t>::values = { L"(", L", ", L")" };

并更改operator<<,并print_tuple相应地:

template<class Ch, class Tr, class... Args>
auto operator<<(std::basic_ostream<Ch, Tr>& os, std::tuple<Args...> const& t)
    -> std::basic_ostream<Ch, Tr>&
{
  typedef std::tuple<Args...> tuple_t;
  if(delimiters<tuple_t, Ch>::values.prefix != 0)
    os << delimiters<tuple_t,char>::values.prefix;

  print_tuple(os, t, aux::gen_seq<sizeof...(Args)>());

  if(delimiters<tuple_t, Ch>::values.postfix != 0)
    os << delimiters<tuple_t,char>::values.postfix;

  return os;
}

和

template<class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple(std::basic_ostream<Ch, Tr>& os, Tuple const& t, seq<Is...>){
  using swallow = int[];
  char const* delim = delimiters<Tuple, Ch>::values.delimiter;
  if(!delim) delim = "";
  (void)swallow{0, (void(os << (Is == 0? "" : delim) << std::get<Is>(t)), 0)...};
}

Answer 2

我在C++ 11(gcc 4.7)中运行良好.我确信有些陷阱我没有考虑过,但我认为代码很容易阅读而且并不复杂.唯一可能奇怪的是"guard"struct tuple_printer,它确保我们在到达最后一个元素时终止.另一个奇怪的事情可能是sizeof ...(Types)返回Types type pack中的类型数.它用于确定最后一个元素的索引(大小...(类型) - 1).

template<typename Type, unsigned N, unsigned Last>
struct tuple_printer {

    static void print(std::ostream& out, const Type& value) {
        out << std::get<N>(value) << ", ";
        tuple_printer<Type, N + 1, Last>::print(out, value);
    }
};

template<typename Type, unsigned N>
struct tuple_printer<Type, N, N> {

    static void print(std::ostream& out, const Type& value) {
        out << std::get<N>(value);
    }

};

template<typename... Types>
std::ostream& operator<<(std::ostream& out, const std::tuple<Types...>& value) {
    out << "(";
    tuple_printer<std::tuple<Types...>, 0, sizeof...(Types) - 1>::print(out, value);
    out << ")";
    return out;
}

Answer 3

我很惊讶cppreference的实现还没有在这里发布,所以我会为后代做这件事.它隐藏在文档中,std::tuple_cat所以不容易找到.它使用像其他一些解决方案一样的保护结构,但我认为它们最终更简单,更容易理解.

#include <iostream>
#include <tuple>
#include <string>

// helper function to print a tuple of any size
template<class Tuple, std::size_t N>
struct TuplePrinter {
    static void print(const Tuple& t) 
    {
        TuplePrinter<Tuple, N-1>::print(t);
        std::cout << ", " << std::get<N-1>(t);
    }
};

template<class Tuple>
struct TuplePrinter<Tuple, 1> {
    static void print(const Tuple& t) 
    {
        std::cout << std::get<0>(t);
    }
};

template<class... Args>
void print(const std::tuple<Args...>& t) 
{
    std::cout << "(";
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
    std::cout << ")\n";
}
// end helper function

并测试:

int main()
{
    std::tuple<int, std::string, float> t1(10, "Test", 3.14);
    int n = 7;
    auto t2 = std::tuple_cat(t1, std::make_pair("Foo", "bar"), t1, std::tie(n));
    n = 10;
    print(t2);
}

输出:

(10,Test,3.14,Foo,bar,10,Test,3.14,10)

现场演示

Answer 4

在C++ 17中,我们可以通过利用折叠表达式来减少代码,尤其是一元左折:

template<class TupType, size_t... I>
void print(const TupType& _tup, std::index_sequence<I...>)
{
    std::cout << "(";
    (..., (std::cout << (I == 0? "" : ", ") << std::get<I>(_tup)));
    std::cout << ")\n";
}

template<class... T>
void print (const std::tuple<T...>& _tup)
{
    print(_tup, std::make_index_sequence<sizeof...(T)>());
}

现场演示输出:

(5,您好,-0.1)

特定

auto a = std::make_tuple(5, "Hello", -0.1);
print(a);

说明

我们的一元左折是形式

... op pack

其中op在我们的方案中是逗号运算符,并且pack是包含在象未扩展上下文我们的元组中的表达:

(..., (std::cout << std::get<I>(myTuple))

所以,如果我有这样的元组:

auto myTuple = std::make_tuple(5, "Hello", -0.1);

并且std::integer_sequence其值由非类型模板指定(参见上面的代码)

size_t... I

然后表达

(..., (std::cout << std::get<I>(myTuple))

获取扩展为

((std::cout << std::get<0>(myTuple)), (std::cout << std::get<1>(myTuple))), (std::cout << std::get<2>(myTuple));

哪个会打印

5Hello-0.1

这是粗略的,所以我们需要做一些更多的技巧来添加一个逗号分隔符,以便首先打印,除非它是第一个元素.

为了实现这一点,我们修改packfold表达式的部分," ,"如果当前索引I不是第一个,则打印,因此(I == 0? "" : ", ")部分^*:

(..., (std::cout << (I == 0? "" : ", ") << std::get<I>(_tup)));

而现在我们会得到

5,您好,-0.1

哪个看起来更好(注意:我想要类似的输出作为这个答案)

^{*注意:您可以通过各种方式进行逗号分隔,而不是最终结果.我最初有条件地添加逗号,而不是之前通过测试反对std::tuple_size<TupType>::value - 1,但这太长了,所以我测试反对sizeof...(I) - 1,但最后我复制了Xeo,我们最终得到了我所拥有的.}

Answer 5

利用std::apply(C++17)，我们可以删除std::index_sequence并定义单个函数：

#include <tuple>
#include <iostream>

template<class Ch, class Tr, class... Args>
auto& operator<<(std::basic_ostream<Ch, Tr>& os, std::tuple<Args...> const& t) {
  std::apply([&os](auto&&... args) {((os << args << " "), ...);}, t);
  return os;
}

或者，在字符串流的帮助下稍微修饰一下：

#include <tuple>
#include <iostream>
#include <sstream>

template<class Ch, class Tr, class... Args>
auto& operator<<(std::basic_ostream<Ch, Tr>& os, std::tuple<Args...> const& t) {
  std::basic_stringstream<Ch, Tr> ss;
  ss << "[ ";
  std::apply([&ss](auto&&... args) {((ss << args << ", "), ...);}, t);
  ss.seekp(-2, ss.cur);
  ss << " ]";
  return os << ss.str();
}