Сайт о телевидении

Объявление массива в Си
Массив (Array) относится к вторичным типам данных. Массив в Си представляет собой коллекция явно определенного размера элементов определенного типа. то есть в отличие от массивов в Ruby массивы в Си являются однотипными (хранят данные только одного типа) и имеют заранее определенную длину (размер).

В Си массивы можно грубо разделить на 2 типа: массив чисел и массив символов. Разумеется, такое деление абсолютно условное ведь символы — это также целые числа. Массивы символов также имеют несколько иной синтаксис. Ниже приведены примеры объявления массивов:

Int arr; int a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; char ch = {"R","u","b","y","D","e","v",".","r","u"}; char ch2 = "сайт";

В первом случае мы объявляем массив целых чисел (4 байта на число) размером в 100 элементов. Точнее мы резервируем память для хранения 100 элементов типа int.

Во втором случае мы определяем массив из 10 целочисленных элементов и сразу же присваиваем элементам массива значения.

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

В последнем случае мы также объявляем массив символов с помощью специального — более лаконичного синтаксиса. Массивы ch и ch2 практически идентичны, но есть одно отличие. Когда для создания массива мы используем синтаксис со строковой константой, то в конец массива символов автоматически добавляется символ \0, при использовании стандартного синтаксиса обявления массива мы должны самостоятельно добавлять \0 в качестве последнего элемента массива символов. Символ \0 (null) используется для идентификации конца строки. О страках мы поговорим более подробно в отдельной статье.

Обращение к элементам массива в Си

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

#include int main() { int arr; int a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; char ch = {"R","u","b","y","D","e","v",".","r","u"} ; char ch2 = "сайт"; printf("%d\n", arr); printf("%c\n", ch); }

Код printf(«%d\n», a); напечатает 2, а не 1 потому, что индексация массивов начинается с 0 и лишнее подтверждение тому строка printf(«%c\n», ch); , которая напечатает символ «R» — нулевой элемент массива ch.

В общем случае объявление массива имеет следующий синтаксис:

тип_данных имя_переменной[<количество_элементов>] = <список, элементов, массива>

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

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

Указатели в Си
Типы данных необходимы для того, чтобы мочь выделить кусок памяти определенного размера для хранения данных и определения того, что это за данные ибо без явного определения непонятно является ли набор нулей и единиц числом, символом или чем-нибудь еще. В этом случае переменная является ссылкой на фрагмент памяти определенного размера и типа, например, int переменная ссылается на определенную область памяти объемом 4 байта, в которой хранится целое число, а char переменная ссылается на область памяти объемом 1 байт в которой хранится символ (код символа).

Чтобы получить адрес на который ссылается переменная мы используем специальный оператор & — оператор адреса (address operator), пример:

#include int main() { int arr; int a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; char ch = {"R","u","b","y","D","e","v",".","r","u"} ; char ch2 = "сайт"; int num = 100500; printf("%p\n", &arr); }

Строка printf(«%p\n», &arr); напечатает 0xbfbbe068. 0xbfbbe068 — шестнадцатеричное представление адреса памяти где хранится число 100500.

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

#include int main() { int a, b; b = a = 10; printf("A: %p\n", &a); printf("B: %p\n", &b); }

$ ./program
A: 0xbfe32008
B: 0xbfe3200c

В примере выше мы присваиваем переменным a и b одинаковое значение — число 10, но переменные a и b ссылаются на две разные области памяти, то есть мы сохраняем в памяти число 10 два раза. Если мы изменим значение переменной b, то оно это не отразится на переменной a и наоборот. Это отличается от того, как мы работаем с переменными в Ruby, где переменные — это ссылки на объекты хранимые в памяти, и при присваивании в стиле a = b = 10 мы получаем один объект — число 10 и две ссылки на него.

#include int main() { int a = 10; int * b = &a; printf("A:\n\taddress: %p\n\tvalue: %d\n",&a, a); printf("B:\n\taddress: %p\n\tvalue: %d\n",b, *b); }

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

$ ./program
A:
address: 0xbfed0fa8
value: 10
B:
address: 0xbfed0fa8
value: 10

Указатели и массивы

На самом деле в Си нет массивов в привычном для многих людей понимании. Любой массив в Си — это просто ссылка на нулевой элемент массива. Пример:

#include int main() { int a = {10,20,30}; printf("a-Address:%p\n", &a); printf("a-Address:%p\n", &a); printf("a-Value:%d\n", a); printf("a-Size:%d\n", sizeof(a)); }

