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

Масив це структура даних, подана у вигляді групи осередків одного типу, об'єднаних під одним єдиним ім'ям. Масиви використовують для обробки великої кількості однотипних даних. Ім'я масиву є те, що таке покажчики розповім трохи пізніше. Окрема комірка даних масиву називається елементом масиву. Елементами масиву можуть бути дані будь-якого типу. Масиви можуть мати як один, так і більше одного виміру. Залежно кількості вимірювань масиви діляться на одномірні масиви, двовимірні масиви, тривимірні масиви тощо до 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).

Обробка 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 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); 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 = ((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); cout<< static_cast(176); ) else cout<< " "; // вывести два пробела cout << endl; } return 0; }

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

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

Масиви

Масивє сукупність змінних одного типу із загальним для звернення до них ім'ям. C# масиви можуть бути як одномірними, так і багатовимірними. Масиви служать різним цілям, оскільки вони надають зручні засоби для об'єднання пов'язаних разом змінних.

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

Для того, щоб скористатися масивом у програмі, потрібна двоетапна процедура, оскільки в C# масиви реалізовані у вигляді об'єктів. По-перше, необхідно оголосити змінну, яка може звертатися до масиву. І, по-друге, потрібно створити екземпляр масиву, використовуючи оператор new.

Using System; використовуючи System.Collections.Generic; використовуючи System.Linq; використовуючи System.Text; namespace ConsoleApplication1 (class Program (static void Main(string args)) ( // Оголошуємо масив int myArr = new int; // Ініціалізуємо кожен елемент масиву вручну myArr = 100; myArr = 23; myArr = 25; myArr = 31; myArr = 1 foreach (int i in myArr) Console.WriteLine(i); Console.ReadLine(); ) ) )

Слід мати на увазі, що якщо масив тільки оголошується, але явно не ініціалізується, кожен його елемент буде встановлений у значення, прийняте за умовчанням для відповідного типу даних (наприклад, елементи масиву типу bool будуть встановлюватися в false, а елементи масиву типу int - 0).

Ініціалізація масиву

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

// Синтаксис ініціалізації масиву з використанням // ключове слово new int myArr = new int (10,20,30,40,50); // Синтаксис ініціалізації масиву без використання // ключового слова new string info = ("Прізвище", "Ім'я", "По батькові"); // Використовуємо ключове слово new і бажаний розмір char symbol = new char ("X", "Y", "Z", "M");

Зверніть увагу, що у разі застосування синтаксису з фігурними дужками розмір масиву не потрібно вказувати (як видно на прикладі створення змінної myArr), оскільки цей розмір автоматично обчислюється на основі кількості елементів усередині фігурних дужок. Крім того, застосовувати ключове слово newне обов'язково (як під час створення масиву info).

Ключове слово var дозволяє визначити змінну так, щоб тип, що лежить в її основі, виводився компілятором. Аналогічно можна також визначати неявно типізовані локальні масиви. З використанням такого підходу можна визначити нову змінну масиву без зазначення типу елементів, що містяться у масиві. Давайте розглянемо приклад:

Using System; використовуючи System.Collections.Generic; використовуючи System.Linq; використовуючи System.Text; namespace ConsoleApplication1 ( class Program ( static void Main(string args) ( var arr1 = new ( 1, 2, 3 )); Console.WriteLine("Тип масиву arr1 - (0)",arr1.GetType()); var arr2 = new ("One", "Two", "Three"); Console.WriteLine("Тип масиву arr2 - (0)",arr2.GetType()); Console.ReadLine();

Зрозуміло, як і при створенні масиву з використанням явного синтаксису C#, елементи, що вказуються в списку ініціалізації масиву, повинні обов'язково мати один і той же базовий тип (тобто повинні бути int, string або MyCar).

Визначення масиву об'єктів

Найчастіше щодо масиву тип елемента, що міститься в масиві, вказується явно. Хоча на перший погляд це досить зрозуміло, існує одна важлива особливість. У основі кожного типу у системі типов.NET (зокрема фундаментальних типів даних) зрештою лежить базовий клас System.Object . В результаті виходить, що у разі визначення масиву об'єктів елементи, що знаходяться всередині нього, можуть являти собою що завгодно:

Using System; використовуючи System.Collections.Generic; використовуючи System.Linq; використовуючи System.Text; namespace ConsoleApplication1 (class Program (static void Main(string args)) (// Оголошуємо та ініціалізуємо масив об'єктів object arrByObject = (true, 10, "Привіт", 13.7m); // Виведемо в консоль тип кожного члена масиву foreach (object me in arrByObject) Console.WriteLine("Тип (0) - (1)",me,me.GetType()); Console.ReadLine(); ) ) )

Нехай нам необхідно працювати з великою кількістю однотипних даних. Наприклад, у нас є тисяча вимірів координати маятника з якимось кроком у часі. Створювати 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 void main() ( int a = (1,2,3); unsigned i; for (i = 0; i<10; i++) { printf("%d ", a[i]); } getch(); }

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

Inta = (0);

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

Inta = (1, 2, 3);

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

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

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

Printf("Enter length of array"); scanf("%d", &length); (float x;)

Створення динамічних масивів буде розглянуто далі, при роботі з вказівниками та пам'яттю
У деяких випадках можна дізнатися розмір масиву за допомогою функції sizeof.

#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 = .0f; float mean; float disp; float absError; float relError; && 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; char flag; // Виводь масив for (i = 0; i< 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); // Виводимо відсортований масив for (i = 0; i< SIZE; i++) { printf("%.3f ", a[i]); } getch(); }

6. Перемішаємо масив. Скористаємося для цього алгоритмом

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

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

Як ініціалізувати масиви в сі?

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

Масиви в C

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

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

// @author Subbotin B.P..h> void main(void) ( int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t =\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); ;)

Отримуємо:

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

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

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

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

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

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

printf("nArr\t=\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 = 3;
int nArr;

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

int nMassiv = (1, 2, 3);

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

int nMassiv = (1, 2, 3);

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

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

int nMassiv = (1, 2);

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

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

char cArr = ("S", "B", "P");

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

Int ind = 0;
char cr = cArr;

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

// @author Subbotin B.P..h> void main(void) (const int arrayLength = 3; int nArr; for(int inn = 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, тоді як у другому циклі виводимо ці елементи на екран.