Массивы в C++ | Объявить | Инициализировать | Указатель на примеры массивов

Зачем нужны массивы?

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

Объявить массив в C++

Объявление массива в C++ включает в себя указание типа, а также количества элементов, которые будут храниться в массиве. Синтаксис:

type array-Name [ array-Size ];

Правила объявления одномерного массива в C++.

• Тип: Тип — это тип элементов, которые будут храниться в массиве, и он должен быть допустимым. C++ тип данных.
• Имя массива: Имя массива — это имя, которое будет присвоено массиву.
• Размер массива: Размер массива — это количество элементов, которые будут храниться в массиве. Оно должно быть целым числом и больше 0.

Например, вы можете создать массив с именем age и сохранить возраст 5 учеников следующим образом:

int age[5];

Массив age будет хранить 5 целых чисел, представляющих возраст разных учеников.

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

Инициализация массива — это процесс присвоения/сохранения элементов массива. Инициализация может выполняться в одном операторе или по одному. Обратите внимание, что первый элемент массива хранится с индексом 0, а последний элемент — с индексом n-1, где n — общее количество элементов в массиве.

В случае массива age первый элемент будет храниться с индексом 0, а последний элемент — с индексом 4.

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

int age[5] = {19, 18, 21, 20, 17};

Общее количество элементов в { } не может превышать значение, указанное в [ ]. Элемент 19 имеет индекс 0, 18 — индекс 1, 21 — индекс 2, 20 — индекс 3 и 17 — индекс 4. Если вы не укажете количество элементов, которые будут храниться в массиве в пределах [ ], массив будет достаточно большим, чтобы вместить элементы, добавленные в { }. Например:

int age[] = {19, 18, 21, 20, 17};

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

age[3] = 20;

Приведенный выше оператор сохранит значение 20 в индексе 3 массива с именем age. Это значит, что 20 будет 4^th элемент массива.

Типы массивов

Есть два типа C++ массивы:

• Одномерный массив
• Многомерный массив
• Указатель на массив

Одномерный массив

Это массив, в котором элементы данных расположены линейно только в одном измерении. Его обычно называют одномерным массивом. Синтаксис:

datatype array-name[size];

• Имя массива — это имя массива.
• Размер — это количество элементов, которые будут храниться в массиве.

Например:

#include <iostream>
using namespace std;

int main()
{
	int age[5] = { 19, 18, 21, 20, 17 };
	for (int x = 0; x < 5; x++)
	{
		cout <<age[x]<<"\n";
	}
}

Вывод:

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

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

1. Включение заголовочного файла iostream в наш код. Это позволит нам читать и писать в консоль.
2. Включая пространство имен std, чтобы использовать его классы и функции без его вызова.
3. Вызов функции main(), внутри которой должна быть добавлена ​​логика программы.
4. Начало тела функции main().
5. Объявление массива с именем age для хранения 5 целых чисел. 5 целых чисел также были инициализированы.
6. Создайте целочисленную переменную x, используя цикл for.
7. Начало тела цикла for.
8. Использование переменной цикла x для перебора значений возраста массива и вывода их на консоль. «\n» — это символ новой строки, который печатается на новой строке после каждой итерации.
9. Конец тела для цикла.
10. Конец тела функции main().

Многомерный массив

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

datatype array-name[d1][d2][d3]...[dn];

Имя массива — это имя массива, который будет иметь n измерений. Например:

Двумерный массив

Двумерный массив хранит данные в списке с одномерным массивом. Это матрица со строками и столбцами. Чтобы объявить двумерный массив, используйте следующий синтаксис:

type array-Name [ x ][ y ];

Тип должен быть допустимым C++ тип данных. Рассматривайте двумерный массив как таблицу, где x обозначает количество строк, а y обозначает количество столбцов. Это означает, что вы идентифицируете каждый элемент в двумерном массиве, используя форму a[x][y], где x — номер строки, а y — количество столбцов, которым принадлежит элемент.

Вот пример того, как инициализировать 2D-массив:

int a[2][3] = {  
   {0, 2, 1} ,   /*  row at index 0 */
   {4, 3, 7} ,   /*  row at index 1 */
   };

