memmove() in C

The memmove() function transfers the memory block from one location to another. The function is declared in the string.h file.

Syntax

The syntax for the memmove function is as follows:

Parameters Passed inside the Function

strng1: It is the pointer to the memory block where you wish to copy the contents of the source memory block. The datatype for the pointer is *void.
strng2: It is the pointer to the memory block from where you want to copy the contents to the destination memory block. The datatype for the pointer is *void.
n: It is the number of bytes of data to be moved from one location to another.

Return

It returns a pointer pointing to the destination of the memory block, which according to the syntax, is strng1.

Implementation of memmove() function in C Programming

Let us implement the memmove() function. In this function, we will move the contents of the orgnl array to the new array.

#include <stdio.h>
#include <string.h>
int main ()
{
//The first step is to initialize the source and destination array.

char new[] = "The content will be loaded soon.\n";
char orgnl[] = "The content is to be transferred to a new location.\n";

//Print the contents before performing memmove function.

printf("Before implementing memmove destination and source memory block respt is\n >> new = %s\n orgnl = %s\n", new, orgnl);
memmove(new, orgnl, sizeof(orgnl));

//Display the content in both new and orgnl array after implementing memmove.

printf("After memmove >> new = %s\n orgnl = %s\n", new, orgnl);
return 0;
}

Output:

Some Facts related to the memmove() function in C programming:

Using examples, let us discuss some important facts related to the memmove() function.

As discussed earlier, the memmove() function in C Programming can move the content from the source location to the destination buffer even if both buffers overlap. If it is given that the source and destination are not overlapping with each other, then it is advised to use memcpy() instead of the memmove() function. But if they are overlapping, then the function will show undefined behavior. In that case, you should use the memmove() function.

Let us discuss the example:

#include <string.h>
#include <stdio.h>
int main()
{
char strng1[1000] = "This string will be used to implement the memmove() function.";
char strng2[1000] = "This string will be used to implement the memcpy() function.";
//Use of memmove
printf( "Function:\tUsing the memmove() function while the src and dest overlap\n\n" );
printf( "Orignal content of the first string:\t%s\n",strng1);
//the source content will replace
printf( "Source for copying the content:\t%s\n",strng1 + 5 );
//the destination content will be repl
printf( "Destination to copy the content:\t%s\n\n",strng1 + 11 );
memmove( strng1 + 11, strng1 + 5, 29 );
printf( "Result after implementing the memmove()function:\t%s\n",strng1 );
printf( "Length of the strng1:\t%d characters\n\n", strlen( strng1 ) );
//Use of memcpy
printf( "Function:\tUsing the memcpy() function while the src and dest overlap\n\n" );
printf( "Orignal content of the second string::\t%s\n",strng2);
//the source content will replace
printf( "Source for copying the content:\t%s\n",strng2 + 5 );
//the destination content will be replaced
printf( "Destination to copy the content:\t%s\n\n",strng2 + 11 );
memcpy( strng2 + 11, strng2 + 5, 29 );
printf( "Result after implementing the memcpy()function:\t%s\n",strng2 );
printf( "Length of the strng2:\t%d characters\n\n", strlen( strng2 ) );
return 0;
}

Output:

The execution time for both the functions that is memcpy() and memmove() is almost equal though it may differ with the platform or compiler. The memcpy() function can be slower or faster than the memmove(), but the difference is very small.

//include all the necessary header files
#include <string.h>
#include <stdio.h>
//clock() function is defined in time.h header file.
#include <time.h>
//define the size of the buffer
#define BUFFERSIZE  (100 * 1024)  //It is equal to 100kb
#define LOOP 10000
int main()
{
    char destn[BUFFERSIZE] = {0};
    char source[BUFFERSIZE] = {0};
    int i = 0;
    double t_spent;
    clock_t start, end;
    //Execute the memmove() function
    //Start the clock as the execution begins
    start = clock();
    for ( i = 0; i < LOOP; i++)
    {
        memmove(destn,source,BUFFERSIZE);
    }
    // Store the last time recorded by the clock on completion of the execution of the function
    end = clock();
    // Determine the total time taken from the beginning to the end of execution of the program.
    t_spent = (double)(end - start) / CLOCKS_PER_SEC;
    printf("memmove() took %f seconds to complete\n", t_spent);
    //Execute the memcpy() function
    //Start the clock as the execution begins
    start = clock();
    for ( i = 0; i < LOOP; i++)
    {
        memcpy(destn,source,BUFFERSIZE);
    }
    // Store the last time recorded by the clock on completion of the execution of the function
    end = clock();
    // Determine the total time taken from the beginning to the end of execution of the program.
    t_spent = (double)(end - start) / CLOCKS_PER_SEC;
    printf("memcpy() took %f seconds to complete\n", t_spent);
    return 0;
}

