使用折叠表达式打印每个元素之间的空格

Print spaces between each element using a fold expression

本文关键字：元素 之间 空格 式打印 折叠      更新时间：2023-10-16

我正在使用一个fold表达式来打印可变包中的元素，但如何在每个元素之间获得空间？

当前输出为"1 234"，所需输出为"2 3 4">

template<typename T, typename Comp = std::less<T> >
struct Facility
{
template<T ... list>
struct List
{
static void print()
{
}
};
template<T head,T ... list>
struct List<head,list...>
{
static void print()
{
std::cout<<"""<<head<<" ";
(std::cout<<...<<list);
}
};
};
template<int ... intlist>
using IntList = typename Facility<int>::List<intlist...>;
int main()
{
using List1 = IntList<1,2,3,4>;
List1::print();
}

如果你只需要数字之间的空格(而不是在最后一个数字之后或第一个数字之前(，你可以这样做：

template <std::size_t... Is>
void print_seq(std::index_sequence<Is...>)
{
const char* sep = "";
(((std::cout << sep << Is), sep = " "), ...);
}

演示

(它类似于我的"运行时版本"(，用于带有for循环的常规容器。

您可以

#include <iostream>
template<typename T>
struct Facility
{
template<T head,T ... list>
struct List
{
static void print()
{
std::cout<<""" << head;
((std::cout << " " << list), ...);
std::cout<<""";
}
};
};
template<int ... intlist>
using IntList = typename Facility<int>::List<intlist...>;
int main()
{
using List1 = IntList<1,2,3,4>;
List1::print();
}

折叠表达式((std::cout << " " << list), ...)将扩展为((std::cout << " " << list1), (std::cout << " " << list2), (std::cout << " " << list3)...)

通常，您会对这样的任务使用递归。

您必须定义当列表中有2个或多个元素和1个元素时会发生什么，并递归地返回到这些定义：

template <int ...> struct List;
template <int First, int Second, int ... More> struct List {
static void print() {
std::cout << First << " ";
List<Second, More ...>::print();
}
};
template <int Last> struct List {
static void print() {
std::cout << Last;
}
};

您可以重用print()来实现这种行为。毕竟，你正在做一个fold操作，根据定义，它是复活的。

实时演示

template<T head,T ... rest_of_pack>
struct List<head , rest_of_pack...>
{
static void print_()
{
std::cout<<head<<" ";
List<rest_of_pack...>::print();
}
};

如果您想以这种方式处理许多元素，您可能会遇到模板深度的问题(例如，gcc的限制为900(。幸运的是，您可以使用-ftemplate-depth=选项来调整这种行为。

您可以使用-ftemplate-depth=100000进行编译并使其工作。请注意，编译时间会飙升(很可能(，或者在最坏的情况下内存会耗尽。

不完全符合这个问题，但我认为在这里提出一个基于fold表达式的解决方案可能会很有用，该解决方案可以从类似字符串的参数中生成字符串，从而最大限度地减少动态内存分配：

#include <iostream>
#include <concepts> // std::convertible_to
#include <string>
#include <string_view>
using namespace std::literals;
template<std::convertible_to<std::string_view>... Args>
[[nodiscard]] std::string mystrconcat(Args&&... args)
{
std::string s;
const std::size_t totsiz = sizeof...(args) + (std::size(args) + ...);
s.reserve(totsiz);
((s+=args, s+=' '), ...);
if(!s.empty()) s.resize(s.size()-1); // Get rid of the trailing delimiter?
return s;
}
int main()
{
std::cout << '"' << mystrconcat("aa"s,"bb"sv,"ccc") << '"' << 'n';
}
相关文章：