使用 std::ostream 打印可变参数包的最简单方法是什么？答案

【问题标题】：What is the easiest way to print a variadic parameter pack using std::ostream?使用 std::ostream 打印可变参数包的最简单方法是什么？
【发布时间】：2015-02-07 02:49:22
【问题描述】：

使用std::ostream 打印参数包的最简单方法是什么，以逗号分隔？

例子：

template<typename... Args>
void doPrint(std::ostream& out, Args... args){
   out << args...; // WRONG! What to write here?
}

// Usage:
int main(){
   doPrint(std::cout,34,"bla",15); // Should print: 34,bla,15
}

注意：可以假设 << 运算符的相应重载可用于所有类型的参数包。

【问题讨论】：

在 C++17 中，你会说 (out << ... <<< args);。
注意：这不是重复的——foo << X << Y; 通常与foo << X; foo << Y; 不同，尤其是当foo 具有诸如打开磁盘上的文件等副作用时。
@MSalters，foo << X << Y 也没有指定 X 和 Y 的评估顺序（即在 C++17 之前）

标签： c++ templates c++11 variadic-templates

【解决方案1】：

没有你想要的递归调用和逗号。

在c++11/c++14通过参数包扩展：

template <typename Arg, typename... Args>
void doPrint(std::ostream& out, Arg&& arg, Args&&... args)
{
    out << std::forward<Arg>(arg);
    using expander = int[];
    (void)expander{0, (void(out << ',' << std::forward<Args>(args)), 0)...};
}

DEMO

在c++17 中使用折叠表达式：

template <typename Arg, typename... Args>
void doPrint(std::ostream& out, Arg&& arg, Args&&... args)
{
    out << std::forward<Arg>(arg);
    ((out << ',' << std::forward<Args>(args)), ...);
}

DEMO 2

【讨论】：

这个是最简单的。只是看起来怪怪的，呵呵。
@GermánDiago en.cppreference.com/w/cpp/language/parameter_pack 给出了一个类似的例子：int dummy[sizeof...(Ts)] = { (std::cout << args, 0)... };
附带说明，您可以跳过using 声明，直接写(void)(int[]){(std::cout << ',' << std::forward<Args>(args)), 0)...};。您也不需要大括号中的第一个零或内部 void 演员表。
@AlexanderRevo inserting 到ostream 意味着将参数传递给operator<< 的某个重载。你永远不知道操作员期望什么参数类型
我的 C++ 一定已经过时了。我根本无法解析。

【解决方案2】：

在 C++17 中，将有一种更简单的方法（正如 Kerrek SB 在 cmets 中所暗示的那样；这实际上出现在 N4606，第一个后 C++14 草案中），称为 fold expressions：

代码是：

(out << ... << args);

而模式expression op...op parameter-pack称为二元左折叠，其定义等价于@987654326 @ expression op arg1) op arg2) op arg3) .... op argN.

我认为对于这样的表达式语句来说，外括号并不是绝对必要的，但如果折叠表达式是另一个运算符的操作数，那么它们要么是必需的，要么是一个非常好的主意:)

【讨论】：

使用分隔符：((out << ", " << args), ...);

【解决方案3】：

通常的答案是定义两个单独的重载，一个空的作为基本情况：

// base case
void doPrint(std::ostream& out) {}

template <typename T, typename... Args>
void doPrint(std::ostream& out, T t, Args... args)
{
    out << t;                // add comma here, see below
    doPrint(out, args...);
}

当然，在实际代码中，我不会每次都复制参数，而是使用转发引用，但你明白了。

如果您想在每一项之后添加逗号，即使是在最后一项之后，只需将 out << t 替换为 out << t << ','。

如果您只想在内部使用逗号，而不是在最后一个元素之后，则需要一个单独的不打印逗号的单参数重载，并且通用重载在包之前采用两个不同的参数，即：

template <typename T>
void doPrint(std::ostream& out, T t)
{
    out << t;
}

template <typename T, typename U, typename... Args>
void doPrint(std::ostream& out, T t, U u, Args... args)
{
    out << t << ',';
    doPrint(out, u, args...);
}

【讨论】：

你能详细说明一下转发参考吗？我对 C++11 的东西还不是很坚定，但是复制参数似乎有点过头了。
@gexicide：这个网站上有数千个重复项，只需四处搜索。您正在寻找Args &&... args 和std::forward<Args>(args)...。

