C String memset() Function

What You’ll Learn

The memset() function from <string.h> fills a memory block with a single byte value repeated n times. It is most often used to zero out buffers (memset(ptr, 0, n)) before use, but it can also pad strings or initialize arrays with a chosen character.

Definition and Usage

In C, memset() is declared in <string.h>. It writes the byte value (converted to unsigned char) into each of the first n bytes starting at ptr, then returns ptr.

Unlike memcpy() or memmove(), memset() does not copy from another buffer—it generates bytes from the value you supply. For C-strings, zero-filling with memset(str, 0, sizeof str) clears the buffer to empty strings. Filling with other characters requires leaving space for '\0' if you plan to use printf("%s").

📝 Syntax

The standard library declaration:

void *memset(void *ptr, int value, size_t n);

Parameters

• ptr — pointer to the memory block to fill.
• value — byte value to write, converted to unsigned char (commonly 0 or a character like 'A').
• n — number of bytes to set.

Return Value

Returns ptr (the pointer to the filled block).

Header

#include <string.h>

Examples Gallery

Compile with gcc memset.c -std=c11 -o memset. Examples show safe zero-fill, character padding, and clearing buffers before reuse.

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

int main(void) {
    char buffer[20];

    memset(buffer, 0, sizeof buffer);

    printf("Length after zero-fill: %zu\n", strlen(buffer));
    printf("Buffer is empty: %s\n", buffer[0] == '\0' ? "yes" : "no");

    return 0;
}

Length after zero-fill: 0
Buffer is empty: yes

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

int main(void) {
    char str[20];

    memset(str, 'A', sizeof str - 1);
    str[sizeof str - 1] = '\0';

    printf("Padded string: %s\n", str);
    printf("Length: %zu\n", strlen(str));

    return 0;
}

Padded string: AAAAAAAAAAAAAAAAAAA
Length: 19

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

int main(void) {
    char line[32] = "secret-password-123";

    printf("Before: %s\n", line);

    memset(line, 0, sizeof line);
    strcpy(line, "new data");

    printf("After:  %s\n", line);

    return 0;
}

Before: secret-password-123
After:  new data

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

typedef struct {
    int id;
    char name[16];
    double score;
} Student;

int main(void) {
    Student s;

    memset(&s, 0, sizeof s);

    printf("id=%d, name='%s', score=%.1f\n",
           s.id, s.name, s.score);

    return 0;
}

id=0, name='', score=0.0

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

int main(void) {
    char dest[16];
    const char *src = "Hello";

    memset(dest, 0, sizeof dest);
    memcpy(dest, src, strlen(src) + 1);

    printf("After memset + memcpy: %s\n", dest);

    memset(dest, '-', 5);
    dest[5] = '\0';
    printf("After memset dashes:   %s\n", dest);

    return 0;
}

After memset + memcpy: Hello
After memset dashes:   -----

🚀 Common Use Cases

• Zero initialization — clear stack buffers, structs, and arrays before first use.
• Reset buffers — wipe old string data before reading new input.
• Padding — fill a region with a repeated character (with proper '\0' handling).
• Network / binary frames — set reserved header bytes to zero.
• Embedded systems — initialize RAM regions at startup.

📝 Notes

• memset does not copy from another buffer—use memcpy or memmove for that.
• Filling an entire char array with a non-zero character does not create a valid C-string unless you add '\0'.
• memset(ptr, 0, n) is the standard way to zero memory; only the low byte of value is used.
• Do not call memset on memory you must not write (read-only sections, invalid pointers).
• For floating-point structs, zero bits often mean 0.0 but padding and representation quirks exist—zeroing is still widely used for plain C structs.

⚡ Optimization

Standard library memset() is highly optimized—often using wide stores for large blocks. Prefer it over manual loops for zeroing or filling memory. For very small fixed sizes, compilers may inline memset calls automatically.

💡 Best Practices