Как заполнить массив в си: Статический массив: объявление, заполнение, использование

Язык C++: 42 — Массивы

  int A[6];

   X = [1 3 5 7 9 11]

  for ( k=0; k<6; k++ ) {
...
}

4. Требуется заполнить массив именно так: X = [12 9 6 3 0 -3] Какой оператор надо поместить в тело цикла вместо многоточия? for ( k=0; k<6; k++ ) { ... }
	X[k] = k
	X[k] = 12 — 2*k
	X[k] = 3*k — 12
	X[k] = 3*(k + 1) + 9
	X[k] = 12 — 3*k

    X = [0 3 4 7 8 11]

  for ( k=0; k<6; k++ ) {
...
}

    X = [1 2 4 8 16 32]

  X[0] = 1;
for ( k=1; k<6; k++ ) {
. ..
}

  for ( k=0; k<N; k++ )
cout << ... << endl;

  k = 0;
while ( k < N ) {
cout << A[k] << " ";
...
}

9. Задан массив X[N]. Какой оператор надо поставить вместо многоточия, чтобы найти сумму всех элементов массива в переменной S? Вводите ответ без пробелов. S = 0; for ( k=0 k<N; k++ ) { ... }

Ответ:

  S = 0;
for ( k=0; k<N; k++ ) 
if ( . . . ) S = S + X[k];

  S = 0;
for ( j=0; j<N; j++ )
if ( ... ) S++;

Заполнить массив по заданому правилу: зигзагом по диагонали

Требуется написать программу, которая заполняет массив размерности nxn по заданному правилу:

/*    1  3  4 10 11
      2  5  9 12 19
      6  8 13 18 20
      7 14 17 21 24
     15 16 22 23 25  */

То есть, заполнение массива должно быть по диагонали, сверху-вниз, слева-направо. Причем заполнение еще и зигзагообразное.

Смотрим результат работы программы:

По условию программы, массив — квадратная матрица, то есть имеет одинаковое количество строк и столбцов. Возможно это упростит задачу. Дам подсказку — рассмотрите массив как область в квадратной системе координат. То есть, для перемещения по элементам матрицы, мы условно будем пользоваться x и y координаты. х-координата — переменная, которая будет отвечать за перемещение по горизонтали (по столбцам), 

Мой способ решения состоит из двух этапов:

• заполнение первой половины массива;
• заполнение второй половины;

Например,

/*  заполнение первой половины массива (строки 16 - 44)
      1  3  4 10 11
      2  5  9 12  0
      6  8 13  0  0
      7 14  0  0  0
     15  0  0  0  0  */

ну и конечно же, заполнение остальной части массива (строки 48 — 76):

/*    0  0  0  0  0
      0  0  0  0 19
      0  0  0 18 20
      0  0 17 21 24
      0 16 22 23 25  */

Каждая часть массива заполняется отдельным циклом for, в котором перебор идет по диагоналям. Заметьте, что каждый новый столбец — это начало новой диагонали. Поэтому циклы for

Исходный код этой программы был бы в два раза меньше, но дело в том, что нужно организовать зигзагообразное заполнение. И поэтому, Для каждой заполняемой половины массива, нужно рассмотреть два случая:

• заполнение диагонали снизу-вверх (для первой части — строки: 33 -42, второй части массива — строки: 65 — 74)
• заполнение диагонали сверху-вниз (для первой части — строки: 20 -29, второй части массива — строки: 52 — 62)

И чтобы два способа заполнения диагоналей чередовались, мы делаем проверку в строке 18, для заполнения первой половины массива и в строке 50, для заполнения второй половины массива.

