Массивы

Массив представляет набор однотипных данных. Формальное определение массива выглядит следующим образом:

тип_переменной название_массива [длина_массива]

После типа переменной идет название массива, а затем в квадратных скобках его размер. Например, определим массив из 4 чисел:

int numbers[4];

Число элементов массива также можно определять через константу:

const int n = 4;
int numbers[n];		// содержит 4 элемента

Некоторые компиляторы (например, G++) также поддерживают установку размера с помощью переменных.

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

int numbers[4] {};	 //  {0, 0, 0, 0}

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

Также мы можем указать конкретные значения для всех элементов массива:

int numbers[4] {1, 2, 3, 4};

В данном случае в памяти выделяется некоторая область из четырех ячеек по 4 байта (размер типа int), где каждая ячейка содержит определенный элемент массива:

numbers[0]	numbers[1]	numbers[2]	numbers[3]
1	2	3	4

Если значений в инициализаторе меньше, чем элементов в массиве, то значения передаются первым элементам, а остальные получают нулевые значения:

int numbers[4] {1, 2};	 //  {1, 2, 0, 0}

Если значений в инициализаторе больше, чем элементов в массиве, то при компиляции возникнет ошибка:

int numbers[4] {1, 2, 3, 4, 5, 6};	 // ! Ошибка

Здесь массив имеет размер 4, однако ему передается 6 значений.

Если размер массива не указан явно, то он выводится из количества переданных значений:

int numbers[] {1, 2, 3, 4, 5, 6};

В данном случае в массиве есть 6 элементов.

При этом не допускается присвоение одному массиву другого массива:

int nums1[] {1,2,3,4,5};
int nums2[] = nums1;	// ошибка

Индексы. Получение и изменение элементов массива

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

int n = numbers[1];

Изменение значения второго элемента:

numbers[1] = 123;

Например, получим и изменим значения элементов:

#include <iostream>

int main()
{
	int numbers[4]{1,2,3,4};
	int first = numbers[0];		// получаем первый элемент
	std::cout << first << std::endl;	// 1
	numbers[0] = 34;					/ изменяем значение элемента
	std::cout << numbers[0] << std::endl; // 34
}

При обращении по индексу следует учитывать, что мы не можем обратиться по несуществующему индексу. Так, если в массиве 4 элемента, то мы можем использовать индексы с 0 до 3 для обращения к его элементам. Использование любого другого индекса приведет к ошибке:

int numbers[4]{1,2,3,4};
int forth = numbers[4];		// !Ошибка - в массиве только 4 элемента 

Константные массивы

Если необходимо, чтобы нельзя было изменять значения элементов массива, то такой массив можно определить как константный с помощью ключевого слова const

const int numbers[4]{1,2,3,4};
// numbers[1] = 23;    // ошибка - значения элементов массива изменить нельзя

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

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

#include <iostream>
 
int main()
{   
    int numbers[]{11, 12, 13, 14};
    std::cout << "Length: " << sizeof(numbers) / sizeof(numbers[0]) << std::endl;   // Length: 4
}

По сути длина массива равна совокупной длине его элементов. Все элементы представляют один и тот же тип и занимают один и тот же размер в памяти. Поэтому с помощью выражения sizeof(numbers) находим длину всего массива в байтах, а с помощью выражения sizeof(numbers[0]) - длину одного элемента в байтах. Разделив два значения, можно получить количество элементов в массиве.

Второй способ представляет применение встроенной библиотечной функции std::size():

#include <iostream>
 
int main()
{   
    int numbers[]{11, 12, 13, 14};
    int count = std::size(numbers);
    std::cout << "Length: " << count << std::endl;   // Length: 4
}

Перебор массивов

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

#include <iostream>
 
int main()
{   
    const int n = 4;
    int numbers[n] {11, 12, 13, 14};
    for(int i=0; i < n; i++)
    {
        std::cout << numbers[i] << std::endl;
    }
}

Чтобы пройтись по массиву в цикле, надо знать его длину. Здесь длина задана константой n.вначале надо найти длину массива. И в цикле for перебираем все элементы, пока счетчик i не станет равным длине массива. В итоге на консоль будут выведены все элементы массива:

11
12
13
14

Другой пример - вычислим сумму элементов массива:

#include <iostream>
 
int main()
{   
    int numbers[]{1, 2, 3, 4};
    int sum {};
    for (int i {}; i < std::size(numbers); sum += numbers[i++]);
    std::cout << "Sum: " << sum << std::endl;   // Sum: 10
}

Здесь длина массива вычисляется динамически - с помощью функции std::size().

Перебор элементов в стиле for-each

Используем другую форму цикла for, которая предназначена специально для перебора последовательностей, в том числе для массивов

#include <iostream>

int main()
{
	int numbers[4] {1,2,3,4};
	for(int n : numbers)
	{
		std::cout << n << std::endl;
	}
}

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

Если нам неизвестен тип объектов в массиве, то мы можем использовать спецификатор auto для определения типа:

for(auto n : numbers)
{
	std::cout << n << std::endl;
}

Ввод значений массива с консоли

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

#include <iostream>
 
int main()
{
    const int max {6};     // максимальная длина массива - не больше 6 чисел
    int numbers[max];       // массив для ввода чисел
 
    int i{};        // счетчик введенных чисел
    std::cout << "Enter numbers" << std::endl;
    while(i < max)
    {
        std::cin >> numbers[i];    // вводим число
        i++;
    }
    // выводим массив
    for (i =0; i < max; ++i)
    {
        std::cout << numbers[i] << "\t";
    }
    std::cout << std::endl;
}

Здесь в цикле сначала вводятся шесть чисел для каждого элемента массива, затем выводим этот массив.