В приведенном выше примере у нас есть двумерный массив, который можно рассматривать как матрицу 2×2. Есть 3 строки и 2 столбца. Доступ к элементу 3 можно получить как a[0][0], поскольку он расположен на пересечении строки с индексом 1 и столбца с индексом 0. Доступ к элементу 1 можно получить как a[3][1], поскольку он расположен в пересечение строки с индексом 2 и столбца с индексом 1.

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

int a[2][3] = {0, 2, 1, 4, 3, 7};
   };

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

#include <iostream>
using namespace std;
int main() 
{
	// a 2x3 array
	int a[3][2] = { {0, 2}, {1, 4}, {3, 7} };

	// traverse array elements

	for (int i=0; i<3; i++)
		for (int j=0; j<2; j++) 
		
		{
			cout << "a[" <<i<< "][" <<j<< "]: ";
			cout << a[i][j] << endl;
		}
	return 0;
}

Вывод:

Вот скриншот приведенного выше кода:

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

1. Включение заголовочного файла iostream в наш код. Это позволит нам читать и писать в консоль.
2. Включая пространство имен std, чтобы использовать его классы и функции без его вызова.
3. Вызов функции main(), в которую необходимо добавить код.
4. Начало тела функции main().
5. Комментарий. C++ компилятор пропустит это.
6. Объявление двумерного массива из 2 строк и 3 столбцов. В массив также были добавлены элементы.
7. Комментарий. C++ компилятор пропустит это.
8. Создание переменной с использованием цикла for. Эта переменная будет перебирать индексы строк массива.
9. Создание переменной j с помощью цикла for. Эта переменная будет перебирать индексы столбцов массива.
10. Начало тела цикла.
11. Выведите значения переменных i и j на консоли внутри квадратных скобок на консоли.
12. Распечатайте значение, хранящееся по индексу [i][j] массива a.
13. Конец тела петель.
14. Функция main() должна возвращать целочисленное значение, если программа работает нормально.
15. Конец тела функции main().

Трехмерный массив

3D-массив — это массив массивов. Каждый элемент трехмерного массива идентифицируется набором из трех индексов. Для доступа к элементам трехмерного массива мы используем три цикла for. Например:

#include<iostream>
using namespace std;
void main()
{
	int a[2][3][2] = {{{4, 8},{2, 4},{1, 6}}, {{3, 6},{5, 4},{9, 3}}};
	cout << "a[0][1][0] = " << a[0][1][0] << "\n";
	cout << "a[0][1][1] = " << a[0][1][1] << "\n";
}

Вывод:

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

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

1. Включение заголовочного файла iostream в наш код. Это позволит нам читать и писать в консоль.
2. Включая пространство имен std, чтобы использовать его классы и функции без его вызова.
3. Вызов функции main(), внутри которой должна быть добавлена ​​логика программы.
4. Начало тела функции main().
5. Объявление трехмерного массива с именем an размером 3x2x3. Значения массива также были инициализированы.
6. Доступ к элементу, хранящемуся по индексу [0][1][0] массива, и его печать на консоли.
7. Доступ к элементу, хранящемуся по индексу [0][1][1] массива, и его печать на консоли.
8. Конец тела функции main().

Указатель на массив

A указатель — это переменная, содержащая адрес. Помимо использования указателя для хранения адреса переменной, мы можем использовать его для хранения адреса ячейки массива. Имя массива всегда указывает на его первый элемент. Рассмотрим декларацию, приведенную ниже:

int age[5];

Возраст — это указатель на $age[0], адрес первого элемента массива с именем age. Рассмотрим следующий пример:

#include <iostream>
using namespace std;
int main()
{
	int *john;

	int age[5] = { 19, 18, 21, 20, 17 };

	john = age;

	cout << john << "\n";

	cout << *john;
	
}

Вывод:

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

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

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

1. Включение заголовочного файла iostream в наш код. Это позволит нам читать и писать в консоль.
2. Включая пространство имен std, чтобы использовать его классы и функции без его вызова.
3. Вызов функции main(), внутри которой должна быть добавлена ​​логика программы.
4. Начало тела функции main().
5. Объявление переменной-указателя с именем *john.
6. Объявление целочисленного массива с именем age для хранения 5 целых чисел. Значения целых чисел также были инициализированы.
7. Присвоение переменной john значения адреса элемента, хранящегося в первом индексе массива age.
8. Печать значения переменной john, которая является адресом элемента, хранящегося в первом индексе массива age.
9. Печать первого значения, хранящегося в массиве age.
10. Конец тела функции main().