Непосредственно в циклах while выполняется заполнение диагоналей. В коде оставил много комментариев, надеюсь объяснил понятно.

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    const int colum = 10; // количество столбцов массива
    const int row   = 10; // количество строк массива
    int array[100][100];

    int x, y,  // Координаты текущего элемента массива
        value = 1; // значение, которым заполняется массив

    // зполнение первой половины массива по диагонали, зигзагом, начиная
    // слева и сверху, заканчивая  побочной диагональю
    for (int diag = 0; diag < colum; diag++) // выполняем проход по диагоналям
    {
        if (diag % 2 == 0) // по четным диагоналям
        {
            x = 0; // х-координата первого лемента массива на диагонали - diag
            y = diag; // у-координата элемента массива на диагонали - diag

            while (y >= 0) // пока y-координата находится в верхней части диагонали
            {
                array[x][y] = value; // записать значение в массив
                value++;
                x++;     // по горизонтали, смещаемся влево
                y--;    // по вертикали, смещаемся вниз
            }
        }
        else // по нечетным диагоналям
        {
            x = diag; // х-координата элемента массива на диагонали - diag
            y = 0; // у-координата первого элемента массива на диагонали - diag

            while (x >= 0) // пока x-координата находится в левой части диагонали
            {
                array[x][y] = value; // записать значение в массив
                value++;
                x -= 1;  // по горизонтали, смещаемся вправо
                y +=  1; // по вертикали, смещаемся вверх
            }
        }
    } // конец for

    // заполнение второй половины массива по диагонали, зигзагом, начиная
    // слева и сверху, заканчивая  последним элементом массива
    for (int diag = 1; diag < colum; diag++)
    {
        if (diag % 2 == 0) // по четным диагоналям
        {
            x = 9; // х-координата первого элемента массива на диагонали - diag
            y = diag;  // у-координата элемента массива на диагонали - diag

            while (y <= 9) // Пока не кончилась диагональ
            {
                array[x][y] = value;
                value++;
                x--; // по горизонтали, смещаемся влево
                y++; // по вертикали, смещаемся вниз
            }
        }
        else // по не четным диагоналям
        {
            x = diag; // х-координата первого элемента к-ой диагонали
            y = 9;  // у-координата первого элемента к-ой диагонали

            while (x <= 9) // Пока не кончилась диагональ
            {
                array[x][y] = value;
                value++;
                x++; // по горизонтали, смещаемся вправо
                y--; // по вертикали, смещаемся вверх
            }
        } // конец if-else
    } // конец цикла for (заполнение второй половины массива)

    // вывод масиива на экран
    for (int ix = 0; ix < row; ix++)
    {
        for (int jx = 0; jx < colum; jx++)
            cout << setw(4) << array[ix][jx] << " ";
        cout << endl;
    }

    return 0;
}

Скорее всего мой код можно уменьшить, приблизительно в 2 раза, но у меня с ходу не получилось это сделать. Поэтому оставил все так. Если у вас получится уменьшить исходный код или найти другое решение, поделитесь с читателями нашего сайта. Ах да, я забыл реализовать в данной программе ввод размера массива, но я думаю это у вас получится и без меня. Пример работы программы:

Как заполнить массив

Динамический массив в C — темы масштабирования

Abstract

Динамические массивы — очень полезные структуры данных. Их можно инициализировать с переменным размером во время выполнения. Этот размер можно изменить позже в программе, чтобы расширить (или) уменьшить массив. В отличие от массивов фиксированного размера и массивов переменной длины, массивы динамического размера размещаются в куче. Гибкие члены массива очень похожи на массивы динамического размера. Они используются в структурах и предоставляют член данных, который имеет такие же свойства, как и массивы с динамическим размером.

Сфера применения статьи

• В этой статье рассматриваются массивы переменной длины, создание динамических массивов, гибкие элементы массива.
• Мы используем несколько низкоуровневых функций, таких как malloc, free, realloc, для реализации массивов динамического размера.
• Мы также обсудим плюсы и минусы VLA, гибких членов массива.

Массивы фиксированной длины

Массивы фиксированной длины, как следует из названия, их размер должен быть константой времени компиляции. Его нельзя изменить во время выполнения программы.

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

Массивы переменной длины (VLA) в C

Массивы переменной длины — это массивы, размер которых определяется во время выполнения (но размер не может быть изменен после инициализации). Впервые они были введены в C по стандарту C99. Но в более поздних версиях это стало дополнительной функцией. Они размещались в стеке и освобождались, когда покидали область видимости (как и обычные массивы).

• В массивах фиксированной длины n должно быть константой времени компиляции, тогда как здесь n основано на пользовательском вводе.

Итак, почему именно использование VLA не рекомендуется?

Несмотря на то, что VLA могут быть инициализированы с динамическим размером, размер нельзя изменить после инициализации. Не существует простого способа определить, правильно ли распределен VLA. Если размер слишком велик, программа останавливается с ошибкой сегментации. Они также генерируют гораздо больше ассемблерного кода и работают медленнее, чем статические массивы (фиксированного размера).

Есть несколько ограничений на использование VLA. VLA не может быть:

• внешний
• членов структуры
• статический
• объявлено с неопределенными границами

Введение в динамические массивы

В отличие от других языков высокого уровня (Python, JavaScript и т. д.), C не имеет встроенных динамических массивов. Но он предоставляет способ взаимодействия с необработанной памятью (другими словами, стрелять в ногу).

Динамические массивы могут изменять размер и обеспечивают произвольный доступ к своим элементам. Их можно инициализировать с переменным размером, а их размер можно изменить позже в программе. Динамические массивы размещаются в куче, а VLA — в стеке.

Важно отметить, что VLA — это не то же самое, что динамические массивы. Некоторые из ключевых отличий:

• Область действия: VLA ведут себя как обычные массивы и ограничены областью действия. Динамические массивы можно использовать в любом месте программы, независимо от области видимости, до тех пор, пока не будет вызвана функция free().
• Распределение: VLA размещаются в стеке, тогда как динамические массивы размещаются в куче. Таким образом, VLA быстрее, чем динамическая память. Так как компилятор должен очищать память (для динамического массива) после использования.
• Производительность: Массивы динамического размера часто работают медленно, потому что нам приходится выделять требуемую память и освобождать ее вручную. С точки зрения пространства массивы динамического размера оптимальны, потому что мы можем увеличивать/уменьшать размер, в отличие от VLA. Некоторые тесты производительности здесь.

Building Blocks

Мы можем использовать несколько функций C, таких как malloc, free, calloc, realloc, reallocarray, для реализации массивов динамического размера.

• malloc: Проще говоря, вызов этой функции эквивалентен запросу ОС на выделение n байтов. Если выделение памяти прошло успешно, malloc возвращает указатель на блок памяти. В противном случае он возвращает NULL. malloc относится к «выделению памяти».

использование malloc

В приведенном выше фрагменте мы используем malloc для создания n байтов памяти и назначения их указателю p. Компиляция с указанными ниже флагами немедленно выдает ошибку. Видно, что что-то не так сделано. Мы не освободили память .

• Доступ к элементам массива: В C добавление 1 к указателю p увеличивает адрес указателя на sizeof(pType), где pType — это тип данных, на который указывает p. Используя это, мы можем получить доступ к i-м элементам, добавив i к базовому указателю. Давайте обсудим это на примере (посмотрите на изображение ниже).

  • a — массив с плавающей запятой. Понятно, что a[0] является базовым указателем для этого массива.
  • ptr также указывает на &a, то есть на базовый указатель.
  • ptr++ подразумевает добавление sizeof(float) bytes, т. е. 4 байта к ptr.
  • Итак, теперь ptr указывает на следующий элемент массива, то есть на a[1]. Точно так же, добавляя соответствующий i к ptr, мы можем получить доступ к любому элементу в этом массиве. Например: *(ptr + i) = a[i].

• calloc: Эта функция выделяет непрерывный блок памяти заданного размера и инициализирует каждый блок нулевым значением. тогда как malloc выделяет один блок памяти, но значение в указанном месте является случайным. calloc выделяет память и обнуляет выделенные блоки. calloc относится к «непрерывному распределению»

Ниже приведены еще несколько отличий:-

• calloc принимает два аргумента, тогда как malloc принимает один. nmemb представляет количество блоков памяти . size представляет размер каждого блока . Это больше подходит для выделения памяти под массивы.

• malloc выделяет память сразу в одном блоке, тогда как calloc выделяет память несколькими блоками, которые являются непрерывными .

• Примечание: нулевое значение означает не просто 0. Если мы выделяем массив структур, calloc присваивает NULL строкам, 0 — целым числам/плавающим числам и т. д.

• свободно: Эта функция освобождает динамическую память. Вызов free(p) непосредственно перед возвратом в приведенном выше фрагменте предотвратил бы ошибку. free ДОЛЖЕН вызываться явно после использования динамической памяти, независимо от того, какая функция используется для ее создания (malloc, calloc и т. д.)

Говорить дешево. Покажи мне Код.

Выход

Давайте рассмотрим это подробнее.

• calloc создал память для n целых чисел, где n вводится пользователем.
• arr содержит адрес созданной памяти. Мы проверяем, удалось ли выделение, и выходим из программы, если это не так.
• В следующем цикле мы перемещаем массив на один элемент влево, чтобы можно было удалить последний элемент. Обратите внимание, что мы используем синтаксис, подобный массиву, для ссылки на элементы массива.
• Вызов realloc изменил размер памяти до (n — 1) байт.
• Вызовом free мы освободили память и завершили программу с возвратом 0;.

Гибкие элементы массива (FAM)

FAM — элемент данных массива, с помощью которого мы можем инициализировать массив без ограничений. Размер FAM составляет гибких и может управляться с помощью malloc, calloc и т. д. (точно так же, как динамические массивы).

Это также стандартизировано в C99 вместе с VLA. Есть несколько ограничений на использование FAM: —

• Должен быть хотя бы один другой элемент данных.
• Гибкий член массива должен быть объявлен в конце структуры.
• В структуре может быть не более одного FMA (это очевидно из того факта, что в конце может быть только один член).

Размер массива можно определить во время создания объекта из структуры.

Пример элемента гибкого массива

Вывод

• При выделении памяти с помощью malloc обратите внимание, что мы добавили дополнительные n * sizeof(int) байт. Эта память используется элементом данных arr структуры, а также определяет размер элемента массива Flexible (в данном случае arr).
• Таким образом, мы можем создавать динамические массивы в структурах.

Кажется, что в FMA нет большого преимущества, потому что мы можем использовать указатели в качестве члена данных и выделять динамическую память. Но есть одно слабое преимущество. Если мы перемещаем блок структуры, массив (элемент данных) перемещается вместе со структурой, поскольку массив (элемент данных) выделяется вместе со структурой (и они находятся в одном блоке).