C Language
Twierdzenie

Wprowadzenie

Składnia

• assert (wyrażenie)
• static_assert (wyrażenie, komunikat)
• _Static_assert (wyrażenie, komunikat)

Parametry

Uwagi

#ifdef NDEBUG
#  define assert(condition) ((void) 0)
#else
#  define assert(condition) /* implementation defined */
#endif

Warunki wstępne i dodatkowe

Jednym z przypadków użycia dla asercji jest warunek wstępny i późniejszy. Może to być bardzo przydatne do utrzymania niezmienności i projektu na podstawie umowy . Na przykład długość jest zawsze zerowa lub dodatnia, więc ta funkcja musi zwrócić wartość zerową lub dodatnią.

#include <stdio.h>
/* Uncomment to disable `assert()` */
/* #define NDEBUG */
#include <assert.h>

int length2 (int *a, int count)
{
    int i, result = 0;

    /* Precondition: */
    /* NULL is an invalid vector */
    assert (a != NULL);
    /* Number of dimensions can not be negative.*/ 
    assert (count >= 0);

    /* Calculation */
    for (i = 0; i < count; ++i) 
    {
        result = result + (a[i] * a[i]);
    }

    /* Postcondition: */
    /* Resulting length can not be negative. */
    assert (result >= 0);
    return result;
}

#define COUNT 3

int main (void)
{
    int a[COUNT] = {1, 2, 3};
    int *b = NULL;
    int r;
    r = length2 (a, COUNT);
    printf ("r = %i\n", r);
    r = length2 (b, COUNT);
    printf ("r = %i\n", r);
    return 0;
}

Proste stwierdzenie

Asercja to instrukcja używana do stwierdzenia, że fakt musi być prawdziwy po osiągnięciu tego wiersza kodu. Asercje są przydatne do zapewnienia spełnienia oczekiwanych warunków. Gdy warunek przekazany do asercji jest spełniony, nie ma akcji. Zachowanie w fałszywych warunkach zależy od flag kompilatora. Gdy asercje są włączone, fałszywe dane wejściowe powodują natychmiastowe zatrzymanie programu. Gdy są wyłączone, nie są podejmowane żadne działania. Powszechną praktyką jest włączanie asercji w kompilacjach wewnętrznych i debugujących oraz wyłączanie ich w kompilacjach wersji, chociaż asercje są często włączane w wersji. (To, czy zakończenie jest lepsze czy gorsze od błędów, zależy od programu). Asercji należy używać wyłącznie do wychwytywania wewnętrznych błędów programistycznych, co zwykle oznacza, że przekazywane są złe parametry.

#include <stdio.h>
/* Uncomment to disable `assert()` */
/* #define NDEBUG */
#include <assert.h>

int main(void)
{
    int x = -1;
    assert(x >= 0);

    printf("x = %d\n", x);   
    return 0;
}

Możliwe dane wyjściowe z niezdefiniowanym NDEBUG :