Имена массивов могут использоваться как указатели на константы, и наоборот. Это означает, что вы можете получить доступ к значению, хранящемуся по индексу 3 возраста массива, с помощью *(возраст + 3). Например:

#include <iostream>
using namespace std;

int main() {
	// an array of 5 elements.
	int age[5] = { 19, 18, 21, 20, 17 };
	int *p;

	p = age;

	// output array values

	cout << "Using pointer: " << endl;

	for (int x=0; x<5; x++) {
		cout << "*(p + " << x << ") : ";
		cout << *(p + x) << endl;
	}
	cout << "Using age as address: " << endl;

	for (int x = 0; x < 5; x++) {
		cout << "*(age + " << x << ") : ";
		cout << *(age + x) << endl;
	}

	return 0;
}

Вывод:

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

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

1. Включение заголовочного файла iostream в наш код. Это позволит нам читать и писать в консоль.
2. Включая пространство имен std, чтобы использовать его классы и функции без его вызова.
3. Вызов функции main() и начало тела функции main().
4. Комментарий. C++ компилятор пропустит это.
5. Объявление массива с именем age для хранения 5 целых чисел.
6. Создание целочисленного указателя стр.
7. Присвоение p значения адреса первого элемента массива age.
8. Комментарий. C++ компилятор пропустит это.
9. Распечатайте текст на консоли.
10. Создайте целое число x, используя цикл for. { отмечает начало тела цикла for.
11. Распечатайте значения x в сочетании с другим текстом на консоли.
12. Распечатайте значения *(p + x) на консоли.
13. Конец тела цикла for.
14. Распечатайте текст на консоли.
15. Создайте переменную x, используя цикл for. { отмечает начало тела цикла for.
16. Распечатайте значения x от 0 до 4 вместе с другим текстом.
17. Распечатайте значения *(возраст + x).
18. Конец тела цикла for.
19. Возвращаемое значение, если программа работает успешно.
20. Конец тела функции main().

Доступ к значениям массива

Доступ к элементам массива осуществляется с использованием соответствующих индексов. Индекс элемента, к которому осуществляется доступ, добавляется в квадратных скобках [] сразу после имени массива. Например:

int john = age[2];

В приведенном выше примере мы просто заявляем, что возраст Джона хранится в индексе 2 массива с именем age. Это означает, что возраст Джона - 3^rd значение в массиве age. Вот полный C++ пример, показывающий, как получить доступ к этому значению и распечатать его:

#include<iostream>
using namespace std;
int main()
{
	int age[5] = { 19, 18, 21, 20, 17 };
	int john = age[2];
	cout << "The age of John is:"<<john;
}

Вывод:

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

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

1. Включение заголовочного файла iostream в наш код. Это позволит нам читать и писать в консоль.
2. Включая пространство имен std, чтобы использовать его классы и функции без его вызова.
3. Вызов функции main(), в которую необходимо добавить код.
4. Начало тела функции main().
5. Объявление массива с именем age для хранения 5 целочисленных элементов.
6. Доступ к значению, хранящемуся по индексу 2 возраста массива, и сохранение его значения в переменной с именем john.
7. Печать значения переменной john на консоли вместе с другим текстом.

Преимущества массива в C++

Вот плюсы/преимущества использования Array в C++:

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

Недостатки массива в C++

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

Итого

• Массив — это структура данных, в которой хранятся элементы одного типа данных.
• Элементы массива сохраняются последовательно.
• Элементы массива обозначаются соответствующими индексами. Первый элемент имеет индекс 0, а последний элемент имеет индекс n-1, где — общее количество элементов массива.
• Объявление массива включает определение типов данных элементов массива, а также количества элементов, которые будут храниться в массиве.
• Одномерный массив хранит элементы последовательно.
• Двумерный массив хранит элементы в строках и столбцах.
• Трехмерный массив — это массив массивов.
• Элементы можно добавлять в массив, используя их индексы.
• Доступ к элементам массива осуществляется по их индексам.
• Многомерный массив имеет более одного измерения.
• Имя массива указывает на его первый элемент.
• Массивы имеют фиксированный размер, что означает, что новые элементы не могут быть добавлены в массив после его инициализации.