C String memcmp() Function

What You’ll Learn

The memcmp() function from <string.h> compares the first n bytes of two memory blocks. It returns zero when they match, or a negative or positive value when the first differing byte is smaller or larger—using unsigned char comparison rules.

Definition and Usage

In C, memcmp() is declared in <string.h>. It walks through two memory regions in parallel, comparing bytes until either a difference is found or n bytes have been examined. The comparison treats each byte as unsigned char, so values 128–255 sort after 0–127.

Unlike strcmp(), memcmp() does not stop at a null terminator. You control exactly how many bytes are compared—making it suitable for strings, struct padding, network buffers, and any raw memory.

📝 Syntax

The standard library declaration:

int memcmp(const void *s1, const void *s2, size_t n);

Parameters

• s1 — pointer to the first memory block.
• s2 — pointer to the second memory block.
• n — number of bytes to compare.

Return Value

• 0 — all n bytes are equal.
• < 0 — first differing byte in s1 is less than in s2 (as unsigned char).
• > 0 — first differing byte in s1 is greater than in s2.

Header

#include <string.h>

Examples Gallery

Compile with gcc memcmp.c -std=c11 -o memcmp. Each example interprets the return value and shows when prefix comparison differs from full comparison.

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

int main(void) {
    char str1[] = "Hello, C!";
    char str2[] = "Hello, D!";

    int result = memcmp(str1, str2, 7);

    if (result == 0) {
        printf("The first 7 bytes are equal.\n");
    } else if (result < 0) {
        printf("First differing byte in str1 is less than str2.\n");
    } else {
        printf("First differing byte in str1 is greater than str2.\n");
    }

    return 0;
}

The first 7 bytes are equal.

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

int main(void) {
    char str1[] = "Hello, C!";
    char str2[] = "Hello, D!";

    int result = memcmp(str1, str2, 9);

    if (result == 0) {
        printf("Equal for 9 bytes.\n");
    } else if (result < 0) {
        printf("str1 is less (e.g. 'C' < 'D' at index 7).\n");
    } else {
        printf("str1 is greater.\n");
    }

    return 0;
}

str1 is less (e.g. 'C' < 'D' at index 7).

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

int main(void) {
    const char *a = "OpenAI";
    const char *b = "OpenAI";
    const char *c = "OpenAL";

    size_t len = strlen(a);

    printf("a vs b: %s\n", memcmp(a, b, len) == 0 ? "equal" : "different");
    printf("a vs c: %s\n", memcmp(a, c, len) == 0 ? "equal" : "different");

    return 0;
}

a vs b: equal
a vs c: different

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

int main(void) {
    unsigned char buf1[] = { 0x01, 0x02, 0x03, 0x04 };
    unsigned char buf2[] = { 0x01, 0x02, 0xFF, 0x04 };

    int r = memcmp(buf1, buf2, sizeof buf1);

    if (r == 0) {
        printf("Buffers are identical.\n");
    } else if (r < 0) {
        printf("buf1 is less at first mismatch (0x03 vs 0xFF).\n");
    } else {
        printf("buf1 is greater.\n");
    }

    return 0;
}

buf1 is less at first mismatch (0x03 vs 0xFF).

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

int main(void) {
    const char *s1 = "test";
    const char *s2 = "testextra";

    printf("strcmp:  %d\n", strcmp(s1, s2));
    printf("memcmp 4 bytes: %d\n", memcmp(s1, s2, 4));
    printf("memcmp 7 bytes: %d\n", memcmp(s1, s2, 7));

    return 0;
}

strcmp:  -1
memcmp 4 bytes: 0
memcmp 7 bytes: -1

🚀 Common Use Cases

• Fixed-length records — verify two struct or packet headers match for n bytes.
• Prefix checks — test whether a buffer starts with a magic number or protocol tag.
• Sorting keys — compare fixed-size keys in custom sort routines (sign of return value).
• Password/token compare — compare constant-length secrets (prefer timing-safe alternatives for security-critical code).
• Binary file chunks — detect whether two read buffers differ byte-for-byte.

📝 Notes

• Bytes are compared as unsigned char—signed char on the platform does not change the comparison rules inside memcmp.
• Ensure n does not read past the end of either valid buffer—that is undefined behavior.
• If n is 0, no bytes are compared and the function returns 0.
• The magnitude of a non-zero return is not standardized—only the sign is reliably portable for ordering.
• For null-terminated C-strings of unknown equal length, strcmp() is usually simpler than choosing n manually.

⚡ Optimization

Standard library implementations of memcmp() are heavily optimized—often using word-sized reads on aligned data. For typical buffer sizes, calling memcmp directly is faster and clearer than hand-written byte loops. Avoid comparing more bytes than necessary; pick the smallest correct n.

💡 Best Practices