Malloc int Triple 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

    • Triple pointer points to array of double pointers

    • Double pointer points to array of single pointers

    • Single pointer points to array of integers

  • Example is arr[2][3][4]

  • Now let us take a look at real time examples

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define Triple Pointer

int ***ptr;

  • Step 3.1 : ptr is a triple pointer and points to array of double pointers

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

  • Step 3.2 : *ptr is a double pointer and points to array of single pointers

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

  • Step 3.3 : **ptr is a single pointer and points to array of integers

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

  • Step 4 : Assign a value to integer

***ptr = 65;

  • Step 5 : Print the value of integer

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

  • Step 6.1 : Free array of integers

free(**ptr);

  • Step 6.2 : Free array of single pointers

free(*ptr);

  • Step 6.3 : Free array of double pointers

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 Triple Pointer
 9        int ***ptr;
10
11        // Step 3.1 : ptr is a triple pointer and points to array of double pointers
12        ptr = malloc(sizeof(int **));
13
14        // Step 3.2 : *ptr is a double pointer and points to array of single pointers
15        *ptr = malloc(sizeof(int *));
16
17        // Step 3.3 : **ptr is a single pointer and points to array of integers
18        **ptr = malloc(sizeof(int));
19
20        // Step 4 : Assign a value to integer
21        ***ptr = 65;
22
23        // Step 5 : Print the value of integer
24        printf("***ptr = %d\n", ***ptr);
25
26        // Step 6.1 : Free array of integers
27        free(**ptr);
28
29        // Step 6.2 : Free array of single pointers
30        free(*ptr);
31
32       // Step 6.3 : Free array of double pointers
33        free(ptr);
34
35        return 0;
36}

Statement

Description

ptr

  • ptr is a triple pointer

*ptr

  • *ptr is a double pointer

**ptr

  • **ptr is a single pointer

***ptr

  • ***ptr is a integer

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)

  • 8 Bytes

  • Not fully dereferenced

  • Hence **ptr is a pointer

  • sizeof(pointer) is 8 Bytes always

sizeof(***ptr)

  • 4 Bytes

  • Fully dereferenced

  • Hence ***ptr is a integer

  • sizeof(integer) is 1 Byte always

ptr = malloc( sizeof(int **) )

  • ptr points to array of double pointers

*ptr = malloc( sizeof(int *) )

  • *ptr points to array of single pointers

**ptr = malloc( sizeof(int ) )

  • **ptr points to array of integers

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define Triple Pointer

int ***ptr;

  • Step 3.1 : ptr is a triple pointer and points to array of double pointers

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

  • Step 3.2 : *ptr is a double pointer and points to array of single pointers

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

  • Step 3.3 : **ptr is a single pointer and points to array of integers

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

  • Step 4 : **ptr is now pointing to array of 10 integers. Hence can use it for integer memcpy operations

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

  • Step 5 : Print the array

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

OR

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

  • Step 6.1 : Free array of integers

free(**ptr);

  • Step 6.2 : Free array of single pointers

free(*ptr);

  • Step 6.3 : Free array of double pointers

free(ptr);

  • See the full program below

 1#include <stdio.h>
 2#include <string.h>
 3
 4// Step 1 : Include stdlib.h
 5#include <stdlib.h>
 6
 7int main(void)
 8{
 9        // Step 2 : Define Triple Pointer
10        int ***ptr;
11
12        // Step 3.1 : ptr is a triple pointer and points to array of double pointers
13        ptr = malloc(sizeof(int **));
14
15        // Step 3.2 : *ptr is a double pointer and points to array of single pointers
16        *ptr = malloc(sizeof(int *));
17
18        // Step 3.3 : **ptr is a single pointer and points to array of integers
19        **ptr = malloc(10 * sizeof(int));
20
21        // Step 4 : **ptr is now pointing to array of 10 integers. Hence can use it for integer memcpy operations
22        int i_arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
23        memcpy(**ptr, i_arr, sizeof(i_arr));
24
25        // Step 5 : Print the Integers
26        for (int i = 0; i < 10; i++)
27        {
28                printf("(**ptr)[i] = %d\n", (**ptr)[i]);
29        }
30
31        for (int i = 0; i < 10; i++)
32        {
33                printf("ptr[0][0][i] = %d\n", ptr[0][0][i]);
34        }
35
36        // Step 6.1 : Free array of integers
37        free(**ptr);
38
39        // Step 6.2 : Free array of single pointers
40        free(*ptr);
41
42        // Step 6.3 : Free array of double pointers
43        free(ptr);
44
45        return 0;
46}

Statement

Description

ptr

  • ptr is a triple pointer

*ptr

  • *ptr is a double pointer

**ptr

  • **ptr is a single pointer

***ptr

  • ***ptr is a integer

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)

  • 8 Bytes

  • Not fully dereferenced

  • Hence **ptr is a pointer

  • sizeof(pointer) is 8 Bytes always

sizeof(***ptr)

  • 4 Bytes

  • Fully dereferenced

  • Hence ***ptr is a integer

  • sizeof(integer) is 4 Bytes always

