C ++ 17 Variadic Template Folding
Я не понимаю, почему это не работает. Может ли кто-то, кто понимает шаблоны и свертывание вариативных выражений, объяснить, что происходит, и дать решение, которое работает?
#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 << но тогда нет места между каждым аргументом, когда он печатается.
Решение
Грамматика для двоичного Fold-выражения должен быть одним из:
(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...);
}
}
Другие решения
Это будет работать, но он будет печатать завершающий пробел:
template <typename... Args>
void print(Args... args)
{
std::string sep = " ";
std::string end = "\n";
((std::cout << args << sep), ...) << end;
}
В этом случае, сгиб над оператор запятой выполняется, что приводит к расширению, как:
// (pseudocode)
(std::cout << args<0> << sep),
(std::cout << args<1> << sep),
(std::cout << args<2> << sep),
...,
(std::cout << args<N> << sep),
Что вы действительно хотите сделать, это:
std::string sep = " ";
std::string end = "\n";
(std::cout << ... << (sep << args)) << end;
потому что ты хочешь (sep << args) быть сложенным с std::cout, Это не работает, потому что sep << args не знает, что это поток std::cout или потоком вообще; << только потоковая передача, если левая сторона является потоком.
Короче говоря, проблема в том, что sep << args не понимает, что это потоковое.
Ваша другая проблема не достаточно лямбда.
Мы можем это исправить.
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;
}
живой пример. (Я также использовал литерал для sep чтобы я работал со значениями).
ostreamer захватывает ссылки на вещи это <<D, а затем сбрасывает их, когда по очереди << для ostream,
Весь этот процесс должен быть прозрачен для компилятора, поэтому достойный оптимизатор должен испарять все, что с этим связано.
Как ответили другие, вы пытаетесь использовать неправильно складчато-выражение формат.
Вы можете использовать лямбда-помощник для ваших целей очень простым способом:
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;
}
Вы можете попробовать что-то вроде этого
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)), ...);
}
Лямбда обеспечивает разделитель только между двумя элементами.
С другой стороны, если вы не хотите использовать лямбды, вы можете перегрузить шаблон:
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...);
}
Если вы не хотите вести / трейлинг 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; отдельная инструкция для обработки регистра с одним параметром.
Другой подход заключается в следующем:
#include <iostream>
template<class U, class... T>
void printSpaced(const U& u, const T&... args)
{
using std::cout;
using std::endl;
((cout << u) << ... << (cout << ' ', args)) << endl;
}
Использование:
printSpaced(1, 2, "Hello", 4.5f); //Output 1 2 Hello 4.5 and no trailing space