Malloc int Double pointer

  • In this section, you are going to learn

How to allocate memory using malloc ?

How to allocate memory using calloc ?

How to allocate memory using realloc ?

Topics in this section,

  • Key point to remember

    • Double pointer points to array of single pointers

    • Single pointer points to array of integers

  • Example is arr[2][3]

    • Where there are 2 rows and 3 columns

  • Now let us take a look at real time examples

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define Double pointer

int **ptr;

  • Step 3 : Create One single pointer

ptr = malloc( sizeof(int *) );

Allocates 8 Bytes of memory in heap

  • ptr points to array of single pointers

  • In this case, array has one single pointer

  • sizeof(ptr) is 8 Bytes

  • Step 4 : Create One single integer

*ptr = malloc( sizeof(int) );

OR

ptr[0] = malloc( sizeof(int) );

Allocates 4 Bytes of memory in heap

  • Step 5 : Assign value to Integer

**ptr = 65;

OR

*ptr[0] = 65;

OR

ptr[0][0] = 65;

  • Step 6 : Print the value

printf("**ptr = %d\n", **ptr);
printf("*ptr[0] = %d\n", *ptr[0]);
printf("ptr[0][0] = %d\n", ptr[0][0]);

  • Step 7 : Free after use

free(*ptr);
free(ptr);

Free in the opposite order of allocation

  • See the full program below

 1#include <stdio.h>
 2
 3// Step 1 : Include stdlib.h
 4#include <stdlib.h>
 5
 6int main(void)
 7{
 8        // Step 2 : Define Double pointer
 9        int **ptr;
10
11        // Step 3 : Create One single pointer
12        ptr = malloc( sizeof(int *) );
13
14        // Step 4 : Create One single integer
15        *ptr = malloc( sizeof(int) );
16
17        // Step 5 : Assign value to integer
18        **ptr = 65;
19
20        // Step 6 : Print the value
21        printf("**ptr = %d\n", **ptr);
22
23        // Step 7 : Free after use
24        free(*ptr);
25        free(ptr);
26
27        return 0;
28}

Statement

Description

ptr = malloc( sizeof(int *) )

  • ptr points to array of single pointers

*ptr = malloc( sizeof(int ) )

  • *ptr points to array of integers

sizeof(ptr)

  • 8 Bytes

  • Not fully dereferenced

  • Hence ptr is a pointer

  • sizeof(pointer) is 8 Bytes always

sizeof(*ptr)

  • 8 Bytes

  • Not fully dereferenced

  • Hence *ptr is a pointer

  • sizeof(pointer) is 8 Bytes always

sizeof(**ptr)

  • 4 Bytes

  • Fully dereferenced

  • Hence takes the size of actual type

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define Double pointer

int **ptr;

  • Step 3 : Create One single pointer

ptr = malloc( sizeof(int *) );

Allocates 8 Bytes of memory in heap

  • ptr points to array of single pointers

  • In this case, array has one single pointer

  • sizeof(ptr) is 8 Bytes

  • Step 4 : Create Ten integers

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

OR

ptr[0] = malloc( 10 * sizeof(int) );

Allocates 40 Bytes of memory in heap

OR

Allocates 10 Integers of memory in heap

  • Step 5 : *ptr can be used as an array of Integers now !

int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
memcpy(*ptr, arr, sizeof(arr));

  • Step 6 : Print individual integers : Using (*ptr)[i]

for (int i = 0; i < 10; i++)
{
        printf("%d\n", (*ptr)[i]);
}

  • Step 8 : Print individual integers : Using ptr[0][i]

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

  • Step 9 : Free after use

free(*ptr);
free(ptr);

Free in the opposite order of allocation

  • See the full program below

 1#include <stdio.h>
 2
 3// Step 1 : Include stdlib.h
 4#include <stdlib.h>
 5
 6int main(void)
 7{
 8        // Step 2 : Define Double pointer
 9        int **ptr;
10
11        // Step 3 : Create One single pointer
12        ptr = malloc( sizeof(int *) );
13
14        // Step 4 : Create Ten integers
15        *ptr = malloc( 10 * sizeof(int) );
16
17        // Step 5 : *ptr is now pointing to array of integers
18        int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
19        memcpy(*ptr, arr, sizeof(arr));
20
21        // Step 6 : Print individual Integers : Using (*ptr)[i]
22        printf("\nMethod 2 : Print Integers using (*ptr)[i]\n");
23        for (int i = 0; i < 10; i++)
24        {
25                printf("%d\n", (*ptr)[i]);
26        }
27
28        // Step 8 : Print individual Integers : Using ptr[0][i]
29        printf("\nMethod 2 : Print Integers using ptr[0][i]\n");
30        for (int i = 0; i < 10; i++)
31        {
32                printf("%d\n", ptr[0][i]);
33        }
34
35        // Step 9 : Free after use
36        free(*ptr);
37        free(ptr);
38
39        return 0;
40}

