Массивы

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

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

На рисунке показан массив целых чисел, названный A. Этот массив содержит 6 элементов. На любой элемент массива можно сослаться, указывая имя массива и номер позиции элемента, заключенный в квадратные скобки ([ ]). Первый элемент каждого массива — это нулевой элемент. Таким образом, первый элемент массива A, указывают как A[0], второй элемент — как A[1], шестой — как A[5] и вообще i-ый элемент массива A указывают как A[i-l]. Имена массивов должны удовлетворять тем же требованиям, которые предъявляются к другим именам переменных.

Номер позиции, указанный внутри квадратных скобок, называется индексом. Индекс должен быть целым числом или выражением, результат вычисления которого целое число. Если программа использует выражение в качестве индекса, то выражение вычисляется с целью определения индекса. Например, если мы предположим, что переменная а равна 4, а переменная b равна 1, то оператор A[а + b] += 2; добавляет 2 к элементу массива A[5]. Заметим, что имя индексированного массива является целой L-величиной,т.е. оно может быть использовано в левой части оператора присваивания.

Напечатать сумму значений, содержащихся в первых трех элементах массива A, можно следующим образом:

cout << A[0] + A[1] + A[2] << '\n';

Чтобы разделить значение последнего элемента массива А на 2 и присвоить результат переменной х, необходимо написать

х = А[5] / 2;

Квадратные скобки, внутри которых записывается индекс массива, на самом деле рассматриваются в C++ как операция индексации и имеют тот же приоритет, что и круглые скобки.

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

Массивы занимают область в памяти. Программист указывает тип каждого элемента, количество элементов, требуемое каждым массивом, и компилятор может зарезервировать соответствующий объем памяти. Чтобы указать компилятору зарезервировать память для 6 элементов массива целых чисел A, используется объявление

int A[6];

Память может быть зарезервирована для нескольких массивов с помощью одного объявления. Следующее объявление резервирует память для 100 элементов массива целых чисел b и 27 элементов массива целых чисел х.

int b[100], х[27];

Массивы могут быть объявлены и для хранения других типов данных. Например, для хранения строки символов можно использовать массив типа char.

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

Примеры использования массивов

Как вы помните, в С++ переменные не инициализируются автоматически, это же относится и к массивам. Т.е. программист сам должен позаботиться о присвоении элементам массива начальных значений. В программе 1 используется структура повторения for для присвоения начальных нулевых значений элементам массива n, содержащего десять целых чисел, и для печати массива в табулированном формате. Первый оператор вывода выводит на экран заголовки столбцов ("Элемент" и "Значение"), печатаемых структурой for.

Программа 1

// присвоение массиву начальных значений
#include < iostream.h >

void main()
{
 int n[10]; // объявление массива целых чисел
 
 // присвоение массиву начальных значений (инициализация массива)
 for (int i = 0; i <10; i++)
 n[i] = 0;
 
 cout << "Элемент" << '\t' << "Значение" << '\n';

 // печать массива
 for (i = 0; i <10; i++)
 cout << i << '\t' << n[i] << '\n';
}

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

Программа 2

#include <iostream.h>

void main()
{
 // объявление и инициализация массива 
 int n[10] = {1, 3, 5, 7, 11, 13, 17, 19, 23, 29};
 
 cout << "Элемент" << '\t' << "Значение" << '\n';

 // печать массива
 for (int i = 0; i <10; i++)
 cout << i << '\t' << n[i] << '\n';
}

Обратите внимание!

Если начальных значений меньше, чем элементов в массиве, оставшиеся элементы автоматически получают нулевые начальные значения.

Например, элементам массива n можно присвоить нулевые начальные значения с помощью объявления

int n[10] = {0};

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

Типичная ошибка программирования

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

Следующее объявление массива

int n[5] = {32, 27, 64, 18, 95, 14};

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

Типичная ошибка программирования

Задание в списке начальных значений большего числа значений, чем имеется элементов в массиве, является синтаксической ошибкой.

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

int n[ ] = {1, 2, 3, 4, 5};

создало бы массив из пяти элементов.

Программа 3

Присваивает начальные целые значения 1, 2, 3,… , 10 элементам массива S из десяти элементов и выводит на экран элементы массива с четным индексом.

#include <iostream.h>

void main()
{
 const int arraySize = 10;
 int S[arraySize]; // объявление массива целых чисел
 
 // инициализация массива
 for (int k = 0; k < arraySize; k++)
 S[k] = k + 1;
 
 cout << "Элемент" << '\t' << "Значение" << '\n';
 
 // вывод на экран элементов массива с четным индексом
 for (int i = 0; i < arraySize; i += 2)
 cout << i << '\t' << S[i] << '\n';
}

Строка const int arraySize = 10; использует спецификацию const для объявления именованной константы arraySize, имеющей значение 10. Именованные константы должны получать при объявлении в качестве начальных значений постоянные выражения, которые после этого не могут быть модифицированы.

