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

Масив це структура даних, подана у вигляді групи осередків одного типу, об'єднаних під одним єдиним ім'ям. Масиви використовують для обробки великої кількості однотипних даних. Ім'я масиву є те, що таке покажчики розповім трохи пізніше. Окрема комірка даних масиву називається елементом масиву. Елементами масиву можуть бути дані будь-якого типу. Масиви можуть мати як один, так і більше одного виміру. Залежно кількості вимірювань масиви діляться на одномірні масиви, двовимірні масиви, тривимірні масиви тощо до 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 = (5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // ініціалізація одновимірного масиву

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

Int a=(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 6 array1 arra1 натисніть будь-яку клавішу. . .

Малюнок 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 >> 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 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 Для продовження натисніть будь-яку клавішу. . .

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

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

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

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

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

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

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

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

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

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

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

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

// ініціалізація двовимірного масиву: int a = ((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);<< static_castcout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// код Code::Blocks

// код Dev-C++

(176); using namespace std; int main(int argc, char* argv) ( // 1-умовно "стінки лабіринту" // 2-"правильний шлях, вихід з лабіринту" // 0-"хибний шлях" int mas = ((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 = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176);<< static_castcout<< " "; // вывести два пробела cout << endl; } return 0; }

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

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

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

- Це безперервна ділянка пам'яті, що містить послідовність об'єктів однакового типу, що позначається одним ім'ям.

Масив характеризується такими основними поняттями:

Елемент масиву (значення елемента масиву)– значення, що зберігається у певній комірці пам'яті, розташованої в межах масиву, а також адресу цієї комірки пам'яті.
Кожен елемент масиву характеризується трьома величинами:

• адресою елемента - адресою початкової комірки пам'яті, в якій розташований цей елемент;
• індексом елемента (порядковим номером елемента у масиві);
• значення елемента.

Адреса масиву – адреса початкового елемента масиву.

Ім'я масиву – ідентифікатор, який використовується для звернення до елементів масиву.

Розмір масиву – кількість елементів масиву

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

Графічно розташування масиву у пам'яті комп'ютера можна у вигляді безперервної стрічки адрес.

Представлений малюнку масив містить 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\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" (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 відпадає. Зручно, чи не так?

Масиви надзвичайно важлива тема 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 ++ ) //заповнюємо та виводимо значення на екран

Нехай нам необхідно працювати з великою кількістю однотипних даних. Наприклад, у нас є тисяча вимірів координати маятника з якимось кроком у часі. Створювати 1000 змінних для зберігання всіх значень дуже... обтяжливо. Натомість безліч однотипних даних можна об'єднати під одним ім'ям і звертатися до кожного конкретного елемента за його порядковим номером.
Масив у сі визначається наступним чином
<тип> <имя массива>[<размер>];
Наприклад,
int a;
Ми отримаємо масив з ім'ям a, який містить сто елементів типу int. Як і у випадку зі змінними, масив містить сміття.
Для отримання доступу до першого елемента у квадратних дужках пишемо його номер (індекс). Наприклад

#include #include void main() ( int a; a = 10; a = 333; a = 234; printf("%d %d %d", a, a, a); getch(); )

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

Мал. 1 Масив зберігає адресу першого елемента. Індекс i елемента - це зрушення на i * size of (тип) байт від початку

Індекс масиву вказує, на скільки байт необхідно зміститися щодо початку масиву, щоб отримати доступ до потрібного елемента. Наприклад, якщо масив Aмає тип int, то A означає, що ми змістилися на 10*sizeof(int) байт щодо початку. Перший елемент знаходиться на самому початку і має зсув 0*sizeof(int) .
Си масив не зберігає свого розміру і не перевіряє індекс масиву на коректність. Це означає, що можна вийти за межі масиву та звернутися до пам'яті, що знаходиться далі за останній елемент масиву (або ближче).

Початкова ініціалізація масиву.

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

#include #include void main() ( int a = (1, 2, 5, 3, 9, 6, 7, 7, 2, 4); unsigned i; int max; max = a; for (i = 1; i<10; i++) { if (a[i] >

Розберемо приклад. Спочатку ми створюємо масив та ініціалізуємо його при створенні. Після цього надають максимальному знайденому елементу значення першого елемента масиву.

Max = a;

Після чого проходимо масивом. Оскільки ми вже переглянули перший елемент (у нього індекс 1), немає сенсу знову його переглядати.
Той самий приклад, тільки тепер користувач вводить значення

#include #include void main() ( int a; unsigned i; int max; printf("Enter 10 numbers\n"); for (i = 0; i<10; i++) { printf("%d. ", i); scanf("%d", &a[i]); } max = a; for (i = 1; i<10; i++) { if (a[i] >max) ( max = a[i]; ) ) printf("max element is %d", max);

getch(); )

#include #include Якщо при ініціалізації вказано менше значень, ніж розмір масиву, інші елементи заповнюються нулями.<10; i++) { printf("%d ", a[i]); } getch(); }

