Memory management is one of the most fundamental and important aspects of any computer programming language. In many programming languages, you don’t have to worry about memory management, but in C Programming Language you do memory management manually. C is one of the most powerful programming languages. Pointer is one of the most powerful features of the C programming language which gives you the ability to point memory locations. This feature enables easy memory access.

As we all know computer memory is made up of a large number of cells, which are further organized as addressable registers. Each register is responsible to store a sequence of bits. So it is always necessary to manage these memory locations effectively to increase utilization.

Types of memory allocations in C

There are two ways in which memory can be allocated in C

• Static memory allocation or Compile time allocation
• Dynamic memory allocation or Run time allocation

Static or compile-time memory allocation

In this method desired memory is allocated at the time of variable declaration or beginning of the program. The amount of memory allocation is fixed and is determined at the time of program compilation.

Example:

when the first statement int a,b; is compiled 4 consecutive bytes(integer occupies 4 bytes in a 32-bit machine) for each variable a,b will be allocated.

Drawbacks of static memory allocation

• If we declare more number of elements and we are using less number of elements then the memory allocated for the not used variables will be wasted. The unused memory cells are not made available to other applications. This leads to inefficient use of memory.
• The size of the data type or variable must be known before.
• We can not change the size of a variable at run time.

Dynamic or Runtime C Memory Allocation

In C Programming Language it is not always possible to predict the memory requirement for the program, so it is better to allocate the memory in real-time whenever required, it makes efficient use of memory.

C Programming Language provides the following dynamic allocation and deallocation functions –

• malloc()
• calloc()
• realloc()
• free()

malloc,calloc, and realloc are used for memory allocation and deallocation is achieved by the use of the free function.

Allocating A Block of Memory-malloc()

The malloc() function allocates the memory at run time whenever required. It allocates the memory block with the required number of contiguous bytes in the c memory management system and returns the pointer to the first byte(base address) or null if there is some error occur.

Syntax:

Example:

1. First, we declare a pointer variable ‘p’.
2. Then the pointer itself is equal to a pointer type int that contains the memory address space for an int.
3. Size () return the space it occupies what you want, if you put int in, such as 2 bytes, because we have assigned two bytes.
4. Finally, now that the pointer is contained, we give a value.

Allocating Multiple blocks of Memory-calloc()

The calloc() function is the same as malloc() except it is used to allocate multiple c  memory management blocks of the same size then all bytes sets to zero.

Syntax:

It allocates contiguous space for ‘n’ blocks, each of the size of block_size bytes. All bytes are initialized to zero and a pointer to the first byte of the allocated memory block is returned.

Example:

An int array of 10 elements can be allocated as follows.

We can achieve the same using the malloc() function as below –

However, an area reserved by the malloc() function for the states that are undefined, the area allocated by the calloc function contains a 0.

Difference between malloc() and calloc()

1. the malloc() allocates bytes of memory but calloc() allocates blocks of memory.
2. the malloc() takes a single argument(memory required in bytes) but calloc() takes 2 arguments (number of variables to allocate memory, size in bytes of a single variable)
3. The memory allocated using the malloc() function contains garbage values, the memory allocated by the calloc() function contains the value 0.

Resize the size of a Memory-realloc()

The realloc() function allows us to reset the size of the allocated area.

Syntax:

Where ptr is holding the current base address of the memory block and new_size holds the size in bytes.

Releasing the used memory-free()

The free() function is used to deallocate the allocated memory using the malloc() or calloc() function. It is always important to release the memory that is not in use, so it can be used in the future.

Syntax:

Note:- ptr must be a valid pointer to the address otherwise it can result in a system crash.

Example Program:

Below is the program where we have allocated memory for ptr integer pointer with the byte required for int data type, then assigned value 10. Finally released memory using free() function.

In C Programming Language we have built-in support for “Command Line arguments”. Command-line arguments allow us to pass the parameters to the C Program’s main() function when they are executed. We can pass the parameters from the command line itself.

Below is the prototype for main() when it is supposed to accept command-line arguments –

syntax:

There are two parameters passed to the main() function.

• int argc
• char *argv[]

The first parameter, argc is an integer that is used to define the number of parameters passed to main(), and the second parameter is argv, is an array of pointers to character strings which is consist of the list of these parameters. Each argument on the command line is separated by
spaces.

The program name will be stored in the first item in argv, followed by the list of the parameters. If the program name is followed by n parameters there will be n + 1 element in argv, ranging from argv[0] to argv[n]. argc will be automatically set equal to n + 1.

Example :

Assuming that the executable is called hello.