Массивы чрезвычайно важная тема в C++. В программах они используются очень часто и разобраться в этой теме необходимо досконально. Сразу вас обрадую – понять и научиться применять массивы достаточно просто даже начинающему.

Итак, зачем же нужны массивы и что они из себя представляют? К настоящему моменту вы уже хорошо знаете, что данные программы хранятся в объявленных нами . Но бывает так, что программе необходимо хранить сотни (а то и больше) переменных однотипных данных, а также необходимо с ними работать – присваивать значения, изменять их и т.д.

К примеру, надо хранить порядковые номера строк. Согласитесь – любому станет страшно от мысли, что надо создать пятьсот переменных типа int, каждой дать уникальное имя и присвоить значение от 1-го до 500-та. (мне уже страшно:) В таком случае, массивы нас просто спасут.

Отметим основное и перейдем к практическому примеру:

• массив в С++ – это совокупность определенного количества однотипных переменных, имеющих одно имя. К примеру, int array ; . Эта запись означает, что мы объявили массив с именем array , который содержит в себе 3 переменные типа int ;
• переменные массива называют элементами;
• каждый элемент имеет свой уникальный индекс – свой порядковый номер. Используя индекс мы можем обращаться к конкретному элементу. ВАЖНО – индексация элементов массива начинается с 0 . Так в массиве int array первый элемент имеет индекс 0 , а последний – 2 . Чтобы обратиться, например, к нулевому элементу массива и изменить его значение, надо указать имя массива и в квадратных скобках указать индекс элемента – array = 33 .

Рассмотрим пример:

массивы C++

// в этой программе создаем массив с размером size, // с помощью цикла for вносим данные во все ячейки // массива и отображаем их содержимое на экран #include using namespace std; int main() { setlocale(LC_ALL, "rus"); const int SIZE = 10; //объявляем константу int firstArray; //объявляем массив с количеством элементов SIZE for (int i = 0; i < SIZE ; i++) //заполняем и отображаем значения на экран { firstArray[i] = i + 1; // на первом шаге цикла firstArray присвоить 1 (0 + 1) cout << i << "-я ячейка хранит число " << firstArray[i] << endl; } cout << endl; return 0; }

// в этой программе создаем массив с размером size, // с помощью цикла for вносим данные во все ячейки // массива и отображаем их содержимое на экран #include using namespace std ; int main () setlocale (LC_ALL , "rus" ) ; const int SIZE = 10 ; //объявляем константу int firstArray [ SIZE ] ; //объявляем массив с количеством элементов SIZE for (int i = 0 ; i < SIZE ; i ++ ) //заполняем и отображаем значения на экран firstArray [ i ] = i + 1 ; // на первом шаге цикла firstArray присвоить 1 (0 + 1) cout << i << "-я ячейка хранит число " << firstArray [ i ] << endl ; cout << endl ; return 0 ;

В строке 12 мы определяем целочисленную константу SIZE , которая будет хранить размер массива (определённое нами, количество его элементов). В строке 13 объявляем массив: указываем тип данных, которые будут храниться в ячейках массива, даем имя и указываем размер в квадратных скобках.

Важно, что в квадратные скобки мы можем записывать только целые константные значения. Надо либо сразу вписать целое число в квадратные скобки при объявлении массива (int firstArray; ), либо определить целочисленную константу до объявления массива и ввести в квадратные скобки имя этой константы (как в нашем примере).

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

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

Можете попробовать в нашем примере внести любую другую цифру в константу SIZE . И вы увидите, что программа будет прекрасно работать – создаст массив на столько элементов, на сколько вы укажете, внесет данные и отобразит их на экране.

А если массив совсем небольшой, к примеру на 5 элементов, инициализировать его можно сразу при объявлении:

Так элементу с индексом 0 – firstArray – будет присвоено значение 11 , а последнему элементу массива firstArray – значение 1 5 . Есть такая фишка – вы можете не указывать размер массива в квадратных скобках и сделать такую запись:

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

Так же при начальной инициализации элементов массива, когда массив необходимо очистить от «мусора» (остаточных данных других программ в памяти) лучше сразу присвоить всем элементам значение 0 . Это выглядит так:

