Вопрос 3. Примеры программ по работе с одномерными массивами.
Изложение вопросов.
Вопрос 1. Необходимость группировки данных. Понятие массива.
На этом занятии поговорим на тему хранения данных. На одном из первых уроков вы узнали о существовании переменной и определили её как отрезок оперативной памяти для размещения информации.
Несомненно, что нормальная программа не может существовать без переменных, однако, порой простые переменные не решают проблемы оперирования данными.
Дело в том, что каждая из переменных, рассмотренных на предыдущих
занятиях, способна одновременно хранить лишь один элемент информации.
Чтобы сохранить второй, необходимо создать ещё одну переменную. Но что
делать, если нужно хранить множество элементов однородных типов данных.
Будет весьма неудобно создавать для каждого элемента переменную. А, что
если требуется работать со многими сотнями элементов? Задача очень быстро
становится невыполнимой. Согласитесь, создавать несколько сотен переменных - безумие.
Как же решить такую, казалось бы, непростую задачу?! В нашем случае
решением являются, так называемые массивы информации. Рассмотрим их определение и особенности.
Массив – это совокупность переменных, которая позволяет хранить несколько однотипных значений.
В литературе можно встретить различные определения массива. Приведём ещё одно из самых распространённых:
Массив - есть группа элементов одного типа.
|
|
|
Все значения этой совокупности объединены под одним именем. При этом каждая переменная в массиве является самостоятельной единицей под названием - элемент. Каждый элемент имеет свой порядковый номер - индекс. По индексу можно обращаться к конкретному элементу массива. Нумерация элементов в массиве начинается с нуля.
Массив характеризуется двумя понятиями: размерностью и размером.
Размерность определяет математическую сущность массива. Различают одномерные и многомерные массивы.
Массив, размерность которого равна единице, называют одномерным.
Массив, размерность которого более единицы, называют многомерным. Многомерные массивы могут быть: двумерные, трёхмерные, и т.д., n-мерные массивы. На практике используют массивы, размерность которых, не более трёх.
Размер массива определяется количеством его элементов.
Рассмотрим вначале одномерные массивы.
Массив располагается в памяти последовательно, элемент за элементом. Сначала лежит нулевой, потом первый и т.д. Элементы располагаются по возрастанию адреса: Один элемент массива отстоит от другого на количество байт, равное базовому типу массива.
Общий размер в памяти в байтах всего массива вычисляется по формуле:
|
|
|
общий_размер = размер_типа_данных*количество_элементов_в_массиве
Вопрос 2. Создание массива и заполнение его данными.
Для начала необходимо научиться создавать массив. Для этого нужно определить общий синтаксис и выяснить, каким правилам и ограничениям этот синтаксис подчиняется.
В общем виде синтаксис определения массива имеет следующий вид:
тип_данных имя_массива[количество_элементов];
где:
тип_данных - любой из существующих, известных типов данных.
Именно этим типом будет обладать каждый элемент массива.
имя_массива - любое имя, которое подчиняется "правилам имён переменных"
(рассматривали ранее).
количество_элементов - число элементов в массиве. На данном месте должно
находиться целочисленное положительное константное значение.
Таким значением может быть - либо целочисленный литерал, либо
константная целочисленная переменная.
Замечание: Количество элементов массива должно быть определено на
этапе создания программы (компиляции). Другими словами,
задать размер массива в зависимости от какого-то
|
|
|
условия или по решению пользователя невозможно. Это
приведёт к ошибке на этапе компиляции. Единственным
способом это выполнить является использование
динамического выделения памяти при работе с массивами.
Это рассмотрим позже.
Приведём примеры объявления (определения) массивов:
Пример 1:
int mas[5];
Объявлен массив с именем mas, состоящий из 5 элементов, каждый из которых имеет тип данных int.
Пример 2:
const int size=3;
double br[size];
Объявлена константа size, значение которой равно 3, а затем, массив br,
состоящий из 3 элементов, каждый из которых имеет тип данных double.
Пример 3:
#include <stdio.h>
int temp[365]; /* внешний массив из 365 целых чисел*/
void main(void)
{
float rain[365]; /*автоматический массив из 365 вещественных чисел */
static char code[12]; /* статический массив из 12 символов */
extern int temp[]; /* внешний массив, размер указан выше */
…
}
Рассмотрим, как обратиться к конкретному элементу массива.
имя_массива[индекс_элемента]=значение;
В этом выражении на место индекса_элемента может быть подставлено любое целочисленное значение, в том числе выражение, результатом которого
|
|
|
является целое число.
Пример:
const int size=5;
int ar[size]; // создание массива
ar[2]=25; // запись значения 25 в элемент с индексом 2
cout<<ar[2]<<"\n"; // вывод на экран значения элемента с индексом
2 – (25)
Замечание: В связи с тем, что нумерация элементов в массиве в
языке С/С++ начинается с нуля, то в массиве из 5
элементов последний элемент имеет индекс 4. Выходить за
пределы массива нельзя, это приведёт к ошибке на этапе
выполнения (так называемое переполнение бонда).
Заполнить массив данными можно двумя способами:
Первый способ - инициализация при создании.
Второй способ - инициализация массива при помощи цикла на этапе ввода.
Первый способ в общем виде выглядит следующим образом:
тип_данных имя_массива[количество элементов]={значение1,
значение2, …
значение n};
Пример:
const int size=3;
int ar[size]={1,30,2};
При такой форме инициализации есть некоторые особенности:
1. Все значения списка инициализации имеют такой же тип данных, как и сам
массив, поэтому при создании количество элементов можно не указывать.
Компилятор сам определит размер массива исходя из числа элементов в списке
инициализации.
int ar[]={1,30,2}; /*В данной строке массив автоматически
получит размер 3.*/
2. Если число элементов в списке инициализации меньше чем число
элементов массива, то оставшиеся значения автоматически заполняются
нулями:
int ar[5]={1,2,3};
такая запись эквивалентна записи:
int ar[5]={1,2,3,0,0};
3. Если значений в списке инициализации больше чем количество элементов
массива, то происходит ошибка на этапе компиляции:
int array[2]={1,2,3}; // ошибка на этапе компиляции
При втором способе инициализации массива пользователь сам при помощи цикла осуществляет заполнение массива на этапе ввода.
Пример:
#include <windows.h>
#include <iostream>
using namespace std;
void main(void)
{
system("cls");
const int size=3;
//создание массива из трёх элементов
int ar[size];
//цикл перебирающий элементы массива
for(int i=0;i<size;i++)
{
cout<<"Enter element ar["<<i<<"]=";
/*
на каждой итерации цикла пользователю подставляется
элемент с индексом i для заполнения.
*/
cin>>ar[i];
}
}
Результат работы программы:
Вопрос: Как осуществить показ содержимого массива на экран?
Нетрудно догадаться, что большинство операций с массивами удобнее проводить с помощью циклов, по очереди перебирая элементы. Это действительно так, и показ на экран не является исключением.
Приведём пример полной программы, которая создаёт, заполняет и показывает на экран массив.
#include <windows.h>
#include <iostream>
using namespace std;
void main(void)
{
system("cls");
const int size = 3;
//создание массива из трех элементов
int ar[size];
//цикл перебирающий элементы массива
for(int i = 0; i<size; i++)
{
cout << "Enter element ar[" << i << "]=";
/*
на каждой итерации цикла пользователю подставляется
элемент с индексом i для заполнения.
*/
cin >> ar[i];
}
for(int i = 0; i<size; i++)
{
cout << "Display element ar[" << i << "]=";
/*
показ элемента с индексом i на экране дисплея
*/
cout << ar[i] << endl;
}
}
Результат работы программы:
Вопрос 3. Примеры программ по работе с одномерными массивами.
Теперь, когда мы с вами познакомились с массивами, давайте рассмотрим несколько практических примеров работы с ними.
Пример 1:
Программа для нахождения суммы отрицательных элементов массива.
#include <windows.h>
#include <iostream>
using namespace std;
int main(void)
{
system("cls");
//определение размера массива
const int size = 5;
//создание и инициализация массива данными
int ar[size] = { 23,-11,9,-18,-25 };
//переменная для накопления суммы
int sum = 0;
//счётчик в цикле for
int i;
//цикл, перебирающий по порядку элементы массива
for(i = 0; i<size; i++)
{
//если значение элемента отрицательное (меньше нуля),
//добавить его значение к общей сумме
if(ar[i]<0)
sum += ar[i];
}
//показ значения суммы на экран
cout << "Sum = " << sum << "\n\n";
return 0;
}
Результат работы программы:
Комментарии к программе:
1. Цикл поочерёдно перебирает элементы от 0 до size. При этом size не
входит в проверяемый диапазон, т. к. индекс последнего элемента (size-1).
2. На каждой итерации цикла происходит проверка содержимого элемента на
отрицательное значение.
3. Если значение меньше нуля, оно прибавляется к сумме.
Как видите, работа с массивом очень похожа на анализ какого-то диапазона.
Только, в данном случае, минимальная граница диапазона – 0 (нулевой индекс), а максимальная - определяется количеством элементов в массиве (максимальный индекс).
Пример 2:
Программа для нахождения максимального и минимального элементов массива.
#include <windows.h>
#include <iostream>
using namespace std;
int main(void)
{
system("cls");
// определения количества элементов массива
const int size = 20;
//счётчик в цикле for
int i;
// создание и инициализация массива
int ar[size] = { 23,11,9,18,25,1,2,3,4,5,6,7,8,9,10,11,12,13,-14,-15 };
// пусть 0 элемент максимальный
int max = ar[0];
// пусть 0 элемент минимальный
int min = ar[0];
//цикл перебирает элементы массива начиная с 1-го
for(i = 1; i<size; i++)
{
//если текущий элемент меньше, чем минимум
//перезаписать значение минимума
if(min>ar[i])
min = ar[i];
//если текущий элемент больше, чем максимум
//перезаписать значение максимума
if(max<ar[i])
max = ar[i];
}
// вывод результата на экран
cout << "Max = " << max << "\n\n";
cout << "Min = " << min << "\n\n";
return 0;
}
Результат работы программы:
Комментарии к программе:
1. Для начала, выдвигаем предположение, что минимальным является
элемент массива с индексом 0.
2. Записываем значение элемента с индексом 0 в переменную min.
3. Затем, для того, что бы либо подтвердить, либо опровергнуть этот факт,
перебираем все элементы массива начиная с элемента с индексом 1 в цикле.
4. На каждой итерации цикла, сравниваем предполагаемый минимум с
текущим элементом массива (элемент с индексом i).
5. Если встречается значение меньше, чем предполагаемый минимум -
значение min перезаписывается на меньшее найденное значение и анализ
продолжается.
6. Все вышеописанные действия справедливы и для максимума, только
осуществлять необходимо поиск большего значения.
Пример 3:
Усложним второй пример. Вместе с максимальным и минимальным элементами массива определим их порядковые номера в массиве, т.е. индексы. А также осуществим ввод значений массива с клавиатуры. Считаем, что все элементы массива разные.
#include <windows.h>
#include<iostream>
using namespace std;
void main(void);
void main(void)
{
system("cls");
SetConsoleCP(1251);
SetConsoleOutputCP(1251);
// определения количества элементов массива. Считаем, что все элементы массива разные.
const int size = 20;
// счётчик в цикле for
int i;
// переменные, в которые будут заноситься соответственно значения индексов максимума и минимума
int i_max, i_min;
// переменная, используемая для хранения текущего максимума
int max;
// переменная, используемая для хранения текущего минимума
int min;
// создание массива
int ar[size];
// ввод элементов массива в память компьютера
cout << "Введите элементы массива в память машины. Их количество 20.\n";
for(i = 0; i<size; i++)
{
cout << "Элемент [" << i << "]=";
cin >> ar[i];
}
// Контрольный вывод элементов массива из памяти компьютера по пять элементов в строке
cout << "\n";
cout << "Элементы массива из памяти машины. Их количество 20. По 5 элементов в строке.\n";
for(i = 0; i<size; i++)
{
cout.setf(ios::left);
cout.width(5);
cout << ar[i];
if((i + 1) % 5 == 0)
cout << "\n";
}
// пусть 0-й элемент максимальный
max = ar[0];
// пусть 0-й элемент минимальный
min = ar[0];
// начальный индекс максимального элемента
i_max = 0;
// начальный индекс минимального элемента
i_min = 0;
//цикл перебирает элементы массива начиная с 1-го
for(i = 1; i<size; i++)
{
//если текущий элемент меньше, чем минимум
//перезаписать значение минимума и его индекса
if(min>ar[i])
{
min = ar[i];
i_min = i;
}
//если текущий элемент больше, чем максимум
//перезаписать значение максимума и его индекса
if(max<ar[i])
{
max = ar[i];
i_max = i;
}
}
cout << "\n";
// вывод результатов на экран
cout << "Max = " << max << " Index=" << i_max << "\n\n";
cout << "Min = " << min << " Index=" << i_min << "\n\n";
}
Перепишем данную программу, используя стандартный ввод вывод данных.
#include <windows.h>
#include <stdio.h>
int main(void);
int main(void)
{
system("cls");
SetConsoleCP(1251);
SetConsoleOutputCP(1251);
const int size = 20; // определения количества элементов массива. Считаем, что все элементы массива разные.
int i; // счётчик в цикле for
int i_max, i_min; // переменные, в которые будут заноситься соответственно значения индексов максимума и минимума
int max;
int min;
// создание массива
int ar[size];
// ввод элементов массива в память компьютера
printf("Введите элементы массива в память машины. Их количество 20.\n");
for(i = 0; i<size; i++)
{
printf("Элемент [%d]=", i);
scanf_s("%d", &ar[i]);
}
// Контрольный вывод элементов массива из памяти компьютера по пять элементов в строке.
printf("\n");
printf("Элементы массива из памяти машины. Их количество 20. По 5 элементов в строке.\n");
for(i = 0; i<size; i++)
{
printf("%5d", ar[i]);
if((i + 1) % 5 == 0)
printf("\n");
}
max = ar[0]; // пусть 0 элемент максимальный
min = ar[0]; // пусть 0 элемент минимальный
i_max = 0; // начальный индекс максимального элемента
i_min = 0; // начальный индекс минимального элемента
//цикл перебирает элементы массива начиная с 1-го
for(i = 1; i<size; i++)
{
//если текущий элемент меньше, чем минимум
if(min>ar[i])
{
//перезаписать значение минимума и его индекса
min = ar[i];
i_min = i;
}
//если текущий элемент больше, чем максимум
if(max<ar[i])
{
//перезаписать значение максимума и его индекса
max = ar[i];
i_max = i;
}
}
printf("\n");
// вывод результатов на экран
printf("Max = %d Index = %d\n", max, i_max);
printf("Min = %d Index = %d\n", min, i_min);
return 0;
}
Результат работы программы:
Дата добавления: 2021-07-19; просмотров: 99; Мы поможем в написании вашей работы! |
Мы поможем в написании ваших работ!