{"id":7201,"date":"2025-10-18T00:01:00","date_gmt":"2025-10-18T07:01:00","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=7201"},"modified":"2025-10-25T08:16:02","modified_gmt":"2025-10-25T15:16:02","slug":"adding-pointers-to-pointers","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=7201","title":{"rendered":"Adding Pointers to Pointers"},"content":{"rendered":"

Expanding an allocated buffer is something you can do with a pointer, but not with an array. This flexibility is why I encourage all C language students to understand and use pointers, though it doesn’t make the concept nay less onery.
\n
\nThe goal of the program from last week’s Lesson<\/a> is to build an array of allocated buffers, but it’s not an array. Instead, it’s an expanding buffer that contains pointers (memory locations) to integer storage. Each location holds the values to 10 integers. Figure 1 kinda illustrates how this contraption works.<\/p>\n

\"Memory

Figure 1. How storage is allocated and tracked in an expanding buffer.<\/p><\/div>\n

I call each allocated buffer of 10 integers is a “stick.” The program keeps creating new sticks, tracking their addresses which are held in storage referenced by pointer tenint<\/code>. Each time a new stick of 10 integers is allocated, its address is stored, as illustrated in the figure.<\/p>\n

The program’s goal is to continue allocating new sticks for a total of ten. For today’s post, I improve the code from last week’s Lesson to show how ten such sticks can be allocated and tracked. No data is assigned to the sticks, as at this point my concern is managing the array of pointers.<\/p>\n

2025_10_18-Lesson.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <time.h>\r\n\r\n\/* allocate storage for ten integers *\/<\/span>\r\nint *ten(void)\r\n{\r\n    int *iptr = NULL;\r\n\r\n    iptr = malloc( sizeof(int) * 10 );\r\n\r\n    return(iptr);\r\n}\r\n\r\nint main()\r\n{\r\n    int **tenint = NULL;\r\n    int y;\r\n\r\n    \/* seed the randomizer *\/<\/span>\r\n    srand( (unsigned)time(NULL) );\r\n\r\n    \/* allocate 10 sticks of 10 integers *\/<\/span>\r\n    for( y=0; y<10; y++ )\r\n    {\r\n        \/* allocate first stick *\/<\/span>\r\n        if( tenint==NULL )\r\n        {\r\n            tenint = malloc( sizeof( int *) );\r\n            if( tenint==NULL )\r\n            {\r\n                fprintf(stderr,\"Unable to allocate storage\\n\");\r\n                exit(1);\r\n            }\r\n        }\r\n        else\r\n        \/* allocate additional sticks *\/<\/span>\r\n        {\r\n            tenint = realloc(tenint, sizeof( int *) * (y+1) );\r\n            if( tenint==NULL )\r\n            {\r\n                fprintf(stderr,\"Unable to reallocate storage\\n\");\r\n                exit(1);\r\n            }\r\n        }\r\n        \/* get the storage *\/<\/span>\r\n        *(tenint+y) = ten();\r\n        if( *(tenint+y)==NULL )\r\n        {\r\n            fprintf(stderr,\"Unable to allocate stick %d\\n\",y);\r\n            exit(1);\r\n        }\r\n        printf(\"Stick %d allocated\\n\",y);\r\n    }\r\n\r\n    \/* clean-up *\/<\/span>\r\n    for( y=0; y<10; y++ )\r\n        free( *(tenint+y) );\r\n    free(tenint);\r\n    puts(\"All sticks freed\");\r\n    return 0;\r\n}<\/pre>\n
In the main()<\/em> function, int<\/em> pointer tenint<\/code> is declared as a double-pointer:<\/p>\n
int **tenint = NULL;<\/code><\/p>\n
This variable stores the location where various addresses are stored. Let me explain:<\/p>\n
If the variable were declared as *tenint<\/code>, it would reference the address of a buffer of integers, the location where integer values are stored. This variable was used in last week’s Lesson.<\/p>\n
Because the variable is declared as **tenint<\/code>, it holds the address where addresses are stored, specifically the addresses of integer buffers. (Look at Figure 1 again.)<\/p>\n
In the code, the outer for<\/em> loop uses variable y<\/code> to allocate storage for the ten integer sticks. The first stick is handled differently as tenint<\/code> isn’t yet allocated. An if<\/em> test confirms this condition:<\/p>\n
if( tenint==NULL )<\/code><\/p>\n
If true, the malloc()<\/em> function allocates storage for an integer pointer:<\/p>\n
tenint = malloc( sizeof( int *) );<\/code><\/p>\n
The sizeof<\/em> operator uses expression int *<\/code> to allocate storage for one integer pointer. This size is what’s needed, not storage for ten integers; what’s being stored is the address<\/em> where ten integers are located in memory — a buffer.<\/p>\n
When tenint<\/code> is already initialized, the else<\/em> condition handles its expansion. The realloc()<\/em> function adds one integer-pointer-sized chunk to the storage at tenint<\/code>. Variable y<\/code> is determines how large to expand the buffer based on how many integer pointers (addresses) are already present:<\/p>\n
tenint = realloc(tenint, sizeof( int *) * (y+1) );<\/code><\/p>\n
For each spin of the loop, the tenint<\/code> buffer is enlarged by one int<\/em>-pointer-sized chunk.<\/p>\n
Once new storage is allocated, an address is fetched from the ten()<\/em> function. It’s assigned to the proper offset in the tenint<\/code> buffer based on the value of variable y<\/code>:<\/p>\n
*(tenint+y) = ten();<\/code><\/p>\n
The *<\/code> (dereferencing) operator is used as it’s an address being stored in the buffer. This data type is what the tenint<\/code> buffer is designed to store. If you instead use tenint+y<\/code> (no asterisk), you get an address, not storage.<\/p>\n
No values are assigned to the allocated storage returned from the ten()<\/em> function; I’ll add this code in next week’s Lesson. But the loop continues, storing the addresses of the allocated buffers at specific offsets in the tenint<\/code> buffer. Ten sticks are allocated.<\/p>\n
For clean-up, each stick buffer is freed, then the tenint<\/code> buffer:<\/p>\n
for( y=0; y<10; y++ )
\n    free( *(tenint+y) );
\nfree(tenint);<\/code><\/p>\n
Here’s a sample run:<\/p>\n
Stick 0 allocated
\nStick 1 allocated
\nStick 2 allocated
\nStick 3 allocated
\nStick 4 allocated
\nStick 5 allocated
\nStick 6 allocated
\nStick 7 allocated
\nStick 8 allocated
\nStick 9 allocated
\nAll sticks freed<\/code><\/p>\n
Key takeaways from this code are:<\/p>\n