Malloc, Calloc, ReAlloc, Free, Memcpy, Memcmp, Memmov, Memset
Standard C provides basically these 4 functions for heap memory allocation at runtime. All of these are described in standard C library stdlib.h and should be used to handle plain old data, never for class objects in C++.
malloc() -
takes the size of the memory to be allocated and returns a void* pointing to the chunk of allocated memory. If the memory allocation fails, it returns a NULL. We need to typecast the return value into an appropriate pointer and also initialize it as it is not initialized by malloc. So the returned chunk may contain garbage.
Prototype: void *malloc(size_t size);
Syntax: cchar * String = (char *) malloc(1000)
So above, 1000 bytes are reserved and the pointer string points to the first byte. The memory is uninitialized.
calloc() -
too allocates memory in a very similar fashion as malloc() with two major differences.
- It allocates memory for an array. So it has two parameters, the first gives the number of elements in the array and the second gives the size of each element.
- It initializes the memory to zero, so no initialization overhead on the caller.
Prototype: void *calloc(size_t elements, size_t sz);
Syntax: int * p = (int*) calloc (100, sizeof(int));
realloc() -
does a little bit more than calloc and malloc. As the name suggests, it can reallocate memory to a pointer. This is an important requirement. So realloc has certain important features
- Logically it takes two parameters, one is the pointer whose memory has to be reallocated. And second is the size of the memory to be allocated.
- After reallocation it returns the new void pointer which may be the same address before or a new address and which has to be cast to desired type.
- The contents of the old memory block are preserved if the size of the new block is larger. Then the contents of the outer bytes are indeterminate. If the size is smaller then, the outer bytes are wiped out.
- If the first parameter is zero/NULL, then it behaves exactly like malloc. It returns a pointer to the new allocated memory.
- If the second parameter is 0, it behaves like free and deallocates the memory. It is versatile in that sense.
Below is a program demonstrating the use of realloc(). The program takes a number from the user in a loop and allocates memory for it every time. In the end all the numbers in the memory are displayed.
/* realloc example: rememb-o-matic */
#include < stdio.h >
#include < stdlib.h >
int main ()
{
int input,n;
int count=0;
int * numbers = NULL;
do {
printf ("Enter an integer value (0 to end): ");
scanf ("%d", &input);
count++;
numbers = (int*) realloc (numbers, count * sizeof(int));
if (numbers==NULL)
{
puts ("Error (re)allocating memory"); exit (1);
}
numbers[count-1]=input;
} while (input!=0);
printf ("Numbers entered: ");
for ( n=0; n < count; n++)
printf ("%d ",numbers[n]);
free (numbers);
return 0;
}
free() -
is used to free the memory allocated by any of the above methods.
/* free example */
#include
#include
int main ()
{
int * buffer1, * buffer2, * buffer3;
buffer1 = (int*) malloc (100*sizeof(int));
buffer2 = (int*) calloc (100,sizeof(int));
buffer3 = (int*) realloc (buffer2,500*sizeof(int));
free (buffer1);
free (buffer3);
return 0;
}
There are some other functions which are almost used every time in C and C++ memory related operations.
memset(): -
is used to set the memory to a certain value. We have three parameters to control the behavior of this function.
- Pointer to the memory to get the starting address of the memory location
- Value to be set for each byte of the memory starting from the pointer
- Number of bytes from the start to be set
So the prototype looks something like this:
void* memset(void* ptr, int val, size_t num)
/*
ptr - pointer to the block of memory to fill
val - value to be set. The val is passed as an int but the function fills the
block of memory as an unsigned char version of this value
num - Number of bytes to be set to this value
*/
Ptr is returned as a void pointer, and it is not necessary to catch it.
/* memset example */
#include <stdio.h>
#include <string.h>
int main ()
{
char str[] = "almost every programmer should know memset!";
memset (str,'-',6);
puts (str);
return 0;
}
memchr(): -
searches through the given number of bytes starting from the given pointer for a particular value. If successful, returns the pointer to the first location where the value occurred else returns NULL.
The syntax is very similar to memset. The operation is however different.
const void* memchr(const void* ptr, int val, size_t num)
void* memchr( void* ptr, int val, size_t num)
/*
ptr - pointer to the block of memory to search
val - value to be searched. The val is passed as an int but the function
searches byte per byte of the block of memory as an unsigned char
version of this value
num - Number of bytes to be searched/analyzed for this value
*/
If the value is found, a pointer to the first occurrence of the value in the block is returned. If the value to be matched is not found, a NULL is returned.
int main ()
{
char * pch;
char str[] = "Example string";
pch = (char*) memchr (str, 'p', strlen(str));
if (pch!=NULL)
printf ("'p' found at position %d.\n", pch-str+1);
else
printf ("'p' not found.\n");
return 0;
}
/*
Output: P is found at position 5
*/
memcmp(): -
compares two blocks of memory and returns an integer value of 0, >0 or <0 depending on whether the match. It takes the const pointer of the two memory blocks and the number of bytes to compare.
The syntax is as below:
int memcmp(const void* ptr1, const void* ptr2, size_t num)
/*
ptr1 - const pointer to first the block of memory to compare
ptr2 - const pointer to second the block of memory to compare
num - Number of bytes to be compared
*/
The return value is an integer 0 if the two blocks match exactly for the num bytes. The return value is an integer greater than zero if the first byte that does not match has a greater value in ptr1. Following logically a return value of less than zero indicates the opposite.
/* memcmp example */
#include <stdio.h>
#include <string.h>
int main ()
{
char str1[256];
char str2[256];
int n;
printf ("Enter a sentence: "); gets(str1);
printf ("Enter another sentence: "); gets(str2);
n=memcmp ( str1, str2, 256 );
if (n>0) printf ("'%s' is greater than '%s'.\n",str1,str2);
else if (n<0) printf ("'%s' is less than '%s'.\n",str1,str2);
else printf ("'%s' is the same as '%s'.\n",str1,str2);
return 0;
}
memcpy (): -
copies a chunk of memory from source to destination. The function does a bit by bit copying and does not check for any null terminating characters. So the programmer has to be careful while using this. Also the source and destination blocks should not be overlapping. If so then there is a danger of overflowing(Null Terminators might get moved too). In these cases, a safer option to go for is memmove().
Void* memcpy(void* destination, const void* source, size_t num)
/*
destination - pointer to the destination memory block
source - pointer to the source memory block
num - number of bytes to be copied.
*/
The pointer to the destination is returned.
/* memcpy example */
#include <stdio.h>
#include <string.h>
int main ()
{
char str1[]="Sample string";
char str2[40];
char str3[40];
memcpy (str2,str1,strlen(str1)+1);
memcpy (str3,"copy successful",16);
printf ("str1: %s\nstr2: %s\nstr3: %s\n",str1,str2,str3);
return 0;
}
memmove(): -
copies a chunk of memory from the source memory location to the destination memory. It does a bit by bit copy from the source to the destination. However, the difference of memmove with memcpy is that, in memmove copying takes place as if a buffer was used, thus the source and the destination can overlap. The function prototype is exactly the same as memcpy.
Void* memcpy(void* destination, const void* source, size_t num)
/*
destination - pointer to the destination memory block
source - pointer to the source memory block
num - number of bytes to be copied.
*/
The pointer to the destination is returned.
/* memmove example */
#include <stdio.h>
#include <string.h>
int main ()
{
char str[] = "memmove can be very useful......";
memmove (str+20,str+15,11);
puts (str);
return 0;
}
