Перейти к содержимому

Как задать массив в c с неизвестным количеством элементов

  • автор:

C: Массивы

Тема массивов в С довольно обширна. В этом уроке мы познакомимся с базовыми концепциями работы с массивами.

Задание

Допишите функцию int sum(int *arr, length) , которая принимает массив и его размер и возвращает сумму элементов массива.

Упражнение не проходит проверку — что делать? ��

Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:

  • Обязательно приложите вывод тестов, без него практически невозможно понять что не так, даже если вы покажете свой код. Программисты плохо исполняют код в голове, но по полученной ошибке почти всегда понятно, куда смотреть.

В моей среде код работает, а здесь нет ��

Тесты устроены таким образом, что они проверяют решение разными способами и на разных данных. Часто решение работает с одними входными данными, но не работает с другими. Чтобы разобраться с этим моментом, изучите вкладку «Тесты» и внимательно посмотрите на вывод ошибок, в котором есть подсказки.

Мой код отличается от решения учителя ��

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

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

Прочитал урок — ничего не понятно ��

Создавать обучающие материалы, понятные для всех без исключения, довольно сложно. Мы очень стараемся, но всегда есть что улучшать. Если вы встретили материал, который вам непонятен, опишите проблему в «Обсуждениях». Идеально, если вы сформулируете непонятные моменты в виде вопросов. Обычно нам нужно несколько дней для внесения правок.

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

Создания массива с неопределенным кол-ом элементов

Есть варианты создания одномерного массива который нужно заполнить элементами с ввода клавиатуры неизвестное кол-во раз? Или только вводить в список arrList а потом закинуть в массив?

int[] mas = new int[arrayList.size()]; 

Отслеживать
186 10 10 бронзовых знаков
задан 22 фев 2018 в 7:09
631 1 1 золотой знак 6 6 серебряных знаков 15 15 бронзовых знаков

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

22 фев 2018 в 7:21

Можете еще как вариант сделать массив максимальной длины и потом обрезать его если стоит задача использовать только массивы. Но это еще более кривой хак, чем перезапись массива.

22 фев 2018 в 7:31

1 ответ 1

Сортировка: Сброс на вариант по умолчанию

Есть варианты создания одномерного массива который нужно заполнить элементами с ввода клавиатуры неизвестное кол-во раз?

Нет. Массив всегда имеет предопределенный размер. Как вариант (но не стоит так делать) — создать массив максимальной длины (эта величина зависит от JVM, в старых значение равно Integer.MAX_VALUE-5 (Do Java arrays have a maximum size? ), на моей версии jvm сейчас это Integer.MAX_VALUE-2 ), а по окончании заполнения — урезать до нужной длины.

Или только вводить в список arrList а потом закинуть в массив?

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

List list = new LinkedList<>(); //добавление элементов Integer[] array = list.toArray(new Integer[list.size()]); 

C Language
Массивы

Массивы представляют собой производные типы данных, представляющие упорядоченный набор значений («элементов») другого типа. Большинство массивов в C имеют фиксированное количество элементов любого одного типа, и его представление хранит элементы смежно в памяти без пробелов или отступов. C допускает многомерные массивы, элементами которых являются другие массивы, а также массивы указателей.

C поддерживает динамически распределенные массивы, размер которых определяется во время выполнения. C99 и более поздние версии поддерживают массивы переменной длины или VLA.

Синтаксис

  • имя типа [длина]; / * Определить массив «type» с именем «name» и длиной «length». * /
  • int arr [10] = ; / * Определить массив и инициализировать ВСЕ элементы в 0. * /
  • int arr [10] = ; / * Определить массив и инициализировать 1-й элемент до 42, а остаток — 0. * /
  • int arr [] = ; / * Определить и инициализировать массив длиной 4. * /
  • arr [n] = значение; / * Установленное значение при индексе n. * /
  • значение = arr [n]; / * Получить значение по индексу n. * /

замечания

Зачем нам нужны массивы?

Массивы обеспечивают способ организации объектов в совокупность с его собственным значением. Например, строки C представляют собой массивы символов ( char s) и строку, такую ​​как «Hello, World!». имеет значение как совокупность, которая не присуща персонажам индивидуально. Аналогично, массивы обычно используются для представления математических векторов и матриц, а также списков многих видов. Более того, без какого-либо элемента для группировки элементов нужно будет решать каждый отдельно, например, через отдельные переменные. Мало того, что это громоздко, он не легко вмещает коллекции разной длины.

