How can I immediately close a program in C?
The standard function exit
is what you are looking for:
Terminates the process normally, performing the regular cleanup for terminating processes.
First, all functions registered by calls to atexit are executed in the reverse order of their registration. Then, all streams are closed and the temporary files deleted, and finally the control is returned to the host environment.
The status argument is returned to the host environment.
It would be better though if you fixed the segfault error.
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 ofmad
andmain
to perform proper cleanup, all the objects are going to be destructed properly, includingptr
andos
. - 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, includingos
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]:
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 [...]
[...]
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 callsstd::at_quick_exit
handlers, no other cleanup is performed.std::exit
causes a normal program termination and then callsstd::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 thestd::terminate_handler
which callsstd::abort
by default.
How to end the program from a function which is called in another function (C++)
You can return
from all functions all the way to main
(nicest).
You can call some variant of exit
.
You can throw an exception.
You can use setjmp
/longjmp
to jump to the end of main
(please don't).
You can crash the application (by calling abort
, raise(SIGKILL)
or similar).
I can't think of more options, but there may well be some...
Ask user to repeat the program or exit in C
int main(void) {
float x,y,sum;
char ch;
do {
printf ("Enter the first number:");
scanf ("%f",&x);
printf ("Enter the second number:");
scanf ("%f",&y);
sum=x+y;
printf ("The total number is:%f\n",sum);
printf ("Do you want to repeat the operation Y/N: ");
scanf (" %c", &ch);
}
while (ch == 'y' || ch == 'Y');
}
This uses a do-while
loop. It will continue till the condition in the while
of the do-while
will return false.
In simple words, whenever the user enters y
or Y
, the while
loop will return true. Thus, it will continue.
Check this example and tutorial for do-while
loop.
How to exit the program immediately using strcmp() without printing the next line
The problem is that the character is always asked before the string is checked, that happens because the string and character input routine are in the input function which is completely executed before the string is checked, there are multiple ways to solve this.
The requirement is that the string must be checked before the character, one way to do it is to move this check to the input function:
void input(char *strp, char *chp)
{
printf("# enter string : ");
scanf(" %99s", strp); // the input size should be limited to the container capacity
// %99s -> 99 characters + null terminator at most
if (strcmp(strp, "end") == 0)
{
exit(0); //exit() requires #include <stdlib.h>
}
printf("# enter character : ");
scanf(" %c", chp);
return;
}
int main()
{
int count;
char str[100], ch;
while (1)
{
input(str, &ch);
count = strcheck(str, ch);
if (count == -1)
{
printf("\"%s\" string doesn't have '%c'. \n\n", str, ch);
}
else
{
printf("\"%s\" string has '%c' in position number %d .\n\n", str, ch, count + 1);
}
}
return 0;
}
How to end C++ code directly from a constructor?
You should throw an exception, when the constructor fails, like this:
B() {
if(somethingBadHappened)
{
throw myException();
}
}
Be sure to catch exceptions in main()
and all thread entry functions.
Read more in Throwing exceptions from constructors. Read about Stack unwinding in How can I handle a destructor that fails.
Should we use exit() in C?
Rather than abort()
, the exit()
function in C is considered to be a "graceful" exit.
From C11 (N1570) 7.22.4.4/p2 The exit function (emphasis mine):
The
exit
function causes normal program termination to occur.
The Standard also says in 7.22.4.4/p4 that:
Next, all open streams with unwritten buffered data are flushed, all
open streams are closed, and all files created by thetmpfile
function
are removed.
It is also worth looking at 7.21.3/p5 Files:
If the
main
function returns to its original caller, or if theexit
function is called, all open files are closed (hence all output
streams are flushed) before program termination. Other paths to
program termination, such as calling theabort
function, need not
close all files properly.
However, as mentioned in comments below you can't assume that it will cover every other resource, so you may need to resort to atexit()
and define callbacks for their release individually. In fact it is exactly what atexit()
is intended to do, as it says in 7.22.4.2/p2 The atexit function:
The
atexit
function registers the function pointed to byfunc
, to be
called without arguments at normal program termination.
Notably, the C standard does not say precisely what should happen to objects of allocated storage duration (i.e. malloc()
), thus requiring you be aware of how it is done on particular implementation. For modern, host-oriented OS it is likely that the system will take care of it, but still you might want to handle this by yourself in order to silence memory debuggers such as Valgrind.
Related Topics
Visual Studio Code, #Include ≪Stdio.H≫ Saying "Add Include Path to Settings"
How to Call a Base Class'S Virtual Function If I'M Overriding It
Problem Sorting Using Member Function as Comparator
How to Find the Index of Current Object in Range-Based For Loop
Constants and Compiler Optimization in C++
When Should I Use C++ Private Inheritance
C++ Standard: Dereferencing Null Pointer to Get a Reference
Why Can't Variable Names Start With Numbers
Right Way to Split an Std::String into a Vector≪String≫
Why Are Arrays of References Illegal
How to Efficiently Select a Standard Library Container in C++11
Scope Resolution Operator Without a Scope
Why Will Std::Sort Crash If the Comparison Function Is Not as Operator ≪
How Do Promotion Rules Work When the Signedness on Either Side of a Binary Operator Differ