如何从折叠表达式中获取索引
折叠表达式（Fold Expression）是C++17引入的一种语法特性，用于在编译时对参数包（Parameter Pack）中的元素进行折叠操作。在折叠表达式中，我们可以使用逗号运算符来获取索引。
要从折叠表达式中获取索引，可以使用递归方式实现。以下是一个示例代码：
#include <iostream>
template <typename... Args>
void printIndex(Args&&... args) {
int index = 0;
((std::cout << "Index: " << index++ << ", Value: " << args << std::endl), ...);
}
int main() {
printIndex(1, 2, 3, 4, 5);
return 0;
}在上述代码中，printIndex函数接受可变参数包args，并使用折叠表达式将每个参数的索引和值打印出来。通过递增的index变量，我们可以获取每个参数的索引。
输出结果如下：
Index: 0, Value: 1
Index: 1, Value: 2
Index: 2, Value: 3
Index: 3, Value: 4
Index: 4, Value: 5这里使用了逗号运算符来实现参数的打印和索引的递增。折叠表达式中的逗号运算符会依次对参数进行操作，从而实现获取索引的效果。
在腾讯云的相关产品中，可以使用腾讯云函数（Tencent Cloud Function）来实现类似的功能。腾讯云函数是一种无服务器计算服务，可以在云端运行代码，支持多种编程语言。您可以通过编写腾讯云函数的代码来实现对参数包的折叠操作，并进行相应的处理。
腾讯云函数产品介绍链接地址：腾讯云函数
相关·内容
是否有和现有的函数(或语法)类似：
inline void noop(...) { /* EMPTY */ }
这样我就可以做这样的事情：
template <class... T>
void foo(T... args) {
noop( do_side_effect<T>(args)... );
}
-编辑-编辑
因为这样的东西无法编译：
template <class... T>
void foo(T... args) {
do_side_effect<T>(args)...;
}
template <class..
浏览 0提问于2020-10-20得票数 3
回答已采纳
2回答
#include<iostream>
using namespace std;
template<typename ...Args>
void output_argus(Args&&... args)
{
((cout << args << '\n'), ...); // #1
(... , (cout << args << '\n')); // #2
}
int main()
{
output_argus(1, "test&
浏览 0提问于2018-11-16得票数 15
回答已采纳
1回答
考虑以下使用折叠表达式打印参数的函数。
template <typename... T>
void print(T &&... t)
{
(std::cout << ... << t) << '\n';
}
考虑第二个调用它的函数：
template <typename T, T... vals>
void call_print(std::integer_sequence<T, vals...> &&)
{
print(vals...); //ok: prin
浏览 0提问于2020-06-09得票数 1
回答已采纳
3回答
可变模板参数解包
、、
对于每个参数，我需要应用两个嵌套函数：
obj.apply(someFilter(arg)); // arg is one argument, but here
// should be an unpacking of args
我不知道如何为这样的箱子写拆包。
我看到了这个：
pass{([&]{ std::cout << args << std::endl; }(), 1)...};
，但同样不知道如何将其应用到我的案例中。
浏览 1提问于2013-03-08得票数 3
回答已采纳
我需要用使用相同构造函数参数的N个对象初始化std:数组，就像在std::vector<T>(size_t, {args...})中一样。从我在这里的搜索，我想出了这个，它是有效的：
template<typename T, size_t... Ints, typename... Args>
std::array<T, sizeof...(Ints)> make_array_(std::index_sequence<Ints...>, Args&&... args) {
return { (Ints, T{args...}
浏览 1提问于2019-10-24得票数 4
回答已采纳
我知道那个。在这个问题中，示例如下所示：
template<typename... Args>
inline void increment_all(Args&... args)
{
++args...;
}
先递增还是先展开可能有些含糊，这样括号就不会有什么坏处：
template<typename... Args>
inline void increment_all(Args&... args)
{
(++args)...;
}
或者类似这样的东西：
template<typename... Args>
void co
浏览 0提问于2013-01-21得票数 5
回答已采纳
3回答
在可变模板中...运算符将参数包扩展为一系列以逗号分隔的参数(以最简单的形式)。我的问题是:为什么为多个参数调用some_function()并使用...操作员不需要吗？
我说的是这段代码：
template<typename... Args> inline void expand(Args&&... args)
{
some_function(22),some_function(32); // Works
some_function(args)...; // Doesn't work - ERROR
}
这两行代码不应该产生类似的输出吗？
浏览 0提问于2013-04-15得票数 4
回答已采纳
我在阅读有关折叠表达式的文章，发现了一个在折叠表达式之前使用的示例： template <class... Ts>
void print_all(std::ostream& os, Ts const&... args) {
using expander = int[];
(void)expander{0,
(void(os << args), 0)...
};
} 问题出在void(os << args)位。在这种情况下，void是什么意思？我已经尝试过搜索这个，但它非常通用。 耽误您时间，实在对不起
浏览 22提问于2021-11-16得票数 5
回答已采纳
我想更好地理解参数包扩展，所以我决定稍微研究一下，在试图了解到底发生了什么之后，我曾经觉得很明显的事情就不再那么明显了。让我们使用std::forward检查一个标准的参数包扩展
template <typename... Ts>
void foo(Ts&& ... ts) {
std::make_tuple(std::forward<Ts>(ts)...);
}
我在这里的理解是，对于任何参数pack Ts，std::forward<Ts>(ts)...将产生一个以逗号分隔的转发参数列表及其相应的类型，例如，对于ts equal 1
浏览 3提问于2020-01-09得票数 3
回答已采纳
1回答
我有以下代码，它从指针读取值/参数并调用函数：
#include <iostream>
#include <functional>
#include <string>
#include <tuple>
template<typename T>
T Read(void*& ptr)
{
T result = *static_cast<T*>(ptr);
ptr = static_cast<T*>(ptr) + 1;
return result;
}
template<ty
浏览 2提问于2020-12-12得票数 6
回答已采纳
使用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
}
注意:可以假定<<操作符的相应重载可
浏览 7提问于2014-12-09得票数 43
回答已采纳
1回答
template <std::size_t N, class... Args>
using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
template<typename ...Args, typename Func>
typename std::result_of<Func(Args...)>::type functionOnParams(Func fp, Args&&...args)
{
using Indices = s
浏览 0提问于2020-09-22得票数 0
1回答
我有以下代码来处理n维张量类(偏移量是std：：size_t的std：：向量)：
template <typename ...Ts>
double Tensor::at(int first, Ts... others) {
int i = 0;
std::size_t index = static_cast<std::size_t>(first)*_offset[0];
(void)std::initializer_list<int>{(index += _offset[++i]*static_cast<std::size_t&
浏览 0提问于2020-08-09得票数 0
回答已采纳
1回答
请考虑下列方案：
#include <iostream>
#include <algorithm>
template<typename T, std::size_t N, std::size_t... I>
T sum_impl(T (&a)[N], std::index_sequence<I...>)
{
return (a[I] + ...);
}
template<typename T, std::size_t N>
T sum(T (&a)[N])
{
return sum_impl(a, std:
浏览 0提问于2019-06-02得票数 2
回答已采纳
3回答
在C++17中，折叠表达式是可用的，因此要打印参数，我们可以使用
#define EOL '\n'
template<typename ...Args>
void output_argus(Args&&... args)
{
(cout << ... << args) << EOL;
}
int main()
{
output_argus(1, "test", 5.6f);
}
有输出
1test5.6
如果我想使用折叠表达式，在每个元素中附加一个额外的字符'\n&#
浏览 0提问于2018-11-08得票数 11
回答已采纳
我使用基于策略的设计，我有几个策略实现(使用相同的接口)，但是其中一个策略需要不同数量的args来构建。
所以我在我的类中使用了可变模板参数(typename... InitArgs)
并使用std::forward将它们转发给策略类型的构造器。
示例：
class Policy1 : public PolicyBase
{
Policy1(int arg1, std::string arg2);
}
class Policy2 : public PolicyBase
{
Policy2(int arg1);
}
template<typename T>
con
浏览 8提问于2021-09-23得票数 0
回答已采纳
1回答
我在看"“，想知道逗号扩展能达到多远。
以下是答案的一个变体：
inline void inc() { }
template<typename T,typename ...Args>
inline void inc(T& t, Args& ...args) { ++t; inc(args...); }
由于变量参数被扩展为以逗号分隔的元素列表，这些逗号在语义上是等价于模板/函数参数分隔符，还是插入词汇，使其适合于任何(预处理后)使用，包括逗号运算符？
这适用于我的GCC-4.6：
// Use the same zero-argument "inc
浏览 0提问于2012-04-19得票数 5
回答已采纳
3回答
变量模板参数转发使用逗号运算符
、、、、
最近，我正在学习C++和各种模板。我尝试编写一个接受容器的模板函数(我简化了它，只在这个问题中使用list )和一些其他参数，并将其他参数放置到容器中。我的代码是这样的：
#include <iostream>
#include <list>
#include <utility>
template <typename Container, typename... Args>
void my_emplace(Container &c, Args &&... args){
c.emplace_back(std::fo
浏览 3提问于2020-01-04得票数 1
回答已采纳
1回答
我对lambdas的平等比较有疑问。我试着读过一些参考资料，但是我没有发现任何这方面的资料。
[] (Args ...args) -> ReturnType { ... };
对于这种类型的lambda(实际上不是闭包，因为它们有空捕获列表)，操作符==和!=的工作方式与静态函数的工作方式相同(看来编译器也会将它们作为静态函数生成)。但是对于闭包，任何以相同方式进行比较的尝试都会导致编译错误。
下面是简单的程序，例如：
#include <typeinfo>
#include <iostream>
struct WrapperBase {
virtual
浏览 0提问于2014-11-09得票数 3
回答已采纳
3回答
获取C++可变模板参数的序数
、、、、
我想从variadic template参数中检索每个参数的索引，目前我正在使用以下方法：
来自第三方图书馆：
struct statement {
template <typename T>
void bind(int, T t) { // ....
}
};
我的代码：
template <unsigned Index, typename T>
void bind(statement& stmt, T t) {
stmt.bind(Index, t);
}
template <unsigned Index, typename T,
浏览 2提问于2021-01-11得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储活动推荐
腾讯云开发者
