Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

assert y NDEBUG: comprobaciones de ejecución desactivables

`assert` comprueba una suposición interna durante la ejecución. Definir `NDEBUG` puede desactivar la comprobación sin evaluar su condición, pero no afecta a `static_assert`.

Versión: ISO C++23; implementation support may vary

Sintaxis

#include <cassert>
assert(condition);

En C++23, assert(condition) de <cassert> es una macro de tipo función, no una función llamada std::assert. Si está habilitada y la ejecución llega a ella, evalúa la condición de tipo escalar. Si el resultado es distinto de cero, la ejecución continúa. De lo contrario, escribe un diagnóstico en el flujo de error estándar y llama a std::abort(), lo que termina el programa de forma anormal. El formato del diagnóstico depende de la implementación.

Si NDEBUG está definida al incluir <cassert>, assert(condition) se expande a ((void)0) y la condición no se evalúa. Solo importa si la macro está definida: #define NDEBUG 0 también desactiva las aserciones. Cada inclusión de la cabecera utiliza el estado actual de NDEBUG. Cambiarlo después sin volver a incluir la cabecera no modifica la definición existente de assert. Un nombre de configuración como Release no determina esto por sí solo.

Usa assert para invariantes internos, no para validar entradas, controlar el acceso ni gestionar errores recuperables. Deja las operaciones esenciales, como ++count, fuera de las aserciones. En C++23 la macro acepta un solo argumento: si la expresión contiene una coma no protegida por paréntesis, encierra toda la expresión entre un par adicional de paréntesis.

static_assert es una declaración del lenguaje, no una macro. Comprueba una expresión constante en tiempo de compilación. Si la aserción falla, el programa está mal formado. NDEBUG no puede desactivarla.

Ejemplos

#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.

Con las aserciones activadas, el programa imprime `Reached the next statement.` sin un argumento adicional. Con `extra`, escribe un diagnóstico en el flujo de error estándar y termina de forma anormal antes de imprimir esa línea. Con `NDEBUG`, imprime la línea incluso con `extra` porque no evalúa `argc == 1`.

Lecciones relacionadas

  • C++ · Lección 49 · Intermedio · Versión: 2

Fuentes