Как установить размер массива с клавиатуры с помощью

Обновлено: 19.05.2024

Динамический массив очень похож на обычный массив, но его размер можно изменить во время выполнения программы. Элементы DynamArray занимают непрерывный блок памяти.

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

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

В этом руководстве по C++ вы узнаете

Факторы, влияющие на производительность динамических массивов

Первоначальный размер массива и коэффициент его роста определяют его производительность. Обратите внимание на следующие моменты:

  1. Если массив имеет небольшой размер и небольшой коэффициент роста, он будет чаще перераспределять память. Это снизит производительность массива.
  2. Если массив имеет большой размер и большой коэффициент роста, у него будет огромный кусок неиспользуемой памяти. Из-за этого операции по изменению размера могут занять больше времени. Это снизит производительность массива.

Новое ключевое слово

В C++ мы можем создать динамический массив, используя ключевое слово new. Количество размещаемых элементов указывается в паре квадратных скобок. Имя типа должно предшествовать этому. Запрошенное количество элементов будет выделено.

Синтаксис:

Новое ключевое слово имеет следующий синтаксис:

Переменная_указателя — это имя переменной-указателя.

data_type должен быть допустимым типом данных C++.

Затем ключевое слово возвращает указатель на первый элемент. После создания динамического массива мы можем удалить его с помощью ключевого слова delete.

Пример 1:


Вот скриншот кода:


Пояснение кода:

  1. Включите заголовочный файл iostream в нашу программу, чтобы использовать ее функции.
  2. Включите пространство имен std в нашу программу, чтобы использовать его классы, не вызывая его.
  3. Вызовите функцию main(). Логика программы должна быть добавлена ​​в тело функции.
  4. Объявите две целочисленные переменные x и n.
  5. Выведите на консоль текст, предлагающий пользователю ввести значение переменной n.
  6. Чтение пользовательского ввода с клавиатуры и присвоение его переменной n.
  7. Объявите массив, содержащий в общей сложности n целых чисел, и назначьте его переменной-указателю *arr.
  8. Вывести сообщение, предлагающее пользователю ввести n элементов.
  9. Используйте цикл for для создания переменной цикла x для перебора элементов, введенных пользователем.
  10. Чтение элементов, введенных пользователем, и сохранение их в массиве arr.
  11. Конец тела цикла for.
  12. Выведите текст на консоль.
  13. Используйте цикл for для создания переменной цикла x для перебора элементов массива.
  14. Выведите на консоль значения, содержащиеся в массиве с именем arr.
  15. Конец тела цикла for.
  16. Программа должна возвращать значение после успешного завершения.
  17. Конец тела функции main().

ПРИМЕЧАНИЕ. В приведенном выше примере пользователю разрешено указывать любой размер массива во время выполнения. Это означает, что размер массива определяется во время выполнения.

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

Инициализировать динамический массив значением 0 легко.

Синтаксис:

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

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

Пример 2:

Вывод:


Вот скриншот кода:


Пояснение кода:

  1. Включите заголовочный файл iostream в нашу программу, чтобы использовать ее функции.
  2. Включите пространство имен std в нашу программу, чтобы использовать его классы, не вызывая его.
  3. Вызовите функцию main(). Логика программы должна быть добавлена ​​в тело функции.
  4. Объявите целочисленную переменную с именем x.
  5. Объявите динамический массив с именем array, используя список инициализаторов. Массив будет содержать 5 целочисленных элементов. Обратите внимание, что мы не использовали оператор «=» между длиной массива и списком инициализаторов.
  6. Выведите текст на консоль. Endl — это ключевое слово C++, означающее конечную строку.Курсор перемещается к следующему предложению.
  7. Используйте цикл for для перебора элементов массива.
  8. Вывести на консоль содержимое массива с именем array.
  9. Конец тела цикла for.
  10. Программа должна возвращать значение после успешного завершения.
  11. Конец тела функции main().

Изменение размера массивов

Длина динамического массива устанавливается во время выделения.

Однако в C++ нет встроенного механизма изменения размера массива после его размещения.

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

Примечание: этот метод подвержен ошибкам, поэтому старайтесь его избегать.

Динамическое удаление массивов

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

Примечание:

Чтобы удалить динамический массив из памяти компьютера, вместо удаления следует использовать команду delete[]. [] указывает ЦП удалить несколько переменных, а не одну переменную. Использование delete вместо delete[] при работе с динамическим массивом может привести к проблемам. Примеры таких проблем включают утечки памяти, повреждение данных, сбои и т. д.

Можно ли разрешить пользователю вводить размер массива с помощью клавиатуры?

Я знаю, что массивы не могут изменять размер. Единственное решение, которое я мог придумать, это:

Как я могу убедиться, что это работает? Должен ли я вместо этого использовать вектор?


Вам нужны массивы переменной длины. Их нет в C++, если вы не используете расширения компилятора.

Вы настаиваете на статическом размещении? Я считаю, что лучшим решением было бы использовать type *userArray = new type[numberInputByUser]. НЕ ЗАБУДЬТЕ ПОСЛЕ УДАЛИТЬ ЕГО! :)

Попытаться — это здорово, но то, что это «работает», не означает, что это работает, и мы, безусловно, можем дать более полную информацию о ситуации на этом сайте. Например, даже если это работает на вашем компиляторе, лучше не пытаться выделять в стеке больше ~4 МБ!

5 ответов 5

Массивы переменной длины не одобрены стандартом C++. Стандарт C++ требует, чтобы размер массива был константой времени компиляции.
Вы можете использовать VLA через расширение компилятора, предоставленное в gcc, но обратите внимание, что ваш код не будет переносимым, если вы это сделаете.

Стандартный одобренный способ сделать это — использовать std::vector.


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

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

Второй вариант — это динамическое выделение памяти и использование обычного указателя C для ее отслеживания. Если вы забудете (или не сможете) удалить его, у вас утечка памяти.

Третий вариант — написать собственный интеллектуальный указатель, boost или в C++ 0x unique_ptr . Он будет отслеживать указатель и удалять его, когда он выйдет за пределы области действия.

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

Массив – это индексированная коллекция элементов данных одного типа.
1) Индексация означает, что элементы массива пронумерованы (начиная с 0).
2) Ограничение одного типа важно, т.к. массивы хранятся в последовательных ячейках памяти. Все ячейки должны быть одного типа (и, следовательно, одного размера).

Объявление массивов:

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

Это объявляет массив указанного размера с именем имя_переменной и типом имя_типа. Массив индексируется от 0 до size-1. Размер (в скобках) должен быть целочисленным литералом или постоянной переменной. Компилятор использует размер, чтобы определить, сколько места нужно выделить (т. е. сколько байтов).

Последний пример иллюстрирует двумерный массив (который нам часто нравится представлять как таблицу).Обычно мы думаем о первом размере как о строках, а о втором — как о столбцах, но на самом деле это не имеет значения, если вы последовательны! Таким образом, мы могли бы думать о последнем объявлении как о таблице с 5 строками и 10 столбцами, например.

Инициализация массивов:

Или мы могли бы просто инициализировать переменную в самом операторе объявления:

Можем ли мы сделать то же самое для массивов? Да, для встроенных типов. Просто перечислите значения массива (литералы) в обозначении набора < > после объявления. Вот несколько примеров:

