4 разных способа использования двумерных массивов с указателями, что правильно? Объяснение очень помогло бы

Кажется, это сводится к распространенному заблуждению о том, что «массив — это указатель» — это неправда.

Что правда, так это то, что идентификатор массива оценивается как указатель на первый элемент массива в большинстве контекстов (за исключением, например, операторов & и sizeof).

Теперь взгляните на свой массив:

int a[3][4];

Здесь a — это массив из 3 элементов, а тип элемента — int ()[4]. Это напрямую объясняет, почему ваш первый пример не работает должным образом. В вашем выражении a оценивается как указатель на первый элемент, поэтому тип равен int (*)[4], а а не просто int *, как вы ожидаете. Таким образом, a+1 добавит к значению указателя в 4 раза больше, чем int. С этим объяснением вы также должны понимать предупреждения, которые вы получаете.

Также обратите внимание, что по той же причине второй пример неверен. Добавленный оператор разыменования делает используемые типы правильными, но вы по-прежнему обращаетесь к недопустимым местоположениям, поскольку арифметика ваших указателей по-прежнему работает с int (*)[4]. Конечно, нет никакой гарантии, что "провалится", это просто неопределенное поведение.

Единственная правильная версия с использованием 2d-массива — это третий пример:

(a+i) является указателем на i-й элемент a, разыменование которого дает массив типа int ()[4], и это снова оценивается как указатель на его первый элемент, поэтому добавление к нему j дает вам местоположение желаемого значения.

Четвертый пример — это не двумерный массив, это динамическое распределение, используемое как плоский массив, поэтому здесь это не так интересно. Если вы хотите динамически выделить 2d-массив, вам нужно будет написать, например:

int (*a)[4] = malloc(3 * sizeof *a);

Теперь вернемся к моему первому абзацу: с int a[3][4] у вас есть (void *)a == (void *)*a, потому что первый элемент a начинается в том же месте, что и первый элемент a[0], различаются только типы a и *a. Это было бы невозможно, если бы массивы и указатели были одним и тем же.

(a+4*i+j): компилятор жалуется на тип, потому что a не относится к типу int *. Вы объявили его как int a[3][4], который обычно читается как двумерный массив целых чисел размером 3x4. На самом деле a представляет собой массив из 3 массивов по 4 целых числа. Тогда a — это адрес первого массива из 4 целых чисел. Помните, что определение type v[N] определяет v как адрес первого элемента массива, и что a может распадаться на указатель на тип элемента. Тогда в вашем случае a распадается на указатель на массив из 4 целых чисел. Вот почему компилятор жалуется, что %d нужен соответствующий аргумент типа int *.

Даже если бы адрес мог быть правильным, арифметика на нем не то, что вы думаете. a+3*i+j означает адрес 3*i+j-го массива из 4 целых чисел, начиная с адреса a.

Вы можете заставить распадаться на int *:

int *ta = (int *)a; // ta contains the same address but of different type...
int i=0,j=0,count=0;
for(i=0;i<3;i++){
    for(j=0;j<4;j++){
        scanf("%d",(ta+4*i+j)); // arithmetic is the right one (ints by ints)
    }
}
for(i=0;i<3;i++){
    for(j=0;j<4;j++){
        printf("%d\t",*(ta+4*i+j));
    }
}

То же самое и для второго примера, арифметика неверна.

Третий и четвертый правильные. Третий, потому что вы переходите (с i) к правильному массиву, а затем переходите в этом к правильному int.

Четвертый почти такой же, как код, который я дал.

---РЕДАКТИРОВАТЬ---

Как сказал Феликс в комментариях, будьте осторожны, даже если это работает во многих распространенных архитектурах/ОС/компиляторах, существует строгое правило псевдонимов, которое не позволяет вам это делать. Прочтите ссылку, которую он предоставил, чтобы узнать больше.