La manière la plus élégante d'écrire un `` si '' unique

Depuis C ++ 17, on peut écrire un ifbloc qui sera exécuté exactement une fois comme ceci:

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

    }
}

Je sais que je réfléchis peut-être trop à cela, et il y a d'autres façons de résoudre cela, mais quand même - est-il possible d'écrire ceci d'une manière ou d'une autre comme ça, donc il n'y a pas besoin de do_once = falsela fin?

if (DO_ONCE) {
    // Do stuff
}

Je pense à une fonction d'assistance do_once(), contenant le static bool do_once, mais que faire si je voulais utiliser cette même fonction à différents endroits? Serait-ce le moment et l'endroit pour un #define? J'espère que non.

Utilisez std::exchange:

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

Vous pouvez le raccourcir en inversant la valeur de vérité:

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

Mais si vous l'utilisez beaucoup, ne soyez pas sophistiqué et créez plutôt un wrapper:

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

Et utilisez-le comme:

if (static Once once; once)

La variable n'est pas censée être référencée en dehors de la condition, donc le nom ne nous achète pas beaucoup. En s'inspirant d'autres langages comme Python qui donnent une signification particulière à l' _identifiant, on peut écrire:

if (static Once _; _)

Autres améliorations: profitez de la section BSS (@Deduplicator), évitez l'écriture en mémoire lorsque nous avons déjà exécuté (@ShadowRanger), et donnez un indice de prédiction de branche si vous allez tester plusieurs fois (par exemple comme dans la question):

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

Peut-être pas la solution la plus élégante et vous n'en voyez aucune réelle if, mais la bibliothèque standard couvre en fait ce cas:, voir std::call_once.

#include <mutex>

std::once_flag flag;

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

L'avantage ici est que c'est thread-safe.

C ++ a une primitive de flux de contrôle intégrée qui consiste déjà en "( before-block; condition; after-block )":

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

Ou plus hackeur, mais plus court:

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

Cependant, je pense que l'une des techniques présentées ici doit être utilisée avec précaution, car elles ne sont pas (encore?) Très courantes.

En C ++ 17, vous pouvez écrire

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

afin d'éviter de jouer avec idans le corps de la boucle. icommence par 0 (garanti par la norme), et l'expression après les ;ensembles ijusqu'à 1la première évaluation.

Notez qu'en C ++ 11, vous pouvez réaliser la même chose avec une fonction lambda

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

ce qui présente également un léger avantage en ce qu'il ine fuit pas dans le corps de boucle.

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

Cette solution est thread-safe (contrairement à la plupart des autres suggestions).

Vous pouvez encapsuler l'action ponctuelle dans le constructeur d'un objet statique que vous instanciez à la place du conditionnel.

Exemple:

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

Ou vous pouvez en effet vous en tenir à une macro, qui peut ressembler à ceci:

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

Comme @damon l'a dit, vous pouvez éviter d'utiliser std::exchangeen utilisant un entier décrémentant, mais vous devez vous rappeler que les valeurs négatives se résolvent en vrai. La façon d'utiliser ceci serait:

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

Traduire ceci dans le wrapper sophistiqué de @ Acorn ressemblerait à ceci:

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

Si utiliser std::exchangecomme suggéré par @Acorn est probablement le moyen le plus idiomatique, une opération d'échange n'est pas forcément bon marché. Bien que l'initialisation statique soit bien sûr sûre pour les threads (à moins que vous disiez à votre compilateur de ne pas le faire), toute considération concernant les performances est de toute façon quelque peu futile en présence du staticmot - clé.

Si vous êtes préoccupé par micro-optimisation (comme les personnes utilisant C ++ sont souvent), vous pouvez aussi bien gratter boolet utiliser à la intplace, ce qui vous permettra d'utiliser post-décrément (ou plutôt, incrément , comme la différence booldécrémentation un intsera pas sature à zéro ...):

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

Il fut un temps que boolHAD incrément / décrément opérateurs, mais ils ont été dépréciée depuis longtemps (C ++ 11? Pas sûr?) Et sont à éliminer complètement en C ++ 17. Néanmoins, vous pouvez décrémenter une intamende juste, et cela fonctionnera bien sûr comme une condition booléenne.

Bonus: vous pouvez mettre en œuvre do_twiceou de do_thricemanière similaire ...

Basé sur l'excellente réponse de @ Bathsheba à ce sujet, c'est encore plus simple.

Dans C++ 17, vous pouvez simplement faire:

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

(Dans les versions précédentes, déclarez simplement int i dehors du bloc. Fonctionne également en C :)).

En termes simples: vous déclarez i, qui prend la valeur par défaut de zéro ( 0). Zéro est faux, nous utilisons donc l' !opérateur point d'exclamation ( ) pour l'annuler. On prend alors en compte la propriété increment de la<ID>++ opérateur, qui est d'abord traitée (assignée, etc.) puis incrémentée.

Par conséquent, dans ce bloc, i sera initialisé et n'aura la valeur 0qu'une seule fois, lorsque le bloc sera exécuté, puis la valeur augmentera. Nous utilisons simplement l' !opérateur pour l'annuler.