具有延迟初始化局部变量的 constexpr 函数

Question

我正在尝试编写一个constexpr 形式的函数：

constexpr int foo(bool cond) {
    int a, b, c;
    if (cond) {
        a = 1;
        b = 2;
        c = 3;
    }
    else {
        a = -1;
        b = -2;
        c = -3;
    }

    return a + b + c;
}

然而，编译器抱怨我使用了未初始化的变量，尽管局部变量的最终初始化是有保证的。

我可以重写函数以使用三元运算符，即int a = cond ? 1 : -1; 等，但我不希望这样做。有没有办法让编译器相信局部变量会被初始化？

Answer 1

然而，编译器抱怨我使用了一个未初始化的变量，尽管局部变量的最终初始化是有保证的。

初始化，或者不初始化，没有“最终初始化”。而且，对于constexpr 函数，有一个要求，在 [dcl.constexpr] 中：

constexpr 函数的定义应满足以下要求：[...] 它的 function-body 应为 = delete、= default 或 compound-声明不包含[...]非文字类型或静态或线程存储持续时间的变量的定义，或没有 执行初始化。

constexpr 函数中不能有未初始化的变量，这就是 a、b 和 c 适合你的。

那你能做什么？您可以将a、b 和c 初始化为零。这绕过了这个要求。或者您可以在if 的每个作用域内初始化a、b 和c。或者您可以推迟到另一个 constexpr 函数进行求和：

constexpr int f(int a, int b, int c) { return a+b+c; };

constexpr int foo(bool cond) {    
    if (cond) {
        return f(1,2,3);
    }
    else {
        return f(-1,-2,-3);
    }    
}

有很多方法可以解决这个问题。

Answer 2

然而，编译器抱怨我使用了一个未初始化的变量，尽管局部变量的最终初始化是有保证的。

该标准要求初始化constexpr 函数中的所有局部变量。

来自§7.1.5, par. 3([dcl.constexpr])：

constexpr 函数的定义应满足以下要求：[...]

其函数体应为= delete、= default，或不包含[...]的复合语句

非文字类型或静态或线程存储持续时间或不执行初始化的变量的定义。 [...]

constexpr int uninit() {
    int a;     // error: variable is uninitialized
    return a;
}

---

在 C++17 中，您可以使用 std::tuple、structured bindings 和 IIFE (immediately-invoked function expression) 来保留原始结构：

constexpr int foo(bool cond) 
{
    const auto [a, b, c] = [&cond]
    {
        if (cond) 
        {
            return std::tuple(1, 2, 3);
        }
        else
        {
            return std::tuple(-1, -2, -3);
        }    
    }();

    return a + b + c;
}

由于您的条件和分支是微不足道的，一个 三元运算符 就足够了。如果将来您的初始化逻辑变得更复杂，上面的代码 sn-p 可能会对您有所帮助，但下面的代码应该足够好：

constexpr int foo(bool cond) 
{
    const auto [a, b, c] = cond ? std::tuple(1, 2, 3)
                                : std::tuple(-1, -2, -3);

    return a + b + c;
}

---

在 C++14 中，您可以使用 std::make_tuple 和 std::get 代替：

constexpr int foo(bool cond) 
{
    const auto abc = cond ? std::make_tuple(1, 2, 3) 
                          : std::make_tuple(-1, -2, -3);

    return std::get<0>(abc) + std::get<1>(abc) + std::get<2>(abc);
}

---

在 C++11 中，您可以将函数拆分为两个较小的函数：

template <typename TTuple>
constexpr int sum3(const TTuple& abc)
{
    return std::get<0>(abc) + std::get<1>(abc) + std::get<2>(abc);
}

constexpr int foo(bool cond) 
{
    return cond ? sum3(std::make_tuple(1, 2, 3)) 
                : sum3(std::make_tuple(-1, -2, -3));   
}

如果你决定走那条路，Barry's solution 肯定会更好。

---

以上所有解决方案：

• 让你的a、b、c变量const，这总是一件好事。

• 仅对cond 执行一次检查，以便与 OP 中的代码结构非常相似。

Answer 3

@Borgleader 方式就够了：

constexpr int foo(bool cond) {
    int a=0, b=0, c=0;
    if (cond) {
        a = 1;
        b = 2;
        c = 3;
    }
    else {
        a = -1;
        b = -2;
        c = -3;
    }

    return a + b + c;
}

在 C++11 中编译没有错误，并且仅警告 constexpr 函数中的变量声明是 C++14 扩展，并且在 C++14 模式下没有警告（使用 CLang 3.4. 1)

这是干净、易于阅读和编写并且接近原始代码的代码。但毫无疑问，@Barry's solution 更好。