A maneira mais elegante de escrever um único 'se'

Desde o C ++ 17, é possível escrever um ifbloco que será executado exatamente uma vez assim:

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

    }
}

Eu sei que posso estar pensando demais nisso, e há outras maneiras de resolver isso, mas ainda assim - é possível escrever isso de alguma forma assim, para que não haja necessidade de do_once = falseno final?

if (DO_ONCE) {
    // Do stuff
}

Estou pensando em uma função auxiliar do_once(), contendo o static bool do_once, mas e se eu quisesse usar a mesma função em lugares diferentes? Pode ser esse o momento e o local para um #define? Espero que não.

Use std::exchange:

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

Você pode diminuir a reversão do valor verdade:

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

Mas se você estiver usando muito isso, não seja chique e crie um wrapper:

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

E use-o como:

if (static Once once; once)

A variável não deve ser referenciada fora da condição, portanto o nome não nos compra muito. Inspirando-se em outras linguagens como Python, que dão um significado especial ao _identificador, podemos escrever:

if (static Once _; _)

Outras melhorias: tire proveito da seção BSS (@Duplicator), evite a gravação na memória quando já executamos (@ShadowRanger) e dê uma dica de previsão de ramificação se você for testar várias vezes (por exemplo, como na pergunta):

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

Talvez não seja a solução mais elegante e você não veja nenhuma if, mas a biblioteca padrão realmente cobre esse caso :, veja std::call_once.

#include <mutex>

std::once_flag flag;

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

A vantagem aqui é que isso é seguro para threads.

O C ++ possui uma primitiva de fluxo de controle integrada que consiste em "( antes do bloco; condição; pós-bloco )" já:

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

Ou mais hackier, mas mais curto:

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

No entanto, acho que qualquer uma das técnicas apresentadas aqui deve ser usada com cuidado, pois não são (ainda?) Muito comuns.

No C ++ 17 você pode escrever

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

para evitar brincar com io corpo do laço. icomeça com 0 (garantido pelo padrão) e a expressão após os ;conjuntos ipara 1a primeira vez que é avaliada.

Observe que no C ++ 11 você pode conseguir o mesmo com uma função lambda

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

o que também traz uma pequena vantagem, pois inão vaza para o corpo do loop.

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

Esta solução é segura para threads (ao contrário de muitas das outras sugestões).

Você pode agrupar a ação única no construtor de um objeto estático que você instancia no lugar da condicional.

Exemplo:

#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 você pode realmente ficar com uma macro, que pode ser algo como isto:

#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 o @damon disse, você pode evitar o uso std::exchangeusando um número inteiro decrescente, mas é preciso lembrar que os valores negativos são verdadeiros. A maneira de usar isso seria:

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

Traduzir isso para o invólucro sofisticado da @ Acorn ficaria assim:

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

Embora o uso std::exchangesugerido pelo @Acorn seja provavelmente a maneira mais idiomática, uma operação de troca não é necessariamente barata. Embora seja claro que a inicialização estática é garantida como segura para threads (a menos que você diga ao seu compilador para não fazê-lo), qualquer consideração sobre desempenho é algo fútil de qualquer maneira na presença da staticpalavra - chave.

Se você está preocupado com a micro-otimização (como costumam usar as pessoas que usam C ++), também pode boolusar e fazer scratch int, o que permitirá que você use o pós-decremento (ou melhor, o incremento , pois, ao contrário do booldecrementar de um int, não saturará zero) ...):

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

Costumava ter booloperadores de incremento / decremento, mas eles foram preteridos há muito tempo (C ++ 11? Não tenho certeza?) E devem ser totalmente removidos no C ++ 17. No entanto, você pode diminuir uma intmulta e, é claro, funcionará como uma condição booleana.

Bônus: Você pode implementar do_twiceou do_thricesimilarmente ...

Com base na ótima resposta da @ Bathsheba para isso - simplificou ainda mais.

Em C++ 17, você pode simplesmente fazer:

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

(Nas versões anteriores, basta declarar int ifora do bloco. Também funciona em C :)).

Em palavras simples: você declara i, que assume o valor padrão de zero ( 0). Zero é falsey, portanto, usamos o !operador de ponto de exclamação ( ) para negá-lo. Em seguida, levamos em conta a propriedade de incremento do <ID>++operador, que primeiro é processada (atribuída etc.) e depois incrementada.

Portanto, neste bloco, eu serei inicializado e só terá o valor 0uma vez, quando o bloco for executado, e o valor aumentará. Simplesmente usamos o !operador para negá-lo.