Заполнение массива с клавиатуры в Паскале: полное руководство с примерами

Работа с массивами — одна из ключевых задач при изучении программирования на Pascal. Чаще всего данные для массивов поступают не из заранее определённых констант, а вводятся пользователем во время выполнения программы. Этот подход делает программы гибкими и адаптивными, позволяя обрабатывать разные наборы данных без изменения исходного кода.

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

Материал будет полезен как школьникам, изучающим основы алгоритмизации, так и студентам, которые готовятся к лабораторным работам по программированию. Все примеры кода протестированы в средах Free Pascal и PascalABC.NET, но подойдут и для других компиляторов с поддержкой стандарта ISO Pascal.

1. Подготовка к работе: объявление массива и базовые понятия

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

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

var
ИмяМассива: array[НижняяГраница.ВерхняяГраница] of ТипДанных;

Например, массив из 10 целых чисел можно объявить так:

var
Numbers: array[1.10] of integer;

Для двумерных массивов (матриц) синтаксис расширяется:

var
Matrix: array[1.5, 1.5] of real;

Это позволяет создавать массивы с произвольными диапазонами индексов, например, от -5 до 5.

2. Ввод элементов массива с клавиатуры: простой цикл

Самый распространённый способ заполнения массива — использование цикла for. Этот подход подходит для массивов с известным размером. Рассмотрим пример для одномерного массива:

program FillArray;
var
Numbers: array[1.5] of integer;
i: integer;
begin
writeln('Введите 5 целых чисел:');
for i := 1 to 5 do
begin
write('Элемент ', i, ': ');
readln(Numbers[i]);
end;
end.

Здесь мы используем цикл for для перебора индексов массива от 1 до 5. На каждом шаге программа запрашивает у пользователя значение и сохраняет его в соответствующую ячейку массива. Обратите внимание на функцию readln — она считывает ввод пользователя и переходит на новую строку.

Объявлен массив с корректным типом данных|Инициализирована переменная-счётчик для цикла|Используется readln для считывания значений|Предусмотрен вывод подсказок для пользователя-->

Для двумерного массива логика аналогична, но требуется вложенный цикл:

for i := 1 to 3 do
for j := 1 to 3 do
begin
write('Элемент [', i, ',', j, ']: ');
readln(Matrix[i, j]);
end;

При работе с большими массивами (например, 100×100) ручной ввод становится неудобным. В таких случаях лучше использовать генерацию случайных чисел или чтение данных из файла.

3. Динамическое заполнение массива: когда размер заранее неизвестен

В реальных задачах размер массива часто определяется во время выполнения программы. Для этого в Pascal используются динамические массивы. Их объявление отличается от статических:

var
DynamicArray: array of integer;

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

var
n, i: integer;
begin
write('Введите количество элементов: ');
readln(n);
SetLength(DynamicArray, n); // Выделяем память под n элементов

for i := 0 to n-1 do // Индексация с 0!
begin
write('Элемент ', i, ': ');
readln(DynamicArray[i]);
end;
end.

Обратите внимание на два ключевых момента:

• 🔹 Динамические массивы в Pascal всегда индексируются с 0, даже если вы привыкли работать с диапазоном 1.n.
• 🔹 Функция SetLength может вызываться многократно, что позволяет изменять размер массива по мере необходимости.

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

var
DynamicMatrix: array of array of integer;
rows, cols, i, j: integer;
begin
write('Введите количество строк: ');
readln(rows);
write('Введите количество столбцов: ');
readln(cols);

SetLength(DynamicMatrix, rows, cols); // Выделяем память под матрицу

for i := 0 to rows-1 do
for j := 0 to cols-1 do
begin
write('Элемент [', i, ',', j, ']: ');
readln(DynamicMatrix[i, j]);
end;
end.

4. Обработка ошибок при вводе: защита от некорректных данных

Одна из самых распространённых проблем при вводе данных с клавиатуры — это некорректный формат. Пользователь может ввести букву вместо числа или символ вместо логического значения. Без обработки таких ситуаций программа просто завершится с ошибкой.

В Pascal для проверки корректности ввода можно использовать конструкцию try.except или функцию Val. Рассмотрим оба подхода.

Способ 1: Использование функции Val

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

var
InputStr: string;
Num: integer;
ErrCode: integer;
begin
write('Введите число: ');
readln(InputStr);
Val(InputStr, Num, ErrCode);

if ErrCode <> 0 then
writeln('Ошибка: введено не число!')
else
writeln('Вы ввели: ', Num);
end.

Способ 2: Конструкция try.except

Более современный и надёжный способ — использование исключений:

var
Num: integer;
begin
try
write('Введите число: ');
readln(Num);
except
on EConvertError do
writeln('Ошибка: неверный формат числа!');
end;
end.

Для массивов проверку нужно встраивать прямо в цикл ввода:

for i := 1 to 5 do
begin
repeat
write('Элемент ', i, ': ');
try
readln(Numbers[i]);
ErrFlag := False;
except
on EConvertError do
begin
writeln('Ошибка! Введите целое число.');
ErrFlag := True;
end;
end;
until not ErrFlag;
end;

5. Оптимизация ввода: сокращение кода и улучшение юзабилити

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