ptr = malloc( sizeof(int **) )

  • ptr points to array of double pointers

*ptr = malloc( sizeof(int *) )

  • *ptr points to array of single pointers

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

  • **ptr points to array of 10 integers

memcpy(**ptr, i_arr, sizeof(i_arr));

  • Copies “i_arr” to **ptr

(**ptr)[i]

  • Method 1 : To access individual integers

ptr[0][0][i]

  • Method 2 : To access individual integers

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define Triple Pointer

int ***ptr;

  • Step 3.1 : ptr is a triple pointer and points to array of double pointers

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

  • Step 3.2 : Create array of single pointers from (*ptr)[0] … (*ptr)[9]

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

  • Step 3.3 : Now create array of integers for every single pointer from (*ptr)[0] … (*ptr)[9]

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

  • Step 4 : (*ptr)[0] .. (*ptr)[9] is now pointing to array of integers each

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

  • Step 5 : Print the Integer arrays

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

  • Step 6.1 : Free array of integers pointed by all single pointers

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

  • Step 6.2 : Free array of single pointers

free(*ptr);

  • Step 6.3 : Free array of double pointers

free(ptr);

  • See the full program below

 1#include <stdio.h>
 2#include <string.h>
 3
 4// Step 1 : Include stdlib.h
 5#include <stdlib.h>
 6
 7int main(void)
 8{
 9        // Step 2 : Define Triple Pointer
10        int ***ptr;
11
12        // Step 3.1 : ptr is a triple pointer and points to array of double pointers
13        ptr = malloc(sizeof(int **));
14
15        // Step 3.2
16        // *ptr is a double pointer and points to array of single pointers
17        // Create array of single pointers from (*ptr)[0] ... (*ptr)[9]
18        *ptr = malloc(10 * sizeof(int *));
19
20        // Step 3.3 : Now create array of integers for every single pointer from (*ptr)[0] ... (*ptr)[9]
21
22        for (int i = 0; i < 10; i++) {
23                (*ptr)[i] = malloc(10 * sizeof(int));
24        }
25
26        // Step 4 : (*ptr)[0] .. (*ptr)[9] is now pointing to array of integers each
27        for (int i = 0; i < 10; i++) {
28                int i_arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
29                memcpy((*ptr)[i], i_arr, sizeof(i_arr));
30        }
31
32        // Step 5 : Print the Integers
33        for (int i = 0; i < 1; i++) {
34                for (int j = 0; j < 10; j++) {
35                        for (int k = 0; k < 10; k++) {
36                                printf("ptr[%d][%d][%d] = %d\n", i, j, k, ptr[i][j][k]);
37                        }
38                }
39        }
40
41        // Step 6.1 : Free array of integers pointed by all single pointers
42        for (int i = 0; i < 10; i++) {
43                free((*ptr)[i]);
44        }
45
46        // Step 6.2 : Free array of single pointers
47        free(*ptr);
48
49        // Step 6.3 : Free array of double pointers
50        free(ptr);
51
52        return 0;
53}

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define Triple Pointer

int ***ptr;

  • Step 3.1 : Create array of double pointers from ptr[0] … ptr[9]

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

  • Step 3.2 : Create array of single pointers for every double pointer

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

  • Step 3.3 : Create array of integers for every single pointer from ptr[0][9] … ptr[9][9]

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

  • Step 4 : Use ptr[0][0] … ptr[9][9] as integer array

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

  • Step 5 : Print the Integers

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

  • Step 6.1 : Free array of integers pointed by all single pointers

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

  • Step 6.2 : Free array of single pointers

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

  • Step 6.3 : Free array of double pointers

free(ptr);

  • See the full program below

 1#include <stdio.h>
 2#include <string.h>
 3
 4// Step 1 : Include stdlib.h
 5#include <stdlib.h>
 6
 7int main(void)
 8{
 9        // Step 2 : Define Triple Pointer
10        int ***ptr;
11
12        // Step 3.1 : Create array of double pointers from ptr[0] ... ptr[9]
13        ptr = malloc(10 * sizeof(int **));
14
15        // Step 3.2 : Create array of single pointers for every double pointer
16        for (int i = 0; i < 10; i++) {
17                ptr[i] = malloc(10 * sizeof(int *));
18        }
19
20        // Step 3.3 : Create array of integers for every single pointer from ptr[0][9] ... ptr[9][9]
21        for (int i = 0; i < 10; i++) {
22                for (int j = 0; j < 10; j++) {
23                        ptr[i][j] = malloc(10 * sizeof(int));
24                }
25        }
26
27        // Step 4 : Use ptr[0][0] ... ptr[9][9] as integer array
28        for (int i = 0; i < 10; i++) {
29                for (int j = 0; j < 10; j++) {
30                        int i_arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
31                        memcpy(ptr[i][j], i_arr, sizeof(i_arr));
32                }
33        }
34
35        // Step 5 : Print the Integers
36        for (int i = 0; i < 10; i++) {
37                for (int j = 0; j < 10; j++) {
38                        for (int k = 0; k < 10; k++) {
39                                printf("ptr[%d][%d][%d] = %d\n", i, j, k, ptr[i][j][k]);
40                        }
41                }
42        }
43
44        // Step 6.1 : Free array of integers pointed by all single pointers
45        for (int i = 0; i < 10; i++) {
46                for (int j = 0; j < 10; j++) {
47                        free(ptr[i][j]);
48                }
49        }
50
51        // Step 6.2 : Free array of single pointers
52        for (int i = 0; i < 10; i++) {
53                free(ptr[i]);
54        }
55
56        // Step 6.3 : Free array of double pointers
57        free(ptr);
58
59        return 0;
60}

  • Step 1 : Include stdlib.h

