Najbardziej elegancki sposób na jednorazowe „jeśli”

Od C ++ 17 można napisać ifblok, który zostanie wykonany dokładnie raz w ten sposób:

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

    }
}

Wiem, że mogę się nad tym zastanawiać i są inne sposoby rozwiązania tego problemu, ale nadal - czy można to jakoś napisać w ten sposób, więc do_once = falsena końcu nie ma potrzeby ?

if (DO_ONCE) {
    // Do stuff
}

Myślę o funkcji pomocniczej do_once()zawierającej static bool do_once, ale co jeśli chciałbym użyć tej samej funkcji w różnych miejscach? Czy to może być czas i miejsce na spotkanie #define? Mam nadzieję, że nie.

Zastosowanie std::exchange:

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

Możesz go skrócić, odwracając wartość prawdy:

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

Ale jeśli często tego używasz, nie bądź wyszukany i zamiast tego utwórz opakowanie:

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

I używaj go jak:

if (static Once once; once)

Do zmiennej nie należy odwoływać się poza warunkiem, więc nazwa niewiele nas kupuje. Czerpiąc inspirację z innych języków, takich jak Python, które nadają _identyfikatorowi specjalne znaczenie , możemy napisać:

if (static Once _; _)

Dalsze ulepszenia: skorzystaj z sekcji BSS (@Deduplicator), unikaj zapisu do pamięci, gdy już uruchomiliśmy (@ShadowRanger) i daj wskazówkę dotyczącą przewidywania gałęzi, jeśli zamierzasz testować wiele razy (np. Jak w pytaniu):

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

Może nie jest to najbardziej eleganckie rozwiązanie i nie widzisz żadnego rzeczywistego if, ale standardowa biblioteka faktycznie obejmuje ten przypadek: patrz std::call_once.

#include <mutex>

std::once_flag flag;

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

Zaletą jest to, że jest to bezpieczne dla wątków.

C ++ ma wbudowaną operację podstawową przepływu sterowania, która już składa się z „( przed blokiem; warunek; po bloku )”:

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

Lub trudniejszy, ale krótszy:

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

Uważam jednak, że każdej z przedstawionych tu technik należy używać ostrożnie, ponieważ nie są (jeszcze?) Bardzo powszechne.

W C ++ 17 możesz pisać

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

aby uniknąć zabawy z ikorpusem pętli. izaczyna się od 0 (gwarantowane przez standard), a wyrażenie po ;zestawach ido 1pierwszej oceny.

Zauważ, że w C ++ 11 możesz osiągnąć to samo dzięki funkcji lambda

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

co również ma niewielką zaletę polegającą na tym, że inie przecieka do korpusu pętli.

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

To rozwiązanie jest bezpieczne dla wątków (w przeciwieństwie do wielu innych sugestii).

Możesz opakować jednorazową akcję w konstruktorze statycznego obiektu, którego instancję tworzysz zamiast warunku.

Przykład:

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

Lub możesz trzymać się makra, które może wyglądać mniej więcej tak:

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

Jak powiedział @damon, możesz uniknąć używania std::exchangezmniejszającej się liczby całkowitej, ale musisz pamiętać, że wartości ujemne są rozwiązywane na prawdę. Sposób na to byłby:

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

Tłumaczenie tego na fantazyjne opakowanie @ Acorn wyglądałoby tak:

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

O ile korzystanie std::exchangezgodnie z sugestią @Acorn jest chyba najbardziej idiomatycznym sposobem, operacja wymiany niekoniecznie jest tania. Chociaż oczywiście statyczna inicjalizacja jest gwarantowana jako bezpieczna wątkowo (chyba że powiesz kompilatorowi, aby tego nie robił), więc wszelkie rozważania dotyczące wydajności są i tak daremne w obecnościstatic słowa kluczowego.

Jeśli obawiasz się o mikro optymalizacji (jako osób korzystających z C ++ często są), można także zarysować booli używać intzamiast, który pozwoli Ci korzystać z post-ubytek (lub raczej przyrost , jak w przeciwieństwie boolzmniejszanie intbędzie nie nasycić do zera ...):

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

Kiedyś boolmiały operatory inkrementacji / dekrementacji, ale zostały one przestarzałe dawno temu (C ++ 11? Nie jesteś pewien?) I mają zostać całkowicie usunięte w C ++ 17. Niemniej jednak możesz zmniejszyćint sprawiedliwą karę i będzie to oczywiście działało jako warunek logiczny.

Bonus: możesz wdrożyć do_twicelub do_thricepodobnie ...

W oparciu o świetną odpowiedź @ Bathsheby - po prostu uczyniłem to jeszcze prostszym.

W C++ 17możesz po prostu:

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

(W poprzednich wersjach po prostu zadeklaruj int ipoza blokiem. Działa również w C :)).

W prostych słowach: deklarujesz i, które przyjmuje domyślną wartość zero ( 0). Zero to fałsz, dlatego używamy !operatora wykrzyknika ( ), aby go zanegować. Następnie bierzemy pod uwagę właściwość inkrementacji <ID>++operatora, która najpierw jest przetwarzana (przypisywana itp.), A następnie zwiększana.

Dlatego w tym bloku zostanie zainicjowany i będzie miał wartość 0tylko raz, kiedy blok zostanie wykonany, a następnie wartość wzrośnie. Po prostu używamy !operatora, aby to zanegować.