C++ 17可变模板折叠

Question

我不明白为什么这不起作用。能理解模板和可变表达式折叠的人能解释发生了什么，并给出可行的解决方案吗？

#include <iostream> 
#include <string> 

template <typename... Args> 
void print(Args... args) 
{ 
    std::string sep = " "; 
    std::string end = "\n"; 
    (std::cout << ... << sep << args) << end; 
} 

int main() 
{ 
    print(1, 2, 3); 
} 

它应该打印出每个参数的中间和最后一个换行符。如果您删除sep <<，但它在打印时每个参数之间没有空格，则此功能起作用。

Answer 1

Th二进制fold-expressionsé语法必须是一个：

(pack op ... op init) 
(init op ... op pack) 

你有什么是(std::cout << ... << sep << args)，这不符合任何一种形式。您需要诸如(cout << ... << pack)之类的东西，这就是为什么要删除sep的原因。

相反，你可以折叠逗号：

((std::cout << sep << args), ...); 

或使用递归：

template <class A, class... Args> 
void print(A arg, Args... args) { 
    std::cout << arg; 
    if constexpr (sizeof...(Args) > 0) { 
     std::cout << sep; 
     print(args...); 
    } 
} 

Answer 2

这将工作，但它会打印尾随空格：

template <typename... Args> 
void print(Args... args) 
{ 
    std::string sep = " "; 
    std::string end = "\n"; 

    ((std::cout << args << sep), ...) << end; 
} 

live wandbox example

---

在这种情况下，正在执行在逗号操作折叠，导致扩展如：

// (pseudocode) 
(std::cout << args<0> << sep), 
(std::cout << args<1> << sep), 
(std::cout << args<2> << sep), 
..., 
(std::cout << args<N> << sep), 

Answer 3

你真正想要做的是：

std::string sep = " "; 
std::string end = "\n"; 
(std::cout << ... << (sep << args)) << end; 

，因为你想(sep << args)与std::cout左折叠。这是行不通的，因为sep << args不知道它正在流入std::cout或者流式传输; <<只在流媒体的左边是流。

总之，问题是sep << args不明白它是流媒体。

您的其他问题是不够lambda。

我们可以解决这个问题。

template<class F> 
struct ostreamer_t { 
    F f; 
    friend std::ostream& operator<<(std::ostream& os, ostreamer_t&& self) { 
     self.f(os); 
     return os; 
    } 
    template<class T> 
    friend auto operator<<(ostreamer_t self, T&& t) { 
     auto f = [g = std::move(self.f), &t](auto&& os)mutable { 
      std::move(g)(os); 
      os << t; 
     }; 
     return ostreamer_t<decltype(f)>{std::move(f)}; 
    } 
}; 

struct do_nothing_t { 
    template<class...Args> 
    void operator()(Args&&...)const {} 
}; 

const ostreamer_t<do_nothing_t> ostreamer{{}}; 

template <typename... Args> 
void print(Args... args) 
{ 
    std::string sep = " "; 
    std::string end = "\n"; 
    (std::cout << ... << (ostreamer << sep << args)) << end; 
} 

live example。 （我也用sep的文字来确保我用rvalues工作）。

ostreamer捕获对事物的引用，它是<<'d，然后将它们转储到<<到ostream。

整个过程对于编译器来说应该是透明的，所以体面的优化器应该会消除所有涉及的事情。

Answer 4

正如其他人回答的那样，您尝试使用错误的折叠表达式格式。 你可以使用你的目的拉姆达帮手一个非常简单的方法：

template <typename... Args> 
void print(Args&&... args) 
{ 
    std::string sep = " "; 
    std::string end = "\n"; 
    auto streamSep = [&sep](const auto& arg) -> decltype(arg) { 
     std::cout << sep; 
     return arg; 
    }; 
    (std::cout << ... << streamSep(args)) << end; 
} 

这会按照预期你写的代码的行为。但是，如果你想避免的第一个参数前月，你可以使用以下命令：

template <typename Arg, typename... Args> 
void print(Arg&& arg, Args&&... args) 
{ 
    std::string sep = " "; 
    std::string end = "\n"; 
    auto streamSep = [&sep](const auto& arg) -> decltype(arg) { 
     std::cout << sep; 
     return arg; 
    }; 
    std::cout << arg; 
    (std::cout << ... << streamSep(args)) << end; 
} 

Answer 5

你可以尝试这样的事情

template <typename... Args> 
void print(Args... args) 
{ 
    bool first = true; 
    auto lambda = [&](auto param) 
    { 
    if(!first) std::cout << ','; 
    first= false; 
    return param; 
    }; 

    ((std::cout << lambda(args)), ...); 
} 

拉姆达保证分离器只之间插入两个项目。

在另一方面，如果你不想要使用lambda表达式，你可以重载模板：

template<typename T> 
void print(T item) 
{ 
    std::cout << item; 
} 

template<typename T, typename... Args> 
void print(T item, Args... args) 
{ 
    print(item); 
    std::cout << ','; 
    print(args...); 
} 

Answer 6

如果你不想前/后sep：

template <typename First, typename... Rest> 
void print(First first, Rest... rest) 
{ 
    std::string sep = " "; 
    std::string end = "\n"; 

    std::cout << first; 
    ((std::cout << sep << rest), ...); 
    std::cout << end; 
} 

你需要让std::cout << end;一个单独的指令来处理一个参数的情况。