Cara paling elegan untuk menulis satu jepretan 'jika'

Sejak C ++ 17 seseorang dapat menulis ifblok yang akan dieksekusi persis seperti ini:

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

    }
}

Saya tahu saya mungkin terlalu memikirkan ini, dan ada cara lain untuk menyelesaikannya, tetapi tetap - apakah mungkin untuk menulis ini dengan cara seperti ini, jadi tidak perlu do_once = falsebagian akhir?

if (DO_ONCE) {
    // Do stuff
}

Saya sedang memikirkan fungsi pembantu do_once(),, berisi static bool do_once, tetapi bagaimana jika saya ingin menggunakan fungsi yang sama di tempat yang berbeda? Mungkinkah ini waktu dan tempat untuk #define? Saya harap tidak.

Penggunaan std::exchange:

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

Anda dapat mempersingkatnya dengan membalikkan nilai kebenaran:

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

Tetapi jika Anda sering menggunakan ini, jangan berlebihan dan buatlah pembungkus sebagai gantinya:

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

Dan gunakan seperti:

if (static Once once; once)

Variabel tidak seharusnya direferensikan di luar kondisi tersebut, sehingga nama tidak banyak membeli. Mengambil inspirasi dari bahasa lain seperti Python yang memberikan arti khusus pada _pengenalnya, kami dapat menulis:

if (static Once _; _)

Perbaikan lebih lanjut: manfaatkan bagian BSS (@Deduplicator), hindari penulisan memori ketika kita sudah menjalankan (@ShadowRanger), dan berikan petunjuk prediksi cabang jika Anda akan menguji berkali-kali (misalnya seperti dalam pertanyaan):

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

Mungkin bukan solusi yang paling elegan dan Anda tidak melihat yang sebenarnya if, tetapi pustaka standar sebenarnya mencakup kasus ini :, lihat std::call_once.

#include <mutex>

std::once_flag flag;

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

Keuntungannya di sini adalah benang ini aman.

C ++ memang memiliki primitif aliran kontrol bawaan yang terdiri dari "( before-block; condition; after-block )" sudah:

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

Atau lebih hack, tapi lebih pendek:

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

Namun, menurut saya teknik apa pun yang disajikan di sini harus digunakan dengan hati-hati, karena tidak (belum?) Sangat umum.

Di C ++ 17 Anda bisa menulis

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

untuk menghindari bermain-main dengan idi tubuh lingkaran. idimulai dengan 0 (dijamin oleh standar), dan ekspresi setelah ;disetel ike1 pertama kali dievaluasi.

Perhatikan bahwa di C ++ 11 Anda bisa mencapai hal yang sama dengan fungsi lambda

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

yang juga membawa sedikit keuntungan karena itidak bocor ke loop body.

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

Solusi ini aman untuk utas (tidak seperti banyak saran lainnya).

Anda bisa menggabungkan tindakan satu kali dalam konstruktor objek statis yang Anda buat sebagai pengganti kondisional.

Contoh:

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

Atau Anda mungkin tetap menggunakan makro, yang mungkin terlihat seperti ini:

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

Seperti yang dikatakan @damon, Anda dapat menghindari penggunaan std::exchangedengan menggunakan decrementing integer, tetapi Anda harus ingat bahwa nilai negatif berubah menjadi true. Cara menggunakannya adalah:

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

Menerjemahkan ini ke bungkus mewah @ Acorn akan terlihat seperti ini:

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

Meskipun menggunakan std::exchangeseperti yang disarankan oleh @Acorn mungkin adalah cara yang paling idiomatis, operasi pertukaran tidak selalu murah. Meskipun tentu saja inisialisasi statis dijamin aman untuk thread (kecuali jika Anda memberi tahu kompiler Anda untuk tidak melakukannya), jadi pertimbangan apa pun tentang kinerja agak sia-sia dengan adanyastatic kata kunci.

Jika Anda khawatir tentang pengoptimalan mikro (seperti yang sering dilakukan orang yang menggunakan C ++), Anda dapat menggaruk booldan menggunakan intsebagai gantinya, yang akan memungkinkan Anda untuk menggunakan penurunan pasca (atau lebih tepatnya, kenaikan , tidak seperti boolpenurunan yang tidakint akan jenuh ke nol ...):

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

Dulu booloperator tersebut memiliki operator increment / decrement, tetapi sudah lama tidak digunakan lagi (C ++ 11? Tidak yakin?) Dan harus dihapus seluruhnya dalam C ++ 17. Namun demikian, Anda dapat menurunkan fileint baik, dan itu tentu saja akan bekerja sebagai kondisi Boolean.

Bonus: Anda dapat menerapkan do_twiceatau do_thriceserupa ...

Berdasarkan jawaban bagus @ Batsyeba untuk ini - hanya membuatnya lebih sederhana.

Di C++ 17, Anda cukup melakukan:

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

(Di versi sebelumnya, cukup nyatakan di int iluar blok. Juga berfungsi di C :)).

Dengan kata sederhana: Anda mendeklarasikan i, yang mengambil nilai default nol ( 0). Nol adalah falsey, oleh karena itu kami menggunakan !operator tanda seru ( ) untuk meniadakannya. Kami kemudian memperhitungkan properti increment dari<ID>++ operator, yang pertama diproses (ditugaskan, dll) dan kemudian bertambah.

Oleh karena itu, di blok ini, saya akan diinisialisasi dan memiliki nilai 0 hanya satu kali, ketika blok dieksekusi, maka nilainya akan meningkat. Kami hanya menggunakan !operator untuk meniadakannya.