a.out: main.c:9: main: Assertion `x >= 0' failed.

Możliwe dane wyjściowe ze zdefiniowanym NDEBUG :

x = -1

Dobrą praktyką jest globalne definiowanie NDEBUG , abyś mógł łatwo skompilować kod ze wszystkimi NDEBUG , zarówno włączonymi jak i wyłączanymi. Łatwym sposobem na to jest zdefiniowanie NDEBUG jako opcji kompilatora lub zdefiniowanie go we wspólnym nagłówku konfiguracji (np. config.h ).

Twierdzenie statyczne

#include <assert.h>

enum {N = 5};
_Static_assert(N == 5, "N does not equal 5");
static_assert(N > 10, "N is not greater than 10");  /* compiler error */

#define STATIC_MSG(msg, l) STATIC_MSG2(msg, l)
#define STATIC_MSG2(msg,l) on_line_##l##__##msg
#define STATIC_ASSERT(x, msg) extern char STATIC_MSG(msg, __LINE__) [(x)?1:-1]
 
enum { N = 5 };
STATIC_ASSERT(N == 5, N_must_equal_5);
STATIC_ASSERT(N > 5, N_must_be_greater_than_5); /* compile error */

Asercja nieosiągalnego kodu

Podczas programowania, gdy pewne ścieżki kodu muszą być zabezpieczone przed zasięgiem przepływu sterowania, można użyć funkcji assert(0) aby wskazać, że taki warunek jest błędny:

switch (color) {
    case COLOR_RED:
    case COLOR_GREEN:
    case COLOR_BLUE:
        break;

    default:
        assert(0);
}

Ilekroć argument assert() wartość false, makro zapisuje informacje diagnostyczne do standardowego strumienia błędów, a następnie przerywa działanie programu. Informacje te obejmują numer pliku i linii instrukcji assert() i mogą być bardzo pomocne w debugowaniu. Aserty można wyłączyć, definiując makro NDEBUG .

Innym sposobem zakończenia programu w przypadku wystąpienia błędu jest exit ze standardowej funkcji bibliotecznej, quick_exit exit lub abort . exit i quick_exit przyjmują argument, który można przekazać z powrotem do środowiska. abort() (i tym samym assert ) może być naprawdę poważnym zakończeniem twojego programu, a niektóre porządki, które w innym przypadku zostałyby wykonane na końcu wykonania, mogą nie zostać wykonane.

Podstawową zaletą assert() jest to, że automatycznie drukuje informacje debugowania. Wywołanie abort() ma tę zaletę, że nie można go wyłączyć jak aser, ale nie może powodować wyświetlania żadnych informacji debugujących. W niektórych sytuacjach jednoczesne użycie obu konstruktów może być korzystne:

if (color == COLOR_RED || color == COLOR_GREEN) {
   ...
} else if (color == COLOR_BLUE) {
   ...
} else {
   assert(0), abort();
}

Gdy asserty są włączone , wywołanie assert() spowoduje wydrukowanie informacji debugowania i zakończenie programu. Wykonanie nigdy nie osiąga wywołania abort() . Gdy aserty są wyłączone , wywołanie assert() nic nie robi i wywoływana jest funkcja abort() . Zapewnia to, że program zawsze kończy działanie z powodu tego błędu; włączanie i wyłączanie zapewnia tylko efekty, niezależnie od tego, czy wydrukowane jest wyjście debugowania.

Nigdy nie należy pozostawiać takiego assert w kodzie produkcyjnym, ponieważ informacje debugowania nie są pomocne dla użytkowników końcowych i ponieważ abort jest na ogół zbyt surowym zakończeniem, które quick_exit procedury czyszczące zainstalowane dla exit lub quick_exit uruchomienia.

Potwierdź komunikaty o błędach

Istnieje sztuczka, która może wyświetlać komunikat o błędzie wraz z asercją. Zwykle piszesz taki kod

void f(void *p)
{
    assert(p != NULL);
    /* more code */
}

Jeśli asercja się nie powiedzie, komunikat o błędzie będzie podobny

Asercja nie powiodła się: p! = NULL, plik main.c, wiersz 5

Możesz jednak użyć logicznego AND ( && ) również do wyświetlenia komunikatu o błędzie

void f(void *p)
{
    assert(p != NULL && "function f: p cannot be NULL");
    /* more code */
}

Teraz, jeśli asercja się nie powiedzie, komunikat o błędzie przeczyta coś takiego

Asercja nie powiodła się: p! = NULL && "funkcja f: p nie może być NULL", plik main.c, wiersz 5

Powodem, dla którego to działa, jest to, że literał łańcuchowy zawsze zwraca wartość niezerową (prawda). Dodanie && 1 do wyrażenia logicznego nie ma żadnego efektu. Zatem dodanie && "error message" również nie ma żadnego efektu, poza tym, że kompilator wyświetli całe wyrażenie, które nie powiodło się.