Pointer Arithmetic in C Explained — How, Why, and When to Use It

#include <stdio.h>

int main(void) {
    int   scores[5]  = {10, 20, 30, 40, 50};
    char  letters[5] = {'A', 'B', 'C', 'D', 'E'};
    double temps[5]  = {36.6, 37.1, 38.0, 36.9, 37.5};

    int    *score_ptr  = scores;   /* points to scores[0]  */
    char   *letter_ptr = letters;  /* points to letters[0] */
    double *temp_ptr   = temps;    /* points to temps[0]   */

    /* Adding 1 to each pointer — watch how far each jumps */
    printf("=== Type sizes on this machine ===\n");
    printf("sizeof(int)    = %zu bytes\n", sizeof(int));
    printf("sizeof(char)   = %zu bytes\n", sizeof(char));
    printf("sizeof(double) = %zu bytes\n", sizeof(double));

    printf("\n=== Address jump when pointer is incremented by 1 ===\n");
    printf("score_ptr  before: %p\n", (void *)score_ptr);
    printf("score_ptr  after:  %p  (jumped %zu bytes)\n",
           (void *)(score_ptr + 1), sizeof(int));

    printf("letter_ptr before: %p\n", (void *)letter_ptr);
    printf("letter_ptr after:  %p  (jumped %zu bytes)\n",
           (void *)(letter_ptr + 1), sizeof(char));

    printf("temp_ptr   before: %p\n", (void *)temp_ptr);
    printf("temp_ptr   after:  %p  (jumped %zu bytes)\n",
           (void *)(temp_ptr + 1), sizeof(double));

    /* Prove array[i] == *(array + i) */
    printf("\n=== array[2] vs *(array + 2) ===\n");
    printf("scores[2]        = %d\n", scores[2]);          /* subscript form   */
    printf("*(scores + 2)    = %d\n", *(scores + 2));      /* pointer form     */
    printf("*(score_ptr + 2) = %d\n", *(score_ptr + 2));   /* via pointer var  */

    return 0;
}

#include <stdio.h>

/* Count characters in a string — reimplementing strlen with visible pointer steps */
size_t count_chars(const char *text) {
    const char *cursor = text;   /* cursor walks forward; text stays at the start */
    while (*cursor != '\0') {    /* dereference: read the byte cursor is pointing at */
        cursor++;                /* move cursor one char (1 byte) forward           */
    }
    /* Subtracting two pointers gives element count between them, not byte count */
    return (size_t)(cursor - text);
}

/* Sum a slice of an integer array — no index needed, just start + end pointers */
int sum_range(const int *start, const int *end) {
    int total = 0;
    /* 'end' is one-past-the-last valid element — a standard C idiom */
    for (const int *ptr = start; ptr < end; ptr++) {
        total += *ptr;           /* dereference ptr to read the current element */
    }
    return total;
}

/* Find the first negative number in an array; return pointer to it or NULL */
int *find_first_negative(int *data, size_t count) {
    int *ptr = data;
    int *sentinel = data + count;   /* one past the end — do NOT dereference this */
    while (ptr < sentinel) {
        if (*ptr < 0) return ptr;   /* return the actual address inside the array */
        ptr++;
    }
    return NULL;   /* no negative found */
}

int main(void) {
    /* --- String traversal --- */
    const char *message = "TheCodeForge";
    printf("String: \"%s\"\n", message);
    printf("Length via count_chars: %zu\n", count_chars(message));

    /* --- Slice summing --- */
    int readings[8] = {12, 7, 34, 5, 89, 23, 61, 4};
    /* Sum only elements at index 2, 3, 4 (readings[2] through readings[4]) */
    int slice_sum = sum_range(readings + 2, readings + 5);
    printf("\nReadings array: {12, 7, 34, 5, 89, 23, 61, 4}\n");
    printf("Sum of slice [2..4]: %d  (expected: 34+5+89 = 128)\n", slice_sum);

    /* --- Finding negative values --- */
    int temperatures[6] = {22, 18, -3, 25, -1, 30};
    int *first_negative = find_first_negative(temperatures, 6);

    if (first_negative != NULL) {
        /* Pointer subtraction tells us which index it landed on */
        ptrdiff_t index = first_negative - temperatures;
        printf("\nFirst negative: %d at index %td\n", *first_negative, index);
    }

    return 0;
}

#include <stdio.h>
#include <stddef.h>

