Understand how this double becomes an array?

Question

So I'm currently reading and learning a code from the internet (related to artificial neural network) and I found a part of the code that I don't understand why it works.

double* inputNeurons;
double* hiddenNeurons;
double* outputNeurons;

This is how it was declared. Then in this next code, it was changed and used as an array?

inputNeurons = new( double[in + 1] );
for ( int i=0; i < in; i++ ) inputNeurons[i] = 0;

inputNeurons[in] = -1; // 'in' is declared in the function as an int

So, I want to understand why and how it works. Did it become an array of "doubles"? If so, in what way can I also use this? Can this be used for struct or even class?

Answer 1

Every array can be treated as a pointer. But that does not mean every pointer is an array. Do not mix this up!

Assuming we have an array int test[..], the variable name also represents the address where the array is stored in the memory. So you could write

int * p = test;

At that moment my pointer p "becomes" an array, where "becomes" means 'points to an array'. Your example is similar - the only difference is that the memory is allocated dynamically (heap) and not on the stack (as in my example).

So how are the elements accessed? Let's say, we want to get the first element (index 0). We could say

int i = test[0];

or we could say

int i = *p;

Now we want to get the element at index 1:

int i = test[1];

Or - by using pointer arithmetics we could write

int i = *(p + 1);

Answer 2

In C++ (and C) pointers support indexing operator [] which basically adjusts the value of the pointer by the amount specified times the size of the type pointed.

So basically

inputNeurons[5] = 0;

is equivalent to

*(inputNeurons+5) = 0

Now this doesn't give you any guarantee about the fact that inputNeurons points to an address which is correctly allocated to store at least 6 double values but syntactically it is correct and well defined.

You are just adjusting an address to point to the i-th element of a given type starting from the specified address.

This means that

double x;
double* px = &x;
px[5] = 0;

Is syntactically correct although it is wrong, since px+5 is an address which points to memory which has not been reserved correctly to hold that value.