Массивы неявно преобразуются в указатели в большинстве контекстов .

За исключением случаев, когда он является операндом оператора sizeof оператором _Alignof (C2011) или оператором unary & (address-of) или как строковый литерал, используемый для инициализации (другого) массива, массив неявно преобразуется в ( «decays to») указатель на свой первый элемент. Это неявное преобразование тесно связано с определением оператора субтипирования массива ( [] ): выражение arr[idx] определяется как эквивалентное *(arr + idx) . Кроме того, поскольку арифметика указателя коммутативна, *(arr + idx) также эквивалентна *(idx + arr) , что, в свою очередь, эквивалентно idx[arr] . Все эти выражения действительны и оцениваются с одинаковым значением при условии, что либо idx либо arr является указателем (или массивом, который распадается на указатель), а другой является целым числом, а целое число является допустимым индексом в массив на который указывает указатель.

В качестве частного случая заметим, что &(arr[0]) эквивалентно &*(arr + 0) , что упрощается до arr . Все эти выражения взаимозаменяемы везде, где последний разпад указателя. Это просто снова выражает, что массив распадается на указатель на его первый элемент.

Напротив, если адрес-оператор применяется к массиву типа T[N] ( т.е. &arr ), тогда результат имеет тип T (*)[N] и указывает на весь массив. Это отличается от указателя на первый элемент массива, по крайней мере, относительно арифметики указателя, которая определяется в терминах размера заостренного типа.

Функциональные параметры не являются массивами .

void foo(int a[], int n); void foo(int *a, int n); 

Хотя первое объявление foo использует синтаксис типа массива для параметра a , такой синтаксис используется для объявления параметра функции, объявляющего этот параметр как указатель на тип элемента массива. Таким образом, вторая сигнатура для foo() семантически идентична первой. Это соответствует распаду значений массива указателям, где они отображаются в качестве аргументов для вызова функции, так что если переменная и параметр функции объявлены с тем же типом массива, то значение этой переменной подходит для использования в вызове функции как аргумент, связанный с параметром.

Объявление и инициализация массива

Общий синтаксис объявления одномерного массива

type arrName[size]; 

где type может быть любым встроенным типом или определяемыми пользователем типами, такими как структуры, arrName является определяемым пользователем идентификатором, а size является целочисленной константой.

Объявление массива (массив из 10 переменных int в этом случае) выполняется следующим образом:

int array[10]; 

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

int array[10] = ; 

В массивах также могут быть инициализаторы, в этом примере объявляется массив из 10 int , где первые 3 int будут содержать значения 1 , 2 , 3 , все остальные значения будут равны нулю:

int array[10] = ; 

В приведенном выше методе инициализации первое значение в списке будет присвоено первому члену массива, второе значение будет присвоено второму элементу массива и так далее. Если размер списка меньше размера массива, то, как и в предыдущем примере, остальные члены массива будут инициализированы нулями. С назначенной инициализацией списка (ISO C99) возможна явная инициализация элементов массива. Например,

int array[5] = ; /* array is */ 

В большинстве случаев компилятор может вывести длину массива для вас, этого можно добиться, оставив квадратные скобки пустыми:

int array[] = ; /* an array of 3 int's */ int array[] = ; /* size is 4 */ 

Объявление массива нулевой длины недопустимо.

В C99 были добавлены массивы переменной длины (VLA для краткости) и были добавлены в C11. Они равны нормальным массивам, с одной, важной, разницей: длина не обязательно должна быть известна во время компиляции. У VLA есть время автоматического хранения. Только указатели на VLA могут иметь статическую продолжительность хранения.

size_t m = calc_length(); /* calculate array length at runtime */ int vla[m]; /* create array with calculated length */ 

Важный:

VLA потенциально опасны. Если для массива vla в приведенном выше примере требуется больше места в стеке, чем доступно, стек будет переполняться. Поэтому использование VLA часто не поощряется в руководствах по стилю, а также книгами и упражнениями.

Очистка содержимого массива (обнуление)