Следует запомнить, что такая инициализация возможна только для заполнения нулями. Если необходимо заполнить элементы массива какими-либо другими числами, лучше применять цикл. В C++11 (стандарт кодирования) при использовании списковой инициализации (инициализации с фигурными скобками) разрешается даже отбросить знак = .

Хочется показать еще один прием инициализации при создании массива. К примеру, для массива из 30-ти элементов нам надо внести значения 33 и 44 только в ячейки с индексом 0 и 1 соответственно, а остальные заполнить нулями. Тогда делаем так:

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

Организовать заполнение массива можно и при помощи оператора cin :

for (int i = 0; i < size; i++) //заполняем и выводим значения на экран { cout << "Введите значение в ячейку №" << i << " :"; cin >> firstArray[i]; }

for (int i = 0 ; i < size ; i ++ ) //заполняем и выводим значения на экран

Последнее обновление: 17.09.2017

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

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

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

Int numbers;

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

Int numbers = {1,2,3,4};

Значения в фигурных скобках еще называют инициализаторами. Если инициализаторов меньше, чем элементов в массиве, то инициализаторы используются для первых элементов. Если в инициализаторов больше, чем элементов в массиве, то при компиляции возникнет ошибка:

Int numbers = {1, 2, 3, 4, 5, 6};

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

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

Int numbers = {1, 2, 3, 4, 5, 6};

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

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

Char s1 = {"h", "e", "l", "l", "o"}; char s2 = "world";

Причем во втором случае массив s2 будет иметь не 5 элементов, а 6, поскольку при инициализации строкой в символьный массив автоматически добавляется нулевой символ "\0".

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

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

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

#include int main() { int numbers = {1,2,3,4}; int first_number = numbers; std::cout << first_number << std::endl; // 1 numbers = 34; // изменяем элемент std::cout << numbers << std::endl; // 34 return 0; }

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

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

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

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

#include int main() { int numbers = {1,2,3,4}; int size = sizeof(numbers)/sizeof(numbers); for(int i=0; i < size; i++) std::cout << numbers[i] << std::endl; return 0; }

Чтобы пройтись по массиву в цикле, вначале надо найти длину массива. Для нахождения длины применяется оператор sizeof . По сути длина массива равна совокупной длине его элементов. Все элементы представляют один и тот же тип и занимают один и тот же размер в памяти. Поэтому с помощью выражения sizeof(numbers) находим длину всего массива в байтах, а с помощью выражения sizeof(numbers) - длину одного элемента в байтах. Разделив два значения, можно получить количество элементов в массиве. А далее с помощью цикла for перебираем все элементы, пока счетчик i не станет равным длине массива. В итоге на консоль будут выведены все элементы массива:

Но также есть и еще одна форма цикла for , которая предназначена специально для работа с коллекциями, в том числе с массивами. Эта форма имеет следующее формальное определение:

For(тип переменная: коллекция) { инструкции; }

Используем эту форму для перебора массива:

#include int main() { int numbers = {1,2,3,4}; for(int number: numbers) std::cout << number << std::endl; return 0; }

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

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

For(auto number: numbers) std::cout << number << std::endl;

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

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

Int numbers;

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

Int numbers = { {1, 2}, {4, 5}, {7, 8} };

Вложенные фигурные скобки очерчивают элементы для каждого подмассива. Такой массив еще можно представить в виде таблицы:

1	2
4	5
7	8

Также при инициализации можно опускать фигурные скобки:

Int numbers = { 1, 2, 4, 5, 7, 8 };

Возможна также инициализация не всех элементов, а только некоторых:

Int numbers = { {1, 2}, {}, {7} };

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

Int numbers = { {1, 2}, {3, 4}, {5, 6} }; std::cout << numbers << std::endl; // 3 numbers = 12; // изменение элемента std::cout << numbers << std::endl; // 12

Переберем двухмерный массив:

#include int main() { const int rows = 3, columns = 2; int numbers = { {1, 2}, {3, 4}, {5, 6} }; for(int i=0; i < rows; i++) { for(int j=0; j < columns; j++) { std::cout << numbers[i] [j] << "\t"; } std::cout << std::endl; } return 0; }

Также для перебора элементов многомерного массива можно использовать другую форму цикла for:

#include int main() { const int rows = 3, columns = 2; int numbers = { {1, 2}, {3, 4}, {5, 6} }; for(auto &subnumbers: numbers) { for(int number: subnumbers) { std::cout << number << "\t"; } std::cout << std::endl; } return 0; }

Для перебора массивов, которые входят в массив, применяются ссылки. То есть во внешнем цикле for(auto &subnumbers: numbers) &subnumbers представляет ссылку на подмассив в массиве. Во внутреннем цикле for(int number: subnumbers) из каждого подмассива в subnumbers получаем отдельные его элементы в переменную number и выводим ее значение на консоль.

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

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

Массив характеризуется следующими основными понятиями:

Элемент массива (значение элемента массива) – значение, хранящееся в определенной ячейке памяти, расположенной в пределах массива, а также адрес этой ячейки памяти.
Каждый элемент массива характеризуется тремя величинами:

• адресом элемента — адресом начальной ячейки памяти, в которой расположен этот элемент;
• индексом элемента (порядковым номером элемента в массиве);
• значением элемента.

Адрес массива – адрес начального элемента массива.

Имя массива – идентификатор, используемый для обращения к элементам массива.

Размер массива – количество элементов массива

Размер элемента – количество байт, занимаемых одним элементом массива.

Графически расположение массива в памяти компьютера можно представить в виде непрерывной ленты адресов.

Представленный на рисунке массив содержит q элементов с индексами от 0 до q-1 . Каждый элемент занимает в памяти компьютера k байт, причем расположение элементов в памяти последовательное.

Адреса i -го элемента массива имеет значение

Адрес массива представляет собой адрес начального (нулевого) элемента массива. Для обращения к элементам массива используется порядковый номер (индекс) элемента, начальное значение которого равно 0 . Так, если массив содержит q элементов, то индексы элементов массива меняются в пределах от 0 до q-1 .

Длина массива – количество байт, отводимое в памяти для хранения всех элементов массива.

ДлинаМассива = РазмерЭлемента * КоличествоЭлементов

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

int sizeof (тип);

Например,

sizeof (char ) = 1;
sizeof (int ) = 4;
sizeof (float ) = 4;
sizeof (double ) = 8;

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

Для объявления массива в языке Си используется следующий синтаксис:

тип имя[размерность]={инициализация};

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

int a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // массив a из 10 целых чисел

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

int b = {0}; // массив b из 10 элементов, инициализированных 0

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

int a = {1, 2, 3, 4, 5, 6, 7, 8, 9};

При обращении к элементам массива индекс требуемого элемента указывается в квадратных скобках .

Пример на Си

1
2
3
4
5
6
7
8

#include
int main()
{
int a = { 5, 4, 3, 2, 1 }; // массив a содержит 5 элементов
printf("%d %d %d %d %d\n" , a, a, a, a, a);
getchar();
return 0;
}

Результат выполнения программы:

Однако часто требуется задавать значения элементов массива в процессе выполнения программы. При этом используется объявление массива без инициализации. В таком случае указание количества элементов в квадратных скобках обязательно.

int a;

