Bir kerelik 'if' yazmanın en zarif yolu

C ++ 17 beri iftam olarak böyle bir kez yürütülecek bir blok yazabilirsiniz :

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

    }
}

Bunu düşünüyor olabileceğimi biliyorum, ve bunu çözmenin başka yolları da var, ama yine de - bunu böyle bir şekilde yazmak mümkün do_once = falsemü , bu yüzden sonunda buna gerek yok mu?

if (DO_ONCE) {
    // Do stuff
}

Yardımcı bir işlev düşünüyorum do_once(), içeren static bool do_once, ama ya aynı işlevi farklı yerlerde kullanmak istersem? Bu bir zaman ve yer olabilir #definemi? Umarım değildir.

Kullanım std::exchange:

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

Gerçeğin değerini tersine çevirmeyi daha kısa yapabilirsiniz:

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

Ancak bunu çok kullanıyorsanız, süslü olmayın ve bunun yerine bir ambalaj oluşturmayın:

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

Ve şöyle kullanın:

if (static Once once; once)

Değişkenin koşul dışında referans gösterilmemesi gerekir, bu nedenle ad bizi fazla satın almaz. Tanımlayıcıya özel bir anlam veren Python gibi diğer dillerden ilham alarak _şunları yazabiliriz:

if (static Once _; _)

Diğer iyileştirmeler: BSS bölümünden (@Deduplicator) yararlanın, zaten çalıştırdığımızda bellek yazma işleminden kaçının (@ShadowRanger) ve birçok kez test edecekseniz bir dal tahmin ipucu verin (örneğin, sorudaki gibi):

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

Belki de en zarif çözüm değil ve gerçek bir şey görmüyorsunuz if, ancak standart kütüphane aslında bu durumu kapsıyor :, bkz std::call_once.

#include <mutex>

std::once_flag flag;

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

Buradaki avantaj, bunun iş parçacığı için güvenli olmasıdır.

C ++, zaten "( blok öncesi; koşul; blok sonrası )" dan oluşan yerleşik bir kontrol akış ilkeline sahiptir :

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

Veya hackier, ancak daha kısa:

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

Bununla birlikte, burada sunulan tekniklerin herhangi birinin (henüz?) Çok yaygın olmadıkları için dikkatle kullanılması gerektiğini düşünüyorum.

C ++ 17'de yazabilirsiniz

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

idöngü gövdesi ile oynamaktan kaçınmak için. i(standart tarafından garanti) 0 ile başlar ve ardından ekspresyon ;setleri iiçin 1de değerlendirilir ilk kez.

C ++ 11'de lambda işleviyle aynı şeyi başarabileceğinizi unutmayın

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

bu da iilmek gövdesine sızdırılmaması açısından hafif bir avantaj taşır .

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

Bu çözüm ipliğe karşı güvenlidir (diğer önerilerin çoğunun aksine).

Koşullu yerine somutlaştırdığınız statik nesnenin yapıcısına tek seferlik eylemi sarabilirsiniz.

Misal:

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

Ya da gerçekten böyle bir şeye benzeyen bir makroya bağlı kalabilirsiniz:

#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'un dediği gibi, std::exchangeazalan bir tam sayı kullanarak kullanmaktan kaçınabilirsiniz , ancak negatif değerlerin true değerine çözümlendiğini hatırlamanız gerekir. Bunu kullanmanın yolu:

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

Bunu @ Acorn'un süslü ambalajına çevirmek şöyle görünür:

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 tarafından önerildiği gibi kullanmak muhtemelen en deyimsel yol olsa da, bir değişim işlemi mutlaka ucuz değildir. Elbette statik başlatmanın iş parçacığı açısından güvenli olduğu garanti edilmesine rağmen (derleyicinize bunu yapmamasını söylemediğiniz sürece), bu nedenle performansla ilgili tüm noktalar staticanahtar kelime varlığında yine de biraz nafile olur .

Eğer (genellikle C ++ kullanarak insanlar gibi) mikro optimizasyonu hakkında endişeleriniz varsa, siz de çizebilecek boolve kullanımı intBunun yerine post-eksiltme (veya kullanma izni verecek olan yerine artışı aksine olarak, boolbir azaltma intolacaktır değil sıfıra doyurmak ...):

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

Eskiden boolarttırma / azaltma operatörleri vardı, ancak uzun zaman önce kullanımdan kaldırıldı (C ++ 11? Emin değil misiniz?) Ve C ++ 17'de tamamen kaldırılacaklardı. Bununla birlikte, intadil bir cezayı azaltabilirsiniz ve elbette bir Boole koşulu olarak çalışacaktır.

Bonus: Uygulayabilirsiniz do_twiceya da do_thricebenzer şekilde ...

@ Bathsheba'nın bunun için büyük cevabına dayanarak - daha da basitleştirdi.

İçinde C++ 17şunları yapabilirsiniz:

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

(Önceki sürümlerde, int i blok dışında bildirir. Ayrıca C :) de çalışır).

Basit bir deyişle: varsayılan sıfır ( 0) değerini alan i'yi bildirirsiniz . Sıfır falseydir, bu nedenle ünlem işareti ( !) operatörünü reddetmek için kullanırız. Daha sonra <ID>++, ilk önce işlenen (atanan vb.) Ve daha sonra artan operatörün artış özelliğini dikkate alırız.

Bu nedenle, bu blokta, başlatılacak ve 0blok yürütüldüğünde sadece bir kez değere sahip olacağım ve sonra değer artacaktır. !Operatörü sadece onu reddetmek için kullanırız.