Die eleganteste Art, ein One-Shot-If zu schreiben

Seit C ++ 17 kann man einen ifBlock schreiben , der genau einmal so ausgeführt wird:

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

    }
}

Ich weiß, dass ich das vielleicht überdenke, und es gibt andere Möglichkeiten, dies zu lösen, aber dennoch - ist es möglich, dies irgendwie so zu schreiben, so dass es do_once = falseam Ende nicht nötig ist ?

if (DO_ONCE) {
    // Do stuff
}

Ich denke an eine Hilfsfunktion, do_once() , die die enthält static bool do_once, aber was ist, wenn ich dieselbe Funktion an verschiedenen Orten verwenden möchte? Könnte dies die Zeit und der Ort für eine sein #define? Ich hoffe nicht.

Verwendung std::exchange:

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

Sie können es kürzer machen, indem Sie den Wahrheitswert umkehren:

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

Aber wenn Sie dies häufig verwenden, seien Sie nicht schick und erstellen Sie stattdessen einen Wrapper:

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

Und benutze es wie:

if (static Once once; once)

Die Variable sollte nicht außerhalb der Bedingung referenziert werden, daher kauft uns der Name nicht viel. Wir lassen uns von anderen Sprachen wie Python inspirieren , die dem _Bezeichner eine besondere Bedeutung geben , und schreiben möglicherweise:

if (static Once _; _)

Weitere Verbesserungen: Nutzen Sie den BSS-Abschnitt (@Deduplicator), vermeiden Sie das Schreiben des Speichers, wenn wir ihn bereits ausgeführt haben (@ShadowRanger), und geben Sie einen Hinweis zur Verzweigungsvorhersage, wenn Sie mehrmals testen möchten (z. B. wie in der Frage):

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

Vielleicht nicht die eleganteste Lösung, und Sie sehen keine tatsächliche if, aber die Standardbibliothek deckt diesen Fall tatsächlich ab std::call_once.

#include <mutex>

std::once_flag flag;

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

Der Vorteil hierbei ist, dass dies threadsicher ist.

C ++ verfügt bereits über ein integriertes Kontrollflussprimitiv, das aus "( vor dem Block; Bedingung; nach dem Block )" besteht:

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

Oder hackiger, aber kürzer:

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

Ich denke jedoch, dass jede der hier vorgestellten Techniken mit Vorsicht angewendet werden sollte, da sie (noch?) Nicht sehr häufig sind.

In C ++ 17 können Sie schreiben

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

um nicht iim Loop-Body herumzuspielen. ibeginnt mit 0 (vom Standard garantiert) und der Ausdruck nach den ;Sätzen wird izum 1ersten Mal ausgewertet.

Beachten Sie, dass Sie in C ++ 11 dasselbe mit einer Lambda-Funktion erreichen können

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

Dies hat auch den leichten Vorteil, dass ies nicht in den Schleifenkörper gelangt.

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

Diese Lösung ist threadsicher (im Gegensatz zu vielen anderen Vorschlägen).

Sie können die einmalige Aktion in den Konstruktor eines statischen Objekts einschließen, das Sie anstelle der Bedingung instanziieren.

Beispiel:

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

Oder Sie bleiben tatsächlich bei einem Makro, das ungefähr so ​​aussieht:

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

Wie @damon sagte, können Sie die Verwendung vermeiden, std::exchangeindem Sie eine dekrementierende Ganzzahl verwenden, aber Sie müssen sich daran erinnern, dass negative Werte in true aufgelöst werden. Der Weg, dies zu benutzen, wäre:

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

Die Übersetzung in @ Acorns ausgefallenen Wrapper würde folgendermaßen aussehen:

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

Während die Verwendung std::exchangewie von @Acorn vorgeschlagen wahrscheinlich die idiomatischste Methode ist, ist eine Austauschoperation nicht unbedingt billig. Obwohl die statische Initialisierung garantiert threadsicher ist (es sei denn, Sie weisen Ihren Compiler an, dies nicht zu tun), sind Überlegungen zur Leistung bei Vorhandensein des staticSchlüsselworts ohnehin vergeblich .

Wenn Sie sich Gedanken über die Mikrooptimierung machen (wie dies bei C ++ häufig der Fall ist), können Sie diese auch kratzen boolund verwenden int, um die Nachdekrementierung (oder besser gesagt die Inkrementierung) zu verwenden , im Gegensatz zur boolDekrementierung und intwird nicht auf Null gesättigt ...):

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

Früher gab es boolInkrementierungs- / Dekrementierungsoperatoren, aber diese waren längst veraltet (C ++ 11? Nicht sicher?) Und müssen in C ++ 17 vollständig entfernt werden. Trotzdem können Sie eine intGeldstrafe dekrementieren , und es wird natürlich als boolesche Bedingung funktionieren.

Bonus: Sie können implementieren do_twiceoder do_thriceähnlich ...

Basierend auf @ Bathshebas großartiger Antwort darauf - hat es nur noch einfacher gemacht.

In C++ 17können Sie einfach tun:

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

(In früheren Versionen deklarieren Sie einfach int iaußerhalb des Blocks. Funktioniert auch in C :)).

In einfachen Worten: Sie deklarieren i, was den Standardwert Null ( 0) annimmt . Null ist falsch, daher verwenden wir den Ausrufezeichen ( !), um sie zu negieren. Wir berücksichtigen dann die Inkrement-Eigenschaft des <ID>++Operators, die zuerst verarbeitet (zugewiesen usw.) und dann inkrementiert wird.

Daher wird in diesem Block i initialisiert und hat den Wert 0nur einmal, wenn der Block ausgeführt wird, und dann erhöht sich der Wert. Wir benutzen einfach den !Operator, um es zu negieren.