Результат:

$ ./program
a-Address:0xbfc029b4
a-Address:0xbfc029b4
a-Value:10
a-Size:12

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

Когда мы запускаем программу, то операционная система предоставляет программе два особых объема памяти — стек (stack) и кучу (heap). В нашей программе используется только стек. Стек хранит значения упорядочено. Когда мы создаем массив, мы на самом деле создаем указатель ну нулевой элемент коллекции элементов и резервируем память для N-количества элементов. В примере выше мы создали коллекцию из 3 элементов типа int, т.е. каждый элемент занимает 4 байта памяти. Когда мы воспользовались функцией sizeof(), которая возвращает размер в байтах переданного ей аргумента, то получили значение 12 т.е. массив занимает 12 байт памяти: 3элемента * 4 байта. Поскольку для хранения элементов коллекции используется стек — элементы сохраняются по порядку, то есть занимают соседние области стека, а это означает, что мы можем перемещаться по коллекции зная позицию элемента и размер коллекции. Пример:

#include int main() { int a = {10,20,30,40,10}, i; for(i = 0; i <= sizeof(a)/sizeof(int); i++) printf("a[%d] has %d in %p\n", i, a[i], &a[i]); }

Результат:

$ ./program
a has 10 in 0xbfbeda88
a has 20 in 0xbfbeda8c
a has 30 in 0xbfbeda90
a has 40 in 0xbfbeda94
a has 10 in 0xbfbeda98
a has 5 in 0xbfbeda9c

Программа напечатала нам информацию о массиве из 5 элементов: номер элемента, значение и адрес в памяти. Обратите внимание на адреса элементов — это то, о чем я вам говорил. Адреса идут подряд и каждый следующий больше предыдущего на 4. В 5 элементе коллекции, которого мы на самом деле не объявляли хранится общее количество элементов коллекции. Самое интересное — это то, что мы можем аналогичным образом использовать и указатели для прохода по массиву. Пример:

#include int main() { int a = {10,20,30,40,10}, i; int * b = a; for(i = 0; i <= sizeof(a)/sizeof(int); i++) printf("a[%d] has %d in %p\n", i, *(b + i), b + i); }

Примечания

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

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

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

4. Адрес 1 элемента массива больше адреса 0 элемента массива на объем памяти выделяемой под хранение элемента данного типа. Мы работаем с элементами типа int, для хранения каждого из которых используется 4 байта. Адрес элемента массива в памяти и вообще любых данных — это адрес первого байта выделяемой под его хранение памяти.

5. Для упрощения понимания представьте, что память компьютера — это огромный кинотеатр, где места пронумерованы от 0 до, скачем 1_073_741_824. У данных типа char задница нормального размера и они помещаются в одном кресле (занимают один байт), а у толстых посетителей типа long double задницы огромные и каждый из них вмещается только на 10 сидениях. Когда у толстых посетителей кинотеатра спрашивают номер их места, они говорят только номер первого кресла, а количество и номера всех остальных кресел можно легко вычислить исходя из комплекции посетителя (типа данных). Массивы можно представить в виде групп однотипных посетителей кинотеатра, например группа худеньких балерин типа char из 10 человек займет 10 мест потому, что char вмещается в одном кресле, а группа любителей пива состоящая из 5 человек типа long int займет 40 байт.

6. У операторов & и * имеется несколько популярных названий, но вы можете называть их хоть Васей и Петей. Главное, что стоит запомнить — это:

& — показывает номер первого занятого посетителем кинотеатра сидения. То есть адрес первого занимаемого байта.

* — позволяет обратиться к посетителю сищящему на определенном месте. То есть позволяет получить значение, что хранится по определенному адресу в памяти.

На этом статья окончена, но не окончена тема массивов и указателей, а тем более изучения всего языка Си.

Responses

1. anonymouse says:
   

   Проверь, действительно ли эти два массива одинаковы:
   char ch = {‘R’,"u’,"b’,"y’,"D’,"e’,"v’,’.’,"r’,"u’};
   char ch2 = «сайт»;
   Во втором случае массив содержит на один элемент больше, /0, который используется как ограничитель при печати, копировании строк и так далее.

2. admin says:
   

   На самом деле оба массива содержат символ \0 в качестве 10 элемента, по этому они действительно одинаковы, но о символе \0 я расскажу в отдельной статье посвященной символьным массивам и строкам.

