Didn't understand creating 2d dynamic array with double pointer (**) - c++

Question

I have some problems with understanding double-pointer stuff.Okay , I know, that it means "pointer to pointer". But when I see it in code I just don't get it. For example:
// Create Dynamic 2D-Array
int **arr = new int*[rows];
for (int i = 0; i < rows; i++)
{
arr[i] = new int[cols];
}
This the code that my teacher used to create 2d dynamic array, but I didn't understand. Can anyone explain? For example what int **arr = new int*[rows]; means? Or For what did we use for there?
And one more question: Is there any way to create 2d dynamic array without using pointers?

Answer 1

While you will see a lot of this type of code in code written from the 90s through say 2011 (and some past then). This type of collection of pointers that allows elements to be accessed using 2D array indexing has been replaced by std::vector (or a vector-of-vectors in this case).
The first thing to understand is int **arr; declares a single-pointer to pointer-to-int. (also called a double-pointer). Either way you have a single-pointer to what? (a pointer-to-type, whatever the type used is).
In order to make this approach useful, you first allocate the number of pointers you will need. The following allocates a block of memory containing rows number of pointers-to-int and assigns the address of the first pointer to arr.
int **arr = new int*[rows];
Now you have rows number of uninitialized pointers. (e.g. you have a block of memory capable of holding rows pointers). To access each pointer in arr, you simply use array-indexing (e.g. arr[2] is the 3rd pointer in the block allocated.) Equivalent pointer notation would be *(arr + 2). (note: the [..] acts as a dereference just the same as *(..) does in the pointer notation case)
To be useful, each of the pointers in the block allocated must point to valid memory holding some number of integers. You can either assign an address for an existing array of integers, e.g.
#define COLS 5
...
int myarray[COLS] = {0}; /* array of COLS integer values initialized zero */
int **arr = new int*[rows]; /* your allocation a block for rows pointers to int */
...
arr[0] = myarray; /* assigning pointer to existing block to arr[0] */
In your case, you are simply allocating a block of memory that can contain cols number of integer and assigning the starting address for that block to one of your pointers in the block you allocated with int **arr = new int*[rows];. That is what the following code does:
// Create rows pointers pointing to allocated blocks of cols integers
int **arr = new int*[rows]; /* allocated block of rows pointers */
for (int i = 0; i < rows; i++) /* for each pointer */
{
arr[i] = new int[cols]; /* allocate & assign block of cols int */
}
Now your object is complete. You have a block of memory sized so it can contain rows number of pointers, and you have allocated rows number of blocks of memory that can hold cols number of integers and have assigned the starting address for each of the blocks of memory holding cols number of integers to each of the pointers contained in the original block allocated.
Since you can access each pointer with arr[x] where 0 <= x < rows, you can access each individual integer within each block of memory simply by including another index (the simulated 2D indexing) so that arr[x][y] will address the yth integer in the block of memory pointed to by arr[x] where 0 <= y < cols. The equivalent pointer notation would be *(*(arr + x) + y).
That's it in a nutshell. You allocate storage for some number of pointers, and then allocate storage for some number of type values and assign the starting address for each of those pointers such that each of your pointers now holds the address of (e.g. points to) an allocated block of memory holding your values.
Now you must individually delete[] each of the blocks of storage for cols number of ints, (e.g. loop and delete[] arr[i];) and then make one final call to delete[] arr; to free the block of memory containing the pointers.
Think though it and let me know if you have further questions.

Answer 2

A couple of observations that might help you:
A pointer occupies memory in the same way any other variable does. It is similar to any other type. So, if you draw a little rectangle for the variable i, you can also draw one for a pointer.
Use typedef or using to create aliases and simplify definition of complex types:
using pointer_to_int = int*;
pointer_to_int* arr = new pointer_to_int[rows]; // allocates an array of pointer_to_int (similar to new int[rows])
for (int i = 0; i < rows; i++)
{
arr[i] = new int[cols]; // arr[i] is of type pointer_to_int
}
"Is there any way to create 2d dynamic array without using pointers?" It depends on the level you are looking at. In the end, somewhere, there will be a pointer. You may use an 1d array (vector<T>, if allowed) and divide it by rows (or columns). If the row has 3 columns, the first row starts at index 0, the second row starts at index 3, the third row starts at index 6, etc. See Dynamically create matrix from numerical input in C++
.

Answer 3

It creates an array of pointers, each pointer in that array points to a different place in memory
+-arr--+
| | +---------------+
| 0 | -> | ... cols |
| | +---------------+
+------+
| | +---------------+
| 1 | -> | ... cols |
| | +---------------+
+------+
...
+------+
| | +---------------+
|rows-1| -> | ... cols |
| | +---------------+
+------+
So it does not consist of consecutive memory like it would if you would declare it as
int arr[rows][cols];