Одновимірна масив c приклад. Статичний масив: оголошення, заповнення, використання

Масив це структура даних, представлена \u200b\u200bу вигляді групи осередків одного типу, об'єднаних під одним єдиним ім'ям. Масиви використовуються для обробки великої кількості однотипних даних. Ім'я масиву є, що таке покажчики розповім трохи пізніше. Окрема осередок даних масиву називається елементом масиву. Елементами масиву можуть бути дані будь-якого типу. Масиви можуть мати як одне, так і більш одного вимірювань. Залежно від кількості вимірювань масиви діляться на одномірні масиви, двовимірні масиви, тривимірні масиви і так далі до n-мірного масиву. Найчастіше в програмуванні використовуються одномірні і двовимірні масиви, тому ми розглянемо тільки ці масиви.

Одномірні масиви в С ++

Одновимірна масив - масив, з одним параметром, що характеризує кількість елементів одновимірного масиву. Фактично одновимірний масив - це масив, у якого може бути тільки один рядок, і n-е кількість стовпців. Стовпці в одновимірному масиві - це елементи масиву. На малюнку 1 показана структура целочисленного одновимірного масиву a. Розмір цього масиву - 16 осередків.

Малюнок 1 - Масиви в С ++

Зауважте, що максимальний індекс одновимірного масиву a дорівнює 15, але розмір масиву 16 осередків, тому що нумерація осередків масиву завжди починається з 0. Індекс осередки - це ціле невід'ємне число, за яким можна звертатися до кожної клітинки масиву і виконувати будь-які дії над нею (осередком).

// синтаксис оголошення одновимірного масиву в С ++: / * тип даних * / / * ім'я одновимірного масиву * /; // приклад оголошення одновимірного масиву, зображеного на малюнку 1: int a;

де, int -целочісленний;

А - ім'я одновимірного масиву;
16 - розмір одновимірного масиву, 16 осередків.

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

// ще один спосіб оголошення одновимірних масивів int mas, a;

Оголошено два одновимірних масиву mas і а розмірами 10 і 16 відповідно. Причому в такому способі оголошення все масиви матимуть однаковий тип даних, в нашому випадку - int.

// масиви можуть бути ініційовані при оголошенні: int a \u003d (5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // ініціалізація одновимірного масиву

Ініціалізація одновимірного масиву виконується в фігурних дужках після знака одно, Кожен елемент масиву відокремлюється від попереднього коми.

Int a \u003d (5, -12, -12,9,10,0, -9, -12, -1,23,65,64,11,43,39, -15); // ініціалізації масиву без визначення його розміру.

В даному випадку компілятор сам визначить розмір одновимірного масиву. Розмір масиву можна не вказувати тільки при його ініціалізації, при звичайному оголошенні масиву обов'язково потрібно вказувати розмір масиву. Розробимо просту програму на обробку одновимірного масиву.

// array.cpp: визначає точку входу для консольного застосування. #include "stdafx.h" #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// код Code :: Blocks

// код Dev-C ++

// array.cpp: визначає точку входу для консольного застосування. #include using namespace std; int main (int argc, char * argv) (cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

В рядках 10 - 11оголошений і ініціалізованим першим цілочисельний одномірний масив з ім'ям array1, розмір якого дорівнює 16 осередків, тобто такий масив може зберігати 16 чисел. Будь-яка обробка масиву здійсненна тільки спільно з циклами. Який цикл вибрати для обробки масиву - це вам вирішувати. Але найкраще для цього завдання підходить. Змінну-лічильник counter будемо використовувати для звернення до елементів одновимірного масиву array1. В умови продовження циклу for варто строгий знак нерівності, так як шістнадцятого індексу в одновимірному масиві array1 немає. А так як нумерація осередків починається з нуля, то елементів в масиві 16. У тілі циклу for оператор cout друкує елементи одновимірного масиву (див. Малюнок 2).

Obrabotka massiva indeks element massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 39 array1 -15 Для продовження натисніть будь-яку клавішу. . .

Малюнок 2 - Масиви в С ++