3. anonymouse says:
   

   Да, ты оказался прав, я написал тот комментарий до того как сам проверил вот этот код в GCC:
   #include
   #include

   int main(void)
   {
   char ch = {‘R’,"u’,"b’, ‘y’, ‘D’, ‘e’, ‘v’, ‘.’, ‘r’, ‘u’};
   char ch2 = «сайт»;

   printf(«%x\n», ch[ strlen(ch) ]);

   return 0;
   }
   Печатает ноль.

4. admin says:
   

   Самое интересно, что если верить спецификации ANSI C, то ты прав ведь там ничего не сказано об автодобавлении нулевого символа в конец массива символов созданного стандартным для массивов способом (и в K&R это в обоих вариантах делается явно). Думаю, это или отличие в С99 или в компиляторе дело, так как производители компиляторов реализуют возможности С99 в основном частично, а некоторые добавляют что-то свое. Теперь понятно, почему выбор компилятора так важен. Нужно будет над этим вопросом попозже поработать и написать статью о различиях компиляторов Си, поддержке ими С99 и различиях между ANSI C и C 99.

5. admin says:
   

   Провел расследование, все таки я дезинформировал тебя. В традиционном синтаксисе \0 не добавляется, это просто такое совпадение, что следующим в стеке идет символ \0, но он не относится к массиву символов. Если использовать strlen() то явно видна разница в 1 символ между традиционным синтаксисом создания массива. где символы просто перечисляются и использованием строковой константы. null-символ добавляется автоматически только в конец массива символов созданного при помощи строковой констранты.

6. andr says:
   

   Очень много вводящих в заблуждение высказываний. Такими статьями начинающих программистов только портить. :)
   Например, «В 5 элементе коллекции, которого мы на самом деле не объявляли хранится общее количество элементов коллекции.», — вот это невиданные сказки. В языке С нигде не хранится длина массивов. В этом примере происходит выход за пределы массива ‘a’, т.к. для 5-ти элементов массива последний индекс == 4, а ты его индексируешь до 5-ти. Тем самым обращаешься по адресу переменной i, которую компилятор разместил в памяти сразу после массива, поэтому на последнем цикле (когда i == 5) и получаешь в результате 5-ку на выходе.

   «Как я уже говорил, в Си нету традиционных массивов потому, я называю их коллекциями для того, чтобы подчеркнуть эту особенность Си.» — это совсем что-то непонятное. Что такое «традиционные массивы»? Коллекции, кстати, это более широкий термин. Под определение коллекций подходят массивы, списки, матрицы, стеки и даже хеш-таблицы. Зачем вводить неподходящие термины и вводить в заблуждение читателей?

7. admin says:
   

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

8. faustman says:
   

   Про худеньких балерин и группу любителей пива хорошо сказал!))

9. Myname says:
   

   А у меня gcc a, которое, вы говорите, хранит количество элементов, выдает значение 32767.

Массивы чрезвычайно важная тема в 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; }

В строке 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]; }

Продолжаем изучение основ C++. В этой статье мы рассмотрим массивы.

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

Введение в массивы

Визуализировать массив можно следующим образом:

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

Card1 = getRandomCard(); Card2 = getRandomCard(); Card3 = getRandomCard(); Card4 = getRandomCard(); Card5 = getRandomCard();

For (int i = 0; i < 5; i++) { card[i] = getRandomCard(); }

А теперь представьте разницу, если переменных 100!

Синтаксис

Для объявления массива необходимо указать две вещи (помимо имени): тип и размер массива:

Int my_array[ 6 ];

Данная строка объявляет массив из шести целочисленных значений. Обратите внимание, что размер массива заключен в квадратные скобки после имени массива.

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

My_array[ 3 ];

Визуализировать данный процесс можно так:

my_array ссылается на весь массив целиком, в то время как my_array только на первый элемент, my_array — на четвертый. Обратите внимание, что индексация элементов в массиве начинается с 0. Таким образом Обращение к элементам массива всегда будет происходить со смещением, например:

Int my_array[ 4 ]; // объявление массива my_array[ 2 ] = 2; // установить значение третьего (именно третьего!) равным 2

Объявление многомерных массивов в C++

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

Для объявления двумерного массива необходимо указать размерность двух измерений:

Int tic_tac_toe_board;

Визуализация массива с индексами его элементов:

Для доступа к элементам такого массива потребуется два индекса — один для строки второй для столбца. На изображении показаны нужные индексы для доступа к каждому из элементов.

