In the previous lesson, we saw four basic types of pointers. There are some nontrivial types of pointers that every programmer should know and understand the usage of, including:

Pointer to pointers
void pointer
Function pointers

Let’s start by discussing pointer to pointers and its applications.

Pointer to pointers

As we know, the pointer holds the address of any data type Type, and its generic syntax is:

Press + to interact

#include <iostream>
using namespace std;
int main() 
{
  int val = 14;
  int * ptr = & val;
  cout <<"&val  : "<<&val<<'\n';
  cout <<" val  : "<<val<<'\n';
  cout <<"&ptr  : "<<&ptr <<'\n';
  cout <<" ptr  : "<<ptr <<'\n';
  cout <<"*ptr  : "<<*ptr <<'\n'; 
  /* int **ptr1 = &val this instruction is not posible the double pointer
  must be pointed the memory of a pointer*/
  int **pptr = &ptr;
  cout<< "&pptr : "<<&pptr<<'\n';
  cout<< " pptr : "<<pptr<<'\n';
  cout<< "*pptr : "<< *pptr<<'\n';
  cout<< "**ptr : " << **pptr << '\n';
  return 0;
}

The code begins by declaring an integer variable val and initializing it with the value 14. Then, a pointer variable ptr is declared and assigned the memory address of val using the address-of operator (&). The subsequent lines print out the memory addresses and values of val, ptr, and *ptr. Next, a double pointer pptr is declared and assigned the memory address of ptr. The code then prints out the memory address of pptr, the value of pptr (which is the address of ptr), the value pointed to by pptr (which is the address of val), and the value pointed to by the double pointer (**pptr), which is the value of val.

In the following drawing, we can see what the memory structure for the above program looks like. The red arrow doesn’t exist physically (it is just shown to help you understand that it’s a pointer pointing to the memory location).

Press + to interact

By utilizing dynamic memory allocation, pointers, and pointer to pointers, we can efficiently store an upper triangular matrix in memory. This approach allows us to store only the nonzero elements of the matrix and avoid storing certain zero elements, resulting in significant memory savings. Additionally, this approach offers a significant improvement over static two-dimensional arrays, which require each row to be of equal size. With dynamic memory allocation and pointer to pointers, we have the flexibility to store rows of different sizes, providing greater versatility and efficiency in managing memory for an upper triangular matrix.

Let’s write the code for storing a lower triangular matrix:

Press + to interact

#include <iostream>
using namespace std;
void printLowerTriangularMatrix(int** matrix, int n)
{
    cout << "Lower Triangular Matrix:" << endl;
    for (int i = 0; i < n; i++) 
    {
        cout << "\t";
        for (int j = 0; j < n; j++) 
        {
            if(j>i)
                cout << "0" << " ";
            else
                cout << matrix[i][j] << " ";
        }   
        cout << endl;
    }
}
void displayMemoryStructure(int** &matrix, int n)
{
    cout << "&matrix: "<<&matrix
         << " => "<< matrix << endl;
    // The pointers table
    for(int i=0; i<n; i++)              // &matrix[i]    =>     matrix[i]
    {
         cout << "\t & matrix["<< i << "]: "<< matrix+i <<" => " << *(matrix+i) << "    {";
         for(int j=0; j<=i; j++)
         {
             cout << (*(matrix+i)+j) << ": "<<*(*(matrix+i)+j) ;
             if(j!=i)
                cout << " , ";
         }
        cout << " }" << endl;
    }   
}
int main() 
{
    int rows;
    // cout << "Dimension: ";
    cin >> rows;
    // Dynamic memory allocation for rows
    int** matrix = new int*[rows];
    // Dynamic memory allocation for each row
    for (int i = 0; i < rows; i++) 
        matrix[i] = new int[i + 1];
    
    // Storing values in the lower triangular matrix
    for (int i = 0; i < rows; i++) 
        for (int j = 0; j <= i; j++) 
            matrix[i][j] = rand()%10; // assigning a random value
    
    // Printing the lower triangular matrix
    printLowerTriangularMatrix(matrix, rows);
    cout << "\n\nMemory Structure\n\n";
    displayMemoryStructure(matrix, rows);
    // Deallocating the memory
    for (int i = 0; i < rows; i++) 
        delete[] matrix[i];
    delete[] matrix;
    return 0;
}

Enter the input below

Press + to interact

Each pointer in the array points to a one-dimensional array of varying sizes. The memory addresses of the array elements have a difference of 8 bytes because each pointer takes up 8 bytes of memory. However, when looking at the one-dimensional arrays themselves, the increment factor is 4 bytes since they are arrays of integers.

Overall, this memory structure allows for efficient storage of a lower triangular matrix by dynamically allocating memory only for the required elements. Pointers enable flexibility in accessing and manipulating the matrix while optimizing memory usage.

Practice exercise: Upper triangular matrix

Modify the above code to store an upper triangular matrix. Carefully think about what should be changed. Challenge yourself by seeing if you can also write a program that displays the entire memory structure of the upper triangular matrix.

If you have trouble getting to the solution, you can click the “Solution” button to see how to solve the problem.

Exercise: Allocating higher dimensional dynamic arrays

This idea can be easily extended to make multidimensional arrays. As we saw earlier, when allocating a single-dimensional array, we needed a Type *. For allocating a two-dimensional array, we need a pointer to pointers Type**, which will point to an array of Type*.

Similarly, if we want to extend this idea to allocate a three-dimensional array, then we’ll need Type***. Let’s look at the following example to construct a cube of the dimension $H$ where it should have $H$ faces, each of $H \times H$ size.

Here's an example of a $3\times3$ cube:

Press + to interact

#include <iostream>
using namespace std;
void AllocatingCube(char*** &cube, int size) 
{   // Notice: cube pointer is passed by reference
    // Write your code here
    
}
void initCube(char *** cube, int size)
{
    // Write your code here
}
void printCube(char*** cube, int size)
{
    // Write your code here
}
void deallocateCube(char*** &cube, int size)
{
    // Write your code here
}
int main() 
{
    // This main should work
    int H = 5; // Size of each dimension
    char*** cube;
    AllocatingCube(cube, H);
    initCube(cube, H);
    printCube(cube, H);
    deallocateCube(cube, H);
    return 0;
}

Applications of pointer to pointer/pointers

Here are a few core applications:

Dynamic memory allocation: Pointer to pointers is used for managing complex data structures and efficient memory allocation.
Function parameters and return values: Pointer to pointers enables modifying variables and passing data between functions, allowing for flexible parameter passing and return values.
Multidimensional arrays: Pointer to pointers facilitates the creation and manipulation of multidimensional arrays without the restrictions imposed by fixed-size multidimensional arrays, providing flexibility in array dimensions. Unlike fixed-size multidimensional arrays, passing multidimensional arrays allocated through a pointer to pointers does not require explicitly specifying each dimension’s size, avoiding wastage of memory and the need for separate functions for each dimension.
Efficient memory management: Pointer to pointers allows for efficient memory management, as memory can be allocated and deallocated dynamically based on program needs.

These points highlight the key applications and advantages of using pointers to pointers in various scenarios.

Getting Started

Review of Variable, Arrays and Pointers

Journey towards Object Oriented Programming

Objects Relationships

Introduction to Operator Overloading

Matrix Calculator Case Study

Conclusion

Extended Types of Pointers I

Pointer to pointers

Practice exercise: Upper triangular matrix

Exercise: Allocating higher dimensional dynamic arrays

Applications of pointer to pointer/pointers