what is the difference between std::call_once and function-level static initialization

Question

1) std::call_once

A a;
std::once_flag once;

void f ( ) {
    call_once ( once, [ ] { a = A {....}; } );
}

2) function-level static

A a;

void f ( ) {
    static bool b = ( [ ] { a = A {....}; } ( ), true );
}

Answer 1

For your example usage, hmjd's answer fully explains that there is no difference (except for the additional global once_flag object needed in the call_once case.) However, the call_once case is more flexible, since the once_flag object isn't tied to a single scope. As an example, it could be a class member and be used by more than one function:

class X {
  std::once_flag once;

  void doSomething() {
    std::call_once(once, []{ /* init ...*/ });
    // ...
  }

  void doSomethingElse() {
    std::call_once(once, []{ /*alternative init ...*/ });
    // ...
  }
};

Now depending on which member function is called first the initialization code can be different (but the object will still only be initialized once.)

So for simple cases a local static works nicely (if supported by your compiler) but there are some less common uses that might be easier to implement with call_once.