Иногда необходимо установить массив в ноль после завершения инициализации.

#include /* for EXIT_SUCCESS */ #define ARRLEN (10) int main(void) < int array[ARRLEN]; /* Allocated but not initialised, as not defined static or global. */ size_t i; for(i = 0; i < ARRLEN; ++i) < array[i] = 0; >return EXIT_SUCCESS; > 

Общим сокращением к вышеуказанному циклу является использование memset() из . Проходящий array как показано ниже, заставляет его распадаться на указатель на его 1-й элемент.

memset(array, 0, ARRLEN * sizeof (int)); /* Use size explicitly provided type (int here). */ 
memset(array, 0, ARRLEN * sizeof *array); /* Use size of type the pointer is pointing to. */ 

Как и в этом примере, array представляет собой массив, а не только указатель на 1-й элемент массива (см. Длину массива на том, почему это важно), возможно третий вариант для вывода из массива:

 memset(array, 0, sizeof array); /* Use size of the array itself. */ 

Длина массива

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

int array[] = < 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 >; /* size of `array` in bytes */ size_t size = sizeof(array); /* number of elements in `array` */ size_t length = sizeof(array) / sizeof(array[0]); 

Однако в большинстве контекстов, где массив появляется в выражении, он автоматически преобразуется в указатель («decays to») на свой первый элемент. Случай, когда массив является операндом оператора sizeof является одним из небольшого числа исключений. Результирующий указатель сам по себе не является массивом, и он не несет никакой информации о длине массива, из которого он был получен. Поэтому, если эта длина необходима в сочетании с указателем, например, когда указатель передается функции, он должен передаваться отдельно.

Например, предположим, что мы хотим написать функцию для возврата последнего элемента массива из int . Продолжая вышеизложенное, мы можем назвать это так:

/* array will decay to a pointer, so the length must be passed separately */ int last = get_last(array, length); 

Функция может быть реализована следующим образом:

int get_last(int input[], size_t length)

Обратите внимание, в частности, что хотя объявление input параметра похоже на объявление массива, оно фактически объявляет input как указатель (для int ). Это точно эквивалентно объявлению input как int *input . То же самое было бы верно, даже если бы было дано измерение. Это возможно, потому что массивы никогда не могут быть фактическими аргументами для функций (они распадаются на указатели, когда они появляются в выражениях вызова функций), и их можно рассматривать как мнемонические.

Это очень распространенная ошибка, чтобы попытаться определить размер массива из указателя, который не может работать. НЕ ДЕЛАЙТЕ ЭТОГО:

int BAD_get_last(int input[]) < /* INCORRECTLY COMPUTES THE LENGTH OF THE ARRAY INTO WHICH input POINTS: */ size_t length = sizeof(input) / sizeof(input[0])); return input[length - 1]; /* Oops -- not the droid we are looking for */ >

На самом деле эта конкретная ошибка настолько распространена, что некоторые компиляторы ее распознают и предупреждают об этом. clang , например, выдает следующее предупреждение:

warning: sizeof on array function parameter will return size of 'int *' instead of 'int []' [-Wsizeof-array-argument] int length = sizeof(input) / sizeof(input[0]); ^ note: declared here int BAD_get_last(int input[]) ^ 

Установка значений в массивах

Доступ к значениям массива обычно выполняется с помощью квадратных скобок:

int val; int array[10]; /* Setting the value of the fifth element to 5: */ array[4] = 5; /* The above is equal to: */ *(array + 4) = 5; /* Reading the value of the fifth element: */ val = array[4]; 

В качестве побочного эффекта операндов к оператору + заменить (-> коммутативный закон) следующее эквивалентно:

*(array + 4) = 5; *(4 + array) = 5; 

так что следующие утверждения эквивалентны:

array[4] = 5; 4[array] = 5; /* Weird but valid C . */ 
val = array[4]; val = 4[array]; /* Weird but valid C . */ 

C не выполняет никаких пограничных проверок, доступ к содержимому вне объявленного массива не определен (доступ к памяти за пределами выделенного фрагмента ):

int val; int array[10]; array[4] = 5; /* ok */ val = array[4]; /* ok */ array[19] = 20; /* undefined behavior */ val = array[15]; /* undefined behavior */ 

Определить массив и элемент массива доступа