void main() ( int a = (1,2,3); unsigned i; for (i = 0; i

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

Inta = (0);

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

Inta = (1, 2, 3);

масив матиме розмір 3

Розмір масиву

Масив повинен мати константний розмір. Це означає, що неможливо, наприклад, запросити у користувача розмір, а потім задати розмір масиву.

Printf("Enter length of array"); scanf("%d", &length); (float x;)
Створення динамічних масивів буде розглянуто далі, при роботі з вказівниками та пам'яттю У деяких випадках можна дізнатися розмір масиву за допомогою функції

#include #include void main() ( int A; //sizeof повертає розмір всього масиву в байтах //Для визначення кількості елементів необхідно //розділити розмір масиву на розмір його елемента int size = sizeof(A) / sizeof(int); printf("Size of array equals до %d", size); getch(); )

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

Переповнення масиву

Нехай у вас є такий код

Int A; int i; for (i=0; i<=10; i++) { A[i] = 1; }

Тут цикл forзаданий з помилкою. У деяких старих версіях компіляторів код зациклювався. Справа в тому, що змінна iрозташовувалася при компіляції відразу за масивом A. При виході межі масиву лічильник переводився до 1.
Масиви небезпечні, оскільки неправильна робота з індексом може призводити до доступу до довільної ділянки пам'яті.
Якщо ви працюєте з масивами, необхідно стежити за тим, щоб лічильник не перевищував розмір масиву і не був негативним. Для цього, як мінімум,

• 1. Використовуйте тип size_t для індексування. Він убезпечить вас від негативних значень і його вистачить для масиву будь-якого розміру.
• 2. Пам'ятайте, що масив починається з нуля.
• 3. Останній елемент масиву має індекс (розмір масиву – 1)

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

Приклади

Тепер кілька типових прикладів роботи з масивами
1. Перевертаємо масив.

#include #include //Це макрос. SIZE у коді буде замінено на 10u #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i, j; // лічильники unsigned half; // середина масиву unsigned tmp; // тимчасова змінна для обміну значеннями half = SIZE / 2;< half; i++, j--) { tmp = A[i]; A[i] = A[j]; A[j] = tmp; } for (i = 0; i < SIZE; i++) { printf("%d ", A[i]); } getch(); }

Тут незнайома вам конструкція

#define SIZE 10u

макрос. У всьому коді препроцесор автоматично замінить усі входження SIZE на 10u.
2. Видалення елемента, вибраного користувачем.

#include #include #define SIZE 10u void main() ( int A = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9); unsigned i; //лічильник int index; //індекс, введений користувачем / /Виводимо масив for (i = 0; i< SIZE; i++) { printf("(%d)=%d ", i, A[i]); } //Просим пользователя ввести валидный индекс while (1) { printf("\nEnter index of element to delete "); scanf("%d", &index); if (index >0 && index< SIZE) { break; } } //Копируем следующий элемент массива на место удаляемого //и так до конца for (i = index; i < SIZE-1; i++) { A[i] = A; } //Выводим результат for (i = 0; i < SIZE-1; i++) { printf("(%d)=%d ", i, A[i]); } getch(); }

Видалення елемента у разі, звісно, ​​немає. Масив залишається того самого розміру, що й раніше. Ми просто затираємо елемент, що видаляється наступним за ним і виводимо SIZE-1 елементів.
3. Користувач вводить значення масив. Після цього вивести всі різні значення, які він запровадив.
Нехай користувач вводить кінцеве число елементів, припустимо 10. Тоді заздалегідь відомо, що всього різних значень буде не більше 10. Щоразу, коли користувач вводить число проходитимемо по масиву і перевіряти, чи було таке число введено.

#include #include #define SIZE 10u void main() ( int A = (0); unsigned i, j; int counter = 1; //скільки різних чисел введено. Як мінімум одне. int input; int wasntFound; //прапор, що введене число не було знайдено //Вводимо перше число.< SIZE; i++) { printf("%d. ", i); scanf("%d", &input); wasntFound = 1; //Проверяем, встречалось ли такое число. Если да, //то выставляем флаг и выходим из цикла for (j = 0; j <= counter; j++) { if (input == A[j]) { wasntFound = 0; break; } } //Если флаг был поднят, то заносим число в массив if (wasntFound) { A = input; counter++; } } for (i = 0; i < counter; i++) { printf("%d ", A[i]); } getch(); }

4. Користувач вводить число - кількість вимірів (від 2 до 10). Після цього вводить усі виміри. Програма видає середнє значення, дисперсію, похибку.

#include #include #include #define SIZE 20u void main() ( //Коефіцієнти Стьюдента йдуть, починаючи з двох вимірів const float student = (12.7, 4.3, 3.2, 2.8, 2.6, 2.4, 2.4, 2.3, 2.3); float A; un; limit; float tmp; float sum; && limit< 11) { break; } } while(1); for (i = 0; i < limit; i++) { printf("#%d: ", i); scanf("%f", &A[i]); sum += A[i]; } mean = sum / (float)limit; sum = .0f; for (i = 0; i < limit; i++) { tmp = A[i] - mean; sum += tmp * tmp; } disp = sum / (float)limit; absError = student * sqrt(sum / (float)(limit - 1)); relError = absError / mean * 100; printf("Mean = %.6f\n", mean); printf("Dispertion = %.6f\n", disp); printf("Abs. Error = %.6f\n", absError); printf("Rel. Error = %.4f%", relError); getch(); }

5. Сортування масиву бульбашкою

#include #include #define SIZE 10 #define false 0 #define true !false void main() ( float a = (1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 0). f);float tmp; unsigned i, j;< SIZE; i++) { printf("%.3f ", a[i]); } printf("\n"); //Пока массив не отсортирован do { flag = false; //Проходим по массиву. Если следующий элемент больше предыдущего, то //меняем их местами и по новой проверяем массив for (i = 1; i < SIZE; i++) { if (a[i] >a) (tmp = a [i]; a [i] = a; a = tmp; flag = true;))) while (flag = = true);< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

// Виводимо відсортований масив for (i = 0; i