C String memchr() Function

What You’ll Learn

The memchr() function from <string.h> locates the first occurrence of a byte value within a memory region of length n. Unlike strchr(), it does not require a null terminator—making it ideal for strings, fixed buffers, and binary data alike.

Definition and Usage

In C, memchr() is declared in <string.h>. It examines exactly n bytes starting at pointer s, comparing each byte to c after converting c to unsigned char. The scan stops at the first match or after n bytes—whichever comes first.

When a match is found, the return value points into the original memory block. Subtract the base pointer ((char*)result - (char*)s) to get a zero-based index. Always check for NULL before using the result.

📝 Syntax

The standard library declaration:

void *memchr(const void *s, int c, size_t n);

Parameters

• s — pointer to the memory block to search.
• c — byte value to find, passed as int and converted to unsigned char (e.g. 'C' or 67).
• n — maximum number of bytes to examine.

Return Value

Pointer to the first matching byte in the searched region, or NULL if not found within n bytes.

Header

#include <string.h>

Examples Gallery

Compile with gcc memchr.c -std=c11 -o memchr. Each example shows bounded search, null checks, and practical patterns for text and binary buffers.

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *str = "Hello, C Programming!";
    char searchChar = 'C';
    size_t len = strlen(str);

    void *result = memchr(str, searchChar, len);

    if (result != NULL) {
        size_t index = (const char *)result - str;
        printf("'%c' found at index %zu (1-based position %zu).\n",
               searchChar, index, index + 1);
    } else {
        printf("'%c' not found.\n", searchChar);
    }

    return 0;
}

'C' found at index 7 (1-based position 8).

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *word = "Hello";
    void *found = memchr(word, 'z', strlen(word));

    if (found == NULL) {
        printf("'z' is not in the first %zu bytes.\n", strlen(word));
    } else {
        printf("Found at %td\n", (char *)found - word);
    }

    return 0;
}

'z' is not in the first 5 bytes.

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *text = "ABC-DEF-GHI";
    void *dash = memchr(text, '-', 4);   /* only "ABC-" */

    if (dash != NULL) {
        printf("Dash in first 4 bytes at index %td\n",
               (const char *)dash - text);
    } else {
        printf("No dash in first 4 bytes.\n");
    }

    dash = memchr(text, '-', strlen(text));
    if (dash != NULL) {
        printf("Dash in full string at index %td\n",
               (const char *)dash - text);
    }

    return 0;
}

Dash in first 4 bytes at index 3
Dash in full string at index 3

#include <stdio.h>
#include <string.h>

int main(void) {
    unsigned char packet[] = { 0x01, 0x02, 0xFF, 0x04, 0x05 };
    size_t packetLen = sizeof packet;

    void *marker = memchr(packet, 0xFF, packetLen);

    if (marker != NULL) {
        size_t offset = (unsigned char *)marker - packet;
        printf("0xFF found at offset %zu\n", offset);
    } else {
        printf("Marker byte not found.\n");
    }

    return 0;
}

0xFF found at offset 2

#include <stdio.h>
#include <string.h>

int main(void) {
    const char *email = "user@example.com";

    char *at1 = strchr(email, '@');
    void *at2 = memchr(email, '@', strlen(email));

    if (at1 != NULL && at2 != NULL) {
        printf("strchr index:  %td\n", at1 - email);
        printf("memchr index:  %td\n", (char *)at2 - email);
        printf("Same match:    %s\n",
               (at1 == at2) ? "yes" : "no");
    }

    return 0;
}

strchr index:  4
memchr index:  4
Same match:    yes

🚀 Common Use Cases

• Delimiter search — locate '@', ':', '/', or '=' within a known-length buffer.
• Binary protocols — find marker bytes in packets or firmware images.
• Partial buffer scan — search only the first n bytes of a larger allocation.
• Safe string search — avoid reading past a buffer when length is known but the data may lack '\0'.
• Validation — verify a required character exists before parsing further.

📝 Notes

• Comparison uses unsigned char semantics—negative int values for c still map to 0–255.
• Always test for NULL before dereferencing or subtracting pointers.
• The return pointer points into the original block—not a new allocation.
• If n is 0, no bytes are examined and the function returns NULL.
• For null-terminated strings only, strchr() is simpler; pass strlen(str) to memchr when mimicking strchr.

⚡ Optimization

memchr() is highly optimized in standard C libraries and is the right tool for bounded byte search. Pass the smallest accurate n you can to avoid unnecessary work. For repeated searches, advance the start pointer and reduce n rather than rescanning from the beginning each time.

💡 Best Practices