【解决方案4】：

参数包扩展仅适用于普通函数调用，不适用于中缀运算符。因此，您需要将s << x 语法转换为普通函数调用语法f(s, x)：

template<class Head>
void print_args_(std::ostream& s, Head&& head) {
    s << std::forward<Head>(head);
}

template<class Head, class... Tail>
void print_args_(std::ostream& s, Head&& head, Tail&&... tail) {
    s << std::forward<Head>(head);
    print_args_(s, std::forward<Tail>(tail)...);
}

template<class... Args>
void print_args(Args&&... args) {
    print_args_(std::cout, std::forward<Args>(args)...);
}

【讨论】：

【解决方案5】：

我知道这是一个老问题，但它对我的问题帮助很大。我根据这篇帖子的答案创建了一个实用程序类，我想分享我的结果。

考虑到我们使用 C++11 或更高版本的 C++，这个类提供了 print 和 println 函数来在调用标准输出流之前组合字符串，避免并发问题。这些是可变参数函数，它们使用模板来打印不同的数据类型。

您可以在我的 github 上查看它在生产者-消费者问题中的用途：https://github.com/eloiluiz/threadsBar

所以，这是我的代码：

class Console {
private:
    Console() = default;

    inline static void innerPrint(std::ostream &stream) {}

    template<typename Head, typename... Tail>
    inline static void innerPrint(std::ostream &stream, Head const head, Tail const ...tail) {
        stream << head;
        innerPrint(stream, tail...);
    }

public:
    template<typename Head, typename... Tail>
    inline static void print(Head const head, Tail const ...tail) {
        // Create a stream buffer
        std::stringbuf buffer;
        std::ostream stream(&buffer);
        // Feed input parameters to the stream object
        innerPrint(stream, head, tail...);
        // Print into console and flush
        std::cout << buffer.str();
    }

    template<typename Head, typename... Tail>
    inline static void println(Head const head, Tail const ...tail) {
        print(head, tail..., "\n");
    }
};

比起重载<< 运算符或使用复杂的流函数，我更喜欢这种替代方法。它是一种递归方法，但并不难理解。

【讨论】：

我会更改= delete 中的构造函数。由于只有静态方法，实例化Console对象是没有意义的

【解决方案6】：

同样适用于std::wostream 的通用形式：

template <typename CharT, typename Traits>
std::basic_ostream<CharT, Traits> &
Print(std::basic_ostream<CharT, Traits> &out)
{
    return out;
}

template <typename CharT, typename Traits, typename T>
std::basic_ostream<CharT, Traits> &
Print(std::basic_ostream<CharT, Traits> &out, T &&t)
{
    return (out << std::forward<T>(t));
}

template <typename CharT, typename Traits, typename T, typename... Args>
std::basic_ostream<CharT, Traits> &
Print(std::basic_ostream<CharT, Traits> &out, T &&t, Args &&...args)
{
    return Print( Print(out, std::forward<T>(t)), std::forward<Args>(args)... );
}

在常见情况下，我无法使其与 std::endl 一起使用（在特定情况下可以处理 std::endl，例如当它是第一个或最后一个参数时，但不是在常见情况下，尤其是如果单个呼叫中有多个std::endl）。如果您确实需要 std::endl，您仍然可以使用 '\n' 或使用 std::endl 指定模板参数：

Print(std::cout, "hello world", std::endl<char, std::char_traits<char>>);

std::endl 和 '\n' 之间的 differences

如果流在二进制模式下工作，则'\n' 不会转换为编译代码所针对的平台的行尾格式（但在文本模式下仍会转换）。
'\n' 不会用std::flush 刷新流（但如果程序在终端上运行，它仍然是flushes std::cout）

所以对我来说可以使用'\n'，甚至可以使用preferred。

仍然可以使用其他一些 IO 操纵器：

Print(std::cout, std::hex, 11, '\n');

我还实现了sprintf 对应物，它与可变参数模板一起使用并返回std::string：

template <typename CharT = char, typename Traits = std::char_traits<CharT>, typename... Args>
std::basic_string<CharT, Traits>
SPrint(Args &&...args)
{
    std::basic_stringstream<CharT, Traits> ss;
    Print(ss, std::forward<Args>(args)...);
    return std::move(ss.str());
}

这里有一些demos。

【讨论】：