Для задания начальных значений элементов массива очень часто используется параметрический цикл:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include
int main()
{
int a;
int i;
// Ввод элементов массива
for (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
// Вывод элементов массива
for (i = 0; i<5; i++)
printf("%d " , a[i]); // пробел в формате печати обязателен
getchar(); getchar();
return 0;
}

Результат выполнения программы

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

В языке Си могут быть также объявлены многомерные массивы. Отличие многомерного массива от одномерного состоит в том, что в одномерном массиве положение элемента определяется одним индексом, а в многомерном - несколькими. Примером многомерного массива является матрица.

Общая форма объявления многомерного массива

тип имя[размерность1][размерность2]...[размерностьm];

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

int a;

будет расположен в памяти следующим образом

Общее количество элементов в приведенном двумерном массиве определится как

КоличествоСтрок * КоличествоСтолбцов = 2 * 3 = 6.

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

КоличествоЭлементов * РазмерЭлемента = 6 * 4 = 24 байта.

Инициализация многомерных массивов

Значения элементов многомерного массива, как и в одномерном случае, могут быть заданы константными значениями при объявлении, заключенными в фигурные скобки {} . Однако в этом случае указание количества элементов в строках и столбцах должно быть обязательно указано в квадратных скобках .

Пример на Си

1
2
3
4
5
6
7
8
9

#include
int main()
{
int a = { 1, 2, 3, 4, 5, 6 };
printf("%d %d %d\n" , a, a, a);
getchar();
return 0;
}

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

Пример на Си

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
int a; // массив из 2 строк и 3 столбцов
int i, j;
// Ввод элементов массива
for (i = 0; i<2; i++) // цикл по строкам
{
for (j = 0; j<3; j++) // цикл по столбцам
{
printf("a[%d][%d] = " , i, j);
scanf("%d" , &a[i][j]);
}
}
// Вывод элементов массива
for (i = 0; i<2; i++) // цикл по строкам
{
for (j = 0; j<3; j++) // цикл по столбцам
{
printf("%d " , a[i][j]);
}
printf("\n" ); // перевод на новую строку
}
getchar(); getchar();
return 0;
}

Передача массива в функцию

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

• адрес массива,
• размер массива.

Исключение составляют функции обработки строк, в которые достаточно передать только адрес.

При передаче переменные в качестве аргументов функции данные передаются как копии. Это означает, что если внутри функции произойдет изменение значения параметра, то это никак не повлияет на его значение внутри вызывающей функции.

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

Пример на Си Дан массив из 10 элементов. Поменять местами наибольший и начальный элементы массива. Для операций поиска максимального элемента и обмена использовать функцию.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#define _CRT_SECURE_NO_WARNINGS
#include
// Функция обмена
void change(int *x, int n)
{
// x - указатель на массив (адрес массива)
// n - размер массива
int i;
int max, index;
max = x;
index = 0;
// Поиск максимального элемента
for (i = 1; i {
if (x[i]>max)
{
max = x[i];
index = i;
}
}
// Обмен
x = x;
x = max;
}
// Главная функция
int main()
{
int a;
int i;
for (i = 0; i<10; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]);
}
change(a, 10); // вызов функции обмена
// Вывод элементов массива
for (i = 0; i<10; i++)
printf("%d " , a[i]);
getchar();
getchar();
return
p = p * x[i];
}
return p;
}
// Главная функция
int main()
{
int a; // объявлен массив a из 5 элементов
int i;
int pr;
// Ввод элементов массива
for (i = 0; i<5; i++)
{
printf("a[%d] = " , i);
scanf("%d" , &a[i]); // &a[i] - адрес i-го элемента массива
}
pr = func(a, 5); // вычисление произведения
printf("\n pr = %d" , pr); // вывод произведения четных элементов
getchar(); getchar();
return 0;
}

Пожалуйста, приостановите работу AdBlock на этом сайте.

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

Рис.1 Переменные и массивы. Аналогия с коробками.

На картинке выше изображено три массива:

• целочисленный массив из 8 элементов с именем arr_int
• вещественный массив из 11 элементов с именем arr_float
• символьный массив из 6 элементов с именем arr_char

У массива, как и у переменной, имеются свои имя и тип данных. Кроме того, у массива ещё есть одна дополнительная характеристика – размер массива. Размер массива – количество элементов, которые могут в нём храниться. В нашей аналогии с коробочками это количество коробок.

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

Нумерация элементов массива начинается с нуля, а не с единицы.

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

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

Листинг 1.

Int arr_int; double arr_float; float number;

На имя массива накладываются ограничения, аналогичные тем, которые накладываются на имя переменной.

Правило именования массивов

Имя массива – любая последовательность символов, цифр и знака нижнего подчеркивания «_», которая начинается с буквы. Регистр букв важен.

Вот ещё несколько примеров объявления массивов:

