Làm thế nào để tôi đảm bảo một đoạn mã chỉ chạy một lần?

Tôi có một số mã mà tôi chỉ muốn chạy một lần, mặc dù các trường hợp kích hoạt mã đó có thể xảy ra nhiều lần.

Ví dụ: khi người dùng nhấp chuột, tôi muốn nhấp vào điều:

void Update() {
    if(mousebuttonpressed) {
        ClickTheThing(); // I only want this to happen on the first click,
                         // then never again.
    }
}

Tuy nhiên, với mã này, mỗi lần tôi nhấp chuột, mọi thứ sẽ được nhấp. Làm thế nào tôi có thể làm cho nó xảy ra chỉ một lần?

Sử dụng cờ boolean.

Trong ví dụ hiển thị, bạn sẽ sửa đổi mã thành như sau:

//a boolean flag that lets us "remember" if this thing has happened already
bool thatThingHappened = false;

void Update() {
    if(!thatThingHappened && mousebuttonpressed) {
        //if that thing hasn't happened yet and the mouse is pressed
        thatThingHappened = true;
        ClickTheThing();
    }
}

Hơn nữa, nếu bạn muốn có thể lặp lại hành động, nhưng giới hạn tần suất của hành động (tức là thời gian tối thiểu giữa mỗi hành động). Bạn sẽ sử dụng một cách tiếp cận tương tự, nhưng đặt lại cờ sau một khoảng thời gian nhất định. Xem câu trả lời của tôi ở đây để biết thêm ý tưởng về điều đó.

Nếu cờ bool không đủ hoặc bạn muốn cải thiện khả năng đọc * của mã trong void Update()phương thức, bạn có thể xem xét sử dụng các đại biểu (con trỏ hàm):

public class InputController 
{
  //declare delegate type:
  //<accessbility> delegate <return type> <name> ( <parameter1>, <paramteter2>, ...)
  public delegate void ClickAction();

  //declare a variable of that type
  public ClickAction ClickTheThing { get; set; }

  void onStart()
  {
    //assign it the method you wish to execute on first click
    ClickTheThing = doStuff;
  }

  void Update() {
    if(mousebuttonpressed) {
        //you simply call the delegate here, the currently assigned function will be executed
        ClickTheThing();
     }
  }

  private void doStuff()
  {
    //some logic here
    ClickTheThing = doNothing; //and set the delegate to other(empty) funtion
  }

  //or do something else
  private void doNothing(){}
}

Đối với các đại biểu "thực hiện một lần" đơn giản là quá mức cần thiết, vì vậy tôi sẽ đề nghị sử dụng cờ bool thay thế.
Tuy nhiên, nếu bạn cần chức năng phức tạp hơn, các đại biểu có lẽ là sự lựa chọn tốt hơn. Ví dụ: nếu bạn muốn chuỗi thực hiện nhiều hành động khác nhau: một lần nhấp đầu tiên, lần khác vào lần thứ hai và một lần nữa vào lần thứ ba, bạn có thể thực hiện:

func1() 
{
  //do logic 1 here
  someDelegate = func2;
}

func2() 
{
  //do logic 2 here
  someDelegate = func3;
}
//etc...

thay vì làm hỏng mã của bạn với hàng chục cờ khác nhau.
* với chi phí bảo trì thấp hơn của phần còn lại của mã

Tôi đã làm một số hồ sơ với kết quả khá nhiều như tôi mong đợi:

----------------------------------------
|     Method     |  Unity   |    C++   |
| -------------------------------------|
| positive flag  |  21 ms   |   6 ms   |
| negative flag  |  5 ms    |   7 ms   |
| delegate       |  25 ms   |   14 ms  |
----------------------------------------

Thử nghiệm đầu tiên được chạy trên Unity 5.1.2, được đo bằng System.Diagnostics.Stopwatchdự án được xây dựng 32 bit (không phải trong thiết kế!). Một cái khác trên Visual Studio 2015 (v140) được biên dịch ở chế độ phát hành 32 bit với cờ / Ox. Cả hai thử nghiệm đều được chạy trên CPU Intel i5-4670K @ 3,4GHz, với 10.000.000 lần lặp cho mỗi lần thực hiện. mã:

