折叠表达式中使用if constexpr编译失败的修复方法问询

尝试实现一个使用折叠表达式的函数，将std::vector<std::string>中的值赋值给函数的输出参数。编写的折叠表达式代码如下：

((if constexpr (std::is_integral_v<Args>)
  {
      args = std::stoi(vec[index++]);
  }
  else if constexpr (std::is_same_v<Args, std::string>)
  {
      args = vec[index++];
  }
  else
  {
      throw std::invalid_argument("Unsupported argument type.");
  }), ...);

编译时出现错误：

• Clang提示：error: expected expression
• GCC提示：error: expected primary-expression before 'if'

完整代码上下文：

#include <vector>
#include <string>
#include <type_traits>
#include <iostream>
#include <stdexcept>
template <typename... Args>
void populateArgs(std::vector<std::string>& vec, Args&... args)
{
    const size_t numArgs = sizeof...(Args);
    if (vec.size() != numArgs)
    {
        throw std::invalid_argument("Number of arguments doesn't match the size of the vector.");
    }
    int index = 0;
    ((if constexpr (std::is_integral_v<Args>)
      {
          args = std::stoi(vec[index++]);
      }
      else if constexpr (std::is_same_v<Args, std::string>)
      {
          args = vec[index++];
      }
      else
      {
          throw std::invalid_argument("Unsupported argument type.");
      }), ...);
}

int main()
{
    std::vector<std::string> vec{ "1", "2", "3", "hello" };
    short a;
    int b;
    long long c;
    std::string d;
    populateArgs(vec, a, b, c, d);
    std::cout << "a = " << a << ", b = " << b << ", c = " << c << ", d = " << d << std::endl;
    // Output: a = 1, b = 2, c = 3, d = hello
}

编译错误的核心原因是：折叠表达式要求展开的内容必须是一个表达式，而if constexpr语句块属于语句范畴，并非表达式，因此无法直接放入折叠表达式中。以下两种方式可解决问题：

方法一：用lambda封装逻辑并立即调用 #

将if constexpr逻辑包裹在lambda表达式中并立即执行，让整个结构成为合法的表达式，适配折叠要求：

template <typename... Args>
void populateArgs(std::vector<std::string>& vec, Args&... args)
{
    const size_t numArgs = sizeof...(Args);
    if (vec.size() != numArgs)
    {
        throw std::invalid_argument("Number of arguments doesn't match the size of the vector.");
    }
    int index = 0;
    (([&](){
        if constexpr (std::is_integral_v<Args>)
        {
            args = std::stoi(vec[index++]);
        }
        else if constexpr (std::is_same_v<Args, std::string>)
        {
            args = vec[index++];
        }
        else
        {
            throw std::invalid_argument("Unsupported argument type.");
        }
    }()), ...);
}

方法二：提取逻辑到辅助函数 #

把类型判断和赋值逻辑封装到单独的模板辅助函数中，在折叠表达式里调用该函数：

template <typename T>
void assignValue(std::vector<std::string>& vec, int& index, T& arg)
{
    if constexpr (std::is_integral_v<T>)
    {
        arg = std::stoi(vec[index++]);
    }
    else if constexpr (std::is_same_v<T, std::string>)
    {
        arg = vec[index++];
    }
    else
    {
        throw std::invalid_argument("Unsupported argument type.");
    }
}

template <typename... Args>
void populateArgs(std::vector<std::string>& vec, Args&... args)
{
    const size_t numArgs = sizeof...(Args);
    if (vec.size() != numArgs)
    {
        throw std::invalid_argument("Number of arguments doesn't match the size of the vector.");
    }
    int index = 0;
    (assignValue(vec, index, args), ...);
}

补充说明 #

两种方案均能保留原有逻辑并通过编译：

• 方法一更紧凑，适合简单逻辑场景；
• 方法二更清晰，逻辑分离后便于后续扩展支持更多类型。

修改后的代码可正常输出预期结果：a = 1, b = 2, c = 3, d = hello。

内容的提问来源于stack exchange，提问作者Ferenc Deak