#include #define ARRLEN (10) int main (void) < int n[ ARRLEN ]; /* n is an array of 10 integers */ size_t i, j; /* Use size_t to address memory, that is to index arrays, as its guaranteed to be wide enough to address all of the possible available memory. Using signed integers to do so should be considered a special use case, and should be restricted to the uncommon case of being in the need of negative indexes. */ /* Initialize elements of array n. */ for ( i = 0; i < ARRLEN ; i++ ) < n[ i ] = i + 100; /* Set element at location i to i + 100. */ >/* Output each array element's value. */ for (j = 0; j < ARRLEN ; j++ ) < printf("Element[%zu] = %d\n", j, n[j] ); >return 0; > 

Выделить и нуль инициализировать массив с заданным пользователем размером

#include #include int main (void) < int * pdata; size_t n; printf ("Enter the size of the array: "); fflush(stdout); /* Make sure the prompt gets printed to buffered stdout. */ if (1 != scanf("%zu", &n)) /* If zu is not supported (Windows?) use lu. */ < fprintf("scanf() did not read a in proper value.\n"); exit(EXIT_FAILURE); >pdata = calloc(n, sizeof *pdata); if (NULL == pdata) < perror("calloc() failed"); /* Print error. */ exit(EXIT_FAILURE); >free(pdata); /* Clean up. */ return EXIT_SUCCESS; > 

Эта программа пытается сканировать в значении без знака со стандартного ввода, выделяет блок памяти для массива из n элементов типа int , вызывая функцию calloc() . Память инициализируется всеми нулями последней.

В случае успеха память освобождается вызовом free() .

Итерация через массив эффективно и порядок строк

Массивы в C можно рассматривать как непрерывный кусок памяти. Точнее, последнее измерение массива — это смежная часть. Мы называем это строковым порядком . Понимая это и тот факт, что ошибка кэша загружает полную кеш-строку в кеш при доступе к нераскрытым данным, чтобы предотвратить последующие ошибки кэша, мы видим, почему доступ к массиву размера 10000×10000 с array[0][0] потенциально может быть загружен в array[0][1] в кеше, но доступ к array[1][0] сразу же сгенерировал бы вторую ошибку кэша, так как это sizeof(type)*10000 bytes from array[0][0] , и, следовательно, в той же строке кэша. Вот почему итерация таким образом неэффективна:

#define ARRLEN 10000 int array[ARRLEN][ARRLEN]; size_t i, j; for (i = 0; i < ARRLEN; ++i) < for(j = 0; j < ARRLEN; ++j) < array[j][i] = 0; >> 

Итерация таким образом более эффективна:

#define ARRLEN 10000 int array[ARRLEN][ARRLEN]; size_t i, j; for (i = 0; i < ARRLEN; ++i) < for(j = 0; j < ARRLEN; ++j) < array[i][j] = 0; >> 

В том же духе, поэтому при работе с массивом с одним измерением и несколькими индексами (скажем, 2 измерения здесь для простоты с индексами i и j) важно выполнить итерацию по массиву следующим образом:

#define DIM_X 10 #define DIM_Y 20 int array[DIM_X*DIM_Y]; size_t i, j; for (i = 0; i < DIM_X; ++i) < for(j = 0; j < DIM_Y; ++j) < array[i*DIM_Y+j] = 0; >> 

Или с 3 измерениями и индексами i, j и k:

#define DIM_X 10 #define DIM_Y 20 #define DIM_Z 30 int array[DIM_X*DIM_Y*DIM_Z]; size_t i, j, k; for (i = 0; i < DIM_X; ++i) < for(j = 0; j < DIM_Y; ++j) < for (k = 0; k < DIM_Z; ++k) < array[i*DIM_Y*DIM_Z+j*DIM_Z+k] = 0; >> > 

Или более общим образом, когда у нас есть массив с элементами N1 x N2 x . x Nd , d измерениями и индексами, отмеченными как n1, n2, . nd, смещение рассчитывается так

формула

Многомерные массивы

Язык программирования C позволяет использовать многомерные массивы . Вот общая форма объявления многомерного массива —

type name[size1][size2]. [sizeN]; 

Например, следующее объявление создает трехмерный (5 x 10 x 4) целочисленный массив:

int arr[5][10][4]; 

Двумерные массивы

Простейшей формой многомерного массива является двумерный массив. Двумерный массив представляет собой, по существу, список одномерных массивов. Чтобы объявить двумерный целочисленный массив размеров mxn, мы можем написать следующее:

type arrayName[m][n]; 

Где type может быть любым допустимым типом данных C ( int , float и т. Д.), А arrayName может быть любым допустимым идентификатором C. Двумерный массив можно визуализировать как таблицу с m строками и n столбцами. Примечание : порядок имеет значение в C. Массив int a[4][3] не совпадает с массивом int a[3][4] . Количество строк приходит сначала в качестве С является строка -Майора языка.

Двумерный массив a , содержащий три строки и четыре столбца, можно показать следующим образом:

визуальная компоновка 2D-массива в виде таблицы

Таким образом, каждый элемент в массиве a идентифицируется именем элемента формы a[i][j] , где a — это имя массива, i представляет, какую строку и j представляет собой какой столбец. Напомним, что строки и столбцы нулевые индексируются. Это очень похоже на математическое обозначение для подписи двухмерных матриц.

Инициализация двумерных массивов

Многомерные массивы могут быть инициализированы путем задания скобок для каждой строки. Следующие определяют массив с 3 строками, где каждая строка имеет 4 столбца.

int a[3][4] = < , /* initializers for row indexed by 0 */ , /* initializers for row indexed by 1 */ /* initializers for row indexed by 2 */ >; 

Вложенные фигурные скобки, которые указывают предполагаемую строку, являются необязательными. Следующая инициализация эквивалентна предыдущему примеру:

int a[3][4] = ; 

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

Доступ к двумерным элементам массива

Доступ к элементу в двумерном массиве осуществляется с помощью индексов, то есть индекса строки и индекса столбца массива. Например,

int val = a[2][3]; 

Вышеприведенный оператор берет 4-й элемент из 3-й строки массива. Давайте проверим следующую программу, в которой мы использовали вложенный цикл для обработки двумерного массива:

#include int main () < /* an array with 5 rows and 2 columns*/ int a[5][2] = < , , , ,>; int i, j; /* output each array element's value */ for ( i = 0; i < 5; i++ ) < for ( j = 0; j < 2; j++ ) < printf("a[%d][%d] = %d\n", i,j, a[i][j] ); >> return 0; > 

Когда приведенный выше код компилируется и выполняется, он производит следующий результат:

a[0][0]: 0 a[0][1]: 0 a[1][0]: 1 a[1][1]: 2 a[2][0]: 2 a[2][1]: 4 a[3][0]: 3 a[3][1]: 6 a[4][0]: 4 a[4][1]: 8 

Трехмерный массив:

3D-массив по существу представляет собой массив массивов массивов: это массив или набор 2D-массивов, а 2D-массив — массив из 1-го массива.

визуальная компоновка 2D-массива в виде набора таблиц

Карта памяти 3D-массива:

3D-массив, встроенный в память

Инициализация 3D-массива:

double cprogram[3][2][4]=< , >, , >, , > >; 

Мы можем иметь массивы с любым количеством измерений, хотя вполне вероятно, что большинство создаваемых массивов будут иметь один или два измерения.

Итерация через массив с помощью указателей

#include #define SIZE (10) int main() < size_t i = 0; int *p = NULL; int a[SIZE]; /* Setting up the values to be i*i */ for(i = 0; i < SIZE; ++i) < a[i] = i * i; >/* Reading the values using pointers */ for(p = a; p < a + SIZE; ++p) < printf("%d\n", *p); >return 0; > 

Здесь, при инициализации p в первом for цикла условиях, массив a распадается на указатель на его первый элемент, как и во всех местах, где используется такая переменная массива.

Затем ++p выполняет арифметику указателя на указателе p и идет один за другим через элементы массива и ссылается на них путем разыменования их с помощью *p .

Передача многомерных массивов в функцию

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

