How to end a program

[elbeno]

Channel

C++Weekly

Topics

How to safely and effectively cause (abnormal) termination of a program when something goes wrong.

• std::terminate? std::abort? std::exit? std::quick_exit?
• assert?
• throw unhandled exception?
• cause processor exception (many ways people try to do this involve UB eg dereferencing a null pointer)
• other?

Also - how to test this?

Length

Not sure. Long form? Multi part? There's probably a lot to cover here.

[lefticus]

destructors not called with abort situation

// sometimes abort, depending on build settings
assert(false);

// unconditionally abort
abort(); 

std::exit(0); // terminate normally
std::exit(EXIT_SUCCESS); // lawful good
std::puts("Program succeeded!");
std::exit(42); // rude, will be treated as a failure

// only calls at_quick_exit registered things, so not destructors
std::quick_exit(0);

extern "C"  void dontabort(int) { std::exit(0); } // actually UB, exit is not allowed in signal handler
std::signal(SIGABRT, dontabort)

extern "C"  void dontabort(int) { std::quick_exit(0); }
// still doesn't call global destructors, but isn't `abort`?
std::signal(SIGABRT, dontabort)

int main() {
  // indirectly call terminate, which indirectly calls abort
  throw 42; // terminate with unhandled exception
}

int main() {
  try {
    []() noexcept { throw 42; }();
  } catch (...) {
    // never caught, terminate by unhandled exception
  }
}

int main() {
  // directly terminate, indirectly call abort
  std::terminate();
}

int main()
{
  // hope you exit, but depends on compiler
  int *i = nullptr;
  return *i;
}

// maybe try to raise a floating point exception?

  std::cout << "Hello world\n";
  // buffers not flushed!
  std::quick_exit(42);

[LB--]

If something is "wrong", running destructors could do more wrong, potentially in ways that outlive the process, so termination without normal unwind/destructors is appropriate. If something is an expected "part of doing business" failure like failing to open a user-specified file, returning EXIT_FAILURE from main is the better option, possibly by getting there with exceptions or std:.expected or C error code convention or whatever else works normally.

[lefticus]

There's basically 6 ways to exit a program, I've discovered.

1. Cleanly with exit, implied or not, with a proper exit code that unrolls and destroys objects. This is return from main or exit from anywhere.
2. 1/2 cleanly with quick_exit, but really this isn't far off from terminate. It calls the handlers that are registered for quick_exit.
3. abort this can be called manually or indirectly through assert. You can also try to catch it and convert the abort crash failure into a quick_exit.
4. terminate which is called directly through terminate, or indirectly through an unhandled exception, or even more indirectly by throwing an exception from a noexcept function
5. Cause UB and hope to crash?
6. Infinite loop / consume all resources and hope you get killed by the hardware watchdog or OS

[lefticus]

Even more updated version with actual recommendations: https://compiler-explorer.com/z/6nszKqx43

[lefticus]

Coming in Ep 513