Dynamic Memory Allocation | Memory Management in C

Anuj Raghuwanshi — Sun, 08 Sep 2024 06:59:39 +0000

A statically allocated variable or array has a fixed size in memory.

Dynamic Memory Allocation is a way in which the size of a data structure can be changed during the runtime.

Memory assigned to a program in a typical architecture can be broken down into four segments:

- Code
- Static/global variables
- Stack
- Heap

Dynamic memory allocation takes place in Heap.
Static memory allocation takes place in Stack.

Functions for dynamic memory allocation:

1. Malloc
2. Calloc
3. Realloc
4. Free

malloc() stands for memory allocation.

It reserves a block of memory with the given amount of bytes,sizeof operator is used.
Syntax: ptr = (ptr-type*) malloc(size-in-bytes);

The return value is a void pointer to the allocated space.
Therefore, the void pointer needs to be casted to the appropriate type as per the requirements.
However, if the space is insufficient, allocation of memory fails and it returns a NULL pointer.
All the values at allocated memory are initialized to garbage values.

#include<stdio.h>
#include<stdlib.h>

int main() {
    int *ptr;
    int n;

    printf("Enter size: \n");
    scanf("%d", &n);

    ptr = (int*) malloc(n * sizeof(int));

    for (int i = 0; i < n; i++) {
        printf("Enter the value no %d of array\n", i);
        scanf("%d", &ptr[i]);
    }

    for (int i = 0; i < n; i++) {
        printf("The value at %d is %d\n", i, ptr[i]);
    }

    return 0;
}

calloc() stands for contiguous allocation.

It reserves n blocks of memory with the given amount of bytes.
It initializes each block with a default value ‘0’.
It has two parameters or arguments as compare to malloc().

The return value is a void pointer to the allocated space.
Therefore, the void pointer needs to be casted to the appropriate type as per the requirements.
However, if the space is insufficient, allocation of memory fails and it returns a NULL pointer.
Syntax: ptr = (ptr-type*) calloc(n, size-in-bytes);

realloc() stands for reallocation.

If the dynamically allocated memory is insufficient, we can change the size of previously allocated memory using realloc() function.
Syntax: ptr = (ptr-type*) realloc(ptr, new-size-in-bytes);

free()

free is used to free the allocated memory.
If the dynamically allocated memory is not required anymore, we can free it using free function.
This will free the memory being used by the program in the heap.
Syntax: free(ptr)

STORAGE CLASSES IN C

Anuj Raghuwanshi — Thu, 29 Aug 2024 20:09:15 +0000

Hello everyone, This is my first post to dev.to in which I wanna tell you about STORAGE CLASSES IN C..

Storage classes in C are a set of keywords that guide the compiler in storing and manipulating variables in memory.
A Storage Class defines following attributes about a variable in C.
1.Scope :- Where will this variable be available.
2.Default initial value :- what will be the initial value
3.LifeTime :- Life of that variable in a program

There are FOUR Storage Classes in C which are most often used:
1.Automatic
2.External
3.Static
4.Register

Automatic Storage Class

A variable defined without any Storage Class specification is by default an automatic variable.

int variable_name and auto int variable_name are same.

Scope :- Local to the function body they are defined in
Default Value :- Garbage value
LifeTime :- Till the end of the function block they are defined in.

External Storage Class

They are same as global variable. External storage class in C, represented by the keyword 'extern', is used to give a reference of a global variable that is visible to all program files. When a variable is declared with the 'extern' keyword, it indicates that the variable is defined in another file and the current file is using its reference.
Extern variables cannot be initialised. They only point to an existing variable.
extern int variable_name

Scope :- Global to the program they are defined in
Default Value :- zero
LifeTime :- They are available throughout the lifetime of the program

Static Storage Class

Static storage class in C, represented by the keyword 'static'.
static int variable_name
static variable retains its value between function calls.Static variables are initialised only once.

Scope :- Local to the block they are defined in
Default Value :- zero
LifeTime :- throughout the program

Register Storage Class

Register variable requests the compiler to store the variable in the CPU register instead of storing it in the memory to have faster access.
register int variable_name

Scope :- Local to the function they are defined in
Default Value :- Garbage Value
LifeTime :- Available till the end of the function block in which the variable is defined.

DEV Community: Anuj Raghuwanshi