C assert.h Header

Key assert.h Features

assert(condition);

#define NDEBUG

// Assertions enabled by default

// No runtime overhead

🔹 Basic Assert Usage

Assertions verify program assumptions during development, catching logic errors early and preventing undefined behavior in production C code. The assert() macro checks conditions and terminates execution if assertions fail, displaying the failed condition and source location. Use assertions for internal consistency checks, precondition validation, and invariant verification. Assertions help document expected program behavior and catch bugs during testing phases. They're invaluable for debugging complex logic and ensuring program correctness during development cycles.

#include <stdio.h>
#include <assert.h>

int divide(int a, int b) {
    // Ensure we don't divide by zero
    assert(b != 0);
    return a / b;
}

int factorial(int n) {
    // Ensure input is non-negative
    assert(n >= 0);
    
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    int result;
    
    // These assertions will pass
    result = divide(10, 2);
    printf("10 / 2 = %d\n", result);
    
    result = factorial(5);
    printf("5! = %d\n", result);
    
    // This assertion will pass
    assert(result == 120);
    printf("Factorial calculation verified!\n");
    
    // Uncomment the next line to see assertion failure
    // result = divide(10, 0);  // This would terminate the program
    
    return 0;
}

10 / 2 = 5
5! = 120
Factorial calculation verified!

🔹 Array Bounds Checking

Using assertions to prevent array overflow protects against buffer overrun vulnerabilities and undefined behavior in array access operations. Implement assertions before array indexing to verify indices remain within valid ranges: assert(index >= 0 && index < size). This defensive programming technique catches boundary violations early during testing. Array bounds checking prevents memory corruption, crashes, and potential security exploits. Combined with other validation techniques, assertions significantly improve program robustness and reliability in production systems.

#include <stdio.h>
#include <assert.h>

#define ARRAY_SIZE 5

void safe_array_access(int arr[], int size, int index, int value) {
    // Verify array bounds
    assert(index >= 0);
    assert(index < size);
    assert(arr != NULL);
    
    arr[index] = value;
    printf("Set arr[%d] = %d\n", index, value);
}

int safe_array_get(int arr[], int size, int index) {
    assert(index >= 0);
    assert(index < size);
    assert(arr != NULL);
    
    return arr[index];
}

int main() {
    int numbers[ARRAY_SIZE] = {0};
    
    // Safe operations
    for (int i = 0; i < ARRAY_SIZE; i++) {
        safe_array_access(numbers, ARRAY_SIZE, i, i * 10);
    }
    
    printf("\nArray contents:\n");
    for (int i = 0; i < ARRAY_SIZE; i++) {
        int value = safe_array_get(numbers, ARRAY_SIZE, i);
        printf("numbers[%d] = %d\n", i, value);
    }
    
    // Uncomment to see assertion failure
    // safe_array_access(numbers, ARRAY_SIZE, 10, 999);  // Index out of bounds
    
    return 0;
}

Set arr[0] = 0
Set arr[1] = 10
Set arr[2] = 20
Set arr[3] = 30
Set arr[4] = 40

Array contents:
numbers[0] = 0
numbers[1] = 10
numbers[2] = 20
numbers[3] = 30
numbers[4] = 40

🔹 Disabling Assertions

Assertions can be disabled for release builds using the NDEBUG preprocessor flag to eliminate runtime overhead in production code. Define NDEBUG before including assert.h to compile assertions out completely. This approach maintains assertion benefits during development while ensuring production performance. Compile with gcc -DNDEBUG to disable assertions automatically. Understanding assertion lifecycle from development to deployment demonstrates professional coding practices. Strategic assertion usage balances thorough error checking with production performance requirements.

// Method 1: Define NDEBUG before including assert.h
#define NDEBUG
#include <assert.h>
#include <stdio.h>

// Method 2: Compile with -DNDEBUG flag
// gcc -DNDEBUG program.c -o program

int main() {
    int x = -5;
    
    printf("Starting program with x = %d\n", x);
    
    // This assertion would normally fail, but is disabled
    assert(x > 0);
    
    printf("This line executes because assertions are disabled\n");
    printf("In debug mode, the program would have terminated\n");
    
    // Show the difference
    #ifdef NDEBUG
        printf("NDEBUG is defined - assertions are disabled\n");
    #else
        printf("NDEBUG is not defined - assertions are enabled\n");
    #endif
    
    return 0;
}

Starting program with x = -5
This line executes because assertions are disabled
In debug mode, the program would have terminated
NDEBUG is defined - assertions are disabled

🔹 Best Practices

Effective assertion usage requires clear documentation, appropriate condition selection, and integration into comprehensive error handling strategies. Use assertions for programmer errors and invariant checks, not for user input validation. Write meaningful assertion messages describing expected conditions. Place assertions where bugs are likely and where catching errors early prevents cascading failures. Avoid side effects in assertion expressions since they won't execute in release builds. Following assertion best practices transforms them into powerful debugging and documentation tools.