Statement

Description

ptr = malloc( sizeof(int *) )

  • ptr points to array of single pointers

*ptr = malloc( 10 * sizeof(int) )

  • *ptr points to array of integers

sizeof(ptr)

  • 8 Bytes

  • Not fully dereferenced

  • Hence ptr is a pointer

  • sizeof(pointer) is 8 Bytes always

sizeof(*ptr)

  • 8 Bytes

  • Not fully dereferenced

  • Hence *ptr is a pointer

  • sizeof(pointer) is 8 Bytes always

sizeof(**ptr)

  • 4 Bytes

  • Fully dereferenced

  • Hence takes the size of actual type

*ptr

  • Points to array of 10 integers

(*ptr)[i]

  • Method 1 : To access individual integers

ptr[0][i]

  • Method 2 : To access individual integers

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define Double pointer

int **ptr;

  • Step 3 : Create Ten Single Pointers from ptr[0] … ptr[9]

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

  • Step 4 : Create One Integer in every Row

for (int i = 0; i < 10; i++)
{
        ptr[i] = malloc( sizeof(int) );
}

  • Step 5 : Assign values to Integers

for (int i = 0; i < 10; i++)
{
        ptr[i][0] = ++val;
}

  • Step 6 : Print the values

for (int i = 0; i < 10; i++)
{
        printf("Row %d Column 0 : %d\n", i, ptr[i][0]);
}

  • Step 7 : Free after use

for (int i = 0; i < 10; i++)
{
        free(ptr[i]);
}

free(ptr);

  • See the full program below

 1// Step 1 : Include stdlib.h
 2#include <stdlib.h>
 3
 4int main(void)
 5{
 6        // Step 2 : Define Double pointer
 7        int **ptr;
 8        int val = 0;
 9
10        // Step 3 : Create Ten Single Pointers from ptr[0] ... ptr[9]
11        ptr = malloc( 10 * sizeof(int *) );
12
13        // Step 4 : Create One Character in every Row
14        for (int i = 0; i < 10; i++)
15        {
16                ptr[i] = malloc( sizeof(int) );
17        }
18
19        // Step 5 : Assign values to integers
20        for (int i = 0; i < 10; i++)
21        {
22                ptr[i][0] = ++val;
23        }
24
25        // Step 6 : Print the values
26        for (int i = 0; i < 10; i++)
27        {
28                printf("Row %d Column 0 : %d\n", i, ptr[i][0]);
29        }
30
31        // Step 7 : Free after use
32        for (int i = 0; i < 10; i++)
33        {
34                free(ptr[i]);
35        }
36
37        free(ptr);
38
39        return 0;
40}

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define Double pointer

int **ptr;

  • Step 3 : Create Ten Single Pointers from ptr[0] … ptr[9]

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

  • Step 4 : Create Ten Integers in every Row

for (int i = 0; i < 10; i++)
{
        ptr[i] = malloc( 10 * sizeof(int) );
}

  • Step 5 : Assign values to array of integers

for (int i = 0; i < 10; i++)
{
        int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        memcpy(ptr[i], arr, sizeof(arr));
}

  • Step 6 : Print the integers

for (int i = 0; i < 10; i++)
{
        for (int j = 0; j < 10; j++)
        {
                printf("Row %d : Col %d : Integer : %d\n", i, j, ptr[i][j] );
        }
}

  • Step 7 : Free after use

for (int i = 0; i < 10; i++)
{
        free(ptr[i]);
}
free(ptr);

  • See the full program below

 1#include <stdio.h>
 2
 3// Step 1 : Include stdlib.h
 4#include <stdlib.h>
 5
 6int main(void)
 7{
 8        // Step 2 : Define Double pointer
 9        int **ptr;
10        int val = 0;
11
12        // Step 3 : Create Ten Single Pointers from ptr[0] ... ptr[9]
13        ptr = malloc( 10 * sizeof(int *) );
14
15        // Step 4 : Create Ten Characters in every Row
16        for (int i = 0; i < 10; i++)
17        {
18                ptr[i] = malloc( 10 * sizeof(int) );
19        }
20
21        //ptr[0] is an array of 10 integers. Same is true for ptr[1] to ptr[9]
22
23        // Step 5 : Assign values to array of integers
24        for (int i = 0; i < 10; i++)
25        {
26                int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
27
28                memcpy(ptr[i], arr, sizeof(arr));
29        }
30
31        // Step 6 : Print the integers
32        for (int i = 0; i < 10; i++)
33        {
34                for (int j = 0; j < 10; j++)
35                {
36                        printf("Row %d : Col %d : Integer : %d\n", i, j, ptr[i][j] );
37                }
38        }
39
40        // Step 7 : Free after use
41        for (int i = 0; i < 10; i++)
42        {
43                free(ptr[i]);
44        }
45
46        free(ptr);
47
48        return 0;
49}

  • Example is arr has 5 rows, and

    • arr[0] points to an array of 7 integers

    • arr[1] points to an array of 5 integers

    • arr[2] points to an array of 4 integers

    • arr[3] points to an array of 9 integers

    • arr[4] points to an array of 3 integers

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define Double pointer

