可变类成员(元组或其他)的参数包扩展

Question

我试图在类中存储引用元组(通过可变模板)，然后我想"循环";>

下面的函数process2按预期工作，但我想使函数process1工作相同(利用类本身的存储引用)。然而，我不能使process1编译。正确的方法是什么?是否有一种方法可以让成员Args&... args;而不是std::tuple<Args&...> args(因为这可能允许参数扩展)?欢迎提出建议。

样例代码:

#include <tuple>
#include <string>
#include <iostream>
template<class... Args>
class Handler
{
private:
template <class T>
static bool process_arg(T& val)
{
if constexpr (std::is_same_v<T, int>)
val = 123;
else if constexpr (std::is_same_v<T, std::string>)
val = "string";
else
{
// do something
return false;
}
return true;
}
public:
const std::tuple<Args&...> args;
Handler(Args&... args)
: args(args ...) { }
// bool process1() const
// {
//     // Compile Error: operand of fold expression has no unexpanded parameter packs
//     const bool success = (process_arg(args) && ...);
//     // Compile Error: no matching function for process_arg(int&, int&, std::string&)
//     bool success = true;
//     std::apply([&success](auto &&... v) { success = success && process_arg(v...); }, args);

//     return success;
// }
template<class... Args2>
static bool process2(Args2&... args2)
{
const bool success = (process_arg(args2) && ...);
return success;
}
};
int main()
{
int a, b;
std::string c;
// Handler(a, b, c).process1();
Handler<>::process2(a, b, c);
std::cout << a << "," << b << "," << c << "n";
return 0;
}

Answer 1

你在正确的轨道上与std::apply，但语法是不正确的;包扩展需要在process_arg调用之外。此外，您根本不需要变量success;您可以直接使用折叠表达式:

bool process1() const
{
return std::apply([](auto &&... v) {
return (process_arg(v) && ...); 
}, args); 
}

这是一个演示

Answer 2

不确定这是您需要的，因为它不将任何内容存储为成员。但我认为它给出了期望的输出。啊嗯…也许你能从中学到些什么:)

class Handler
{
private:
template <class T>
static bool process_arg(T& val)
{
if constexpr (std::is_same_v<T, int>)
val = 123;
else if constexpr (std::is_same_v<T, std::string>)
val = "string";
else
{
// do something
return false;
}
return true;
}
public:
template<typename arg_t, typename... args_t>
static constexpr bool process(arg_t& arg, args_t&... args)
{
if constexpr (sizeof...(args_t) > 0)
{
bool success = process_arg<arg_t>(arg) && process(args...);
return success;
}
return process_arg<arg_t>(arg);
}
};
int main()
{
int a, b;
std::string c;
Handler::process(a, b, c);
std::cout << a << "," << b << "," << c << "n";
return 0;
}