Розробимо ще одну програму на обробку одновимірного масиву в С ++. Програма повинна послідовно зчитувати десять введених чисел з клавіатури. Всі введені числа підсумувати, результат вивести на екран.

// array_sum.cpp: визначає точку входу для консольного застосування. #include "stdafx.h" #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// код Code :: Blocks

// код Dev-C ++

// array_sum.cpp: визначає точку входу для консольного застосування. #include using namespace std; int main (int argc, char * argv) (int array1; // оголошуємо цілочисельний масив cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >\u003e Array1; // зчитуємо вводяться з клавіатури числа cout<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Перед тим як виконувати обробку масиву його необхідно оголосити, причому розмір одновимірного масиву дорівнює 10, так як це обумовлено умовою завдання. В змінної sum будемо накопичувати суму елементів одновимірного масиву. Перший цикл for заповнює оголошений одновимірний масив, введеними з клавіатури числами, рядки 12 - 13. Мінлива лічильник counter використовується для послідовного доступу до елементів одновимірного масиву array1, починаючи з індексу 0 і до 9-го включно. Другий цикл for виводить на екран елементи масиву, рядки 15 - 16. Третій цикл for послідовно зчитує елементи одновимірного масиву і підсумовує їх, сума накопичується в змінної sum, рядки 17 - 18. Результат роботи програми дивитися на малюнку 3.

Enter elementi massiva: 0 1 2 3 4 5 6 7 8 9 array1 \u003d (0 1 2 3 4 5 6 7 8 9) sum \u003d 45 Для продовження натисніть будь-яку клавішу. . .

Малюнок 3 - Масиви в С ++

Спочатку послідовно були введені всі 10 чисел, після чого відобразився одновимірний масив, і надрукувалася сума чисел масиву.

Двовимірні масиви в С ++

До цього моменту ми розглядали одномірні масиви, якими не завжди можна обмежитися. Припустимо, необхідно обробити деякі дані з таблиці. У таблиці є дві характеристики: кількість рядків і кількість стовпців. Також і в двовимірному масиві, крім кількості елементів масиву, є такі характеристики як, кількість рядків і кількість стовпців двовимірного масиву. Тобто, візуально, двовимірний масив - це звичайна таблиця, з рядками і стовпцями. Фактично двовимірний масив - це одновимірний масив одновимірних масивів. Структура двовимірного масиву, з ім'ям a, розміром m на n показана нижче (див. Малюнок 4).

Малюнок 4 - Масиви в С ++

де, m - кількість рядків двовимірного масиву;
n - кількість стовпців двовимірного масиву;
m * n - кількість елементів масиву.

// синтаксис оголошення двовимірного масиву / * тип даних * / / * ім'я масиву * /;

В оголошенні двовимірного масиву, також як і в оголошенні одновимірного масиву, в першу чергу, потрібно вказати:

тип даних;
ім'я масиву.

Після чого, в перших квадратних дужках вказується кількість рядків двовимірного масиву, по-друге квадратних дужках - кількість стовпців двовимірного масиву. Двовимірний масив візуально відрізняється від одновимірного другою парою квадратних скобочек. Розглянемо приклад оголошення двовимірного масиву. Припустимо нам необхідно оголосити двовимірний масив, з кількістю елементів, рівним 15. У такому випадку двовимірний масив може мати три рядки і п'ять стовпців або п'ять рядків і три стовпці.

// приклад оголошення двовимірного масиву: int a;

a - ім'я целочисленного масиву
число в перших квадратних дужках вказує кількість рядків двовимірного масиву, в даному випадку їх 5;
число по-друге квадратних дужках вказує кількість стовпців двовимірного масиву, в даному випадку їх 3.

// ініціалізація двовимірного масиву: int a \u003d ((4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), (1, 1, 1));