//positive flag
if(flag){
    doClick();
    flag = false;
}
//negative flag
if(!flag){ }
else {
    doClick();
    flag = false;
}
//delegate
action();

kết luận: Mặc dù trình biên dịch Unity thực hiện công việc tốt khi tối ưu hóa các lệnh gọi hàm, mang lại kết quả gần như tương tự cho cả cờ dương và đại biểu (tương ứng 21 và 25 ms), việc gọi sai nhánh hoặc gọi hàm vẫn khá tốn kém (lưu ý: đại biểu nên được giả sử bộ đệm trong bài kiểm tra này).
Thật thú vị, trình biên dịch Unity không đủ thông minh để tối ưu hóa chi nhánh khi có 99 triệu lỗi sai liên tiếp, do đó, việc phủ định thủ công thử nghiệm sẽ mang lại một số hiệu suất tăng cho kết quả tốt nhất là 5 ms. Phiên bản C ++ không hiển thị bất kỳ tăng hiệu suất nào cho điều kiện phủ định, tuy nhiên tổng chi phí chung của chức năng gọi thấp hơn đáng kể.
quan trọng nhất: sự khác biệt là khá nhiều không liên quan cho bất kỳ kịch bản trong thế giới thực

Để hoàn thiện

(Không thực sự khuyên bạn nên làm điều này vì nó thực sự khá đơn giản để chỉ viết một cái gì đó như thế if(!already_called), nhưng nó sẽ là "chính xác" để làm điều đó.)

Không có gì đáng ngạc nhiên, tiêu chuẩn C ++ 11 đã giải thích vấn đề khá tầm thường khi gọi một hàm và làm cho nó trở nên siêu rõ ràng:

#include <mutex>

void Update() {
if(mousebuttonpressed) {
    static std::once_flag f;
    std::call_once(f, ClickTheThing);
}

}

Phải thừa nhận rằng, giải pháp tiêu chuẩn có phần vượt trội so với giải pháp tầm thường khi có chủ đề vì nó vẫn đảm bảo luôn luôn chính xác một cuộc gọi xảy ra, không bao giờ có gì khác.

Tuy nhiên, thông thường bạn không chạy một vòng lặp sự kiện đa luồng và nhấn các nút của nhiều con chuột cùng một lúc, do đó sự an toàn của luồng là hơi thừa đối với trường hợp của bạn.

Về mặt thực tế, điều đó có nghĩa là ngoài việc khởi tạo an toàn luồng của boolean cục bộ (mà C ++ 11 vẫn đảm bảo an toàn cho luồng), phiên bản tiêu chuẩn cũng phải thực hiện thao tác test_set nguyên tử trước khi gọi hoặc không gọi chức năng.

Tuy nhiên, nếu bạn thích rõ ràng, có giải pháp.

EDIT:
Hừ. Bây giờ tôi đã ngồi ở đây, nhìn chằm chằm vào mã đó trong vài phút, tôi gần như có xu hướng giới thiệu nó.
Trên thực tế, nó gần như không ngớ ngẩn như lúc đầu, thực sự nó truyền đạt rất rõ ràng và rõ ràng ý định của bạn ... được cho là có cấu trúc tốt hơn và dễ đọc hơn bất kỳ giải pháp nào khác liên quan đến một ifhoặc như vậy.

Một số đề xuất sẽ thay đổi tùy thuộc vào kiến ​​trúc.

Tạo click ThisThing () dưới dạng con trỏ hàm / biến thể / DLL / so / etc ... và đảm bảo rằng nó được khởi tạo cho hàm yêu cầu của bạn khi đối tượng / thành phần / mô-đun / vv ... được khởi tạo.

Trong trình xử lý bất cứ khi nào nhấn nút chuột, sau đó gọi con trỏ hàm click ThisThing () và sau đó thay thế ngay con trỏ bằng một con trỏ hàm NOP (không hoạt động) khác.

