Ініціалізація всього 2D-масиву одним значенням

З наступною декларацією

int array[ROW][COLUMN]={0};

Я отримую масив з усіма нулями, але з наступним

int array[ROW][COLUMN]={1};

Я не отримую масив з одним значенням. Значення за замовчуванням все ще 0.

Чому така поведінка і як я можу ініціалізувати всі 1?

РЕДАКТУВАТИ: Я щойно зрозумів, що використання memsetзі значенням 1 буде встановлювати кожен байт як 1, а отже, фактичне значення кожної комірки масиву не буде 1, але 16843009. Як встановити значення 1?

Ви отримуєте таку поведінку, оскільки int array [ROW][COLUMN] = {1};це не означає "встановити всі елементи до одного". Дозвольте мені спробувати пояснити, як це працює поетапно.

Явний, надто зрозумілий спосіб ініціалізації вашого масиву буде таким:

#define ROW 2
#define COLUMN 2

int array [ROW][COLUMN] =
{
  {0, 0},
  {0, 0}
};

Однак, C дозволяє вилучити деякі елементи з масиву (або структури / об'єднання). Наприклад, ви можете написати:

int array [ROW][COLUMN] =
{
  {1, 2}
};

Це означає, що ініціалізуйте перші елементи до 1 і 2, а решту елементів "ніби вони мають статичну тривалість зберігання". У C є правило, яке говорить, що всі об’єкти статичної тривалості зберігання, які явно не ініціалізовані програмістом, повинні мати нульове значення.

Отже, у наведеному вище прикладі перший рядок має значення 1,2, а наступний - 0,0, оскільки ми не надали їм явних значень.

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

int array [ROW][COLUMN] = {0, 0, 0, 0};

хоча, звичайно, це поганий стиль, його важче читати та розуміти. Але це правило зручне, оскільки воно дозволяє нам писати

int array [ROW][COLUMN] = {0};

що означає: "ініціалізуйте перший стовпець у першому рядку значенням 0, а всі інші елементи так, ніби вони мають статичну тривалість зберігання, тобто встановіть їх на нуль."

тому, якщо ви спробуєте

int array [ROW][COLUMN] = {1};

це означає "ініціалізувати перший стовпець у першому рядку рівним 1 і встановити всі інші елементи на нуль".

Якщо ви хочете ініціалізувати масив, -1тоді ви можете використовувати наступне:

memset(array, -1, sizeof(array[0][0]) * row * count)

Але це спрацює 0і -1лише

int array[ROW][COLUMN]={1};

Це ініціює лише перше елемент до 1. Все інше отримує 0.

У першому випадку ви робите те саме - ініціалізуєте перший елемент до 0, а решта за замовчуванням дорівнює 0.

Причина проста: для масиву компілятор ініціює кожне значення, яке ви не вказали 0.

З charмасивом, який ви можете використовувати memsetдля встановлення кожного байта, але це, як правило, не працює з intмасивом (хоча це добре для 0).

Загальний forцикл зробить це швидко:

for (int i = 0; i < ROW; i++)
  for (int j = 0; j < COLUMN; j++)
    array[i][j] = 1;

Або, можливо, швидше (залежно від компілятора)

for (int i = 0; i < ROW*COLUMN; i++)
  *((int*)a + i) = 1;

Зауважте, що GCC має розширення до позначеного позначення ініціалізатора, що є дуже корисним для контексту. Це також допускається clangбез коментарів (частково тому, що він намагається бути сумісним із GCC).

Позначення розширення дозволяє використовувати ...для позначення діапазону елементів, які потрібно ініціалізувати з наступним значенням. Наприклад:

#include <stdio.h>

enum { ROW = 5, COLUMN = 10 };

int array[ROW][COLUMN] = { [0 ... ROW-1] = { [0 ... COLUMN-1] = 1 } };

int main(void)
{
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COLUMN; j++)
            printf("%2d", array[i][j]);
        putchar('\n');
    }
    return 0;
}

Результат, як не дивно:

 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1

Зверніть увагу, що Fortran 66 (Fortran IV) мав кількість повторень для ініціалізаторів масивів; мені завжди здається дивним, що C не отримав їх, коли до мови додали призначені ініціалізатори. І Паскаль використовує 0..9позначення для позначення діапазону від 0 до 9 включно, але C не використовує.. як маркер, тому не дивно, що він не використовувався.

Зауважте, що пробіли навколо ...позначень по суті є обов’язковими; якщо вони прикріплені до чисел, то число інтерпретується як число з плаваючою комою. Наприклад, 0...9буде лексеми , як 0., ., .9і числа з плаваючою комою не допускається в якості індексів масиву. З названими константами ...ROW-1це не призведе до проблем, але краще увійти в безпечні звички.

Додатки:

Побіжно зазначаю, що GCC 7.3.0 відхиляє:

int array[ROW][COLUMN] = { [0 ... ROW-1] = { [0 ... COLUMN-1] = { 1 } } };

де є додатковий набір фігурних дужок навколо скалярного ініціалізатора 1( error: braces around scalar initializer [-Werror]). Я не впевнений, що це правильно, враховуючи те, що ви зазвичай можете вказати фігурні дужки навколо скаляра int a = { 1 };, що явно дозволено стандартом. Я також не впевнений, що це неправильно.

Мені також цікаво, чи було б кращим позначенням [0]...[9]- це однозначно, не можна сплутати з будь-яким іншим дійсним синтаксисом і уникає плутанини з числами з плаваючою комою.

int array[ROW][COLUMN] = { [0]...[4] = { [0]...[9] = 1 } };

Може, комітет зі стандартів це розгляне?

Для ініціалізації 2d-масиву нулем використовуйте наведений нижче спосіб: int arr[n][m] = {};

ПРИМІТКА : Наведений вище метод буде працювати лише для ініціалізації з 0;

Замість цього використовуйте векторний масив:

vector<vector<int>> array(ROW, vector<int>(COLUMN, 1));

char grid[row][col];
memset(grid, ' ', sizeof(grid));

Це для ініціалізації елементів масиву символів пробілами.