ワンショットの「if」を書く最もエレガントな方法

C ++ 17以降ifでは、次のように1回だけ実行されるブロックを記述できます。

#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ループ本体での遊びを避けるために。i0で始まり（標準で保証）、最初の評価に;設定さiれ1た後の式。

C ++ 11ではラムダ関数で同じことを達成できることに注意してください

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

これiは、ループ本体に漏れないという点でもわずかな利点があります。

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

このソリューションはスレッドセーフです（他の多くの提案とは異なります）。

条件付きの代わりにインスタンス化する静的オブジェクトのコンストラクターで、1回限りのアクションをラップできます。

例：

#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:)でも機能します）。

簡単に言うと、デフォルト値のゼロ（0）を取るiを宣言します。ゼロは誤っているため、感嘆符（!）演算子を使用して否定します。次に、<ID>++オペレーターのインクリメントプロパティを考慮します。これは、最初に処理（割り当てなど）され、次にインクリメントされます。

したがって、このブロックで0は、ブロックが実行されたときにiが初期化されて値が1回だけになり、その後値が増加します。単に!演算子を使用してそれを否定します。