std::abort(3)

💅 std::abort 💅

okay so this is std::abort(3), the C++ Standard Libary page for the function that yeets your program into abnormal termination — but like, in a standardized way. bestie, it is literally the “nope, we’re done here” function. 🫶

🌸 NAME 🌸

std::abort — yes bestie, it’s std::abort. no mystery, no plot twist, just the std::abort(3) manual page. it’s giving “abnormal program termination, but make it standard”. 💅

✨ Synopsis ✨

Defined in header <cstdlib>, and the signature changed in C++11, so keep up:

Defined in header <cstdlib>
void abort();                        (until C++11)
[[noreturn]] void abort() noexcept;  (since C++11)

Translation: before C++11 it’s plain void abort();; since C++11 it’s [[noreturn]] void abort() noexcept;.

okay so what does it actually do? std::abort causes abnormal program termination unless SIGABRT is being caught by a signal handler passed to std::signal and the handler does not return. no cap.

Destructors of variables with automatic, thread local (since C++11) and static storage durations are not called. Functions registered with std::atexit() and std::at_quick_exit (since C++11) are also not called. Whether open resources such as files are closed is implementation defined. An implementation defined status is returned to the host environment that indicates unsuccessful execution.

🎀 Parameters 🎀

(none) — bestie, there are literally no parameters. zero arguments, zero notes, zero chill. 💀

🔥 Return value 🔥

None because it does not return. not a drill, not a vibe, it literally never comes back. 😭

💜 Exceptions 💜

Throws nothing. periodt.

🌈 Notes 🌈

• POSIX specifies that the abort() function overrides blocking or ignoring the SIGABRT signal.
• Some compiler intrinsics, e.g. __builtin_trap (gcc, clang, and icc) or __fastfail/__debugbreak (msvc), can be used to terminate the program as fast as possible.

🧚 Example 🧚

okay this is the whole demo, bestie — run it and watch the destructors not show up:

// Run this code

#include <csignal>
#include <cstdlib>
#include <iostream>

class Tester
{
public:
    Tester()  { std::cout << "Tester ctor\n"; }
    ~Tester() { std::cout << "Tester dtor\n"; }
};

Tester static_tester; // Destructor not called

void signal_handler(int signal)
{
    if (signal == SIGABRT)
        std::cerr << "SIGABRT received\n";
    else
        std::cerr << "Unexpected signal " << signal << " received\n";
    std::_Exit(EXIT_FAILURE);
}

int main()
{
    Tester automatic_tester; // Destructor not called

    // Setup handler
    auto previous_handler = std::signal(SIGABRT, signal_handler);
    if (previous_handler == SIG_ERR)
    {
        std::cerr << "Setup failed\n";
        return EXIT_FAILURE;
    }

    std::abort(); // Raise SIGABRT
    std::cout << "This code is unreachable\n";
}

Output:

Tester ctor
Tester ctor
SIGABRT received

notice: no Tester dtor lines, because destructors don’t run here. the vibe check failed on purpose 💅

⭐ See also ⭐

• exit — causes normal program termination with cleaning up (function)
• atexit — registers a function to be called on std::exit() invocation (function)
• quick_exit — causes quick program termination without completely cleaning up (C++11) (function)
• at_quick_exit — registers a function to be called on std::quick_exit invocation (C++11) (function)
• signal — sets a signal handler for particular signal (function)
• terminate — function called when exception handling fails (function)
• C documentation for abort

---

mwah 💋 this page’s source is http://cppreference.com, version/date 2024.06.10, and it’s the std::abort(3) manual page. byeee, go terminate something abnormally (responsibly) 🫶✨