Строки в стиле C

  • Мы часто используем строки, но в языке нет встроенного строкового типа
  • Строка в стиле C реализована в виде массива типа char, который заканчивается специальным символом, называемым "нулевым символом".
    • Нулевой символ имеет значение ASCII 0
    • Нулевой символ можно записать как литерал в коде следующим образом: '\0'

    Поскольку массивы символов используются для хранения строк в стиле C, вы можете инициализировать массив символов строковым литералом (то есть строкой в ​​двойных кавычках), если в выделенном пространстве остается место для нулевого символа.< /p>

    Обратите внимание, что это будет эквивалентно:

    Варианты инициализации

    Объявления массива должны содержать информацию о размере массива. Можно оставить размер вне [ ] в объявлении, если вы инициализируете массив встроенно, и в этом случае массив делается достаточно большим, чтобы захватить инициализированные данные. Примеры:

    Еще один быстрый способ использования наборов инициализаторов – использование меньшего количества элементов, чем указано в размере. Остальные элементы по умолчанию будут равны 0. Использование набора, содержащего больше элементов, чем выделенный размер, является незаконным.

    Примечание. Использование инициализаторов в объявлении, как в приведенных выше примерах, вероятно, не будет таким желательным для очень больших массивов.
    Еще один распространенный способ инициализации массива — с помощью цикла for:
    В этом примере массив numList инициализируется значением .

    Использование массивов:

    После объявления ваших массивов вы получаете доступ к элементам в массиве с именем массива и порядковым номером в квадратных скобках [ ]. Если массив объявлен как: typeName varName[size], то элемент с индексом n упоминается как varName[n]. Примеры:

    Однако нецелесообразно использовать индекс массива, выходящий за пределы допустимых индексов массива:

    Однако приведенное выше утверждение синтаксически допустимо. Работа программиста состоит в том, чтобы убедиться, что индексы за пределами границ не используются. Не рассчитывайте на то, что компилятор проверит это за вас — этого не произойдет!

    Копирование массивов:

    С переменными мы используем оператор присваивания, так что это было бы естественной тенденцией, но это неправильно!

    Мы должны копировать между массивами поэлементно. Однако цикл for упрощает эту задачу:

    Простой ввод-вывод со строками:

    В особом случае строк (массивы символов с нулем в конце) их можно использовать как обычные массивы. Доступ к одному элементу массива означает доступ к одному символу.

    Строки также могут выводиться и вводиться целиком со стандартными объектами ввода и вывода (cin и cout):
    Следующая строка выводит слово "Hello": Будьте осторожны, используйте это только для массивов символов которые используются как строки в стиле C. (Это означает, что только если нулевой символ присутствует в качестве терминатора).

    Следующая строка позволяет ввести слово (до 19 символов и завершающий нулевой символ) с клавиатуры, которое хранится в массиве word1:

    Символы считываются с клавиатуры до тех пор, пока не встретится первый "пробел" (пробел, табуляция, новая строка и т. д.). Ввод сохраняется в массиве символов, и нулевой символ добавляется автоматически.

    array_pad() возвращает копию массива, дополненного до размера, заданного длиной, со значением value . Если длина положительна, то массив дополняется справа, если отрицателен, то слева. Если абсолютное значение длины меньше или равно длине массива, то заполнение не происходит. За один раз можно добавить не более 1048576 элементов.

    Параметры

    Исходный массив значений для заполнения.

    Новый размер массива.

    Значение для заполнения, если массив меньше длины .

    Возвращаемые значения

    Возвращает копию массива, дополненного до размера, заданного длиной, со значением value . Если длина положительна, то массив дополняется справа, если отрицателен, то слева. Если абсолютное значение длины меньше или равно длине массива, заполнение не выполняется.

    Примеры

    = массив( 12 , 10 , 9 );

    $result = array_pad ( $input , 5 , 0 );
    // результат - массив (12, 10, 9, 0, 0)

    $result = array_pad ( $input , - 7 , - 1 );
    // результат - массив (-1, -1, -1, -1, 12, 10, 9)

    $result = array_pad ( $input , 2 , "noop" );
    // без заполнения
    ?>

    См. также

    • array_fill() — заполнение массива значениями
    • range() — создает массив, содержащий диапазон элементов

    Пользовательские заметки 11 заметок

    Остерегайтесь, если вы попытаетесь дополнить ассоциативный массив с помощью цифровых клавиш, ваши ключи будут перенумерованы.

    = массив('размер' => 'большой', 'число' => 20, 'цвет' => 'красный');
    print_r ($a);
    print_r (array_pad ($a, 5, 'foo'));

    // используем метки времени в качестве ключей
    $b = array( 1229600459 => 'большой' , 1229604787 => 20 , 1229609459 => 'красный' );
    print_r ( $b );
    print_r (array_pad ($b, 5, 'foo'));
    ?>

    выдает это:
    ----
    Массив
    ( < br />[размер] => большой
    [число] => 20
    [цвет] => красный
    )
    Массив
    (
    [размер ] => большой
    [число] => 20
    [цвет] => красный
    [0] => foo
    [1] => foo
    ) < br />Массив
    (
    [1229600459] => большой
    [1229604787] => 20
    [1229609459] => красный
    )
    Массив < br />(
    [0] => большой
    [1] => 20
    [2] => красный
    [3] => foo
    [4 ] => foo
    )

    к предыдущему комментатору: если вы прочитаете ввод вручную, вы увидите, что отрицательное значение pad_size поместит значения pad в начало массива.

    Читайте также: