KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

assert en NDEBUG: uitschakelbare controles tijdens uitvoering

`assert` controleert tijdens de uitvoering een interne aanname. Met `NDEBUG` kan de controle vervallen zonder dat de voorwaarde wordt geëvalueerd. Dit heeft geen invloed op `static_assert`.

Versie: ISO C++23; implementation support may vary

Syntax

#include <cassert>
assert(condition);

In C++23 is assert(condition) uit <cassert> een functieachtige macro, geen functie met de naam std::assert. Als de controle aanstaat en tijdens de uitvoering wordt bereikt, wordt de voorwaarde van een scalair type geëvalueerd. Is het resultaat ongelijk aan nul, dan gaat het programma verder. Anders schrijft de macro een diagnostische melding naar de standaardfoutuitvoer en roept ze std::abort() aan, waardoor het programma abnormaal eindigt. De implementatie bepaalt de vorm van de melding.

Als NDEBUG bij het opnemen van <cassert> is gedefinieerd, expandeert assert(condition) naar ((void)0) en wordt de voorwaarde niet geëvalueerd. Alleen het bestaan van de definitie telt: ook #define NDEBUG 0 schakelt assertions uit. Bij elke opname van de header telt de huidige toestand van NDEBUG. Een latere wijziging zonder de header opnieuw op te nemen verandert de bestaande definitie van assert niet. Een configuratienaam als Release bepaalt dit niet op zichzelf.

Gebruik assert voor interne invarianten, niet voor invoervalidatie, toegangscontrole of herstelbare fouten. Houd noodzakelijke bewerkingen zoals ++count buiten assertions. In C++23 neemt de macro één argument: bevat de expressie een komma die niet door ronde haakjes wordt afgeschermd, zet dan een extra paar haakjes om de hele expressie.

static_assert is een taaldeclaratie, geen macro. De declaratie controleert een constante expressie tijdens het compileren; bij een mislukte controle is het programma niet welgevormd. NDEBUG kan deze controle niet uitschakelen.

Voorbeelden

#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);
}

Resultaat

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.

Met assertions ingeschakeld toont het programma zonder extra argument `Reached the next statement.`. Met `extra` schrijft het een diagnostische melding naar de standaardfoutuitvoer en eindigt het abnormaal voordat die regel verschijnt. Met `NDEBUG` verschijnt de regel ook met `extra`, omdat `argc == 1` niet wordt geëvalueerd.

Gerelateerde lessen

  • C++ · Les 49 · Gemiddeld · Versie: 2

Bronnen