Cách thanh lịch nhất để viết một cú 'nếu'

Vì C ++ 17, người ta có thể viết một ifkhối sẽ được thực thi chính xác một lần như thế này:

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

    }
}

Tôi biết tôi có thể đang xem xét lại điều này, và có nhiều cách khác để giải quyết vấn đề này, nhưng vẫn có thể viết điều này bằng cách nào đó như thế này, vì vậy do_once = falsecuối cùng không cần đến nó?

if (DO_ONCE) {
    // Do stuff
}

Tôi đang nghĩ một chức năng của trình trợ giúp do_once(), có chứa static bool do_once, nhưng nếu tôi muốn sử dụng cùng chức năng đó ở những nơi khác nhau thì sao? Đây có thể là thời gian và địa điểm cho một #define? Tôi hy vọng là không.

Sử dụng std::exchange:

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

Bạn có thể làm cho nó ngắn hơn đảo ngược giá trị thật:

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

Nhưng nếu bạn đang sử dụng nhiều thứ này, đừng thích và thay vào đó hãy tạo một trình bao bọc:

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

Và sử dụng nó như:

if (static Once once; once)

Biến không được phép tham chiếu ngoài điều kiện, vì vậy tên không mua cho chúng tôi nhiều. Lấy cảm hứng từ các ngôn ngữ khác như Python mang ý nghĩa đặc biệt cho mã _định danh, chúng tôi có thể viết:

if (static Once _; _)

Cải thiện thêm: tận dụng phần BSS (@Ded repeatator), tránh ghi bộ nhớ khi chúng tôi đã chạy (@ShadowRanger) và đưa ra gợi ý dự đoán chi nhánh nếu bạn sẽ kiểm tra nhiều lần (ví dụ như trong câu hỏi):

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

Có thể không phải là giải pháp tao nhã nhất và bạn không thấy bất kỳ thực tế nào if, nhưng thư viện tiêu chuẩn thực sự bao gồm trường hợp này:, xem std::call_once.

#include <mutex>

std::once_flag flag;

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

Ưu điểm ở đây là đây là chủ đề an toàn.

C ++ đã có một luồng nguyên thủy điều khiển dựng sẵn bao gồm "( trước khối; điều kiện; sau khối )":

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

Hoặc tin tặc, nhưng ngắn hơn:

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

Tuy nhiên, tôi nghĩ rằng bất kỳ kỹ thuật nào được trình bày ở đây nên được sử dụng cẩn thận, vì chúng không (chưa?) Rất phổ biến.

Trong C ++ 17 bạn có thể viết

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

để tránh chơi xung quanh với itrong cơ thể vòng lặp. ibắt đầu bằng 0 (được đảm bảo bởi tiêu chuẩn) và biểu thức sau các ;tập hợp icho 1lần đầu tiên được đánh giá.

Lưu ý rằng trong C ++ 11, bạn có thể đạt được điều tương tự với chức năng lambda

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

cũng mang một lợi thế nhỏ trong đó ikhông bị rò rỉ vào thân vòng lặp.

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

Giải pháp này là chủ đề an toàn (không giống như nhiều đề xuất khác).

Bạn có thể bao bọc hành động một lần trong hàm tạo của một đối tượng tĩnh mà bạn khởi tạo thay cho điều kiện.

Thí dụ:

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

Hoặc bạn thực sự có thể gắn bó với một macro, có thể trông giống như thế này:

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

Giống như @damon đã nói, bạn có thể tránh sử dụng std::exchangebằng cách sử dụng số nguyên giảm dần, nhưng bạn phải nhớ rằng các giá trị âm giải quyết thành đúng. Cách sử dụng này sẽ là:

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

Dịch cái này sang trình bao bọc ưa thích của @ Acorn sẽ như thế này:

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

Mặc dù sử dụng std::exchangetheo đề xuất của @Acorn có lẽ là cách thành ngữ nhất, một hoạt động trao đổi không nhất thiết phải rẻ. Mặc dù tất nhiên việc khởi tạo tĩnh được đảm bảo an toàn cho luồng (trừ khi bạn nói với trình biên dịch của mình không làm điều đó), do đó, bất kỳ cân nhắc nào về hiệu suất dù sao cũng có phần vô ích khi có statictừ khóa.

Nếu bạn lo lắng về tối ưu hóa vi mô (như mọi người thường sử dụng C ++), bạn cũng có thể cào boolvà sử dụng intthay thế, điều này sẽ cho phép bạn sử dụng giảm dần (hay đúng hơn là tăng dần , vì không giống như boolgiảm dần intsẽ không bão hòa về 0 ...):

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

Trước đây, nó từng boolcó các toán tử tăng / giảm, nhưng chúng không được dùng nữa từ lâu (C ++ 11? Không chắc chắn?) Và sẽ bị xóa hoàn toàn trong C ++ 17. Tuy nhiên, bạn có thể giảm giá inttốt, và tất nhiên nó sẽ hoạt động như một điều kiện Boolean.

Phần thưởng: Bạn có thể thực hiện do_twicehoặc do_thricetương tự ...

Dựa trên câu trả lời tuyệt vời của @ Bathsheba cho điều này - chỉ làm cho nó đơn giản hơn nữa.

Trong C++ 17, bạn có thể chỉ cần làm:

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

(Trong các phiên bản trước, chỉ cần khai báo int ibên ngoài khối. Cũng hoạt động trong C :)).

Nói một cách đơn giản: bạn khai báo i, lấy giá trị mặc định là zero ( 0). Zero là falsey, do đó chúng tôi sử dụng !toán tử dấu chấm than ( ) để phủ định nó. Sau đó, chúng tôi sẽ tính đến thuộc tính gia tăng của <ID>++toán tử, đầu tiên được xử lý (được gán, v.v.) và sau đó tăng lên.

Do đó, trong khối này, tôi sẽ được khởi tạo và 0chỉ có giá trị một lần, khi khối được thực thi, và sau đó giá trị sẽ tăng. Chúng tôi chỉ đơn giản là sử dụng !toán tử để phủ nhận nó.