一次性写“ if”的最优雅方式

由于C ++ 17可以编写一个if块，该块将被完全执行一次，如下所示：

#include <iostream>
int main() {
    for (unsigned i = 0; i < 10; ++i) {

        if (static bool do_once = true; do_once) { // Enter only once
            std::cout << "hello one-shot" << std::endl;
            // Possibly much more code
            do_once = false;
        }

    }
}

我知道我可能对此有过多的思考，还有其他方法可以解决此问题，但是仍然-是否可以这样写，所以do_once = false最后不需要了吗？

if (DO_ONCE) {
    // Do stuff
}

我在考虑一个do_once()包含的辅助函数，static bool do_once但是如果我想在不同的地方使用相同的函数怎么办？可能这是时间和地点#define吗？我希望不是。

用途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 ++确实具有内置的控制流原语，该原语已经由“（（before-block; condition; after-block）”）组成：

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

或更骇客，但更短：

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;
}

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

如果你关注微优化（如使用C ++往往是人），你可能还有划伤bool和使用int代替，这将允许您使用后递减（或更确切地说，增量，因为不像bool递减的int将不饱和为零...）：

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

过去bool曾经有增减运算符，但是很早以前就已弃用它们（C ++ 11？不确定吗？），并且在C ++ 17中将其完全删除。不过，您可以递减int就可以了，它当然可以作为布尔条件工作。

奖励：您可以实施do_twice或do_thrice类似地...

基于@Bathsheba的出色答案-使其变得更加简单。

在中C++ 17，您可以简单地执行以下操作：

if (static int i; !i++) {
  cout << "Execute once";
}

（在以前的版本中，只需int i在块外部声明即可。也可以在C :)中使用）。

简单来说：您声明i，它的默认值为零（0）。零是假的，因此我们使用感叹号（!）运算符将其取反。然后，我们考虑<ID>++运算符的递增属性，该属性首先被处理（分配等），然后递增。

因此，在该块中，执行块时，我将被初始化并0仅具有一次值，然后该值将增加。我们只需使用!运算符对其进行否定即可。