#include #include /* When passing a multidimensional array (i.e. an array of arrays) to a function, it decays into a pointer to the first element as usual. But only the top level decays, so what is passed is a pointer to an array of some fixed size (4 in this case). */ void f(int x[][4]) < assert(sizeof(*x) == sizeof(int) * 4); >/* This prototype is equivalent to f(int x[][4]). The parentheses around *x are required because [index] has a higher precedence than *expr, thus int *x[4] would normally be equivalent to int *(x[4]), i.e. an array of 4 pointers to int. But if it's declared as a function parameter, it decays into a pointer and becomes int **x, which is not compatable with x[2][4]. */ void g(int (*x)[4]) < assert(sizeof(*x) == sizeof(int) * 4); >/* An array of pointers may be passed to this, since it'll decay into a pointer to pointer, but an array of arrays may not. */ void h(int **x) < assert(sizeof(*x) == sizeof(int*)); >int main(void) < int foo[2][4]; f(foo); g(foo); /* Here we're dynamically creating an array of pointers. Note that the size of each dimension is not part of the datatype, and so the type system just treats it as a pointer to pointer, not a pointer to array or array of arrays. */ int **bar = malloc(sizeof(*bar) * 2); assert(bar); for (size_t i = 0; i < 2; i++) < bar[i] = malloc(sizeof(*bar[i]) * 4); assert(bar[i]); >h(bar); for (size_t i = 0; i < 2; i++) < free(bar[i]); >free(bar); > 

Как создать массив с неизвестным количеством элементов c

Как создать массив с неизвестным количеством элементов c

При создании массива с фиксированными размерами под него выделяется определенная память. Например, пусть у нас будет массив с пятью элементами:

Для такого массива выделяется память 5 * 8 (размер типа double) = 40 байт. Таким образом, мы точно знаем, сколько в массиве элементов и сколько он занимает памяти. Однако это не всегда удобно. Иногда бывает необходимо, чтобы количество элементов и соответственно размер выделяемой памяти для массива определялись динамически в зависимости от некоторых условий. Например, пользователь сам может вводить размер массива. И в этом случае для создания массива мы можем использовать динамическое выделение памяти.

Для управления динамическим выделением памяти используется ряд функций, которые определены в заголовочном файле stdlib.h :

malloc() . Имеет прототип

Выделяет память длиной в s байт и возвращает указатель на начало выделенной памяти. В случае неудачного выполнения возвращает NULL

calloc() . Имеет прототип

Выделяет память для n элементов по m байт каждый и возвращает указатель на начало выделенной памяти. В случае неудачного выполнения возвращает NULL

realloc() . Имеет прототип

Изменяет размер ранее выделенного блока памяти, на начало которого указывает указатель bl, до размера в ns байт. Если указатель bl имеет значение NULL , то есть память не выделялась, то действие функции аналогично действию malloc

free() . Имеет прототип

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

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

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

Консольный вывод программы:

Здесь для управления памятью для массива определен указатель block типа int . Количество элементов массива заранее неизвестно, оно представлено переменной n.

Вначале пользователь вводит количество элементов, которое попадает в переменную n. После этого необходимо выделить память для данного количества элементов. Для выделения памяти здесь мы могли бы воспользоваться любой из трех вышеописанных функций: malloc, calloc, realloc. Но конкретно в данной ситуации воспользуемся функцией malloc :

Прежде всего надо отметить, что все три выше упомянутые функции для универсальности возвращаемого значения в качестве результата возвращают указатель типа void * . Но в нашем случае создается массив типа int, для управления которым используется указатель типа int * , поэтому выполняется неявное приведение результата функции malloc к типу int * .

В саму функцию malloc передается количество байтов для выделяемого блока. Это количество подсчитать довольно просто: достаточно умножить количество элементов на размер одного элемента n * sizeof(int) .

После выполнения всех действий память освобождается с помощью функции free() :

Важно, что после выполнения этой функции мы уже не сможем использовать массив, например, вывести его значения на консоль:

И если мы попытаемся это сделать, то получим неопределенные значения.

Вместо функции malloc аналогичным образом мы могли бы использовать функцию calloc() , которая принимает количество элементов и размер одного элемента:

Либо также можно было бы использовать функцию realloc() :

При использовании realloc желательно (в некоторых средах, например, в Visual Studio, обязательно) инициализировать указатель хотя бы значением NULL.

Но в целом все три вызова в данном случае имели бы аналогичное действие:

Теперь рассмотрим более сложную задачу — динамическое выделение памяти для двухмерного массива:

Переменная table представляет указатель на массив указателей типа int* . Каждый указатель table[i] в этом массиве представляет указатель на подмассив элементов типа int , то есть отдельные строки таблицы. А переменная table фактически представляет указатель на массив указателей на строки таблицы.

Для хранения количества элементов в каждом подмассиве определяется указатель rows типа int . Фактически он хранит количество столбцов для каждой строки таблицы.

Сначала вводится количество строк в переменную rowscount . Количество строк — это количество указателей в массиве, на который указывает указатель table . И кроме того, количество строк — это количество элементов в динамическом массиве, на который указывает указатель rows . Поэтому вначале необходимо для всех этих массивов выделить память:

Далее в цикле осуществляется ввод количества столбцов для каждый строки. Введенное значение попадает в массив rows. И в соответствии с введенным значением для каждой строки выделяется необходимый размер памяти:

Затем производится ввод элементов для каждой строки.

В конце работы программы при выводе происходит освобождение памяти. В программе память выделяется для строк таблицы, поэтому эту память надо освободить:

И кроме того, освобождается память, выделенная для указателей table и rows:

Как задать вывести массив с неопределенным изначально количеством переменных?

Задача заключается в том, что юзер вводит количество учеников, тем самым задавая размерночть массива и в последствии сам же заполняет массив. При таком коде выдает ошибку указываю на mas[], подскажите ошибку

Объявить как указатель

и динамически выделить под него память:

А вообще тема динамических массивов достаточно подробно изучена в таких местах как Google, Яндекс, StackOverflow, а так же в учебниках в разделах, где содержится кодовое словосочетание «динамический массив».

Всё ещё ищете ответ? Посмотрите другие вопросы с метками c++ массивы или задайте свой вопрос.

Site design / logo © 2022 Stack Exchange Inc; user contributions licensed under cc by-sa. rev 2022.6.10.42345

Нажимая «Принять все файлы cookie», вы соглашаетесь, что Stack Exchange может хранить файлы cookie на вашем устройстве и раскрывать информацию в соответствии с нашей Политикой в отношении файлов cookie.

Массив неизвестной длины в C#

Я только начал изучать C# , и во введении к массивам они показали, как установить переменную в качестве массива, но кажется, что нужно указать длину массива при назначении, так что, если я не знаю длину массива?

11 ответов

массивам должна быть назначена длина. Чтобы разрешить любое количество элементов, используйте List класса.

использовать List<> для создания «массива» неизвестной длины.

использовать List<>.ToArray() вернуться в реальный массив, а не List .

Вы можете создать массив с размером переменной, т. е.

однако этот размер не может измениться позже, если вы решите, что вам нужно 100 слов. Если вам нужен размер, чтобы быть действительно динамичным, вам нужно будет использовать другую структуру данных. Попробуй!—5—> List .

немного справочной информации:

как сказано, Если вы хотите иметь динамическую коллекцию вещей, используйте List . Внутренне список также использует массив для хранения. Этот массив имеет фиксированный размер, как и любой другой массив. Как только массив объявлен как имеющий размер, он не изменяется. При добавлении элемента в List , он добавлен в массив. Изначально List начинается с массива, который, как я считаю, имеет длину 16. При попытке добавить 17-й элемент в List происходит то, что выделяется новый массив, который (я думаю) в два раза больше старой, поэтому 32-х наименований. Затем содержимое старого массива копируются в новый массив. Так как List может показаться динамичным внешнему наблюдателю, внутренне он также должен соответствовать правилам.

и, как вы могли догадаться, копирование и распределение массивов не является бесплатным, поэтому следует стремиться иметь как можно меньше из них и делать то, что вы можете указать (в конструктор List ) начальный размер массива, который в идеальном сценарии достаточно велик, чтобы вместить все, что вы хотите. Тем не менее, это микро-оптимизация, и вряд ли это когда-либо будет иметь значение для вас, но всегда приятно знать, что вы на самом деле делаешь.

использовать ArrayList Если в .NET 1.x или a List если в .NET 2.0 или 3.x.

поиск их в System.Collections и System.Collections.Generics .

вы также можете посмотреть в Dictionarys если ваши данные уникальны, это даст вам два столбца для работы.

имя пользователя, общий счет

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *