unsigned / signed / const / volatile

// Declares an unsigned integer type (non-negative values only).
unsigned int variableName;
unsigned char variableName;

// Declares a signed integer type (can hold negative values). This is the default.
signed int variableName;

// Declares a constant whose value cannot be changed.
const type variableName = value;

// Suppresses compiler optimization for this variable.
volatile type variableName;

// You can also combine multiple qualifiers.
const unsigned int variableName = value;

#include <stdio.h>

int main(void) {
    // unsigned int holds non-negative integers.
    unsigned int population = 1280000000u; // The 'u' suffix denotes an unsigned constant.
    printf("Population: %u\n", population); // Outputs: Population: 1280000000

    // unsigned char is useful for processing byte data.
    unsigned char byte = 255;
    printf("Byte value: %u\n", byte); // Outputs: Byte value: 255

    // Observe the difference in overflow behavior.
    unsigned int u = 0;
    u = u - 1; // For unsigned types, 0 - 1 wraps around to the maximum value.
    printf("unsigned wraparound: %u\n", u); // Outputs: 4294967295

    // Declare constants with const.
    const double PI = 3.14159265358979;
    const int MAX_SIZE = 100;
    printf("Pi: %f\n", PI);
    printf("Max size: %d\n", MAX_SIZE);
    // PI = 3.0; // This would cause a compile error.

    // volatile is used for hardware registers and interrupt variables.
    volatile int sensor_value = 0;
    // The compiler will not optimize away accesses to this variable.
    printf("Sensor value: %d\n", sensor_value);

    // Combining const and volatile (e.g., a read-only hardware register).
    // const volatile int *reg = (int *)0x40000000;

    return 0;
}

The unsigned type extends the range of positive values by not supporting negative numbers. Mixing signed and unsigned types in arithmetic can produce unexpected results. Unsigned types also take precedence in comparison operations, so extra care is required.

const tells the compiler that a value will not be changed, allowing invalid assignments to be caught at compile time. It provides better type checking than macro-based constants using #define, so using const is recommended in C99 and later. For more on macros, see #include / #define (Constants).

volatile is important in hardware control and embedded programming. Compilers may apply optimizations such as register caching, but these optimizations can cause incorrect behavior for variables whose values may change externally. You can check the actual size of each type using sizeof.