int main(void) {
    int buffer[5] = {100, 200, 300, 400, 500};
    int *start = buffer;          /* points to buffer[0] */
    int *end   = buffer + 5;      /* one-past-end: valid ADDRESS, never dereference */

    /* === LEGAL: integer + pointer === */
    int *third_element = start + 2;       /* buffer[2], address is buffer_base + 8  */
    printf("Legal: start + 2 = %d\n", *third_element);

    /* === LEGAL: pointer - pointer (same array) === */
    ptrdiff_t distance = end - start;     /* gives 5 — element count, not byte count */
    printf("Legal: end - start = %td elements\n", distance);

    /* === LEGAL: pointer comparison within same array === */
    int *cursor = start;
    int count   = 0;
    while (cursor < end) {   /* cursor < end is legal — both point into buffer */
        count++;
        cursor++;
    }
    printf("Legal: counted %d elements via pointer comparison\n", count);

    /* === LEGAL: one-past-end address computation (no dereference) === */
    printf("Legal: end address computed = %p (not dereferenced)\n", (void *)end);

    /* === ILLEGAL (commented out to keep this code safe to run) ===

    // 1. Adding two pointers — compile error:
    //    int *bad = start + end;   // error: invalid operands to binary +

    // 2. Subtracting pointers from DIFFERENT arrays — undefined behaviour:
    //    int other[5] = {1,2,3,4,5};
    //    ptrdiff_t garbage = buffer - other;  // UB: might crash, might return wrong value

    // 3. Dereferencing one-past-end — undefined behaviour:
    //    int forbidden = *end;   // UB: reading memory that isn't yours

    // 4. Pointer arithmetic past the bounds — undefined behaviour:
    //    int *too_far = start + 10;  // UB even before dereferencing on some platforms
    */

    printf("\nAll legal operations completed safely.\n");
    return 0;
}

#include <stdio.h>
#include <string.h>   /* memcpy  */
#include <stdint.h>   /* uint8_t */
#include <stddef.h>   /* ptrdiff_t, size_t */

#define BUFFER_CAPACITY 64

typedef struct {
    uint8_t  storage[BUFFER_CAPACITY]; /* raw byte storage                        */
    uint8_t *write_ptr;                /* where the next byte will be written     */
    uint8_t *end_ptr;                  /* one-past-end sentinel for bounds checks */
} WriteBuffer;

void buffer_init(WriteBuffer *buf) {
    buf->write_ptr = buf->storage;                  /* start at the beginning     */
    buf->end_ptr   = buf->storage + BUFFER_CAPACITY;/* one past the last byte     */
}

/* Returns bytes used so far */
size_t buffer_used(const WriteBuffer *buf) {
    return (size_t)(buf->write_ptr - buf->storage); /* pointer subtraction = count */
}

/* Returns bytes remaining */
size_t buffer_remaining(const WriteBuffer *buf) {
    return (size_t)(buf->end_ptr - buf->write_ptr); /* space left to write into   */
}

/* Write a 32-bit integer into the buffer (big-endian) */
int buffer_write_int32(WriteBuffer *buf, int32_t value) {
    if (buffer_remaining(buf) < sizeof(int32_t)) {
        return -1;  /* not enough space */
    }
    /* memcpy is the safe way to write non-char data through a byte pointer */
    memcpy(buf->write_ptr, &value, sizeof(int32_t));
    buf->write_ptr += sizeof(int32_t); /* advance past the 4 bytes we just wrote */
    return 0;
}

/* Write a null-terminated string (without the null terminator) into the buffer */
int buffer_write_string(WriteBuffer *buf, const char *text) {
    size_t text_length = strlen(text);
    if (buffer_remaining(buf) < text_length) {
        return -1;  /* not enough space */
    }
    memcpy(buf->write_ptr, text, text_length);
    buf->write_ptr += text_length;     /* advance past the string bytes we wrote  */
    return 0;
}

int main(void) {
    WriteBuffer packet;
    buffer_init(&packet);

    printf("Buffer capacity: %d bytes\n", BUFFER_CAPACITY);
    printf("Initial — used: %zu, remaining: %zu\n",
           buffer_used(&packet), buffer_remaining(&packet));

    /* Write a 32-bit sensor ID */
    int32_t sensor_id = 4029;
    buffer_write_int32(&packet, sensor_id);
    printf("After writing int32 (%d) — used: %zu, remaining: %zu\n",
           sensor_id, buffer_used(&packet), buffer_remaining(&packet));

    /* Write a status string */
    const char *status = "SENSOR_OK";
    buffer_write_string(&packet, status);
    printf("After writing string (\"%s\") — used: %zu, remaining: %zu\n",
           status, buffer_used(&packet), buffer_remaining(&packet));

    /* Write another int */
    int32_t timestamp = 1718000000;
    buffer_write_int32(&packet, timestamp);
    printf("After writing timestamp (%d) — used: %zu, remaining: %zu\n",
           timestamp, buffer_used(&packet), buffer_remaining(&packet));

    /* Show the raw bytes written */
    printf("\nRaw bytes in buffer (%zu total):\n", buffer_used(&packet));
    for (uint8_t *p = packet.storage; p < packet.write_ptr; p++) {
        /* Print hex for non-printable bytes, char for printable ones */
        if (*p >= 32 && *p < 127)
            printf(" '%c'", *p);
        else
            printf(" %02X", *p);
    }
    printf("\n");

    return 0;
}