Allocating Memory at Runtime
There are many cases when you do not know the exact sizes of arrays used in your programs, until much later when your programs are actually being executed. You can specify the sizes of arrays in advance, but the arrays can be too small or too big if the numbers of data items you want to put into the arrays change dramatically at runtime.
Fortunately, C provides you with four dynamic memory allocation functions that you can employ to allocate or reallocate certain memory spaces while your program is running. Also, you can release allocated memory storage as soon as you don't need it. These four C functions, malloc(), calloc(), realloc(), and free(), are introduced in the following sections.
The malloc() Function
You can use the malloc() function to allocate a specified size of memory space.
The syntax for the malloc() function is#include <stdlib.h>
void *malloc(size_t size);
Here size indicates the number of bytes of storage to allocate. The malloc() function returns a void pointer.
Note that the header file, stdlib.h, has to be included before the malloc() function can be called. Because the malloc() function returns a void pointer, its type is automatically converted to the type of the pointer on the left side of an assignment operator.
If the malloc() function fails to allocate a piece of memory space, it returns a null pointer. Normally, this happens when there is not enough memory. Therefore, you should always check the returned pointer from malloc() before you use it.
Listing 17.1 demonstrates the use of the malloc() function.
TYPE
Listing 17.1. Using the malloc() function.1: /* 17L01.c: Using the malloc function */
2: #include <stdio.h>
3: #include <stdlib.h>
4: #include <string.h>
5: /* function declaration */
6: void StrCopy(char *str1, char *str2);
7: /* main() function */
8: main()
9: {
10: char str[] = "Use malloc() to allocate memory.";
11: char *ptr_str;
12: int result;
13: /* call malloc() */
14: ptr_str = malloc( strlen(str) + 1);
15: if (ptr_str != NULL){
16: StrCopy(str, ptr_str);
17: printf("The string pointed to by ptr_str is:\n%s\n",
18: ptr_str);
19: result = 0;
20: }
21: else{
22: printf("malloc() function failed.\n");
23: result = 1;
24: }
25: return result;
26: }
27: /* function definition */
28: void StrCopy(char *str1, char *str2)
29: {
30: int i;
31:
32: for (i=0; str1[i]; i++)
33: str2[i] = str1[i];
34: str2[i] = `\0';
35: }
The following output is shown on the screen after the executable, 17L01.exe, of the program in Listing 17.1 is created and executed:
OUTPUT
C:\app>17L01
The string pointed to by ptr_str is:
Use malloc() to allocate memory.
C:\app>
ANALYSIS
The purpose of the program in Listing 17.1 is to use the malloc() function to allocate a piece of memory space that has the same size as a character string. Then, the content .of the string is copied to the allocated memory referenced by the pointer returned from the malloc() function. The content of the memory is displayed on the screen to prove that the memory space does contain the content of the string after the allocation and duplication.
Note that two more header files, stdlib.h and string.h, are included in lines 3 and 4, respectively, for the functions malloc() and strlen(), which are called in line 14.
Line 10 declares a char array, str, that is initialized with a character string of "Use malloc() to allocate memory.". A char pointer variable, ptr_str, is declared in line 11.
The statement in line 14 allocates a memory space of strlen(str)+1 bytes by calling the malloc() function. Because the strlen() function does not count the null character at the end of a string, adding 1 to the value returned by strlen(str) gives the total number of bytes that need to be allocated. The value of the returned pointer is assigned to the char pointer variable ptr_str after the malloc() function is called in line 14.
The if-else statement in lines 15_24 checks the returned pointer from the malloc() function. If it's a null pointer, an error message is printed out, and the return value of the main() function is set to 1 in lines 22 and 23. (Remember that a nonzero value returned by the return statement indicates an abnormal termination.)
But if the returned pointer is not a null pointer, the start address of the str array and the pointer ptr_str are passed to a subfunction called StrCopy() in line 16. The StrCopy() function, whose definition is given in lines 28_35, copies the content of the str array to the allocated memory pointed to by ptr_str. Then, the printf() function in lines 17 and 18 prints out the copied content in the allocated memory. Line 19 sets the return value to 0 after the success of the memory allocation and string duplication.
The output on my screen shows that a piece of memory has been allocated and that the string has been copied to the memory.
There is a potential problem if you keep allocating memory, because there is always a limit. You can easily run out of memory when you just allocate memory without releasing it. In the next section, you'll learn how to use the free() function to free up memory spaces allocated for you when you don't need them.
- 16 views
