The C Standard Library has 4 Memory Management Functions, and these are:
-
void *calloc( size_t nmemb, size_t size );
-
void free( void *ptr );
-
void *malloc( size_t size );
-
void *realloc( void *ptr, size_t size );
-
You can use the
calloc ,
malloc and
realloc functions to
dynamically allocate space for objects and then use the
free or
realloc functions to get rid of that space when you no longer need it.
You should allocate only what storage you need and to free it as soon as you're done with it; sure it is deallocated at program termination but freeing the space you allocate when you do not need it, provides you more resources and prevents memory leaks which is a common problem.
The functions work together;
mallloc ,
calloc and
realloc return a pointer to the allocated space (if successful) and
free and
realloc may accept that pointer to deallocate the space it points to; that is made available for further allocation.
Let's say that you have a Student object defined as:
-
struct Student{
-
char *name;
-
char *surname;
-
/* add more here... */
-
};
-
To allocate space for a struct Student object you can use this code:
-
struct Student *student = NULL; /*notice the initialization to NULL here! */
-
-
student = ( struct Student * )calloc( 1, sizeof( struct Student ) );
-
-
if ( student == NULL ){
-
/* handle memory failure here */
-
}
-
-
student->name = NULL;
-
student->surname = NULL;
-
-
Notice something:
calloc allocates space for an array of
nmemb objects each of whose size is specified by size and initializes the space to all bits zero.
malloc allocates space for an object whose size is specified by
size and whose value is indeterminate.
For the example i gave, i could have used this code for the allocation:
-
student = ( struct Student * )malloc( sizeof( struct Student ) );
-
Which is equivalent, because i allocate space only for one struct Student object. I used the
calloc function to show you something interesting.
Before moving on to the struct Student example, let me tell you this:
If you want to allocate space for an array of 3 integers then you will write:
-
arrayOfIntegers = ( int * )calloc( 3, sizeof( int ) );
-
But not:
-
arrayOfIntegers = ( int * )calloc( 1, 3 * sizeof( int ) );
-
/* or.. */
-
arrayOfIntegers = ( int * )malloc( 3 *sizeof( int ) );
-
This is not wrong but it might cause some problems when it comes to memory allignment and so on..
Let's continue with the struct Student example now:
Another thing to notice is the i
typecast the return value of the
calloc function to a appropriate type; you should do the same!
Then notice the if test i make; i do this to test whether i got the space i wanted for my struct Student object or not. Only if i have the space i want can i proceed processing my struct Student object.
Then comes one interesting thing. As i said above,
calloc initializes all bits to zero. However, this need not be the same as the representation of a floating-point zero or a null pointer. So, for maximum portability i must not rely on
name and
surname attributes being null. So, i set them explicitly to NULL. Why i do that you may ask! It is very good to initialize all your variables before you use them especially the pointers (which you will set to NULL) !! As an example for this, notice that i set student to NULL before i use
calloc even though i know that i will later use the
calloc function.
In the beginning i said that it is very important that you have a very good memory management in your program; that is allocate space for what you want and free what you do not want at the time that you do not want it.
Let me show an example continuing the struct Student example.
Now that i have my struct Student object i want to set values to it.
Particularly, i have already read a name and a surname from the user and i want to store them as attributes to the struct Student object. Let's say that the name and surnames i already read are:
-
char *_name = NULL;
-
char *_surname = NULL;
-
-
_name = readName(); /* assume there is a readName() function */
-
_surname = readSurname(); /* assume there is a readSurname() function */
-
/* Notice that these functions will call either malloc or calloc to return a pointer */
-
To store them as attributes to the struct Student object you can write:
-
student->name = _name;
-
student->surname = _surname;
-
Now, the name and surname attributes of the struct Student object will point to the strings pointed to by _name and _surname respectively. However there is one problem here.. Probably, the code for the allocation of the struct Student object would be distinct from the code reading the _surname and _name. The function responsible for the allocation would accept as arguments pointers to the strings that _name and _surname point at to do the initialization at the same time. In this way, however, if the function reading the _name and _surname chooses to free them, the struct Student object will have a serious problem!!
So it is better to keep things for the struct Student object to itself; the solution to this is to make copies of the _name and _surname and assign them as name and surname attributes respectively.
One way to do this is:
-
#define MAX_LEN 100
-
/* assume that the allocations will succeed; you must check if calloc returns NULL as in the above example */
-
student->name = ( char * )calloc( MAX_LEN, sizeof( char ) );
-
student->surname = ( char * )calloc( MAX_LEN, sizeof( char ) );
-
-
strcpy( student->name, _name );
-
strcpy( student->surname, _surname );
-
However, the above code has several drawbacks.
-> It wastes space; what if the _name string has only 5 characters? Then, surely i wasted a lot of space!!
-> Since, the function responsible for the allocation does not know about the function responsible for the reading of _name and _surname, then it assumes a max limit of MAX_LEN. What if _name or _surname is larger? Then strcpy will surely cause problems!!
There is a simple solution to this:
-
size_t len = 0; /* length of _name or _surname */
-
-
/* Again assume that allocations will succeed.... */
-
-
/* Obtain the length of the _name */
-
len = strlen( _name );
-
-
/* Allocate as much space as REQUIRED */
-
student->name = ( char * )calloc( len + 1, sizeof( char ) ); /* notice that i allocate space for len + 1 to make space for the terminating null character */
-
-
/* Make the copy safely */
-
memmove( student->name, _name, len + 1 ); /* copy len + 1 to ensure that the terminating null character is copied; just for maximum portability */
-
-
/* Do the same as above for the _surname */
-
-
len = strlen( _surname );
-
-
....
-
So, we have seen how to allocate space and also that we must be careful about memory management with a simple example of using strlen to determine exactly how much space we want. This is just an example.
Now let's see hot to free space. This is actually very simple.
When you do not longer need the struct Student object free it using
free (well you can use and
realloc but leave it...)
-
free( ( void * )student );
-
student = NULL;
-
Notice that i assign NULL to student to be completely safe! I advice you to make this a rule!
But, this code is wrong!!! Not actually wrong, but in a correct memory management aspect yes it is wrong. See this new code and see why:
-
free( ( void * )student->name );
-
free( ( void * )student->surname );
-
free( ( void * )student );
-
student = NULL;
-
Well, this is correct. Remember you must free whatever you have allocated. Do not forget anything! There are some techniques that can help you with that... read Code Complete 2 for some examples. Notice that freeing ->name and ->surname must be done before freeing student cause after freeing student the space will no longer be accessible.
The above is just an example, actually it is very little of how tricky memory management is. I do not describe the
realloc function because i do not thnk it will be of any use for you now; you need to work on
malloc free and
calloc .
Hope i helped!
With respect,
Tassos Souris
1