#include <stdlib.h>

  • Step 2 : Define an allocation function

int get_memory(int ****fp)
{
        return 0;
}

  • Step 3.1 : Create array of double pointers from (*fp)[0] … (*fp)[9]

int get_memory(int ****fp)
{
        // Step 3.1 : Create array of double pointers from (*fp)[0] ... (*fp)[9]
        *fp = malloc(10 * sizeof(int **));

        return 0;
}

  • Step 3.2 : Create array of single pointers for every double pointer

int get_memory(int ****fp)
{
        // Step 3.1 : Create array of double pointers from (*fp)[0] ... (*fp)[9]
        *fp = malloc(10 * sizeof(int **));

        // Step 3.2 : Create array of single pointers for every double pointer
        for (int i = 0; i < 10; i++) {
                (*fp)[i] = malloc(10 * sizeof(int *));
        }

        return 0;
}

  • Step 3.3 : Create array of integers for every single pointer from (*fp)[0][9] … (*fp)[9][9]

int get_memory(int ****fp)
{
        // Step 3.1 : Create array of double pointers from (*fp)[0] ... (*fp)[9]
        *fp = malloc(10 * sizeof(int **));

        // Step 3.2 : Create array of single pointers for every double pointer
        for (int i = 0; i < 10; i++) {
                (*fp)[i] = malloc(10 * sizeof(int *));
        }

        // Step 3.3 : Create array of integers for every single pointer from (*fp)[0][9] ... (*fp)[9][9]
        for (int i = 0; i < 10; i++) {
                for (int j = 0; j < 10; j++) {
                        (*fp)[i][j] = malloc(10 * sizeof(int));
                }
        }

        return 0;
}

  • Step 4 : Define Triple Pointer in caller

int ***tp;

  • Step 5 : Pass Triple pointer as reference

get_memory(&tp);

  • Step 6 : Use tp[0][0] … tp[9][9] as integer array

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

  • Step 7 : Print the Integers

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

  • Step 6.1 : Free array of integers pointed by all single pointers

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

  • Step 6.2 : Free array of single pointers

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

  • Step 6.3 : Free array of double pointers

free(tp);

  • See the full program below

 1#include <stdio.h>
 2#include <string.h>
 3
 4// Step 1 : Include stdlib.h
 5#include <stdlib.h>
 6
 7int get_memory(int ****fp)
 8{
 9        // Step 3.1 : Create array of double pointers from (*fp)[0] ... (*fp)[9]
10        *fp = malloc(10 * sizeof(int **));
11
12        // Step 3.2 : Create array of single pointers for every double pointer
13        for (int i = 0; i < 10; i++) {
14                (*fp)[i] = malloc(10 * sizeof(int *));
15        }
16
17        // Step 3.3 : Create array of integers for every single pointer from (*fp)[0][9] ... (*fp)[9][9]
18        for (int i = 0; i < 10; i++) {
19                for (int j = 0; j < 10; j++) {
20                        (*fp)[i][j] = malloc(10 * sizeof(int));
21                }
22        }
23
24        return 0;
25}
26
27int main(void)
28{
29        // Step 2 : Define Triple Pointer
30        int ***tp;
31
32        // Step 3 : Pass Triple pointer as reference
33        get_memory(&tp);
34
35        // Step 4 : Use tp[0][0] ... tp[9][9] as integer array
36        for (int i = 0; i < 10; i++) {
37                for (int j = 0; j < 10; j++) {
38                        int i_arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
39                        memcpy(tp[i][j], i_arr, sizeof(i_arr));
40                }
41        }
42
43        // Step 5 : Print the Integers
44        for (int i = 0; i < 10; i++) {
45                for (int j = 0; j < 10; j++) {
46                        for (int k = 0; k < 10; k++) {
47                                printf("tp[%d][%d][%d] = %d\n", i, j, k, tp[i][j][k]);
48                        }
49                }
50        }
51
52        // Step 6.1 : Free array of integers pointed by all single pointers
53        for (int i = 0; i < 10; i++) {
54                for (int j = 0; j < 10; j++) {
55                        free(tp[i][j]);
56                }
57        }
58
59        // Step 6.2 : Free array of single pointers
60        for (int i = 0; i < 10; i++) {
61                free(tp[i]);
62        }
63
64        // Step 6.3 : Free array of double pointers
65        free(tp);
66
67        return 0;
68}
See Also