Динамический массив (С++)

#include <iostream>
#include <clocale>
using namespace std;
int main()
{
    setlocale(LC_ALL, "rus");
    int sizeOfArray = 0;
    cout << "Чтобы создать массив чисел, введите его размер: ";
    cin >> sizeOfArray;
    int* arrWithDigits = new int [sizeOfArray]; 
    for (int i = 0; i < sizeOfArray; i++)
    {
        arrWithDigits[i] = i + 1;
        cout << arrWithDigits[i] << " ";
    }   
    cout << endl;
    delete [] arrWithDigits;
    return 0;
}

Запись pointer[index] это тоже самое, что и *(pointer + index), только удобнее. Поэтому, например, можно (но не нужно) писать и так: index[pointer], это преобразуется в *(index + pointer), то есть разницы не будет.

В языках C и C++ встроенный оператор [] всегда работает с указателями и только с указателями. (Не совсем верно, см. поправку ниже).

Когда вы применяете встроенный оператор [] к объекту типа "массив", этот объект сначала незримо преобразуется к типу "указатель" (указывающий на начало массива), а затем уже к этому указателю применяется оператор [].

Например, когда вы пишете

int a[10];
a[5] = 42;

языки С и С++ на самом деле внутренне интерпретируют этот код как

int a[10];
int *ptr = (int *) a; /* `ptr` указывает на начало `a` в памяти */
ptr[5] = 42;

а это, по определению оператора [] через операторы + и *, интерпретируется как

int a[10];
int *ptr = (int *) a; /* `ptr` указывает на начало `a` в памяти */
*(ptr + 5) = 42;

В вашем случае оператор [] сразу применен к указателю, то есть никаких незримых преобразований просто не нужно. С этой точки зрения можно даже утверждать, что использование оператора [] является, в некотором смысле, более естественным, чем использование этого оператора с массивами.

С педантичной точки зрения, вышесказанное справедливо только для С. В С++ оператор [] сначала преобразуется в эквивалентную форму через операторы + и *, а только затем в контексте оператора + происходит преобразование массива к указателю. То есть в С++ (в отличие от С) мой пример проинтерпретируется как

int a[10];
*(a + 5) = 42;

а это уже, в свою очередь, интерпретируется как

int a[10];
int *ptr = (int *) a; /* `ptr` указывает на начало `a` в памяти */
*(ptr + 5) = 42;

Конечный итог, как видите, один и тот же, но абстрактная семантика несколько отличается.

(Спасибо @Croessmah за комментарий.)

Для указателя type* ptr запись

*(ptr+i)

и

ptr[i]

по сути эквивалентны.

Так что arrWithDigits - да, массив, просто в выделенном оператором new месте в памяти.