Allow one thread to execute section while others wait and resume
Use std::once_flag
The std::once_flag class basically does what you want. However, there is no way nice way to reset it, except by using a trick like placement new, or by allocating a flag dynamically, and using a std::unique_ptr to point to it for example. As indi mentioned, it's not really &quot;once&quot; anymore then, but it does work for your specific case. Here is a drop-in replacement for your struct Executive:
struct Executive {
  Executive(int _Id, Target &amp;_Tgt) : m_Id(_Id), m_Tgt(_Tgt) {}
  void update() {
        std::call_once(flag, [this]{ m_Tgt.hit(); });
  }
  void reset() {
    flag.~once_flag();
    new (&amp;flag) std::once_flag;
  }

private:
  int m_Id;
  Target &amp;m_Tgt;
  std::once_flag flag;
};

No need to write inline
If you include the full definition of a member function in a class or struct definition, you don't need to explicitly use the inline specifier, as it will implicitly be an inline function.
Write idiomatic code
There are a few things in your code that are not incorrect in any way, but are a rather unusual way to write things. For example, when declaring an int and initializing it, I would expect int n = 2 or int n{2}, but not int n(2).
Also, when repeating something a number of times, use a for-loop, like so:
for (int i = 0; i &lt; n; ++i) {
    e.reset();
    ...
}

This completely describes how often the loop is run in a single line, which makes it easier to read.