Листинг 2.

Int grades, order; double prices;

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

Листинг 3.

Int arr_int = {2, 5, 5, 3, 4}; double arr_float = {1.2, -2.3, 4.5, 3.83, 0.01, -0.12, 44.2, 123.7, 23.44, -3.7, 7};

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

Листинг 4.

Double arr = {0};

Работа с отдельными элементами массива

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

Давайте, например, выведем элементы массива из пяти элементов на экран.

Листинг 5.

#include int main(void){ int arr = {2, 4, 3, 5, 5}; printf("%d %d %d %d %d\n",arr, arr, arr, arr, arr); return(0); }

Конечно, если массив будет очень большой, то выводить его поэлементно подобным образом то ещё удовольствие. Да и с маленькими массивами так никто не делает. Лучше и правильнее использовать циклы. Например:

Листинг 6.

#include int main(void){ int arr = {0}; for(int i = 0; i < 100; i = i + 1){ arr[i] = 2*i; } for(int i = 0; i < 100; i = i + 1){ printf("%d\t",arr[i]); } return(0); }

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

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

Листинг 7.

#include #include #include int main(void) { srand(time(NULL)); int count = {0}; int rand_number; for (int i = 0; i < 100000; i = i + 1){ rand_number = rand()%3; count = count + 1; } for(int i = 0; i < 3; i = i + 1){ printf("%d - %d\n", i, count[i]); } return 0; }

Обратите внимание на приём, который используется в этой программе.
В нулевом элементе массива хранится количество выпадений числа 0 , в первом элементе – количество выпадений числа 1 , во втором элементе – числа 2 . То есть само сгенерированное число позволяет определить, к какому элементу массива необходимо добавить единичку. Поэтому необходимость в операторе выбора switch отпадает. Удобно, не так ли?

Массивы предназначены для хранения множества значений одного типа. Например, в программе Fahrenheit to Celsius, мы высчитывали среднее значение температуры из трёх. Если значений не три, а намного больше, то тут как раз и нужно использовать массивы.

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

int array;

В этом коде мы определили массив с идентификатором (именем) array (массив) из десяти элементов типа int.
В таком виде, все элементы массива ещё неинициализированы. Чтобы инициализировать их при обьявлении, нужно использовать следующий синтаксис:

int array = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

При этом, первому элементу массива присваивается значение 0, а последнему - значение 9.
Чтобы присвоить элементам массива значение, можно воспользоваться циклами. Самым подходящим для этого будет цикл for.

код на языке c++ int array; //определение массива for (int i = 0; i < 10; i++) { array[i] = i; }

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

Заметьте, что нумерация индексов начинается с нуля. Поэтому число индексов всегда на единицу меньше числа элементов массива.

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

Строки

До сих пор мы могли хранить строки только в константах: "Пример константной строки". В переменных мы могли хранить только один символ - в типе char. В C++ используется два типа строк: массив элементов типа char и тип str. Сейчас мы сосредоточимся на первом варианте.

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

char string = {"с","т","р","о"."к","а"};

К счастью есть более простой способ:)

char string = "строка";

В данном случае автоматически создастся массив из семи элементов. Почему из семи? Дело в том что каждая строка должна заканчиваться символьной константой "\0", которая представляет пустой байт.

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

char string; // string может хранить шесть символов и "\0"

string = "строка!"; // в строке содержится семь символов
Так делать не рекомендуется:)

Ещё один момент на который я хочу обратить ваше внимание. В случае, когда пользователь вводит строку, пробелы считаются за "\0". Мы пока не будем вводить строки в наших программах, поэтому я не буду подробно объяснять данный случай.

Массивы массивов (двумерные массивы)

Ну и наконец-то мы подошли к самому важному в этом выпуске.

Карта в стратегических (и не только) играх (RTS) делится на клетки (в английском - tile, плитка). Эти клетки удобно представлять с помощью двумерного массива.

В данном примере мы продолжим работать с программой pseudo_game и с помощью двумерного массива смоделируем карту по которой может перемещаться игрок. До сих пор "перемещиение" представлялось с помощью координат x, y.

