Як форматуються багатовимірні масиви в пам'яті?

У C я знаю, що можу динамічно виділити двовимірний масив на купі, використовуючи наступний код:

int** someNumbers = malloc(arrayRows*sizeof(int*));

for (i = 0; i < arrayRows; i++) {
    someNumbers[i] = malloc(arrayColumns*sizeof(int));
}

Зрозуміло, що це фактично створює одновимірний масив покажчиків на купу окремих одновимірних масивів цілих чисел, і "Система" може зрозуміти, що я маю на увазі, коли я запитую:

someNumbers[4][2];

Але коли я статично оголошую 2D масив, як у наступному рядку ...:

int someNumbers[ARRAY_ROWS][ARRAY_COLUMNS];

... чи створюється подібна структура на стеці, чи це зовсім інша форма? (тобто це 1D масив покажчиків? Якщо ні, що це таке, і як з'ясовуються посилання на нього?)

Крім того, коли я сказав: "Система", що насправді відповідає за з'ясування цього? Ядро? Або компілятор С розбирається під час компіляції?

Статичний двовимірний масив схожий на масив масивів - він просто викладається безперервно в пам'яті. Масиви - це не те саме, що вказівники, але оскільки ви часто можете користуватися ними в значній мірі взаємозамінно, це може часом заплутатися. Однак компілятор відстежує належним чином, завдяки чому все чітко вирівнюється. Ви повинні бути обережними зі статичними 2D-масивами, як ви згадуєте, оскільки якщо ви спробуєте передати його функції, яка приймає int **параметр, то трапляться погані речі. Ось короткий приклад:

int array1[3][2] = {{0, 1}, {2, 3}, {4, 5}};

У пам'яті виглядає так:

0 1 2 3 4 5

точно так само, як:

int array2[6] = { 0, 1, 2, 3, 4, 5 };

Але якщо ви спробуєте перейти array1до цієї функції:

void function1(int **a);

ви отримаєте попередження (і додаток не зможе отримати доступ до масиву правильно):

warning: passing argument 1 of ‘function1’ from incompatible pointer type

Тому що 2D масив - це не те саме, що int **. Автоматичне розпадання масиву в покажчик йде, так би мовити, лише "на рівні глибини". Вам потрібно оголосити функцію як:

void function2(int a[][2]);

або

void function2(int a[3][2]);

Щоб все було щасливим.

Ця ж концепція поширюється на n -вимірні масиви. Користуючись цим смішним бізнесом у вашому додатку, як правило, лише ускладнює розуміння. Тож будьте обережні там.

Відповідь заснована на ідеї, що C насправді не має 2D-масивів - у ній є масиви-масиви. Коли ви заявляєте про це:

int someNumbers[4][2];

Ви просите someNumbersстати масивом з 4-х елементів, де кожен елемент цього масиву має тип int [2](який сам є масивом у 2 intс).

Інша частина головоломки полягає в тому, що масиви завжди безперервно розкладаються в пам'яті. Якщо ви попросите:

sometype_t array[4];

то це завжди буде виглядати так:

| sometype_t | sometype_t | sometype_t | sometype_t |

(4 sometype_tоб’єкти, розкладені поруч, без проміжків між ними). Отже, у вашому someNumbersмасиві масивів це буде виглядати приблизно так:

| int [2]    | int [2]    | int [2]    | int [2]    |

І кожен int [2]елемент є самим масивом, який виглядає приблизно так:

| int        | int        |

Таким чином, ви отримуєте це:

| int | int  | int | int  | int | int  | int | int  |

unsigned char MultiArray[5][2]={{0,1},{2,3},{4,5},{6,7},{8,9}};

в пам'яті дорівнює:

unsigned char SingleArray[10]={0,1,2,3,4,5,6,7,8,9};

У відповідь на ваше також: Обидва, хоча компілятор робить більшу частину важкого підйому.

У разі статично розподілених масивів компілятором буде "Система". Він збереже пам'ять, як і для будь-якої змінної стека.

У випадку з malloc'd масивом "Система" буде реалізатором malloc (ядро зазвичай). Весь компілятор виділить базовий покажчик.

Компілятор завжди буде обробляти тип як те, про що вони оголошені, за винятком прикладу, який Карл дав, де він може з'ясувати взаємозамінне використання. Ось чому, якщо ви переходите в функцію [] [], ви повинні вважати, що це статично розподілена площина, де ** вважається вказівником на покажчик.

Припустимо, у нас є a1і a2та инициализируется , як показано нижче (c99):

int a1[2][2] = {{142,143}, {144,145}};
int **a2 = (int* []){ (int []){242,243}, (int []){244,245} };

a1являє собою однорідний 2D масив з простим безперервним розташуванням в пам'яті і вираження (int*)a1оцінюється вказівником на його перший елемент:

a1 --> 142 143 144 145

a2ініціалізується з гетерогенного 2D масиву і є вказівником на значення типу int*, тобто вираз dereference *a2оцінюється у значення типу int*, макет пам'яті не повинен бути безперервним:

a2 --> p1 p2
       ...
p1 --> 242 243
       ...
p2 --> 244 245

Незважаючи на абсолютно інший розміщення пам’яті та семантику доступу, граматика на мові С для виразів доступу до масиву виглядає абсолютно однаково як для однорідного, так і для гетерогенного 2D масиву:

• Вираз a1[1][0]отримає значення 144з a1масиву
• Вираз a2[1][0]отримає значення 244з a2масиву

Компілятор знає, що вираз доступу для операційного a1типу працює int[2][2], коли вираз доступу для операційного a2типу працює int**. Створений код складання буде слідувати однорідній або неоднорідній семантиці доступу.

Код зазвичай виходить з ладу під час виконання, коли масив тип набирається int[N][M]на тип і потім отримує доступ до типу int**, наприклад:

((int**)a1)[1][0]   //crash on dereference of a value of type 'int'

Для доступу до певного двовимірного масиву розгляньте карту пам'яті для декларації масиву, як показано в коді нижче:

    0  1
a[0]0  1
a[1]2  3

Для доступу до кожного елемента достатньо просто передати той масив, який вас цікавить як параметри функції. Потім використовуйте зміщення для стовпця для доступу до кожного елемента окремо.

int a[2][2] ={{0,1},{2,3}};

void f1(int *ptr);

void f1(int *ptr)
{
    int a=0;
    int b=0;
    a=ptr[0];
    b=ptr[1];
    printf("%d\n",a);
    printf("%d\n",b);
}

int main()
{
   f1(a[0]);
   f1(a[1]);
    return 0;
}