Use exit(EXIT_FAILURE) if you want to exit normally and have an error code that you may be able to test from the shell. Use abort if you want to flag a critical error and generate a core dump.

std::terminate is a C++ feature that is typically called when an exception is thrown without a corresponding catch block. Typically you would override this with something that outputs the trouble to your log.

There is also std::unexpected_handler which calls std::terminate by default. std::unexpected_handler is called when you throw an exception that is not allowed by the throw specifiers.

// foo may throw *only* int, char, or short.
void foo() throw(int, char, short)
{
    throw float(25);
}

void main()
{
    // Here std::unexpected_handler will be called which then calls std::terminate which then calls abort.
    foo();

    // Here std::terminate will be called which calls abort.
    throw 5;
}

std::set_terminate
std::set_unexpected

Thanks for your answers. But there are still questions left.

Isn't a program termination without cleanup a bad thing? Even if the program doesn't work as it should?

Is the core dump the only benefit of using abort?

I'm not sure if there's any reason to call abort or terminate directly.

So if I have a case where something can go wrong, I throw an exception. I can think of two cases. Please tell me what do you think about it.

1. I don't catch the exception. It's a programming error. I get the core dump and I'm able to debug my program. This kind of error shouldn't ever get in touch with the enduser.

example:

an array index out of range.

2. I catch the exception to handle it. (retry with different settings, or output an error message). This kind of error depends on the surroundings. System settings, data files or user input. It's not a programming error.

example:

couldn't find a bitmap file.