Найелегантніший спосіб записати один кадр "якщо"

Оскільки на C ++ 17 можна записати ifблок, який буде виконуватися точно один раз так:

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

    }
}

Я знаю, що я можу це переосмислити, і є інші способи вирішити це, але все-таки - чи можна це написати якось так, так що немає потреби do_once = falseв кінці?

if (DO_ONCE) {
    // Do stuff
}

Я думаю про функцію помічника do_once(), що містить static bool do_once, але що робити, якщо я хотів використовувати ту саму функцію в різних місцях? Може це час і місце для #define? Я сподіваюся, що ні.

Використання std::exchange:

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

Ви можете скоротити зворотне значення значення істини:

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

Але якщо ви багато використовуєте це, не будьте фантазією, а натомість створіть обгортку:

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

І використовувати його так:

if (static Once once; once)

На змінну не слід посилатися поза умовою, тому ім'я не сильно купує нас. Беручи натхнення з інших мов, таких як Python, які надають особливого значення _ідентифікатору, ми можемо написати:

if (static Once _; _)

Подальші вдосконалення: скористайтеся розділом BSS (@Deduplicator), уникайте запису в пам'ять, коли ми вже запущено (@ShadowRanger), і дайте підказку передбачення гілки, якщо ви збираєтеся тестувати багато разів (наприклад, як у запитанні):

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

Можливо, не найелегантніше рішення і ви не бачите жодного актуального if, але стандартна бібліотека насправді охоплює цей випадок:, див std::call_once.

#include <mutex>

std::once_flag flag;

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

Перевагою тут є те, що це безпечно для ниток.

C ++ має вбудований примітивний потік управління, який складається з "( перед блоком; умова; після блоку )":

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

Або хакітніше, але коротше:

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

Однак я вважаю, що будь-яку з методик, представлених тут, слід використовувати обережно, оскільки вони (поки що не є) дуже поширеними.

На C ++ 17 можна писати

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

щоб уникнути гри iв корпусі петлі. iпочинається з 0 (гарантованим стандартом), а вираз після ;множин iв 1перший раз вона обчислюється.

Зауважте, що в C ++ 11 ви можете досягти того ж за допомогою лямбда-функції

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

що також має незначну перевагу в тому, що iвін не просочується в корпус петлі.

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

Це рішення є безпечним для ниток (на відміну від багатьох інших пропозицій).

Ви можете зафіксувати одноразову дію в конструкторі статичного об'єкта, який ви інстанціюєте замість умовного.

Приклад:

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

Або ви дійсно можете дотримуватися макросу, який може виглядати приблизно так:

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

Як сказав @damon, ви можете уникнути використання std::exchange, використовуючи ціле число, що зменшується, але ви повинні пам'ятати, що негативні значення вирішуються на істинні. Способом використання цього було б:

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

Переклад цього на вигадливу обгортку @ Acorn виглядатиме так:

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

Хоча використання, std::exchangeяк запропонував @Acorn, мабуть, самий ідіоматичний спосіб, операція обміну не обов'язково є дешевою. Хоча, звичайно, статична ініціалізація гарантовано є безпечною для потоків (якщо ви не скажете вашому компілятору цього не робити), тому будь-які міркування щодо продуктивності все одно дещо марні в присутностіstatic ключового слова.

Якщо ви стурбовані мікро-оптимізація (як люди , що використовують C ++ часто), ви могли б, а подряпати boolі використовувати intзамість цього, що дозволить використовувати постдекремент (або , вірніше, приріст , оскільки в відміну від boolдекремента intбуде НЕ насичувати до нуля ...):

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

Це раніше boolбуло операторів збільшення / зменшення, але вони давно застаріли (C ++ 11? Не впевнені?) І повинні бути повністю видалені в C ++ 17. Тим не менш, ви можете декрементуватиint справедливий штраф, і це, звичайно, буде спрацьовувати як булева умова.

Бонус: Ви можете реалізувати do_twiceабо do_thriceаналогічно ...

На основі чудової відповіді на це @ Вірсавія - просто зробив це ще простіше.

В C++ 17, ви можете просто зробити:

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

(У попередніх версіях просто оголосити int iпоза блоком. Також працює в C :)).

Простими словами: ви оголошуєте i, що приймає за замовчуванням значення zero ( 0). Нуль - це фальси, тому ми використовуємо !оператор оклику ( ), щоб заперечувати це. Потім ми враховуємо приріст властивості<ID>++ оператора, який спочатку обробляється (призначається тощо), а потім збільшується.

Тому в цьому блоці я буду ініціалізований і матиме значення 0лише один раз, коли блок буде виконаний, і тоді значення збільшиться. Ми просто використовуємо !оператор, щоб заперечувати його.