The function malloc is used to allocate a certain amount of memory during the execution of a program. The malloc function will request a block of memory from the heap. If the request is granted, the operating system will reserve the requested amount of memory. When the amount of memory is not needed anymore, you must return it to the operating system by calling the function free. Note: If you compile on windows the windows. The malloc statement will ask for an amount of memory with the size of an integer 32 bits or 4 bytes.
|Published (Last):||13 May 2014|
|PDF File Size:||17.89 Mb|
|ePub File Size:||11.15 Mb|
|Price:||Free* [*Free Regsitration Required]|
Let's say that you would like to allocate a certain amount of memory during the execution of your application. You can call the malloc function at any time, and it will request a block of memory from the heap. The operating system will reserve a block of memory for your program, and you can use it in any way you like.
When you are done with the block, you return it to the operating system for recycling by calling the free function. Then other applications can reserve it later for their own use.
If the allocation fails if p is zero , the program terminates. If the allocation is successful, the program then initializes the block to the value 5, prints out the value, and calls the free function to return the memory to the heap before the program terminates.
There is really no difference between this code and previous code that sets p equal to the address of an existing integer i. Two common questions:. The following two programs show two different valid uses of pointers, and try to distinguish between the use of a pointer and of the pointer's value:.
This statement says, "Move the integer value pointed to by q into the integer value pointed to by p. This statement moves the addresses. From all of these examples, you can see that there are four different ways to initialize a pointer.
It may point anywhere, and therefore to dereference it is an error. Initialization of a pointer variable involves pointing it to a known location in memory. Any pointer can be set to point to zero.
When p points to zero, however, it does not point to a block. The pointer simply contains the address zero, and this value is useful as a tag. You can use it in statements such as:. The system also recognizes the zero value, and will generate error messages if you happen to dereference a zero pointer.
For example, in the following code:. The program will normally crash. The zero pointer will be used as a flag when we get to linked lists. The malloc command is used to allocate a block of memory. It is also possible to deallocate a block of memory when it is no longer needed. When a block is deallocated, it can be reused by a subsequent malloc command, which allows the system to recycle memory. The command used to deallocate memory is called free , and it accepts a pointer as its parameter.
The free command does two things:. The free statement simply returns a pointer to its original uninitialized state and makes the block available again on the heap. The following example shows how to use the heap. It allocates an integer block, fills it, writes it, and disposes of it:. This code is really useful only for demonstrating the process of allocating, deallocating, and using a block in C. The malloc line allocates a block of memory of the size specified -- in this case, sizeof int bytes 4 bytes.
The sizeof command in C returns the size, in bytes, of any type. The code could just as easily have said malloc 4 , since sizeof int equals 4 bytes on most machines. Using sizeof , however, makes the code much more portable and readable. The malloc function returns a pointer to the allocated block. This pointer is generic.
Using the pointer without typecasting generally produces a type warning from the compiler. The free statement in C returns a block to the heap for reuse.
The block on the right is the block of memory malloc allocated. The malloc statement first looks at the amount of memory available on the heap and asks, "Is there enough memory available to allocate a block of memory of the size requested? If there is not enough memory available, the malloc function returns the address zero to indicate the error another name for zero is NULL and you will see it used throughout C code.
Otherwise malloc proceeds. If memory is available on the heap, the system "allocates" or "reserves" a block from the heap of the size specified. The system reserves the block of memory so that it isn't accidentally used by more than one malloc statement. The system then places into the pointer variable p, in this case the address of the reserved block. The pointer variable itself contains an address. The allocated block is able to hold a value of the type specified, and the pointer points to it.
Is it really important to check that the pointer is zero after each allocation? Since the heap varies in size constantly depending on which programs are running, how much memory they have allocated, etc. You should check the pointer after any call to malloc to make sure the pointer is valid. What happens if I forget to delete a block of memory before the program terminates?
When a program terminates, the operating system "cleans up after it," releasing its executable code space, stack, global memory space and any heap allocations for recycling. Therefore, there are no long-term consequences to leaving allocations pending at program termination. However, it is considered bad form, and "memory leaks" during the execution of a program are harmful, as discussed below. The final output of this code would be 10 from line 4 and 20 from line 6. One way, as seen already, is to use the malloc statement.
This statement allocates a block of memory from the heap and then points the pointer at the block. This initializes the pointer, because it now points to a known location. The pointer is initialized because it has been filled with a valid address -- the address of the new block. If q is pointing at a valid block, then p is initialized. The pointer p is loaded with the valid address that q contains.
However, if q is uninitialized or invalid, p will pick up the same useless address. The third way is to point the pointer to a known address, such as a global variable's address. The fourth way to initialize the pointer is to use the value zero. The pointer p's address is zero. This is normally diagrammed as:.
The block of memory pointed to by the pointer is unreserved and given back to the free memory on the heap. It can then be reused by later new statements. The pointer is left in an uninitialized state, and must be reinitialized before it can be used again.
Related How Python Works.
C library function - malloc()
The Basics of C Programming