La forma más elegante de escribir un 'si'

Desde C ++ 17 se puede escribir un ifbloque que se ejecutará exactamente una vez como esta:

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

    }
}

Sé que podría estar pensando demasiado en esto, y hay otras formas de resolver esto, pero aún así, ¿es posible escribir esto de alguna manera como esta, por lo que no hay necesidad del do_once = falsefinal?

if (DO_ONCE) {
    // Do stuff
}

Estoy pensando en una función auxiliar do_once(), que contiene el static bool do_once, pero ¿qué pasa si quisiera usar esa misma función en diferentes lugares? ¿Podría ser este el momento y el lugar para un #define? Espero que no.

Uso std::exchange:

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

Puede acortarlo invirtiendo el valor de verdad:

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

Pero si está usando esto mucho, no sea elegante y cree un envoltorio en su lugar:

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

Y úsalo como:

if (static Once once; once)

No se debe hacer referencia a la variable fuera de la condición, por lo que el nombre no nos compra mucho. Inspirándonos en otros lenguajes como Python que le dan un significado especial al _identificador, podemos escribir:

if (static Once _; _)

Mejoras adicionales: aproveche la sección BSS (@Deduplicator), evite la escritura en la memoria cuando ya la hemos ejecutado (@ShadowRanger) y brinde una sugerencia de predicción de rama si va a realizar pruebas muchas veces (por ejemplo, como en la pregunta):

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

Quizás no sea la solución más elegante y no vea ninguna real if, pero la biblioteca estándar en realidad cubre este caso :, vea std::call_once.

#include <mutex>

std::once_flag flag;

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

La ventaja aquí es que esto es seguro para subprocesos.

C ++ tiene una primitiva de flujo de control integrada que consiste en "( antes del bloque; condición; después del bloque )" ya:

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

O más pirateado, pero más corto:

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

Sin embargo, creo que cualquiera de las técnicas presentadas aquí debe usarse con cuidado, ya que no son (¿todavía?) Muy comunes.

En C ++ 17 puedes escribir

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

para evitar jugar con iel cuerpo del bucle. icomienza con 0 (garantizados por la norma), y la expresión después de los ;conjuntos ia 1la primera vez que se evalúa.

Tenga en cuenta que en C ++ 11 podría lograr lo mismo con una función lambda

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

lo que también conlleva una ligera ventaja ya que ino se filtra en el cuerpo del bucle.

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

Esta solución es segura para subprocesos (a diferencia de muchas de las otras sugerencias).

Puede ajustar la acción de una sola vez en el constructor de un objeto estático que instancia en lugar del condicional.

Ejemplo:

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

O, de hecho, puede quedarse con una macro, que puede verse así:

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

Como dijo @damon, puede evitar el uso std::exchangeutilizando un número entero decreciente, pero debe recordar que los valores negativos se resuelven en verdaderos. La forma de usar esto sería:

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

Traducir esto al elegante envoltorio de @ Acorn se vería así:

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 bien usar std::exchangesegún lo sugerido por @Acorn es probablemente la forma más idiomática, una operación de intercambio no es necesariamente barata. Aunque, por supuesto, se garantiza que la inicialización estática sea segura para subprocesos (a menos que le indique a su compilador que no lo haga), por lo que cualquier consideración sobre el rendimiento es algo inútil de todos modos en presencia de la staticpalabra clave.

Si usted está preocupado por micro-optimización (como las personas que usan C ++ son a menudo), usted podría así rayar booly utilizar inten su lugar, lo que le permitirá el uso post-decremento (o más bien, de la subasta , ya que a diferencia booldecrementar una intserá no saturar a cero ...):

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

Solía ​​ser que booltenía operadores de incremento / decremento, pero fueron desaprobados hace mucho tiempo (C ++ 11? No estoy seguro?) Y deben eliminarse por completo en C ++ 17. Sin embargo, puede disminuir una intmulta y, por supuesto, funcionará como una condición booleana.

Bonificación: puede implementar do_twiceo do_thricesimilar ...

Basado en la gran respuesta de @ Bathsheba para esto, simplemente lo hizo aún más simple.

En C++ 17, simplemente puedes hacer:

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

(En versiones anteriores, simplemente declara int ifuera del bloque. También funciona en C :)).

En palabras simples: declaras i, que toma el valor predeterminado de cero ( 0). Zero es falsey, por lo tanto, utilizamos el !operador de signo de exclamación ( ) para negarlo. Luego tomamos en cuenta la propiedad de incremento del <ID>++operador, que primero se procesa (asigna, etc.) y luego se incrementa.

Por lo tanto, en este bloque, se inicializará y tendré el valor 0solo una vez, cuando se ejecute el bloque, y luego el valor aumentará. Simplemente usamos el !operador para negarlo.