CKTIS / C++
assert und NDEBUG: abschaltbare Laufzeitprüfungen
`assert` prüft eine interne Annahme zur Laufzeit. Ist `NDEBUG` definiert, kann die Prüfung entfallen, ohne die Bedingung auszuwerten. `static_assert` bleibt davon unberührt.
Version: ISO C++23; implementation support may vary
Syntax
#include <cassert>
assert(condition);In C++23 ist assert(condition) aus <cassert> ein funktionsartiges Makro, keine Funktion namens std::assert. Ist die Prüfung aktiviert und wird sie bei der Ausführung erreicht, wertet das Makro die Bedingung mit skalarem Typ aus. Ist das Ergebnis ungleich null, läuft das Programm weiter. Andernfalls schreibt es eine Diagnose auf die Standardfehlerausgabe und ruft std::abort() auf, wodurch das Programm abnormal beendet wird. Das Format der Diagnose ist implementierungsdefiniert.
Ist NDEBUG beim Einbinden von <cassert> definiert, expandiert assert(condition) zu ((void)0), und die Bedingung wird nicht ausgewertet. Es zählt nur, ob das Makro definiert ist: Auch #define NDEBUG 0 schaltet die Prüfungen aus. Jedes Einbinden des Headers verwendet den aktuellen Zustand von NDEBUG. Eine spätere Änderung ohne erneutes Einbinden ändert die bestehende Definition von assert nicht. Eine Bezeichnung wie Release entscheidet darüber nicht von sich aus.
Nutze assert für interne Invarianten, nicht für Eingabevalidierung, Zugriffskontrollen oder behebbare Fehler. Notwendige Operationen wie ++count gehören nicht in eine Assertion. In C++23 nimmt das Makro ein Argument entgegen: Enthält der Ausdruck ein Komma, das nicht durch runde Klammern geschützt ist, setze den gesamten Ausdruck in ein zusätzliches Klammerpaar.
static_assert ist eine Sprachdeklaration, kein Makro. Sie prüft einen konstanten Ausdruck zur Übersetzungszeit. Schlägt die Prüfung fehl, ist das Programm nicht wohlgeformt. NDEBUG kann sie nicht abschalten.
Beispiele
#include <cerrno>
#include <csignal>
#include <cstdio>
#include <cstring>
#include <memory>
#include <string>
#include <sys/wait.h>
#include <unistd.h>
#undef NDEBUG
#include <cassert>
static void check_enabled(int argc)
{
assert(argc == 1);
}
#define NDEBUG
#include <cassert>
static void check_disabled([[maybe_unused]] int argc)
{
assert(argc == 1);
}
static constexpr char next_statement[] = "Reached the next statement.";
static bool read_output(std::FILE* file, std::string& text)
{
if (std::fseek(file, 0, SEEK_SET) != 0)
return false;
char buffer[256];
while (const auto n = std::fread(buffer, 1, sizeof buffer, file))
text.append(buffer, n);
return !std::ferror(file);
}
static bool run(const char* executable, const char* name, const char* extra,
bool should_abort, std::string& transcript)
{
using File = std::unique_ptr<std::FILE, decltype(&std::fclose)>;
File out(std::tmpfile(), &std::fclose);
File err(std::tmpfile(), &std::fclose);
if (!out || !err)
return false;
const pid_t child = fork();
if (child < 0)
return false;
if (child == 0) {
if (dup2(fileno(out.get()), STDOUT_FILENO) < 0 ||
dup2(fileno(err.get()), STDERR_FILENO) < 0)
_exit(126);
// Re-execute this binary with the displayed name as argv[0].
if (extra)
execlp(executable, name, extra, static_cast<char*>(nullptr));
else
execlp(executable, name, static_cast<char*>(nullptr));
_exit(127);
}
int status;
pid_t waited;
do {
waited = waitpid(child, &status, 0);
} while (waited < 0 && errno == EINTR);
if (waited != child)
return false;
std::string stdout_text, stderr_text;
if (!read_output(out.get(), stdout_text) || !read_output(err.get(), stderr_text))
return false;
if (should_abort) {
if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGABRT ||
!stdout_text.empty() || stderr_text.empty())
return false;
} else if (!WIFEXITED(status) || WEXITSTATUS(status) != 0 ||
stdout_text != std::string(next_statement) + '\n' || !stderr_text.empty()) {
return false;
}
transcript += name;
if (extra) {
transcript += ' ';
transcript += extra;
}
transcript += "\n stdout: ";
if (should_abort) {
transcript += "empty\n stderr: assertion diagnostic (exact text varies)\n"
" Abnormal termination via std::abort().\n";
} else {
transcript += stdout_text;
}
return true;
}
int main(int argc, char** argv)
{
if (std::strcmp(argv[0], "./assert-on") == 0) {
check_enabled(argc);
} else if (std::strcmp(argv[0], "./assert-off") == 0) {
check_disabled(argc);
} else {
std::string transcript = "Expected results:\n";
if (!run(argv[0], "./assert-on", nullptr, false, transcript) ||
!run(argv[0], "./assert-on", "extra", true, transcript) ||
!run(argv[0], "./assert-off", "extra", false, transcript)) {
std::fputs("Unexpected result from an assertion test run.\n", stderr);
return 1;
}
transcript.pop_back();
return std::fputs(transcript.c_str(), stdout) == EOF ? 1 : 0;
}
std::puts(next_statement);
}Ergebnis
Expected results: ./assert-on stdout: Reached the next statement. ./assert-on extra stdout: empty stderr: assertion diagnostic (exact text varies) Abnormal termination via std::abort(). ./assert-off extra stdout: Reached the next statement.
Mit aktivierten Assertions erscheint ohne zusätzliches Argument `Reached the next statement.`. Mit `extra` schreibt das Programm eine Diagnose auf die Standardfehlerausgabe und bricht vor dieser Zeile ab. Mit `NDEBUG` erscheint die Zeile auch mit `extra`, weil `argc == 1` nicht ausgewertet wird.
Zugehörige Lektionen
- C++ · Lektion 49 · Mittlere Stufe · Version: 2