Output:

The main difference between the working of the memmove() and memcpy() function is that the memmove() function is bidirectional while the memcpy() function is unidirectional. Memmove can also move the bytes in the forward and backward direction, while the memcpy can only move in the forward direction.

Implementing your memmove() function in C Programming

The standard function is defined in string.h header file is very efficient and accounts for all the possible cases the developer may face while moving the data from one location to another. So, if it is not necessary to define your memmove() function, the user should refrain from doing so.

Implementing the memmove() function is just like the memcpy function, but here we must take overlapping into account too. This makes the program more complex than the memcpy() function.

This also increases the space complexity of the program as we would require initializing a temporary array. The temporary array will be used to manage the overlapping scenario.

All the characters that are to be moved will be first stored in this temporary array then these characters stored in the temporary array will be moved to the destination location.

void * my_memmove(void* destn, const void* src, unsigned int n)
{
char *pDest = (char *)destn;
const char *pSrc =( const char*)src;
//allocation of the memory block for the temp array
char *temp = (char *)malloc(sizeof(char ) * n);
if(NULL == temp)
{
return NULL;
}
else
{
unsigned int i = 0;
//Copy the content from the src array to temp array first
for(i =0; i < n ; ++i)
{
*(temp + i) = *(pSrc + i);
}
//copy the content from the temp array to the destination array
for(i =0 ; i < n ; ++i)
{
*(pDest + i) = *(temp + i);
}
free(temp); //free allocated memory
}
return destn;
}

Let us code a driver program to ensure that the function built by us is working properly.

#include <iostream>
//to use the malloc function in your code ensure to
//include cstdlib
#include <cstdlib>
void * my_memove(void* destn, const void* source, unsigned int n)
{
    char *pDest = (char *)destn;
    const char *pSrc =( const char*)source;
    //allocate memory for tmp array
    char *temp  = (char *)malloc(sizeof(char ) * n);
    if(NULL == temp)
    {
        return NULL;
    }
    else
    {
        unsigned int i = 0;
        // Begin with copying the contents
        //from source to the temp
        for(i =0; i < n ; ++i)
        {
            *(temp + i) = *(pSrc + i);
        }
        //Use the copied content in temp to move the contents in the destn
        for(i =0 ; i < n ; ++i)
        {
            *(pDest + i) = *(temp + i);
        }
        free(temp); //free the resources allocated to the temp
    }
    return destn;
}
int main()
{
    char Src[] = "This is the content to be copied.";
    // The destination string size is 14.
    char Dest[16] = {0};
    // Lets begin with copying the content that is stored in Src into the Dest
    //Use your own my_memove function
    my_memove(Dest, Src, 12);
    printf("String after copying the n bytes: %s\n", Dest);
    int dSrc[] = {20, 100, 30, 50, 70};
    int n = sizeof(dSrc)/sizeof(dSrc[0]);
    int dDestn[n], index = 0;
    // Lets begin with copying the content that is stored in dSrc into the dDest
    //Use your own my_memove function
    my_memove(dDestn, dSrc, sizeof(dSrc));
    printf("\nNow after copying the array it is: ");
    for (index=0; index<n; index++)
    {
        printf("%d ", dDestn[index]);
    }
    return 0;
}

Output:

In the above code, we have used the driver code. We have copied a string and array using the my_memove() function defined above. We have used a temporary array to ensure that overlapping is accounted for. Thus the string and array were copied, and our function worked perfectly.

Next TopicMatrix Calculator in C

← prev next →