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