В даному масиві 5 рядків, 3 стовпці. після знака привласнити ставляться загальні фігурні скобочки, всередині яких ставиться стільки пар фігурних скобочек, скільки повинно бути рядків в двовимірному масиві, причому ці скобочки розділяються комами. У кожній парі фігурних скобочек записувати через кому елементи двовимірного масиву. У всіх фігурних дужках кількість елементів має збігатися. Так як в масиві п'ять рядків, то і внутрішніх пар скобочек теж п'ять. У внутрішніх дужках записані по три елементи, так як кількість стовпців - три. Графічно наш масив буде виглядати, як двовимірна таблиця (див. Малюнок 5).

Малюнок 5 - Масиви в С ++

У кожному осередку двовимірного масиву aпоказано значення, в нижньому правому куті показаний адресу даного осередку. Адресою комірки двовимірного масиву є ім'я масиву, номер рядка та номер стовпчика.

Розробимо нескладну програму, на обробку двовимірного масиву, яка називається «Лабіринт». Лабіринт має бути побудований на основі двовимірного масиву. Розмір лабіринту виберемо на свій розсуд.

// array2.cpp: визначає точку входу для консольного застосування. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) Else cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// код Code :: Blocks

// код Dev-C ++

// array2.cpp: визначає точку входу для консольного застосування. #include using namespace std; int main (int argc, char * argv) (// 1-умовно "стінки лабіринту" // 2 "правильний шлях, вихід з лабіринту" // 0- "помилковий шлях" int mas \u003d ((1,2,1 , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // ініціалізація двовимірного масиву (1,2,1,0 , 0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1,), (1,2,2,2,2,2,2,1,2,1,1 , 1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2,1,0,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2,0,0,0,1 , 0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1,0,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,), (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,), (1,1,0,0,0,1,0 , 0,1,1,2,1,1,1,1,0,0,0,0,1,), (1,0,0,1,0,0,0,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1,1,1,1,2 , 1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,), (1,2,1 , 1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1,2,1,2,1,2,1,2,1,0 , 1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1 , 2,1,0,1,1,1,1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0, 0,0,0,0,0,0,0,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1 , 1,1,0,1,2,1,), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0, 1,2,1,), (1,2,1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,) , (1,2,1,1,2,1,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1 , 1,2,1,0,0,1,1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1, 1,0,1,2,2,2,2,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0,1,2 , 1,1,1,1,1,1,1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1, 1,1,1,1,1,2,2,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2 , 2,2,1,), (1,2,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1, ), (1,2,1,1,2,1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2, 2,2,2,1,0,1,1,2,2,2,2,0,0,1,0,0,0,1,), (1,1,1,1,1,1 , 1,1,1,1,1,1,1,1,1,1,1,1,1,1,)); // два циклу - внутрішній і зовнішній, здійснюють звернення до кожного елементу масиву for (int i \u003d 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) Else cout<< " "; // вывести два пробела cout << endl; } return 0; }

Правильний і помилковий шляху можна було б позначати однією і тією ж цифрою, наприклад, нулем, але для наочності правильний шлях позначений цифрою 2. Ініціалізація масиву виконувалася вручну, тільки для того, що б спростити програму. Так як в програмі виконується обробка двовимірного масиву, потрібні два циклу, для перемикання між елементами двовимірного масиву. Перший цикл for виконує перемикання між рядками двовимірного масиву. Так як рядків в двовимірному масиві 33, то і змінна-лічильник i инкрементируется від 0 до 33, рядок 46. Всередині першого циклу варто цикл for, який переключається між елементами рядка двовимірного масиву. У тілі другого циклу for всередині виполняетcя унарна операція перетворення типу даних - static_cast<>(), Яка друкує символ, під номером 176. операція перетворення типів даних дублюється для збільшення ширини лабіринту. Результат роботи програми (див. Малюнок 6).

Малюнок 6 - Масиви в С ++

Масиви призначені для зберігання безлічі значень одного типу. Наприклад, в програмі Fahrenheit to Celsius, ми вираховували середнє значення температури з трьох. Якщо значень не три, а набагато більше, то тут якраз і потрібно використовувати масиви.

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

int array;

