How To End A C++ Program | Stop Without Surprises

Guides / By

A C++ program should usually end by returning from main; use std::exit only for early process shutdown.

A small console app can finish by reaching the closing brace of main, but learning how to end a C++ program matters once files, destructors, and exit codes are involved. The normal choice is return 0; from main, or no final return at all when success is the result.

Use return 0; for success, a nonzero return value for failure, and std::exit only when code far from main must stop the whole process. Avoid std::abort unless the program is already in a failure state where normal cleanup cannot be trusted.

What Should End A C++ Program?

A C++ program should end through main whenever you control the normal flow. Returning from main gives C++ a chance to destroy local objects before the process hands a status value back to the operating system.

For a finished program, write the ending plainly:

#include 

int main() {
    std::cout << "Done\n";
    return 0;
}

The console prints Done, the local objects in main are cleaned up, and the process reports success. If control reaches the closing brace of main with no return, C++ treats that like return 0;.

Ending A C++ Program In Main: What Changes

Ending a C++ program in main changes both control flow and cleanup. The biggest difference is whether automatic objects, such as local class objects, get their destructors called before the process ends.

Use this table as the first decision point before choosing a stop form.

Ending Form Use It When Cleanup Result
Reach the end of main The work succeeded and no status detail is needed. Local objects in main are destroyed; status is success.
return 0; The program succeeded and you want the status to be visible. Local objects in main are destroyed; status is success.
return EXIT_SUCCESS; You prefer the named success macro from . Cleanup is the same as return 0;.
return 1; The program failed and your caller expects a number. Local cleanup runs; the meaning of that nonzero code is platform dependent.
return EXIT_FAILURE; You want a portable failure status from . Local cleanup runs; status means failure.
std::exit(code); A deep function must stop the whole process now. Automatic objects in the current block are skipped; registered exit handlers can run.
std::quick_exit(code); You registered std::at_quick_exit handlers and want a shorter shutdown. Normal std::atexit handlers and many destructors are skipped.
std::abort(); The program hit a fatal state and should stop abnormally. Normal cleanup is not the goal; diagnostic output may appear.

The C++ working draft says returning from main destroys automatic objects before calling std::exit, while calling std::exit without leaving the current block does not destroy those objects. The C++ draft rule for main gives that distinction.

When Should You Use std::exit?

std::exit should be used when a program must stop from outside main and returning an error back through the call stack is not practical. The function belongs in rare process-level exits, not ordinary control flow.

Add #include before using std::exit, EXIT_SUCCESS, or EXIT_FAILURE. A small use might look like this:

#include 

void stop_now() {
    std::exit(EXIT_FAILURE);
}

int main() {
    stop_now();
}

The process ends inside stop_now(), so control never returns to main. Any local object waiting inside stop_now() is not destroyed by leaving that block.

A better pattern for many apps is to return a status value from helper functions and let main decide the final process status. That keeps shutdown in one place and makes tests easier to write.

Exit Codes That Make Sense

Exit codes should tell the caller whether the program succeeded or failed. Use 0 or EXIT_SUCCESS for success, and use EXIT_FAILURE or a documented nonzero value for failure.

Small programs usually need only success and failure. Command-line tools may benefit from several documented nonzero codes, such as one code for bad input and another for a missing file.

Situation Return Form Reason
Normal finish return 0; Most shells and build tools read 0 as success.
Portable success wording return EXIT_SUCCESS; The macro states success without relying on a magic number.
General failure return EXIT_FAILURE; The macro states failure and comes from .
Known error category return 2; A documented number can help scripts react to one failure type.
Helper function fails return false; to main main can convert the result into one process status.
Unrecoverable runtime break std::abort(); The stop is abnormal and may help expose a bug during testing.

Common Mistakes That Break Cleanup

Cleanup breaks when a program stops the process from the wrong level. Calling std::exit from the middle of a function skips destructors for local automatic objects in that function and any caller frames that never unwind.

That matters when a destructor flushes a file, releases a lock, closes a socket, or writes a final log line. C++ code often relies on RAII, which means resource cleanup is tied to object lifetime.

  • Do not call std::exit just to leave a loop; use break or return.
  • Do not use std::abort for normal validation errors; return failure instead.
  • Do not scatter process exits across helper functions unless the app is intentionally shutting down.
  • Do not return random nonzero codes unless a caller or script knows what they mean.

Use This Ending For Each Situation

C++ beginners should make main the place where the final status is chosen. That habit keeps cleanup predictable and makes the program easier to read.

  1. For success, end main with return 0; or let main reach its closing brace.
  2. For a normal error, return EXIT_FAILURE from main after including .
  3. For helper functions, return a value to main instead of stopping the process inside the helper.
  4. For process-level emergency shutdown, use std::exit only after accepting that local destructors in the current path may not run.
  5. For corrupted state or failed assertions, use std::abort only when abnormal termination is the honest result.

The safest habit is not fancy: let work report success or failure upward, then let main return the process status. The program finishes, the caller gets a useful code, and C++ gets the cleanup chance it was designed to use.

References & Sources