编写一次性“如果”的最优雅方式

使用 std::exchange：

if (static bool do_once = true; std::exchange(do_once, false))

您可以缩短反转真值：

if (static bool do_once; !std::exchange(do_once, true))

但是，如果您经常使用它，请不要花哨并创建一个包装器：

struct Once {
    bool b = true;
    explicit operator bool() { return std::exchange(b, false); }
};

并像这样使用它：

if (static Once once; once)

该变量不应该在条件之外被引用，所以这个名字并没有给我们带来太多好处。从给 _ 标识符赋予特殊含义的其他语言（如 Python）中汲取灵感，我们可以这样写：

if (static Once _; _)

进一步改进：利用 BSS 部分（@Deduplicator），避免在我们已经运行时写入内存（@ShadowRanger），如果您要进行多次测试（例如，就像问题中一样），请给出分支预测提示：

// GCC, Clang, icc only; use [[likely]] in C++20 instead
#define likely(x) __builtin_expect(!!(x), 1)

struct Once {
    bool b = false;
    explicit operator bool()
    {
        if (likely(b))
            return false;

        b = true;
        return true;
    }
};

也许不是最优雅的解决方案，而且您看不到任何实际的 if，但标准库实际上涵盖了这种情况：请参阅 std::call_once。

#include <mutex>

std::once_flag flag;

for (int i = 0; i < 10; ++i)
    std::call_once(flag, [](){ std::puts("once\n"); });

这里的优点是这是线程安全的。

C++ 确实有一个内置的控制流原语，它已经由“（前块；条件；后块）”组成：

for (static bool b = true; b; b = false)

或者更hacker，但更短：

for (static bool b; !b; b = !b)

但是，我认为这里介绍的任何技术都应该谨慎使用，因为它们（还不是？）很常见。

在 C++17 中，您可以编写

if (static int i; i == 0 && (i = 1)){

为了避免在循环体中玩弄 i。 i 以 0 开头（由标准保证），; 之后的表达式在第一次计算时将 i 设置为 1。

请注意，在 C++11 中，您可以使用 lambda 函数实现相同的目的

if ([]{static int i; return i == 0 && (i = 1);}()){

这还具有一点优势，因为 i 不会泄漏到循环体中。

static bool once = [] {
  std::cout << "Hello one-shot\n";
  return false;
}();

该解决方案是线程安全的（与许多其他建议不同）。

您可以将一次性操作包装在您实例化的静态对象的构造函数中，以代替条件。

例子：

#include <iostream>
#include <functional>

struct do_once {
    do_once(std::function<void(void)> fun) {
        fun();
    }
};

int main()
{
    for (int i = 0; i < 3; ++i) {
        static do_once action([](){ std::cout << "once\n"; });
        std::cout << "Hello World\n";
    }
}

或者您可能确实坚持使用宏，它可能看起来像这样：

#include <iostream>

#define DO_ONCE(exp) \
do { \
  static bool used_before = false; \
  if (used_before) break; \
  used_before = true; \
  { exp; } \
} while(0)  

int main()
{
    for (int i = 0; i < 3; ++i) {
        DO_ONCE(std::cout << "once\n");
        std::cout << "Hello World\n";
    }
}

就像@damon 所说，您可以通过使用递减整数来避免使用 std::exchange，但您必须记住负值解析为 true。使用它的方法是：

if (static int n_times = 3; n_times && n_times--)
{
    std::cout << "Hello world x3" << std::endl;
} 

将其转换为 @Acorn 的精美包装器将如下所示：

struct n_times {
    int n;
    n_times(int number) {
        n = number;
    };
    explicit operator bool() {
        return n && n--;
    };
};

...

if(static n_times _(2); _)
{
    std::cout << "Hello world twice" << std::endl;
}

虽然使用 @Acorn 建议的 std::exchange 可能是最惯用的方式，但交换操作不一定便宜。尽管静态初始化当然保证是线程安全的（除非您告诉编译器不要这样做），但是在存在 static 关键字的情况下，任何关于性能的考虑都是徒劳的。

如果您担心微优化（就像使用 C++ 的人一样），您也可以从头开始 bool 并改用 int，这将允许您使用后减量（或者更确切地说，increment< /em>，与 bool 不同，减少 int 将不会饱和为零...）：

if(static int do_once = 0; !do_once++)