У цьому коді ми визначили масив з ідентифікатором (ім'ям) array (масив) з десяти елементів типу int.
У такому вигляді, все елементи масиву ще неініціалізованих. Щоб форматувати їх при оголошенні, потрібно використовувати наступний синтаксис:

int array \u003d (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

При цьому, першому елементу масиву присвоюється значення 0, а останнім - значення 9.
Щоб привласнити елементам масиву значення, можна скористатися циклами. Найбільш підходящим для цього буде цикл for.

код на мові c ++ int array; // визначення масиву for (int i \u003d 0; i< 10; i++) { array[i] = i; }

Тут ми звертаємося до кожного елементу масиву через індекс - число стоїть в квадратних дужках. При кожній ітерації циклу воно приймає значення від нуля до 9.

Зауважте, що нумерація індексів починається з нуля. Тому число індексів завжди на одиницю менше числа елементів масиву.

За винятком квадратних дужок і індексу, елемент масиву використовується також як і будь-яка змінна.

рядки

До сих пір ми могли зберігати рядки тільки в константах: "Приклад константної рядки". У змінних ми могли зберігати тільки один символ - в типі char. У C ++ використовується два типи рядків: масив елементів типу char і тип str. Зараз ми зосередимося на першому варіанті.

Для зберігання рядка нам потрібен масив. Виглядає це приблизно так:

char string \u003d ( "с", "т", "р", "о". "до", "а");

На щастя є більш простий спосіб :)

char string \u003d "рядок";

В даному випадку автоматично створиться масив з семи елементів. Чому з семи? Справа в тому що кожен рядок повинна закінчуватися символьної константою "\\ 0", яка представляє порожній байт.

У попередніх прикладах, якщо ми спробуємо ввести в масив string рядок велику ніж шість символів, то відбудеться переповнення масиву тому не можна змінювати розмір масиву під час виконання програми (хоча, не завжди):

char string; // string може зберігати шість символів і "\\ 0"

string \u003d "рядок!"; // в рядку міститься сім символів
Так робити не рекомендується :)

Ще один момент на який я хочу звернути вашу увагу. У разі, коли користувач вводить рядок, прогалини вважаються за "\\ 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 \u003d 0; // дві змінні для зберігання координат гравця int y \u003d 0; char map; // масив для зберігання ігрової карти // ініціалізація масиву for (int i \u003d 0; i< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Тут новим оператором для нас є визначення двовимірного масиву. Але воно майже нічим не відрізняється від одновимірного, просто додається ще одна пара квадратних дужок. У перших дужках ми вказали кількість рядків, у другій - кількість стовпців.

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

Наведу детальний приклад: після кількох ітерацій зовнішнього циклу, лічильник i стає рівним 9. Починає виконуватися тіло зовнішнього циклу: змінна j (лічильник внутрішнього циклу) инициализируется нулем, перевіряється умова і виконується тіло внутрішнього циклу: map \u003d "";, Тобто першому символу (індекс нуль) десятої рядка (не забувайте що відлік ведеться з нуля) присвоюється пробіл. Потім, лічильнику j присвоюється 1, виконується тіло циклу ... і так до тих пір поки лічильник j не стане рівним 20 - умова не виконується і відбувається вихід з внутрішнього циклу. Потім инкрементируется зовнішній лічильник. Тепер він дорівнює 10 і знову виконується тіло зовнішнього циклу ...

Після ініціалізації пробілами ми в перший стовпець першого рядка поміщаємо персонажа нашої гри.

На початку основного циклу ми викликаємо функцію system () для очищення екрана від минулого виведення.

Потім йдуть два циклу схожі на цикли ініціалізації. Вони використовуються для виведення елементів масиву на екран. Єдиною істотною відмінністю є висновок символу нового рядка в кінці тіла першого циклу.

Ну а далі йде розгалуження в якому визначається яка клавіша натиснута. Саме розгалуження мало змінилося з минулого разу, а ось у вмісті блоків є відмінності: по-перше ми присвоюємо координатам на яких стоїть об'єкт пробіл. Тобто ми очищаємо попереднє місце. Потім ми змінюємо одну з координат. І потім, елементу масиву з новими індексами, ми присвоюємо символ "T".

