База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

assert и NDEBUG: изключваеми проверки по време на изпълнение

`assert` проверява вътрешно допускане на програмата. Дефинирането на `NDEBUG` може да изключи проверката, без да се изчислява условието. Това не влияе на `static_assert`.

Версия: ISO C++23; implementation support may vary

Синтаксис

#include <cassert>
assert(condition);

В C++23 assert(condition) от <cassert> е функционално макро, а не функция с име std::assert. Ако проверката е включена и изпълнението стигне до нея, се изчислява условието от скаларен тип. Ако резултатът е различен от нула, изпълнението продължава. В противен случай макрото извежда диагностично съобщение в стандартния поток за грешки и извиква std::abort(), което прекратява програмата аварийно. Форматът на съобщението зависи от реализацията.

Ако NDEBUG е дефинирано при включването на <cassert>, assert(condition) се разгръща до ((void)0) и условието не се изчислява. Важно е само дали има дефиниция: #define NDEBUG 0 също изключва проверките. При всяко включване на заглавния файл се използва текущото състояние на NDEBUG. По-късна промяна без повторно включване не променя вече установената дефиниция на assert. Самото име на конфигурация като Release не определя това поведение.

Използвай assert за вътрешни инварианти, а не за валидиране на входни данни, контрол на достъпа или обработка на грешки, от които програмата може да се възстанови. Изпълнявай необходимите операции, като ++count, извън проверката. В C++23 макрото приема един аргумент: ако изразът съдържа запетая, която не е защитена от кръгли скоби, огради целия израз с още една двойка кръгли скоби.

static_assert е декларация на езика, а не макро. Тя проверява константен израз по време на компилация. Ако статичната проверка е неуспешна, програмата е некоректно формирана. NDEBUG не може да я изключи.

Примери

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

Резултат

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.

При включени проверки програмата извежда `Reached the next statement.`, когато няма допълнителен аргумент. С аргумент `extra` тя извежда диагностично съобщение в стандартния поток за грешки и прекратява аварийно, преди да отпечата реда. С `NDEBUG` редът се извежда и с `extra`, защото `argc == 1` не се изчислява.

Свързани уроци

  • C++ · Урок 49 · Средно · Версия: 2

Източници