如何只执行一次代码？

Question

我有一个应用程序，其中包含多个功能。每个函数可以根据用户输入多次调用。但是，我只需要在一个函数中执行一小段代码，最初是在启动应用程序时。当稍后再次调用相同的函数时，不得执行这段特定的代码。代码在 VC++ 中。请告诉我处理此问题的最有效方法。

Answer 1

使用 lambda 函数的精简版：

void foo()
{
    static bool once = [](){
        cout << "once" << endl;
        return true;
    } ();
    cout << "foo" << endl;
}

当静态变量初始化为 lambda 函数的返回值时，lambda 函数内的代码只执行一次。只要您的编译器支持线程安全的静态初始化，它就应该是线程安全的。

Answer 2

使用 C++11 -- 使用std::call_once

#include <mutex>

std::once_flag onceFlag;

{
    ....
    std::call_once ( onceFlag, [ ]{ /* my code body here runs only once */ } );
    ....
}

Answer 3

使用带构造函数的全局静态对象（在main 之前调用）？或者只是在例程中

static bool initialized;
if (!initialized) {
   initialized = true;
   // do the initialization part
}

很少有这样的速度不够快的情况！

---

附录

在多线程上下文中，这可能还不够：

您可能还对pthread_once 或constructor function __attribute__ of GCC 感兴趣。

使用 C++11，您可能需要std::call_once。

如果您的函数可以从多个线程中调用，您可能想要使用<atomic> 并可能声明static volatile std::atomic_bool initialized;（但您需要小心）。

^{但是这些可能在您的系统上不可用；它们在 Linux 上可用！}

Answer 4

你可以使用局部静态变量：

void foo()
{
     static bool wasExecuted = false;
     if (wasExecuted)
         return;
     wasExecuted = true;

     ...
}

Answer 5

除了@Basile 的回答，您还可以使用 lambda 封装静态变量，如下所示：

if ([] {
    static bool is_first_time = true;
    auto was_first_time = is_first_time;
    is_first_time = false;
    return was_first_time; } ()) 
{ 
    // do the initialization part
}

这使得转换成通用宏变得容易：

#define FIRST_TIME_HERE ([] { \
    static bool is_first_time = true; \
    auto was_first_time = is_first_time; \
    is_first_time = false; \
    return was_first_time; } ())

可以放在任何你想要的地方call-by-need:

if (FIRST_TIME_HERE) {
    // do the initialization part
}

为了更好地衡量，atomics 缩短了表达式并使其成为线程安全的：

#include <atomic>
#define FIRST_TIME_HERE ([] { \
    static std::atomic<bool> first_time(true); \
    return first_time.exchange(false); } ())

Answer 6

你能做到吗

有一个函数可以返回一个 bool 或一些称为 init 的数据类型

我是这样实现的，你需要静态布尔来实现它

bool init()
{
  cout << "Once " <<endl;
  return true||false;// value isn't matter
}

void functionCall()
{
    static bool somebool = init(); // this line get executed once
    cout << "process " <<endl;
}

int main(int argc, char *argv[])
{
    functionCall();
    functionCall();
    functionCall();

    return EXIT_SUCCESS;
}

为 C

#include <stdio.h>

void init()
{
    printf("init\n");
}

void process()
{
    static int someint = 0;
    if(someint == 0)
    {
        someint = 1;
        init();
    }
    printf("process\n");
}


int main()
{
    process();
    process();
    process();
    return 0;
}

Answer 7

如果您不需要完全线程安全的解决方案，

std::call_once() et al. 可能有点过头了。

如果没有，我们可以在使用 C++17 的 initialisation-within-if 和 std::exchange() 时让这个看起来特别优雅：

#include <utility>

void
do_something_expensive_once()
{
    if ( static auto called = false; !std::exchange(called, true) ) {
        do_something_expensive();
    }
}

如果这是你经常使用的模式，那么我们可以通过标签类型对其进行封装：

#include <iostream>
#include <utility>

template <typename T>
auto
call_once()
{
    static auto called = false;
    return !std::exchange(called, true);
}

void
do_something_expensive()
{
    std::cout << "something expensive\n";
}

void
do_something_expensive_once()
{
    if ( call_once<struct TagForSomethingExpensive>() ) {
        do_something_expensive();
    }
}

auto
main() -> int
{
    for (auto i = 0; i < 5; ++i) {
        do_something_expensive_once();
    }

    return 0;
}

这只会打印一次something expensive。结果！它还使用在模板参数列表中声明标签struct 的能力，以最大限度地简洁。

或者，您可以在函数地址、唯一整数等上进行模板化。

然后您还可以将可调用对象传递给call_once()，依此类推。像往常一样 C++：可能性是无限的！

Answer 8

另一个简单的解决方案是：

#define execute_once if(static bool b = false; b) ; else if((b = true))

这样使用：

execute_once std::cout << "Hi mum!\n";

或：

execute_once
{
    std::cout << "These statements are ";
    std::cout << "only executed once\n";
}

显然，这不是线程安全的。

Answer 9

do { 
     //execute code once
} while (false)