Không cần cờ và logic bổ sung để ai đó làm hỏng sau này, chỉ cần gọi nó và thay thế nó mỗi lần và vì đó là NOP, NOP không làm gì cả và được thay thế bằng NOP.

Hoặc bạn có thể sử dụng cờ và logic để bỏ qua cuộc gọi.

Hoặc bạn có thể ngắt kết nối chức năng Update () sau cuộc gọi để thế giới bên ngoài quên nó và không bao giờ gọi lại.

Hoặc bạn có chính click ThisThing () sử dụng một trong những khái niệm này để chỉ trả lời với công việc hữu ích một lần. Bằng cách này, bạn có thể sử dụng một đối tượng / thành phần / mô-đun cơ bản click ThisT BreathOnce () và khởi tạo nó bất cứ nơi nào bạn cần hành vi này và không ai trong số các trình cập nhật của bạn cần logic đặc biệt ở mọi nơi.

Sử dụng con trỏ hàm hoặc đại biểu.

Biến giữ con trỏ hàm không cần phải được kiểm tra rõ ràng cho đến khi cần thay đổi. Và khi bạn không còn cần phải nói logic để chạy, hãy thay thế bằng một tham chiếu đến một chức năng trống / không hoạt động. So sánh với việc thực hiện các điều kiện kiểm tra mọi khung hình trong toàn bộ vòng đời của chương trình của bạn - ngay cả khi cờ đó chỉ cần trong một vài khung hình đầu tiên sau khi khởi động! - Ô uế và không hiệu quả. (Quan điểm của Boreal về dự đoán tuy nhiên được thừa nhận về vấn đề này.)

Các điều kiện lồng nhau, mà những điều này thường tạo thành, thậm chí còn tốn kém hơn so với việc phải kiểm tra một điều kiện duy nhất cho mỗi khung, vì dự đoán nhánh không còn có thể thực hiện phép thuật của nó trong trường hợp đó. Điều đó có nghĩa là sự chậm trễ thường xuyên theo thứ tự 10 giây của chu kỳ - gian hàng tuyệt vời . Việc lồng có thể xảy ra ở trên hoặc dưới cờ boolean này. Tôi hầu như không cần nhắc nhở độc giả về cách các vòng lặp trò chơi phức tạp có thể nhanh chóng trở thành.

Con trỏ hàm tồn tại vì lý do này - sử dụng chúng!

Trong một số ngôn ngữ script như javascript hoặc lua có thể dễ dàng thực hiện kiểm tra tham chiếu hàm. Trong Lua ( love2d ):

function ClickTheThing()
      .......
end
....

local ctt = ClickTheThing  --I make a local reference to function

.....

function update(dt)
..
    if ctt then
      ctt()
      ctt=nil
    end
..
end

Trong máy tính Kiến trúc Von Neumann , bộ nhớ là nơi lưu trữ các hướng dẫn và dữ liệu của chương trình của bạn. Nếu bạn muốn tạo mã chỉ chạy một lần, bạn có thể có mã trong phương thức ghi đè phương thức bằng NOP sau khi phương thức hoàn tất. Bằng cách này, nếu phương thức được chạy lại, sẽ không có gì xảy ra.

Trong python nếu kế hoạch của bạn là một kẻ ngốc với người khác trong dự án:

code = compile('main code'+'del code', '<string>', 'exec')
exec code

kịch bản này chứng thực mã:

from time import time as t

code = compile('del code', '<string>', 'exec')

print 'see code object:'
print code

while True:
    try:
        user = compile(raw_input('play with it (variable name is code) (type done to be done:\t'), '<user_input>', 'exec')
        exec user
    except BaseException as e:
        print e
        break

exec code

print 'no more code object:'
try:
    print code
except BaseException as e:
    print e

while True:
    try:
        user = compile(raw_input('try to play with it again (type done to be done:\t'), '<user_input>', 'exec')
        exec user
    except BaseException as e:
        print e
        break

Đây là một đóng góp khác, đó là một chút chung chung / có thể tái sử dụng, dễ đọc hơn một chút và có thể bảo trì, nhưng có thể kém hiệu quả hơn các giải pháp khác.