Использование массивов

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

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

#include using namespace std; int main() { int array; // Объявляем массив, который выглядит как шахматная доска for (int i = 0; i < 8; i++) { for (int j = 0; j < 8; j++) { array[i][j] = i * j; // Задаем значения каждого элемента } } cout << "Multiplication table:\n"; for (int i = 0; i < 8; i++) { for (int j = 0; j < 8; j++) { cout << "[ " << i << " ][ " << j << "] = "; cout << array[i][j] << " "; cout << "\n"; } } }

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

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

Чтобы передать массив в функцию достаточно просто указать его имя:

Int values[ 10 ]; sum_array(values);

А при объявлении функции указать массив в качестве аргумента:

Int sum_array (int values);

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

Так как внутри функции мы не знаем размер массива, необходимо передать размерность в качестве второго аргумента:

Int sumArray(int values, int size) { int sum = 0; for (int i = 0; i < size; i++) { sum += values[ i ]; } return sum; }

Когда мы передаем многомерные массивы, надо указывать все размерности, за исключением первой:

Int check_tic_tac_toe (int board);

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

Подробнее эта тема будет раскрыта в статье про указатели.

А пока напишем функцию, которая вычисляет сумму элементов массива:

#include using namespace std; int sumArray(int values, int size) { int sum = 0; // цикл остановится когда i == size, потому что индекс последнего элемента = size - 1 for (int i = 0; i < size; i++) { sum += values[i]; } return sum; } int main() { int values; for (int i = 0; i < 10; i++) { cout << "Enter value " << i << ": "; cin >> values[i]; } cout << sumArray(values, 10) << endl; }

Сортировка массива

Решим задачу сортировки массива из 100 чисел, которые ввел пользователь:

#include using namespace std; int main() { int values[ 100 ]; for (int i = 0; i < 100; i++) { cout << "Enter value " << i << ": "; cin >> values[ i ]; } }

Готово, осталось только отсортировать этот массив 🙂 Как обычно люди сортируют массивы? Они ищут самый маленький элемент в нем и ставят его в начало списка. Затем они ищут следующее минимальное значение и ставят его сразу после первого и т.д.

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

Void sort(int array, int size) { for (int i = 0; i < size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } }

Теперь можно подумать о реализации двух вспомогательных методов findSmallestRemainingElement и swap. Метод findSmallestRemainingElement должен пробегать по массиву и находить минимальный элемент, начиная с индекса i:

Int findSmallestRemainingElement(int array, int size, int index) { int index_of_smallest_value = index; for (int i = index + 1; i < size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = I; } } return index_of_smallest_value; }

Наконец, нам надо реализовать функцию swap. Так как функция изменит оригинальный массив, нам просто надо поменять значения местами, используя временную переменную:

Void swap(int array, int first_index, int second_index) { int temp = array[ first_index ]; array[ first_index ] = array[ second_index ]; array[ second_index ] = temp; }

Для проверки алгоритма заполним массив случайными числами и отсортируем. Весь код программы:

#include #include #include using namespace std; int findSmallestRemainingElement(int array, int size, int index); void swap(int array, int first_index, int second_index); void sort(int array, int size) { for (int i = 0; i < size; i++) { int index = findSmallestRemainingElement(array, size, i); swap(array, i, index); } } int findSmallestRemainingElement(int array, int size, int index) { int index_of_smallest_value = index; for (int i = index + 1; i < size; i++) { if (array[ i ] < array[ index_of_smallest_value ]) { index_of_smallest_value = i; } } return index_of_smallest_value; } void swap(int array, int first_index, int second_index) { int temp = array[ first_index ]; array[ first_index ] = array[ second_index ]; array[ second_index ] = temp; } // вспомогательная функция для вывода массива void displayArray(int array, int size) { cout << "{"; for (int i = 0; i < size; i++) { // если элемент не первый выведем запятую if (i != 0) { cout << ", "; } cout << array[ i ]; } cout << "}"; } int main() { int array[ 10 ]; srand(time(NULL)); for (int i = 0; i < 10; i++) { array[ i ] = rand() % 100; } cout << "Original array: "; displayArray(array, 10); cout << "\n"; sort(array, 10); cout << "Sorted array: "; displayArray(array, 10); cout << "\n"; }

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

Массивы предназначены для хранения множества значений одного типа. Например, в программе 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; }

Последнее обновление: 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} };

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

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

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 и выводим ее значение на консоль.