Il modo più elegante per scrivere un 'if' one-shot

Dal momento che C ++ 17 è possibile scrivere un ifblocco che verrà eseguito esattamente una volta in questo modo:

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

    }
}

So che potrei pensare troppo a questo, e ci sono altri modi per risolverlo, ma ancora - è possibile scrivere questo in qualche modo in questo modo, quindi alla fine non è necessario do_once = false?

if (DO_ONCE) {
    // Do stuff
}

Sto pensando a una funzione di supporto do_once(), contenente il static bool do_once, ma se volessi usare la stessa funzione in luoghi diversi? Potrebbe essere questo il momento e il luogo per un #define? Spero di no.

Utilizzare std::exchange:

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

Puoi renderlo più breve invertendo il valore di verità:

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

Ma se lo usi molto, non essere sofisticato e crea un wrapper:

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

E usalo come:

if (static Once once; once)

La variabile non dovrebbe essere referenziata al di fuori della condizione, quindi il nome non ci compra molto. Prendendo ispirazione da altre lingue come Python che danno un significato speciale _all'identificatore, possiamo scrivere:

if (static Once _; _)

Ulteriori miglioramenti: approfitta della sezione BSS (@Deduplicator), evita la scrittura della memoria quando abbiamo già eseguito (@ShadowRanger) e dai un suggerimento sulla previsione del ramo se hai intenzione di testare più volte (ad es. Come nella domanda):

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

Forse non è la soluzione più elegante e non vedi alcun reale if, ma la libreria standard in realtà copre questo caso :, vedi std::call_once.

#include <mutex>

std::once_flag flag;

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

Il vantaggio qui è che questo è thread-safe.

Il C ++ ha una primitiva del flusso di controllo integrata che consiste già di "( blocco precedente; condizione; blocco successivo )":

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

O hacker, ma più breve:

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

Tuttavia, penso che una qualsiasi delle tecniche presentate qui dovrebbe essere usata con cura, poiché non sono (ancora?) Molto comuni.

In C ++ 17 puoi scrivere

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

per evitare di giocare con iil corpo del loop. iinizia con 0 (garantito dallo standard) e l'espressione dopo gli ;insiemi viene valutata iper 1la prima volta.

Si noti che in C ++ 11 è possibile ottenere lo stesso risultato con una funzione lambda

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

che porta anche un leggero vantaggio in quanto inon è trapelato nel corpo del circuito.

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

Questa soluzione è thread-safe (a differenza di molti altri suggerimenti).

È possibile racchiudere l'azione una tantum nel costruttore di un oggetto statico che si crea un'istanza al posto del condizionale.

Esempio:

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

Oppure potresti davvero rimanere con una macro, che potrebbe assomigliare a questa:

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

Come ha detto @damon, puoi evitare di usare std::exchangeusando un numero intero decrescente, ma devi ricordare che i valori negativi si risolvono in vero. Il modo di utilizzare questo sarebbe:

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

Tradurre questo nel wrapper di fantasia di @ Acorn sarebbe simile al seguente:

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

Mentre l'utilizzo std::exchangecome suggerito da @Acorn è probabilmente il modo più idiomatico, un'operazione di scambio non è necessariamente economica. Sebbene, ovviamente, l'inizializzazione statica sia garantita come thread-safe (a meno che non si dica al compilatore di non farlo), quindi qualsiasi considerazione sulle prestazioni è in qualche modo futile in presenza della staticparola chiave.

Se siete preoccupati per micro-ottimizzazione (come le persone che utilizzano C ++ spesso sono), si potrebbe pure graffiare boole utilizzare intinvece, che vi permetterà di utilizzare post-decremento (o meglio, di incremento , come a differenza di booldecremento di intsi non saturare a zero ...):

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

In passato boolc'erano operatori di incremento / decremento, ma erano stati deprecati molto tempo fa (C ++ 11? Non sei sicuro?) E dovevano essere rimossi del tutto in C ++ 17. Tuttavia puoi decrementare una intmulta, e ovviamente funzionerà come una condizione booleana.

Bonus: è possibile implementare do_twiceo in do_thricemodo simile ...

Basato sulla grande risposta di @ Bathsheba per questo, è stato ancora più semplice.

In C++ 17, puoi semplicemente fare:

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

(Nelle versioni precedenti, basta dichiarare int ifuori dal blocco. Funziona anche in C :)).

In parole semplici: dichiari i, che assume il valore predefinito zero ( 0). Zero è falso, quindi utilizziamo l' !operatore punto esclamativo ( ) per negarlo. Quindi prendiamo in considerazione la proprietà di incremento <ID>++dell'operatore, che viene prima elaborata (assegnata, ecc.) E quindi incrementata.

Pertanto, in questo blocco, sarò inizializzato e avrò il valore 0solo una volta, quando il blocco verrà eseguito, e quindi il valore aumenterà. Usiamo semplicemente l' !operatore per negarlo.