memset() in C - JournalDev

The memset() function in C is used to set blocks of memory with a particular value.

In this article, we’ll have a look at how we can use this function in C programs.

Syntax of memset() in C

This function takes a memory location, taken to be a void* pointer. It then copies a byte (character) to the first n bytes pointed to by the memory location.

Since it updates the memory location, it also returns a pointer to that updated memory location, which is again a void* pointer.

Therefore, we can write its prototype as:

void* memset(void* mem_loc, int c, size_t n);

Here, mem_loc is the relevant memory location, and c is the unsigned character. It sets the first n bytes of mem_loc.

Relevant Header Files

Since this deals with characters and therefore strings (char*), we get this function in the <string.h> header.

We will now write the complete import and the function call.

#include <string.h>

void* memset(void* mem_loc, int c, size_t n);

Let’s now look at examples regarding how we can use this function.

Using the memset() function in C

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

int main() {
    char a[] = {"Hello from JournalDev"};

    printf("a = %s\n", a);
    
    printf("Filling the first 5 characters a with 'H' using memset\n");
    
    memset(a, 'H', 5 * sizeof(char));
    
    printf("After memset, a = %s\n", a);

    return 0;
}

The above code snippet fills the first 5 characters of the string “Hello from JournalDev” with ‘H’. Let’s take a look at the output now:

a = Hello from JournalDev
Filling the first 5 characters a with 'H' using memset
After memset, a = HHHHH from JournalDev

As you can observe, the first 5 locations are indeed filled with ‘H’.

Now let’s take another example, where you want to fill elements from an offset location.

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

int main() {
    char a[] = {"Hello from JournalDev"};

    printf("a = %s\n", a);
    
    printf("Filling the last 5 characters a with 'H' using memset\n");
    
    size_t a_len = strlen(a);
    
    //Using an offset of (a + a_len - 5), so that we can
    //fill the last 5 characters
    memset(a + (a_len - 5), 'H', 5 * sizeof(char));
    
    printf("After memset, a = %s\n", a);

    return 0;
}

Output

a = Hello from JournalDev
Filling the last 5 characters a with 'H' using memset
After memset, a = Hello from JournHHHHH

This time, the last five characters are filled with ‘H’, since we specified the starting memory location address appropriately.

memset() vs calloc() vs naive iteration

A lot of times, we can use memset() to zero initialize arrays. Often, the performance of memset() is much faster than similar methods like calloc().

The below example illustrates this point while comparing the running time of both memset() and calloc() on a Linux Machine, using the <time.h> header file.

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

void* init_with_memset(int* arr, size_t num_locations) {
    // Perform zero initialization with memset
    // on an integer array
    return memset(arr, 0, num_locations * sizeof(int)); 
}

void* init_with_calloc(int* arr, size_t num_locations) {
    arr = calloc(num_locations, sizeof(int));
    return arr;
}

void* init_with_iteration(int* arr, size_t num_locations) {
    // Naive unoptimized iteration using array indexing
    for (int i=0; i<num_locations; i++) {
        arr[i] = 0;
    }
    return arr;
}

int main() {
    // Set the array to -1 initially
    int arr[2560];
    for (int i=0; i<2560; i++)
        arr[i] = -1;

    clock_t start_time, end_time;
    double total_time;

    start_time = clock();
    // 1000 locations
    init_with_memset(arr, 1000);
    end_time = clock();
    total_time  =  (double) (end_time - start_time);
    total_time =   total_time / CLOCKS_PER_SEC;
    printf("Time for memset() = %.6f seconds\n", total_time);
    
    start_time = clock();
    // 1000 locations
    init_with_calloc(arr, 1000);
    end_time = clock();
    total_time  =  (double) (end_time - start_time);
    total_time =   total_time / CLOCKS_PER_SEC;
    printf("Time for calloc() = %.6f seconds\n", total_time);
    
    start_time = clock();
    // 1000 locations
    init_with_iteration(arr, 1000);
    end_time = clock();
    total_time  =  (double) (end_time - start_time);
    total_time =   total_time / CLOCKS_PER_SEC;
    printf("Time for naive iteration = %.6f seconds\n", total_time);

    return 0;
}

Output

Time for memset() = 0.000002 seconds
Time for calloc() = 0.000005 seconds
Time for naive iteration = 0.000006 seconds

As you can observe, memset() is almost thrice as fast as both calloc() and naive iteration, since it is optimized based on the architecture, beyond the C compiler!

Conclusion

We learned about how we can use memset() to set values of a memory location. We also verified that the performance of memset() is much better than the other functions since it is optimized as per the architecture.

References

Linux manual page on memset()