Приклад для коду "75" - рух вліво:

код на мові c ++ if else (ch \u003d\u003d 75) (map [x] [y] \u003d ""; y--; map [x] [y] \u003d "T";)

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

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

вправи:

1. У повному лістингу програми я використовував розгалуження switch. Тут же показаний код одного блоку розгалуження if. Допишите інші блоки if.

2. Зараз в програмі можлива запис в неіснуючі елементи масиву. Зробіть перевірку на вихід за межі карти.

3. Для практики створіть програму малює на екрані два поля для морського бою. Перше - гравця, друге - противника. Друге поле повинно розташовуватися праворуч від першого.
Внутрішні клітини заповнюйте прогалиною. Для малювання кордону використовуйте мінус і пряму роздільну лінію: -, |, а для кутів - грати #. Зліва від кожного поля - стобік цифр; зверху - літери.
Для ініціалізації всього поля вам може знадобитися кілька циклів. Ось як може виглядати код для заповнення стовпчика цифр другого поля:

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

Будь ласка, призупините роботу 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 \u003d (2, 5, 5, 3, 4); double arr_float \u003d (1.2, -2.3, 4.5, 3.83, 0.01, -0.12, 44.2, 123.7, 23.44, -3.7, 7);

Якщо потрібно присвоїти нульові значення всіх елементів масиву, то можна зробити ось так:

Лістинг 4.

Double arr \u003d (0);

Робота з окремими елементами масиву

Щоб звернутися до окремого елементу масиву, необхідно написати його ім'я і порядковий номер в квадратних дужках. Не забувайте, що нумерація починається з нуля, а не з одиниці.

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

Лістинг 5.

#include int main (void) (int arr \u003d (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 \u003d (0); for (int i \u003d 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 \u003d (0); int rand_number; for (int i \u003d 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 відпадає. Зручно, чи не так?

Що таке масиви в сі?

Як оголошувати масиви в сі?

Як форматувати масиви в сі?

Масиви в Сі для чайників.

Масиви в C

Масив в Сі - це набір елементів одного типу, звернутися до яких можна за індексом. Елементи масивів в C розташовані один за одним в пам'яті комп'ютера.

Простий приклад створення і заповнення масиву в C:

// @author Subbotin BP.h\u003e void main (void) (int nArr; nArr \u003d 1; nArr \u003d 2; nArr \u003d 3; printf ( "\\ n \\ tArray \\ n \\ n"); printf ( "nArr \\ t \u003d \\ t% d \\ n ", nArr); printf (" nArr \\ t \u003d \\ t% d \\ n ", nArr); printf (" nArr \\ t \u003d \\ t% d \\ n ", nArr); return 0 ;)

отримуємо:

У прикладі оголошуємо масив, що містить елементи типу int:

тут ім'я масиву nArr, кількість елементів масиву дорівнює трьом, тип елементів масиву int.

Масив - це набір елементів. До кожного елементу масиву можна звернутися по його номеру. Номер прийнято називати індексом. Нумерація елементів масиву йде з нуля. Дамо значення першого елемента масиву, а перший елемент має індекс нуль:

Дамо значення другого елементу масиву, а другий елемент має індекс один:

Дамо значення третього елементу масиву, а третій елемент має індекс два:

При виведенні на екран елементів масиву ми отримуємо їх значення. Ось так:

printf ( "nArr \\ t \u003d \\ t% d \\ n", nArr);

Щоб отримати елемент масиву, треба вказати ім'я масиву та індекс елемента:

це перший елемент масиву, адже у першого елеметов індекс нуль.

Дамо значення третього елемента масиву змінної int a:

індекс третього елемента масиву дорівнює двом, так як відлік індексів ведуть з нуля.

Тепер загальне правило оголошення масивів в Сі: при оголошенні масиву потрібно вказати його ім'я, тип елементів, кількість елементів. Кількість елементів є натуральне число, тобто ціле позитивне. Нуль не може бути кількістю елементів. Не можна ставити змінну кількість елементів масиву. Ось приклади оголошень масивів в C:

