วิธีที่สวยงามที่สุดในการเขียน 'if' แบบครั้งเดียว

เนื่องจาก 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 ++ มีพื้นฐานโฟลว์การควบคุมในตัวที่ประกอบด้วย "( before-block; condition; after-block )" อยู่แล้ว:

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ในทำนองเดียวกัน ...

จากคำตอบที่ยอดเยี่ยมของ @ Bathsheba สำหรับสิ่งนี้ทำให้ง่ายยิ่งขึ้น

ในC++ 17คุณสามารถทำได้:

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

(ในเวอร์ชันก่อนหน้านี้เพียงแค่ประกาศint iนอกบล็อกนอกจากนี้ยังใช้งานได้ใน C :))

พูดง่ายๆคือคุณประกาศ i ซึ่งใช้ค่าเริ่มต้นเป็นศูนย์ ( 0) ศูนย์เป็นเท็จดังนั้นเราจึงใช้เครื่องหมายอัศเจรีย์ ( !) ตัวดำเนินการเพื่อลบล้างมัน จากนั้นเราจะพิจารณาคุณสมบัติการเพิ่มขึ้นของตัว<ID>++ดำเนินการซึ่งจะได้รับการประมวลผล (กำหนด ฯลฯ ) ก่อนแล้วจึงเพิ่มขึ้น

ดังนั้นในบล็อกนี้ฉันจะเริ่มต้นและมีค่า 0เพียงครั้งเดียวเมื่อดำเนินการบล็อกแล้วค่าจะเพิ่มขึ้น เราเพียงแค่ใช้ตัว!ดำเนินการเพื่อลบล้างมัน