CKTIS / C++
assert et NDEBUG : assertions désactivables à l’exécution
`assert` vérifie une hypothèse interne à l’exécution. Définir `NDEBUG` peut désactiver la vérification sans évaluer sa condition, mais n’a aucun effet sur `static_assert`.
Version : ISO C++23; implementation support may vary
Syntaxe
#include <cassert>
assert(condition);En C++23, assert(condition), fourni par <cassert>, est une macro de type fonction, pas une fonction nommée std::assert. Si l’assertion est activée et que l’exécution l’atteint, la macro évalue la condition de type scalaire. Si le résultat est différent de zéro, l’exécution se poursuit. Sinon, elle écrit un diagnostic sur le flux d’erreur standard et appelle std::abort(), ce qui termine anormalement le programme. Le format du diagnostic dépend de l’implémentation.
Si NDEBUG est définie à l’inclusion de <cassert>, assert(condition) se développe en ((void)0) et la condition n’est pas évaluée. Seule la présence de la définition compte : #define NDEBUG 0 désactive aussi les assertions. Chaque inclusion de l’en-tête tient compte de l’état courant de NDEBUG. Changer cet état ensuite sans réinclure l’en-tête ne modifie pas la définition existante de assert. Un nom de configuration tel que Release ne détermine pas à lui seul ce comportement.
Utilisez assert pour les invariants internes, pas pour valider les entrées, contrôler les accès ou traiter les erreurs récupérables. Gardez les opérations indispensables, comme ++count, hors des assertions. En C++23, la macro prend un seul argument : si l’expression contient une virgule non protégée par des parenthèses, entourez l’expression entière d’une paire de parenthèses supplémentaire.
static_assert est une déclaration du langage et non une macro. Elle vérifie une expression constante à la compilation. Si l’assertion échoue, le programme est mal formé. NDEBUG ne peut pas la désactiver.
Exemples
#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);
}Résultat
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.
Avec les assertions activées, le programme affiche `Reached the next statement.` sans argument supplémentaire. Avec `extra`, il écrit un diagnostic sur le flux d’erreur standard et s’arrête avant d’afficher cette ligne. Avec `NDEBUG`, il affiche la ligne même avec `extra`, car il n’évalue pas `argc == 1`.
Leçons associées
- C++ · Leçon 49 · Intermédiaire · Version : 2