Hãy gói gọn logic thực hiện một lần của chúng ta trong một lớp, Một lần:

class Once
{
    private Action body;
    public bool HasBeenCalled { get; private set; }
    public Once(Action body)
    {
        this.body = body;
    }
    public void Call()
    {
        if (!HasBeenCalled)
        {
            body();
        }
        HasBeenCalled = true;
    }
    public void Reset() { HasBeenCalled = false; }
}

Sử dụng nó giống như ví dụ được cung cấp trông như sau:

Once clickTheThingOnce = new Once(ClickTheThing);

void Update() {
    if(mousebuttonpressed) {
        clickTheThingOnce.Call(); // ClickTheThing is only called once
                                  // or until .Reset() is called
    }
}

Bạn có thể xem xét sử dụng một biến tĩnh.

void doOnce()
{
   static bool executed = false;

   if(executed == false)
   {
      ...Your code here
      executed = true;
   }
}

Bạn có thể thực hiện điều này trong ClickTheThing()chính chức năng hoặc tạo một chức năng khác và gọi ClickTheThing()trong phần thân.

Nó tương tự như ý tưởng sử dụng một cờ như được đề xuất trong các giải pháp khác, nhưng cờ được bảo vệ khỏi mã khác và không thể bị thay đổi ở nơi khác do là cục bộ của hàm.

Tôi thực sự đã gặp phải vấn đề nan giải này với Đầu vào bộ điều khiển Xbox. Mặc dù không chính xác giống nhau nhưng nó khá giống nhau. Bạn có thể thay đổi mã trong ví dụ của tôi để phù hợp với nhu cầu của bạn.

Chỉnh sửa: Tình huống của bạn sẽ sử dụng điều này ->

https://docs.microsoft.com/en-us/windows/desktop/api/winuser/ns-winuser-tagrawmouse

Và bạn có thể tìm hiểu cách tạo một lớp đầu vào thô thông qua ->

https://docs.microsoft.com/en-us/windows/desktop/inputdev/raw-input

Nhưng .. bây giờ vào thuật toán siêu tuyệt vời ... không thực sự, nhưng hey .. nó khá tuyệt :)

* Vì vậy, ... chúng ta có thể lưu trữ trạng thái của mọi nút và được nhấn, phát hành và giữ xuống !!! Chúng tôi cũng có thể kiểm tra Thời gian giữ, nhưng điều đó yêu cầu một câu lệnh if duy nhất và có thể kiểm tra bất kỳ số lượng nút nào, nhưng có một số quy tắc xem bên dưới để biết thông tin này.

Rõ ràng nếu chúng tôi muốn kiểm tra xem có thứ gì được nhấn, phát hành hay không, v.v. bạn sẽ làm "Nếu (Cái này) {}", nhưng điều này cho thấy cách chúng tôi có thể lấy trạng thái báo chí và sau đó tắt khung hình tiếp theo để " ismousepressed "sẽ thực sự sai trong lần kiểm tra tiếp theo.

Mã đầy đủ ở đây: https://github.com/JeremyDX/DX_B/blob/master/DX_B/XGameInput.cpp

Làm thế nào nó hoạt động..

Vì vậy, tôi không chắc chắn các giá trị bạn nhận được khi bạn mô tả nếu nhấn nút hay không, nhưng về cơ bản khi tôi tải trong XInput, tôi nhận được giá trị 16 bit trong khoảng từ 0 đến 65535, điều này có 15 bit trạng thái có thể cho "Đã nhấn".

Vấn đề là mỗi khi tôi kiểm tra điều này Nó sẽ chỉ cho tôi trạng thái hiện tại của thông tin. Tôi cần một cách để chuyển đổi trạng thái hiện tại thành các giá trị bị ép, phát hành và giữ.

Vì vậy, những gì tôi đã làm là sau đây.

Đầu tiên chúng ta tạo một biến "HIỆN TẠI". Mỗi lần kiểm tra dữ liệu này, chúng tôi đặt "HIỆN TẠI" thành biến "TRƯỚC" và sau đó lưu trữ dữ liệu mới thành "Hiện tại" như được thấy ở đây ->

