How to end C++ code

There are several ways, but first you need to understand why object cleanup is important, and hence the reason std::exit is marginalized among C++ programmers.

RAII and Stack Unwinding

C++ makes use of a idiom called RAII, which in simple terms means objects should perform initialization in the constructor and cleanup in the destructor. For instance the std::ofstream class [may] open the file during the constructor, then the user performs output operations on it, and finally at the end of its life cycle, usually determined by its scope, the destructor is called that essentially closes the file and flushes any written content into the disk.

What happens if you don’t get to the destructor to flush and close the file? Who knows! But possibly it won’t write all the data it was supposed to write into the file.

For instance consider this code

#include <fstream>
#include <exception>
#include <memory>

void inner_mad()
{
    throw std::exception();
}

void mad()
{
    auto ptr = std::make_unique<int>();
    inner_mad();
}

int main()
{
    std::ofstream os("file.txt");
    os << "Content!!!";

    int possibility = /* either 1, 2, 3 or 4 */;

    if(possibility == 1)
        return 0;
    else if(possibility == 2)
        throw std::exception();
    else if(possibility == 3)
        mad();
    else if(possibility == 4)
        exit(0);
}

What happens in each possibility is:

  • Possibility 1: Return essentially leaves the current function scope, so it knows about the end of the life cycle of os thus calling its destructor and doing proper cleanup by closing and flushing the file to disk.
  • Possibility 2: Throwing a exception also takes care of the life cycle of the objects in the current scope, thus doing proper cleanup…
  • Possibility 3: Here stack unwinding enters in action! Even though the exception is thrown at inner_mad, the unwinder will go though the stack of mad and main to perform proper cleanup, all the objects are going to be destructed properly, including ptr and os.
  • Possibility 4: Well, here? exit is a C function and it’s not aware nor compatible with the C++ idioms. It does not perform cleanup on your objects, including os in the very same scope. So your file won’t be closed properly and for this reason the content might never get written into it!
  • Other Possibilities: It’ll just leave main scope, by performing a implicit return 0 and thus having the same effect as possibility 1, i.e. proper cleanup.

But don’t be so certain about what I just told you (mainly possibilities 2 and 3); continue reading and we’ll find out how to perform a proper exception based cleanup.

Possible Ways To End

Return from main!

You should do this whenever possible; always prefer to return from your program by returning a proper exit status from main.

The caller of your program, and possibly the operating system, might want to know whether what your program was supposed to do was done successfully or not. For this same reason you should return either zero or EXIT_SUCCESS to signal that the program successfully terminated and EXIT_FAILURE to signal the program terminated unsuccessfully, any other form of return value is implementation-defined (§18.5/8).

However you may be very deep in the call stack, and returning all of it may be painful…

[Do not] throw a exception

Throwing a exception will perform proper object cleanup using stack unwinding, by calling the destructor of every object in any previous scope.