int **arr;

  • Step 3 : Create Five Single Pointers from arr[0] … arr[4]

arr = malloc( 5 * sizeof(int *) );

  • Step 4 : Create Character arrays in every Row

arr[0] = malloc( 7 * sizeof(int) );
arr[1] = malloc( 5 * sizeof(int) );
arr[2] = malloc( 4 * sizeof(int) );
arr[3] = malloc( 9 * sizeof(int) );
arr[4] = malloc( 3 * sizeof(int) );

  • Step 5 : Copy integers to array of integers

int i_arr_0[7] = {1, 2, 3, 4, 5, 6, 7};
memcpy(arr[0], i_arr_0, sizeof(iarr));

int i_arr_1[5] = {1, 2, 3, 4, 5};
memcpy(arr[1], i_arr_1, sizeof(iarr));

int i_arr_2[4] = {1, 2, 3, 4};
memcpy(arr[2], i_arr_2, sizeof(iarr));

int i_arr_3[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
memcpy(arr[3], i_arr_3, sizeof(iarr));

int i_arr_4[3] = {1, 2, 3};
memcpy(arr[4], i_arr_4, sizeof(iarr));

  • Step 6 : Print the integers

for (int i = 0; i < 7; i++)
{
        printf("arr[0][i] = %d\n", i, arr[0][i]);
}

for (int i = 0; i < 5; i++)
{
        printf("arr[1][i] = %d\n", i, arr[1][i]);
}

for (int i = 0; i < 4; i++)
{
        printf("arr[2][i] = %d\n", i, arr[2][i]);
}

for (int i = 0; i < 9; i++)
{
        printf("arr[3][i] = %d\n", i, arr[3][i]);
}

for (int i = 0; i < 3; i++)
{
        printf("arr[4][i] = %d\n", i, arr[4][i]);
}

  • Step 7 : Free after use

for (int i = 0; i < 5; i++)
{
        free(arr[i]);
}

free(arr);

  • See the full program below

 1#include <stdio.h>
 2
 3// Step 1 : Include stdlib.h
 4#include <stdlib.h>
 5
 6int main(void)
 7{
 8        // Step 2 : Define Double pointer
 9        int **arr;
10
11        // Step 3 : Create Five Single Pointers from arr[0] ... arr[4]
12        arr = malloc( 5 * sizeof(int *) );
13
14        // Step 4 : Create Character arrays in every Row
15        arr[0] = malloc( 7 * sizeof(int) );
16        arr[1] = malloc( 5 * sizeof(int) );
17        arr[2] = malloc( 4 * sizeof(int) );
18        arr[3] = malloc( 9 * sizeof(int) );
19        arr[4] = malloc( 3 * sizeof(int) );
20
21        // Step 5 : Copy integers to array of integers
22
23        int i_arr_0[7] = {1, 2, 3, 4, 5, 6, 7};
24        memcpy(arr[0], i_arr_0, sizeof(i_arr_0));
25
26        int i_arr_1[5] = {1, 2, 3, 4, 5};
27        memcpy(arr[1], i_arr_1, sizeof(i_arr_1));
28
29        int i_arr_2[4] = {1, 2, 3, 4};
30        memcpy(arr[2], i_arr_2, sizeof(i_arr_2));
31
32        int i_arr_3[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
33        memcpy(arr[3], i_arr_3, sizeof(i_arr_3));
34
35        int i_arr_4[3] = {1, 2, 3};
36        memcpy(arr[4], i_arr_4, sizeof(i_arr_4));
37
38        // Step 6 : Print the integers
39
40        for (int i = 0; i < 7; i++)
41        {
42                printf("arr[0][%d] = %d\n", i, arr[0][i]);
43        }
44
45        for (int i = 0; i < 5; i++)
46        {
47                printf("arr[1][%d] = %d\n", i, arr[1][i]);
48        }
49
50        for (int i = 0; i < 4; i++)
51        {
52                printf("arr[2][%d] = %d\n", i, arr[2][i]);
53        }
54
55        for (int i = 0; i < 9; i++)
56        {
57                printf("arr[3][%d] = %d\n", i, arr[3][i]);
58        }
59
60        for (int i = 0; i < 3; i++)
61        {
62                printf("arr[4][%d] = %d\n", i, arr[4][i]);
63        }
64
65        // Step 7 : Free after use
66        for (int i = 0; i < 5; i++)
67        {
68                free(arr[i]);
69        }
70
71        free(arr);
72
73        return 0;
74}

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define an allocation function

void get_memory(int **dp)
{
        // *dp is equal to sp in caller
        *dp = malloc(10 * sizeof(int));

        memset(*dp, 0, 10);
}

  • Step 3: Define a single pointer

int *sp;

  • Step 4 : Pass single pointer sp by reference

get_memory(&sp);

  • Step 5 : sp is now pointing to array of 10 integers

int i_arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
memcpy(sp, i_arr, sizeof(i_arr));

  • Step 6 : Free the memory

free(sp);

  • See full program below

 1#include <stdio.h>
 2
 3// Step 1 : Include stdlib.h
 4#include <stdlib.h>
 5
 6// Step 2 : Define an allocation function
 7void get_memory(int **dp)
 8{
 9        // *dp is equal to sp in caller
10        *dp = malloc(10 * sizeof(int));
11
12        memset(*dp, 0, 10);
13}
14
15int main(void)
16{
17        // Step 3: Define a single pointer
18        int *sp;
19
20        // Step 4 : Pass single pointer "sp" by reference
21        get_memory(&sp);
22
23        // Step 5 : "sp" is now pointing to array of 10 integers
24        int i_arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
25        memcpy(sp, i_arr, sizeof(i_arr));
26
27        for (int i = 0; i < 10; i++) {
28                printf("Row:%d : Integer:%d\n", i, sp[i]);
29        }
30
31        // Step 6 : Free the memory
32        free(sp);
33
34        return 0;
35}

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define an allocation function

void get_memory(int ***tp)
{
}

  • Step 2.1 : Create Ten Single Pointers from tp[0] … tp[9]

void get_memory(int ***tp)
{
        *tp = malloc( 10 * sizeof(int *) );
}

  • tp is a triple pointer

  • *tp is a double pointer and will point to array of single pointers !

  • Step 2.2 : Create Ten Characters in every Row

void get_memory(int ***tp)
{
        *tp = malloc( 10 * sizeof(int *) );

        for (int i = 0; i < 10; i++)
        {
                (*tp)[i] = malloc( 10 * sizeof(int) );
        }
}

  • *tp[] is a single pointer and will point to array of integers

  • Step 3: Define a single pointer

int **dp;

  • Step 4 : Pass double pointer “dp” by reference

get_memory(&dp);

  • Step 5 : Assign integers to array of integers

int val = 0;
for (int i = 0; i < 10; i++)
{
        for (int j = 0; j < 10; j++)
        {
                dp[i][j] = ++val;
        }
}

  • Step 6 : Print the integers

for (int i = 0; i < 10; i++)
{
        for (int j = 0; j < 10; j++)
        {
                printf("Row:%d : Col:%d : Integer:%d\n", i, j, dp[i][j]);
        }
}

  • Step 7 : Free after use

for (int i = 0; i < 10; i++)
{
        free(dp[i]);
}

free(dp);

  • See the full program below

 1#include <stdio.h>
 2
 3// Step 1 : Include stdlib.h
 4#include <stdlib.h>
 5
 6// Step 2 : Define an allocation function
 7void get_memory(int ***tp)
 8{
 9        // Step 2.1 : Create Ten Single Pointers from tp[0] ... tp[9]
10        *tp = malloc( 10 * sizeof(int *) );
11
12        // Step 2.2 : Create Ten Characters in every Row
13        for (int i = 0; i < 10; i++)
14        {
15               (*tp)[i] = malloc( 10 * sizeof(int) );
16        }
17}
18
19int main(void)
20{
21        // Step 3: Define a single pointer
22        int **dp;
23        int val = 0;
24
25        // Step 4 : Pass double pointer "dp" by reference
26        get_memory(&dp);
27
28        // Step 5 : Assign integers to array of integers
29        for (int i = 0; i < 10; i++)
30        {
31                for (int j = 0; j < 10; j++)
32                {
33                        dp[i][j] = ++val;
34                }
35        }
36
37        // Step 6 : Print the integers
38        for (int i = 0; i < 10; i++)
39        {
40                for (int j = 0; j < 10; j++)
41                {
42                        printf("Row:%d : Col:%d : Integer:%d\n", i, j, dp[i][j]);
43                }
44        }
45
46        // Step 7 : Free after use
47        for (int i = 0; i < 10; i++)
48        {
49                free(dp[i]);
50        }
51
52        free(dp);
53
54        return 0;
55}
See Also