int nArr; // Оголошено масив, призначений для зберігання ста цілих чисел;
float fArr; // Оголошено масив, призначений для зберігання 5-ти чисел типу float;
char cArr; // Оголошено масив, призначений для зберігання двох символів;

Помилкою буде оголосити масив з перемінним кількістю елементів:

Int varElem;
int nArr; // Помилка! Кількість елементів не можна ставити змінної;

Але можна задавати кількість елементів постійною величиною: або безпосереднім цілим позитивним числом 1, 2, 3 ... або константою:

Const int arrayLength \u003d 3;
int nArr;

При оголошенні масиву в Сі його відразу можна форматувати:

int nMassiv \u003d (1, 2, 3);

Можна не вказувати кількість елементів масиву в квадратних дужках, якщо не започатковано всі елементи масиву:

int nMassiv \u003d (1, 2, 3);

кількість елементів буде в цьому випадку визначено автоматично.

Можна визначити лише частина елементів масиву при його оголошенні:

int nMassiv \u003d (1, 2);

в цьому прикладі перші два елементи масиву ініціалізовані, а третій не визначено.

Приклад масиву символів:

char cArr \u003d ( "S", "B", "P");

При оголошенні масиву можна вказувати кількість елементів змінної. Але можна використовувати змінні при зверненні до елементів масивів:

Int ind \u003d 0;
char cr \u003d cArr;

Це використовується при роботі з циклами. приклад:

// @author Subbotin B.P..h\u003e void main (void) (const int arrayLength \u003d 3; int nArr; for (int inn \u003d 0; inn< 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

У прикладі в першому циклі заповнюємо масив елементами типу int, а в другому циклі виводимо ці елементи на екран.

Останнє оновлення: 17.09.2017

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

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

Після типу змінної йде назва масиву, а потім в квадратних дужках його розмір. Наприклад, визначимо масив з 4 чисел:

Int numbers;

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

Int numbers \u003d (1,2,3,4);

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

Int numbers \u003d (1, 2, 3, 4, 5, 6);

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

Якщо розмір масиву не вказано явно, то він виводиться з кількості ініціалізаторів:

Int numbers \u003d (1, 2, 3, 4, 5, 6);

В даному випадку в масиві є 6 елементів.

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

Char s1 \u003d ( "h", "e", "l", "l", "o"); char s2 \u003d "world";

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

При цьому не допускається присвоєння одному масиву іншого масиву:

Int nums1 \u003d (1,2,3,4,5); int nums2 \u003d nums1; // помилка nums2 \u003d nums1; // помилка

Після визначення масиву ми можемо звернутися до його окремих елементах за індексом. Індекси починаються з нуля, тому для звернення до першого елементу необхідно використовувати індекс 0. Звернувшись до елементу за індексом, ми можемо отримати його значення, або змінити його:

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

Число елементів масиву також можна визначати через константу:

Const int n \u003d 4; int numbers [n] \u003d (1,2,3,4);

перебір масивів

Використовуючи цикли, можна пробігтися по всьому масиву і через індекси звернутися до її елементів:

#include int main () (int numbers \u003d (1,2,3,4); int size \u003d sizeof (numbers) / sizeof (numbers); for (int i \u003d 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 \u003d (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 \u003d ((1, 2), (4, 5), (7, 8));

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

1	2
4	5
7	8

Також при ініціалізації можна опускати фігурні дужки:

Int numbers \u003d (1, 2, 4, 5, 7, 8);

Можлива також ініціалізація не всіх елементів, а тільки деяких:

Int numbers \u003d ((1, 2), (), (7));

І щоб звернутися до елементів вкладеного масиву, потрібно два індексу:

Int numbers \u003d ((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 \u003d 3, columns \u003d 2; int numbers \u003d ((1, 2), (3, 4), (5, 6)); for (int i \u003d 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 \u003d 3, columns \u003d 2; int numbers \u003d ((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 і виводимо її значення на консоль.