But here’s the catch! It’s implementation-defined whether stack unwinding is performed when a thrown exception is not handled (by the catch(…) clause) or even if you have a noexcept function in the middle of the call stack. This is stated in §15.5.1 [except.terminate]:

  1. In some situations exception handling must be abandoned for less subtle error handling techniques. [Note: These situations are:[…]— when the exception handling mechanism cannot find a handler for a thrown exception (15.3), or when the search for a handler (15.3) encounters the outermost block of a function with a noexcept-specification that does not allow the exception (15.4), or […][…]
  2. In such cases, std::terminate() is called (18.8.3). In the situation where no matching handler is found, it is implementation-defined whether or not the stack is unwound before std::terminate() is called […]

So we have to catch it!

Do throw a exception and catch it at main!

Since uncaught exceptions may not perform stack unwinding (and consequently won’t perform proper cleanup), we should catch the exception in main and then return a exit status (EXIT_SUCCESS or EXIT_FAILURE).

So a possibly good setup would be:

int main()
{
    /* ... */
    try
    {
        // Insert code that will return by throwing a exception.
    }
    catch(const std::exception&)  // Consider using a custom exception type for intentional
    {                             // throws. A good idea might be a `return_exception`.
        return EXIT_FAILURE;
    }
    /* ... */
}

[Do not] std::exit

This does not perform any sort of stack unwinding, and no alive object on the stack will call its respective destructor to perform cleanup.

This is enforced in §3.6.1/4 [basic.start.init]:

Terminating the program without leaving the current block (e.g., by calling the function std::exit(int) (18.5)) does not destroy any objects with automatic storage duration (12.4). If std::exit is called to end a program during the destruction of an object with static or thread storage duration, the program has undefined behavior.

Think about it now, why would you do such a thing? How many objects have you painfully damaged?

Other [as bad] alternatives

There are other ways to terminate a program (other than crashing), but they aren’t recommended. Just for the sake of clarification they are going to be presented here. Notice how normal program termination does not mean stack unwinding but an okay state for the operating system.

  • std::_Exit causes a normal program termination, and that’s it.
  • std::quick_exit causes a normal program termination and calls std::at_quick_exit handlers, no other cleanup is performed.
  • std::exit causes a normal program termination and then calls std::atexit handlers. Other sorts of cleanups are performed such as calling static objects destructors.
  • std::abort causes an abnormal program termination, no cleanup is performed. This should be called if the program terminated in a really, really unexpected way. It’ll do nothing but signal the OS about the abnormal termination. Some systems perform a core dump in this case.
  • std::terminate calls the std::terminate_handler which calls std::abort by default.

Related Posts:

  1. Pause Console in C++ program
  2. Why the switch statement cannot be applied on strings?
  3. How to dynamically allocate arrays in C++
  4. How to convert string to char array in C++?
  5. How can I convert a std::string to int?
  6. Why is “using namespace std;” considered bad practice?
  7. What is a lambda expression in C++11?
  8. How to convert string to char array in C++?
  9. ld: symbol(s) not found for architecture x86_64 error
  10. C++ string to double conversion
  11. C++ for each, pulling from vector elements
  12. How do I erase an element from std::vector<> by index?
  13. Incomplete Type Is Not Allowed
  14. how to implement quick sort algorithm in C++
  15. C++ Vector of pointers
  16. How do I reverse a C++ vector?
  17. Is there a C++ decompiler?
  18. What is a dangling pointer?
  19. undefined reference to WinMain@16 (codeblocks)
  20. Why use ‘glad’ library for opengl initialization? [duplicate]
  21. const int = int const?
  22. Undefined reference to vtable
  23. In C++, what is a virtual base class?
  24. wntdll.pdb not loaded – Can’t see the exception
  25. Difference between const reference and normal parameter
  26. Why am I getting this redefinition of class error?
  27. error: redefinition of class
  28. How to convert a std::string to const char* or char*
  29. How to pass optional arguments to a method in C++?
  30. How to copy a string of std::string type in C++?
  31. C++ forbids converting a `string` constant to `char*` – Alphabets to Morse converting program
  32. What is activation record in the context of C and C++?
  33. Static array vs. dynamic array in C++
  34. C++ terminate called after throwing an instance of ‘std::out_of_range’ Simple Averaging code
  35. Error “C++ requires a type specifier for all declarations whilst defining methods”
  36. How to create a dynamically-allocated array of const objects, but have values assigned to them?
  37. Why doesn’t std::vector::push_front() exist?
  38. Fastest way to check if a file exist using standard C++/C++11,14,17/C?
  39. Invalid use of non-static member function c++
  40. C++ #include guards
  41. Is std::stoi actually safe to use?
  42. C++ forbids variable-size array
  43. Fill array with random numbers within a specified range (C++)
  44. What is the difference between const_iterator and non-const iterator in the C++ STL?
  45. Sorting Linked List C++ with pointers
  46. Get Unix timestamp with C++
  47. Class prototyping
  48. How to dynamically allocate an array of pointers in C++?
  49. How do I compile C++ to JavaScript in a browser?
  50. Is the sizeof(some pointer) always equal to four?
  51. How do you initialise a dynamic array in C++?
  52. What are the distinctions between the various symbols (*,&, etc) combined with parameters?
  53. Accessors and Mutators C++
  54. Error C1083: Cannot open include file: ‘stdafx.h’
  55. How do you handle a “cannot instantiate abstract class” error in C++?
  56. How to cast the size_t to double or int C++
  57. How to get Current Directory?
  58. C++ Convert string (or char*) to wstring (or wchar_t*)
  59. Program received signal SIGSEGV, Segmentation fault
  60. Integer to hex string in C++
  61. Comparison of C++ unit test frameworks
  62. What is the difference between .cc and .cpp file suffix?
  63. C++ error: object of abstract class type is not allowed: pure virtual function has no overrider
  64. Correct way to work with vector of arrays
  65. What’s the difference between nexti and stepi in gdb?
  66. How to get current time in milliseconds?
  67. Resizing dynamic array in c++
  68. C++ – Nested include – Avoiding ‘include nested too deeply error’
  69. Why is inherited member not allowed?
  70. Error: macro names must be identifiers using #ifdef 0
  71. Error: free(): invalid next size (fast):
  72. Trying to use int in getline
  73. c++ error c2015: too many characters in constant
  74. Splitting a C++ std::string using tokens, e.g. “;”
  75. Py_Initialize fails – unable to load the file system codec
  76. C++ pass an array by reference
  77. error LNK2019: unresolved external symbol “” referenced in function
  78. Undefined reference to a static member
  79. How to sort with a lambda?
  80. stoi function gives error: std::invalid_argument at memory location 0x0035E8D8. c++
  81. Stack around the variable ‘ ‘ was corrupted
  82. The difference between cin.ignore and cin.sync
  83. casting int to char using C++ style casting
  84. variable or field declared void
  85. Invalid conversion from ‘char’ to ‘const char *’
  86. How do I deal with “signed/unsigned mismatch” warnings (C4018)?
  87. Creating folders in C++
  88. Unrecognizable template declaration/definition
  89. MSVCP120d.dll missing
  90. Modulo operator with negative values [duplicate]
  91. Finding the type of an object in C++
  92. heap corruption detected | C++
  93. Update g++ but still old version
  94. module unsafe for SAFESEH image C++
  95. Why are there two different getline() functions (if indeed there are)?
  96. Whats the difference between UInt8 and uint8_t
  97. Struct with template variables in C++
  98. error: no member function declared in class
  99. Why does my program give “NULL used in arithmetic”
  100. no matching function to call for “getline”

Leave a Comment