uint64_t LAST = CURRENT;
CURRENT = gamepad.wButtons;

Với thông tin này, đây là nơi thú vị !!

Bây giờ chúng ta có thể tìm ra nếu một Nút đang được H HEL TRỢ XUỐNG!

BUTTONS_HOLD = LAST & CURRENT;

Những gì nó làm về cơ bản là so sánh hai giá trị và bất kỳ lần nhấn nút nào được hiển thị trong cả hai sẽ giữ nguyên 1 và mọi thứ khác được đặt thành 0.

Tức là (1 | 2 | 4) & (2 | 4 | 8) sẽ mang lại (2 | 4).

Bây giờ chúng ta có các nút "H HEL TRỢ" xuống. Chúng ta có thể nhận phần còn lại.

Nhấn là đơn giản .. chúng tôi lấy trạng thái "HIỆN TẠI" và loại bỏ bất kỳ nút nhấn nào.

BUTTONS_PRESSED = CURRENT ^ BUTTONS_HOLD;

Thay vào đó, chúng tôi chỉ so sánh nó với trạng thái LAST của chúng tôi.

BUTTONS_RELEASED = LAST ^ BUTTONS_HOLD;

Vì vậy, nhìn vào tình hình Pressed. Nếu chúng ta nói Hiện tại chúng ta đã có 2 | 4 | 8 ép. Chúng tôi thấy rằng 2 | 4 nơi tổ chức. Khi chúng ta loại bỏ Held Bits, chúng ta chỉ còn lại 8. Đây là bit mới được nhấn cho chu trình này.

Điều tương tự có thể được áp dụng cho Phát hành. Trong kịch bản này, "LAST" đã được đặt thành 1 | 2 | 4. Vì vậy, khi chúng tôi loại bỏ 2 | 4 bit. Chúng tôi chỉ còn lại 1. Vì vậy, nút 1 đã được phát hành kể từ khung cuối cùng.

Kịch bản trên có lẽ là tình huống lý tưởng nhất mà bạn có thể đưa ra để so sánh bit và nó cung cấp 3 cấp độ dữ liệu mà không có câu lệnh if hoặc cho các vòng lặp chỉ bằng 3 phép tính bit nhanh.

Tôi cũng muốn ghi lại dữ liệu giữ vì vậy mặc dù tình huống của tôi không hoàn hảo ... về cơ bản, chúng tôi sẽ thiết lập các khoản giữ mà chúng tôi muốn kiểm tra.

Vì vậy, mỗi khi chúng tôi đặt dữ liệu Báo chí / Phát hành / Giữ, chúng tôi sẽ kiểm tra xem dữ liệu giữ có bằng với kiểm tra bit giữ hiện tại không. Nếu không, chúng tôi sẽ đặt lại thời gian hiện tại. Trong trường hợp của tôi, tôi đang đặt nó thành các chỉ mục khung để tôi biết nó được giữ bao nhiêu khung.

Nhược điểm của phương pháp này là tôi không thể có thời gian giữ riêng lẻ, nhưng bạn có thể kiểm tra nhiều bit cùng một lúc. Tức là nếu tôi đặt bit giữ thành 1 | 16 nếu 1 hoặc 16 không được giữ thì điều này sẽ thất bại. Vì vậy, nó yêu cầu TẤT CẢ các nút đó được giữ để tiếp tục đánh dấu.

Sau đó, nếu bạn nhìn vào mã, bạn sẽ thấy tất cả các lệnh gọi hàm gọn gàng.

Vì vậy, ví dụ của bạn sẽ được giảm xuống chỉ đơn giản là kiểm tra xem có xảy ra nhấn nút hay không và chỉ nhấn nút một lần với thuật toán này. Ở lần kiểm tra tiếp theo, nhấn nó sẽ không tồn tại vì bạn không thể nhấn nhiều hơn sau đó một khi bạn phải phát hành trước khi bạn có thể nhấn lại.

Lối thoát ngu ngốc nhưng bạn có thể sử dụng vòng lặp for

for (int i = 0; i < 1; i++)
{
    //code here
}