Типичная ошибка программирования

Присваивание значения именованной константе в выполняемом операторе является синтаксической ошибкой.

Именованные константы могут быть помещены в любом месте, где ожидается постоянное выражение. В программе 3 именованная константа arraySize используется для задания размера массива S в объявлении int S[arraySize];.

Использование именованных констант для задания размеров массивов делает программу более масштабируемой. В программе 3 первый цикл for мог бы заполнять 1000-элементный массив, если просто измененить значение arraySize в его объявлении с 10 на 1000. Если бы мы не использовали именованную константу arraySize, мы должны были бы изменить программу в трех разных местах, чтобы масштабировать программу для обработки массива из 1000 элементов. В больших программах эта техника становится более полезной для написания понятных программ.

Замечание по технике программирования

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

Программа 4

Программа суммирует значения, которые содержатся в массиве A из 12 целых чисел. Суммирование осуществляется в теле цикла for. Значения, используемые в качестве начальных для массива A, вводятся в программу пользователем с клавиатуры.

#include <iostream.h>

void main()
{
 const int arraySize = 12;
 int A[arraySize]; // объявление массива

 cout << "Введите массив из 12 элементов. \n";
 
 // инициализация массива
 for (int j = 0; j < arraySize; j++)
 {
 // вывод на экран приглашения ввести очередной элемент массива
 cout << "A[" << j << "]= "; 
 
 /* введенное пользователем значение считывается с клавиатуры и 
 запоминается в текущем элементе массива А*/
 cin >> A[j];
 }
 
 int Sum = 0; /* объявление и инициализация 
 переменной для подсчета суммы */
 
 // подсчет суммы
 for (j = 0; j < arraySize; j++)
 Sum += A[j];
 
 cout << "Сумма значений элементов массива = " << Sum << '\n';
}

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

Программа 5

// бросание шестигранной кости 6000 раз
#include < iostream.h >
#include < stdlib.h >
#include < time.h >

void main()
{
 const int arraySize = 6;
 int face, // объявление переменной face
 
 frequency[arraySize] = {0}; /* объявление массива и инициализация 
 его нулевыми значениями */
 
 srand (time(NULL));
 
 for(int i = 0; i < 6000; i++)
 {
 // имитация броска игральной кости
 face = rand() % 6 + 1;
 
 /* увеличение значения соответсвующего элемента 
 массива на 1 */
 ++ frequency[face];
 }

 // вывод результатов на экран
 cout << "Face" << '\t' << "Frequency\n";

 for (face = 0; face < arraySize; face++)
 cout << face + 1 << '\t' << frequency[face] << '\n';
}

Программа нахождения количества отрицательных элементов массива
Рассмотрим следующую задачу: необходимо ввести с клавиатуры N элементов 
массива и подсчитать количество отрицательных элементов.
#include <iostream.h>

void main()
{
 const int n = 10; // Размерность массива
 
 int a[n]; // Объявление массива

 for(int i = 0; i < n; i++)
 {
 cout << "Input the a[" << i << "] element:\t";
 cin >> a[i]; // Ввод значений массива
 }

 int count = 0; // Счетчик отрицательных элементов

 for(i = 0; i < n; i++)
 if(a[i] < 0)
 count++; // Подсчет
 
 cout << endl;

 for(i = 0; i < n; i++) 
 cout << a[i] << "\t"; // Вывод исходного массива

 cout << "\nNumber of negative elements:\t" << count << endl;
 // Вывод результатов подсчета
}

Программа нахождения минимального и максимального элементов массива
Рассмотрим задачу нахождения минимального и максимального элементов 
массива.
#include <iostream.h>

void main()
{
 const int n = 10; // Размерность массива

 float a[n]; // Объявление массива

 for(int i = 0; i < n; i++)
 {
 cout << "Input the a[" << i << "] element:\t";
 cin >> a[i]; // Ввод значений массива
 }

 float Min, Max; // Минимум и максимум
 Min = Max = a[0]; // инициализируются первым элементом массива
 
 for(i = 1; i < n; i++) // Сравнение с текущим элементом
 if(a[i] > Max)
 Max = a[i]; // Текущий максимальный элемент
 else if(a[i] < Min)
 Min = a[i]; // Текущий минимальный элемент
 
 cout << endl;

 for(i = 0; i < n; i++) 
 cout << a[i] << "\t"; // Вывод исходного массива

 cout << "\nMin element:\t" << Min << "\nMax element:\t" << Max << endl;
 // Вывод результатов поиска
}
В данной программе обе переменные Min и Max изначально инициализируются 
первым элементом массива. Затем в цикле идет проверка: если текущий элемент 
массива больше Max, то переменной Max присваивается текущий элемент. И наоборот, 
если текущий элемент массива меньше Min, то переменной Min присваивается текущий 
элемент.