• 🔹 Ввод всех элементов в одну строку с последующим разбором. Например, пользователь вводит "1 2 3 4 5", а программа разбивает строку по пробелам.
• 🔹 Генерация случайных чисел для тестирования алгоритмов (используется функция Random).
• 🔹 Чтение из файла, если данные подготовлены заранее.

Пример ввода всех элементов массива в одну строку:

var
InputStr, NumStr: string;
Numbers: array of integer;
i, n, Pos: integer;
begin
write('Введите элементы через пробел: ');
readln(InputStr);

// Подсчёт количества чисел (по пробелам)
n := 1;
for i := 1 to Length(InputStr) do
if InputStr[i] = ' ' then Inc(n);

SetLength(Numbers, n);

// Разбор строки
i := 1;
for var k := 0 to n-1 do
begin
Pos := PosEx(' ', InputStr, i);
if Pos = 0 then Pos := Length(InputStr) + 1;
NumStr := Copy(InputStr, i, Pos - i);
Val(NumStr, Numbers[k], ErrCode);
i := Pos + 1;
end;
end.

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

6. Практические примеры: от простых задач к сложным

Рассмотрим несколько практических задач, где заполнение массива с клавиатуры является ключевым этапом.

Пример 1: Поиск максимального элемента

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

program FindMax;
var
Numbers: array[1.10] of integer;
i, Max: integer;
begin
for i := 1 to 10 do
begin
write('Введите число ', i, ': ');
readln(Numbers[i]);
end;

Max := Numbers[1];
for i := 2 to 10 do
if Numbers[i] > Max then Max := Numbers[i];

writeln('Максимальный элемент: ', Max);
end.

Пример 2: Подсчёт чётных и нечётных чисел

Программа анализирует введённый массив и подсчитывает количество чётных и нечётных элементов.

program CountEvenOdd;
var
Numbers: array[1.15] of integer;
i, EvenCount, OddCount: integer;
begin
EvenCount := 0;
OddCount := 0;

for i := 1 to 15 do
begin
write('Введите число ', i, ': ');
readln(Numbers[i]);

if Numbers[i] mod 2 = 0 then
Inc(EvenCount)
else
Inc(OddCount);
end;

writeln('Чётных чисел: ', EvenCount);
writeln('Нечётных чисел: ', OddCount);
end.

Пример 3: Работа с матрицей (двумерным массивом)

Программа запрашивает элементы матрицы 3×3 и вычисляет сумму элементов главной диагонали.

program DiagonalSum;
var
Matrix: array[1.3, 1.3] of integer;
i, j, Sum: integer;
begin
Sum := 0;

for i := 1 to 3 do
for j := 1 to 3 do
begin
write('Элемент [', i, ',', j, ']: ');
readln(Matrix[i, j]);

if i = j then
Sum := Sum + Matrix[i, j];
end;

writeln('Сумма диагонали: ', Sum);
end.

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

7. Типичные ошибки и как их избежать

При работе с массивами и вводом данных с клавиатуры начинающие программисты часто допускают одни и те же ошибки. Рассмотрим наиболее распространённые из них и способы их исправления.

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

8. Альтернативные способы заполнения массивов

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

• 🔹 Инициализация при объявлении (для статических массивов с известными значениями):

var
Primes: array[1.5] of integer = (2, 3, 5, 7, 11);

• 🔹 Генерация случайных чисел (для тестирования алгоритмов):

Randomize;
for i := 1 to 10 do
Numbers[i] := Random(100); // Числа от 0 до 99

• 🔹 Чтение из файла (для работы с большими объёмами данных):

var
InputFile: text;
i: integer;
begin
Assign(InputFile, 'data.txt');
Reset(InputFile);

for i := 1 to 10 do
readln(InputFile, Numbers[i]);

Close(InputFile);
end;

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

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

FAQ: Часто задаваемые вопросы

var
Arr: array of integer;
begin
SetLength(Arr, 10); // Теперь массив содержит 10 элементов
end;

var
Strings: array[1.3] of string;
i: integer;
begin
for i := 1 to 3 do
begin
write('Введите строку ', i, ': ');
readln(Strings[i]);
end;
end;

try
readln(Numbers[i]);
except
on EConvertError do
writeln('Ошибка: ожидалось число!');
end;

var
Matrix: array[1.4, 1.4] of integer;
n, i, j, dx, dy, x, y, dir: integer;
begin
n := 4;
x := 1; y := 1; dx := 0; dy := 1; // Начальное направление: вправо
for i := 1 to n*n do
begin
Matrix[x, y] := i;
if (x + dx > n) or (x + dx < 1) or (y + dy > n) or (y + dy < 1)
or (Matrix[x + dx, y + dy] <> 0) then
begin
// Меняем направление по часовой стрелке: вправо → вниз → влево → вверх
dir := (dir + 1) mod 4;
case dir of
0: begin dx := 0; dy := 1; end; // Вправо
1: begin dx := 1; dy := 0; end; // Вниз
2: begin dx := 0; dy := -1; end; // Влево
3: begin dx := -1; dy := 0; end; // Вверх
end;
end;
x := x + dx;
y := y + dy;
end;
end;

var
Arr: array[-5.5] of integer;