Массив для разметки указателя и передачи многомерных массивов в функции

Ответ 1

У вас это немного неверно: moreThings также распадается на указатель на первый элемент, но поскольку он представляет собой массив массива символов, первый элемент представляет собой "массив из 8 символов". Таким образом, разлагающийся указатель относится к этому типу:

char (*p)[8] = moreThings;

Значение указателя, конечно, совпадает с значением &moreThings[0][0], то есть первого элемента первого элемента, а также тем же значением &a, но тип в каждом случае является другим.

Вот пример, если char a[N][3]:

+===========================+===========================+====
|+--------+--------+-------+|+--------+--------+-------+|
|| a[0,0] | a[0,1] | a[0,2]||| a[1,0] | a[1,1] | a[1,2]|| ...
|+--------+--------+-------+++--------+--------+-------++ ...
|            a[0]           |            a[1]           |
+===========================+===========================+====
                                    a
^^^
||+-- &a[0,0]
|+-----&a[0]
+-------&a

• &a: адрес всего массива массивов символов, который является char[N][3]

• &a[0], то же, что и a: адрес первого элемента, который сам является char[3]

• &a[0][0]: адрес первого элемента первого элемента, который является char

Это показывает, что разные объекты могут иметь один и тот же адрес, но если два объекта имеют один и тот же адрес и один и тот же тип, то они являются одним и тем же объектом.

Ответ 2

"АДРЕС МАССИВА И УКАЗЫВАЕТСЯ МНОГОМЕРНЫМ МАССАМ"

Давайте сначала начнем с 1-D массива:

• Объявление char a[8]; создает массив из 8 элементов.
  И здесь a есть адрес элемента , но не адрес массива.

• char* ptr = a; является правильным выражением, поскольку ptr является указателем на char и может обращаться к первому элементу.

• Но выражение ptr = &a неверно! Поскольку ptr не может адресовать массив.

• и означает адрес массива. Действительное значение a и &a одинаково, но семантически оба разные, один является адресом char other - адресом массив из 8 символов.

• char (*ptr2)[8]; Здесь ptr2 is pointer to an array of 8 chars, и на этот раз ptr2=&a является допустимым выражением.

• Тип данных &a равен char(*)[8], а тип a - char[8], который просто распадается на char* в большинстве операций, например. char* ptr = a;

  Чтобы лучше понять: Разница между char *str и char str[] и как оба хранилища в памяти?

Второй случай,

• Объявление char aa[8][8]; создает 2-мерный массив размера 8x8.

• Любой 2-D массив также можно рассматривать как 1-D массив, в котором каждый элемент массива представляет собой 1-D массив.

• aa - это адрес первого элемента, который представляет собой массив из 8 символов. Выражение ptr2 = aa является правильным и правильным.

• Если мы заявляем следующее:

  char (*ptr3)[8][8];    
  char ptr3 = &aa;  //is a correct expression
  

  Аналогично,
  moreThings в объявлении char moreThings[8][8]; содержит адрес элемента fist, который представляет собой массив char из 8 элементов.

  Чтобы лучше понять: Разница между char* str[] и char str[][] и как оба хранилища в памяти?

Было бы интересно узнать:

• morething - это адрес массива 8 char.

• *morething - это адрес первого элемента, который &morething[0][0].

• &morething - адрес 2-мерного массива 8 x 8.

  И значения адреса всех выше трех одинаковы, но семантически все разные.

• **morething - значение первого элемента, который morething[0][0].

  Чтобы лучше понять: Разница между &str и str, когда str объявлен как char str[10]?

Далее,

• void doThings(char thingsGoHere[8][8]) - не что иное, как void doThings(char (*thingsGoHere)[8]) и, таким образом, принимает любой массив, который является двумерным, а второй размер равен 8.

О типе переменных в C и С++: (я бы хотел добавить в ответ)

• Ничто не пропускает по ссылке в C концепцию С++. Если его использовать в C, это означает, что автор говорит о переменной указателя.
• C поддерживает pass by Address и pass by value.

• С++ поддерживает pass by Address, pass by value, а также pass by Reference.

  Читайте: указательные переменные и ссылочные переменные

В конце,

• Имя массива - это постоянный идентификатор, а не переменный.

Ответ 3

Хорошо объяснено Kerrek,

В дополнение к этому мы можем доказать это в следующем примере:

#include <stdio.h>

int main ()
{
 int a[10][10];

 printf (".. %p  %p\n", &a, &a+1);
 printf (".. %p  %p \n ", &a[0], &a[0]+1);
printf (".. %p   %p \n ", &a[0][0], &a[0][0] +1);
}

Выход:

.. 0x7fff6ae2ca5c  0x7fff6ae2cbec    = 400 bytes difference
.. 0x7fff6ae2ca5c  0x7fff6ae2ca84    = 40 bytes difference
 .. 0x7fff6ae2ca5c   0x7fff6ae2ca60  = 4 bytes difference. 

& a +1 → Перемещает указатель, добавляя размер всего массива. т.е.: 400 байт

& a [0] + 1 → Перемещает указатель, добавляя размер столбца. т.е.: 40 байт.

& a [0] [0] +1 → Перемещает указатель, добавляя размер элемента ie: 4 байта.

[int size is 4 bytes]

Надеюсь, это поможет.:)