Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

assert e NDEBUG: verificações desativáveis em tempo de execução

`assert` verifica um pressuposto interno em tempo de execução. Definir `NDEBUG` pode desativar a verificação sem avaliar a condição, mas não afeta `static_assert`.

Versão: ISO C++23; implementation support may vary

Sintaxe

#include <cassert>
assert(condition);

Em C++23, assert(condition), fornecida por <cassert>, é uma macro do tipo função, não uma função com o nome std::assert. Quando está ativa e é atingida durante a execução, avalia a condição de tipo escalar. Se o resultado for diferente de zero, a execução prossegue. Caso contrário, escreve um diagnóstico no fluxo de erro padrão e chama std::abort(), terminando o programa de forma anormal. O formato do diagnóstico depende da implementação.

Se NDEBUG estiver definida ao incluir <cassert>, assert(condition) expande-se para ((void)0) e a condição não é avaliada. Basta que a macro esteja definida: #define NDEBUG 0 também desativa as asserções. Cada inclusão do cabeçalho usa o estado atual de NDEBUG. Alterá-lo depois sem voltar a incluir o cabeçalho não modifica a definição existente de assert. Um nome de configuração como Release não determina, por si só, este comportamento.

Usa assert para invariantes internos, não para validar dados de entrada, controlar acessos ou tratar erros recuperáveis. Mantém operações essenciais, como ++count, fora das asserções. Em C++23, a macro aceita um único argumento: se a expressão contiver uma vírgula não protegida por parênteses, envolve toda a expressão num par adicional de parênteses.

static_assert é uma declaração da linguagem, não uma macro. Verifica uma expressão constante em tempo de compilação. Se a asserção falhar, o programa fica malformado. NDEBUG não a pode desativar.

Exemplos

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

Resultado

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.

Com as asserções ativas, o programa escreve `Reached the next statement.` sem um argumento adicional. Com `extra`, escreve um diagnóstico no fluxo de erro padrão e termina de forma anormal antes de escrever essa linha. Com `NDEBUG`, escreve a linha mesmo com `extra`, porque não avalia `argc == 1`.

Lições relacionadas

  • C++ · Lição 49 · Intermédio · Versão: 2

Fontes