Клетки мы будем представлять символами. Размер "карты" - 15x20. Пятнадцать в высоту, двадцвать в ширину. Игрока мы будем представлять символом Т.

Сначала добавьте заголовочный файл stdlib.h.

Усовершенствованная pseudo_game

Я приведу только куски кода. Желательно чтобы у вас перед глазами была полная программа. Найти её Вы можете в разделе "листинги программ" - pseudo_game_0_2. Она компилируется и запускается. Просто скопируйте её в редактор вашей IDE и следите за текстом.

Инициализация данных:

код на языке c++ char act; // переменная для считывания ввода пользователя int ch; // переменная для хранения приведённого значения переменной act int x = 0; // две переменные для хранения координат игрока int y = 0; char map; // массив для хранения игровой карты // инициализация массива for (int i = 0; i < 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

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

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

Приведу подробный пример: после нескольких итераций внешнего цикла, счётчик i становится равным 9. Начинает выполняться тело внешнего цикла: переменная j (счётчик внутреннего цикла) инициализируется нулём, проверяется условие и выполняется тело внутреннего цикла: map = " ";, То есть первому символу (индекс ноль) десятой строки (не забывайте что отсчёт ведётся с нуля) присваивается пробел. Затем, счётчику j присваивается 1, выполняется тело цикла... и так до тех пор пока счётчик j не станет равным 20 - условие не выполняется и происходит выход из внутреннего цикла. Затем инкрементируется внешний счётчик. Теперь он равен 10 и снова выполняется тело внешнего цикла...

После инициализации пробелами мы в первый столбец первой строки помещаем персонажа нашей игры.

В начале основного цикла мы вызываем функцию system() для очистки экрана от прошлого вывода.

Затем идут два цикла похожие на циклы инициализации. Они используются для вывода элементов массива на экран. Единственным существенным отличием является вывод символа новой строки в конце тела первого цикла.

Ну а дальше идёт ветвление в котором определяется какая клавиша нажата. Само ветвление мало изменилось с прошлого раза, а вот в содержимом блоков есть отличия: во-первых мы присваиваем координатам на которых стоит объект пробел. То есть мы очищаем предыдущее место. Затем мы изменяем одну из координат. И затем, элементу массива с новыми индексами, мы присваиваем символ "T".

Пример для кода "75" - движение влево:

код на языке c++ if else (ch == 75) { map[x][y] = " "; y--; map[x][y] = "T"; }

Ну, вот в общем и всё. На данный момент у нас есть карта 15х20 по которой с помощью стрелочек можно перемещать персонаж - букву "T". Для шестого урока неплохо! Данное приложение станет основой для всех наших консольных программ. Никаких графических улучшений не будет. Большего из досовской консоли просто не выжать, а консоль windows мы рассматривать не будем. Это существенно сэкономит время и силы.

Я подробно закомментировал программу pseudo_game и Вы скорее всего без труда в ней разберётесь. Если нет, то перечитывайте листинг программы и этот выпуск пока не разберётесь:). Закрепить материал вам помогут упражнения. Выполнение упражнений обязательно. Если что непонятно, пишите на мой e-mail - постараюсь помочь.

Упражнения:

1. В полном листинге программы я использовал ветвление switch. Здесь же показан код одного блока ветвления if. Допишите остальные блоки if.

2. Сейчас в программе возможна запись в несуществующие элементы массива. Сделайте проверку на выход за пределы карты.

3. Для практики создайте программу рисующую на экране два поля для морского боя. Первое - игрока, второе - противника. Второе поле должно располагаться справа от первого.
Внутренние клетки заполняйте пробелом. Для рисования границы используйте минус и прямую разделительную черту: -, |, а для углов - решётку #. Слева от каждого поля - стобик цифр; сверху - буквы.
Для инициализации всего поля вам может понадобиться несколько циклов. Вот как может выглядеть код для заполнения столбика цифр второго поля:

код на языке c++ int string; // переменная представляющая строки int column; // переменная представляющая столбцы char map; column = 15; for (string = 2; string < 12; string++) { map = string - 1; }