3. Керування виходом із циклів С#
Інколи виникає необхідність термінового переривання циклів. Таку логіку програми забезпечує інструкція break;, з якою ми познайомились у конструкції switch. Якщо всередині циклу знаходиться інструкція break;, то відбувається вихід із циклу, а управління передається інструкції, що безпосередньо слідує за даним циклом. Таким чином можна, наприклад перервати виконання «нескінченного» циклу.
bool condition;
…
for (;;)
{
…
if (condition) break;
…
}
Слід зауважити, що у випадку вкладених циклів інструкція break; викликає вихід лише із того циклу, де вона знаходиться, у зовнішній, не впливаючи на останній.
Крім інструкції break; для керування циклами використовується інструкція continue. У циклі for вона викликає перехід до обчислення <�виразу-ітерації> (тобто до кроку 3), а у циклах while та do-while – перехід до обчислення <�виразу-умови> циклу.
Радикальну дію викликає інструкція безумовного переходу goto. Її вживання у програмах вкрай небажане (тому що воно порушує послідовну логіку виконання програми та ускладнює її налагодження) і може бути зумовлене лише крайньою необхідністю, наприклад, дострокового виходу із кількох вкладених циклів в разі виникнення помилки. Синтаксис цієї інструкції наступний:
goto <�мітка>;
Тут <�мітка> – це звичайний ідентифікатор, який помічає інструкцію, на яку передбачено передачу управління програмою. Наприклад,
int counter = 10;
label : counter--;
Console.WriteLine("counter = " + counter.ToString());
// Реалізований цикл із 10 кроків
if (counter > 0) goto label;
Масиви в мові С#
Масив – це тип даних (reference-type) для збереження елементів однакового типу, доступ до яких здійснюється за індексом. Першим значенням індексу є 0. Головна особливість масивів в мові С# полягає у тому, що вони реалізовані як об’єкти, що спадкують свої властивості та методи від класу System.Array.
Синтаксис визначення масиву наступний:
<�тип_елементів> [] <�ідентифікатор_масиву>;
<�ідентифікатор_масиву> = new <�тип_елементів> [кількість_елементів];
У першому рядку масив декларується (описується), точніше кажучи, визначається адресна змінна, яка буде вказувати на масив. У другому рядку масив власне створюється (операція new) в динамічній області пам’яті Heap і адреса його місця розташування пов’язується із ідентифікатором масиву. Ті самі дії можна здійснити в одному рядку:
<�тип_елементів> [] <�ідентифікатор_масиву> =
new <�тип_елементів> [кількість_елементів];
Індексами елементів масиву будуть значення 0, 1, …, кількість_елементів-1. (Зверніть особливу увагу на те, що індексація елементів починається з нуля!) Для ініціалізації масиву можна використати фігурні дужки, в яких перелічити значення його елементів. В цьому разі кількість_елементів при визначенні масиву можна не вказувати – компілятор визначить її по кількості ініціалізованих елементів. До елементів масиву звертаються, вказуючи ідентифікатор масиву та індекс потрібного елементу у квадратних дужках. Розглянемо приклади визначення масивів.
using System;
namespace Array_1
{
class Program
{
static void Main()
{ // Робота з масивом
const int SIZE = 10;
int[] iArray = new int[SIZE]; // Визначаємо масив
for (int i = 0; i < SIZE; i++)
// Елементи масиву ініціалізуються нулями!
Console.WriteLine(
"iArray [{0}] = {1}", i, iArray [i]);
}
}
}
Потрібно зазначити, що в мові C# на відміну від мови C або C++ у якості розміру масиву можна задавати звичайну змінну, проте, в даному випадку використання сталої є ознакою хорошого стилю програмуванням, це полегшує читання та подальше супроводження програми.
В даному прикладі масив був створений, але не проініціалізований. Тим не менше на екрані ми побачимо, що всі елементи масиву мають нульові значення – про це дбає компілятор, створюючи змінну reference-типу. Проте, хорошим стилем у програмуванні вважаються явні ініціалізації. Зробимо це у наступному прикладі.
using System;
namespace Array_2
{
class Program
{
static void Main()
{
// Визначаємо (без new) та ініціалізуємо масив –
// його розмір визначаться компілятором
int[] iArray = {1, 2, 3, 4, 5};
Console.WriteLine("Масив цiлий iArray");
for (int i = 0; i < iArray.Length; i++)
Console.WriteLine("iArray [{0}] = {1}",i, iArray[i]);
// Визначаємо та ініціалізуємо масив
double[] dArray = new double[5] {1.1,2.2,3.3,4.4,5.5};
Console.WriteLine("Масив дiйсний dArray");
for (int i = 0; i < dArray.Length; i++)
Console.WriteLine("dArray [{0}] = {1}",i, dArray[i]);
// Інший масив з тим самим ідентифікатором –
// попередні значення втрачені
dArray = new double[4] { 1.2, 2.3, 3.4, 4.5 };
Console.WriteLine("Ще один дiйсний масив dArray");
for (int i = 0; i < dArray.Length; i++)
Console.WriteLine("dArray [{0}] = {1}",i, dArray[i]);
double[] dArray_new;
// Той самий масив з іншим ідентифікатором
dArray_new = dArray;
Console.WriteLine(
"Той самий дiйсний масив dArray_new");
for (int i = 0; i < dArray_new.Length; i++)
Console.WriteLine(
"dArray [{0}] = {1}", i, dArray_new[i]);
}
}
}
Зауваження.
В даному прикладі у рядку int[] iArray = {1, 2, 3, 4, 5}; створюється масив цілих чисел iArray, який ініціалізується п’ятьма значеннями. Зверніть увагу, в цьому випадку службове слово new та вказання кількості елементів не потрібно – компілятор автоматично визначає розмір масиву за кількістю ініціалізованих елементів.
У рядку double[] dArray = new double[5] { 1.1, 2.2, 3.3, 4.4, 5.5 }; створюється та ініціалізується дійсний масив із 5 елементів, про що явно повідомляється компілятору. Ця вказівка в принципі є надмірною, хоча й синтаксично правильною. Але в разі явного визначення розміру масиву службове слово new є необхідним.
Інструкцією dArray = new double[4] { 1.2, 2.3, 3.4, 4.5 }; для уже визначеного ідентифікатора dArray створюється та ініціалізується новий масив із чотирьох елементів.
Зручною формою для умови продовження циклу for є використання властивості Length , яка для будь-якого масиву визначає кількість елементі у ньому.
Зверніть увагу на інструкції :
double[] dArray_new;
dArray_new = dArray;
У першій з них описується ідентифікатор dArray_new дійсного масиву. А у другій – цьому ідентифікатору присвоюється значення ідентифікатора уже визначеного масиву dArray . В результаті обидва ідентифікатори вказують на один і той самий масив, точніше на одне й те саме місце у пам’яті, де записані 4 дійсних числа.
Щоб підкреслити «об’’єктну природу» масивів, розглянемо ще один приклад, що стосується зауваження 5. В ньому створюються, ініціалізуються та виводяться на екран 2 різних масиви. Потім ідентифікатору першого масиву присвоюється ідентифікатор другого. Фізично масиви знаходяться на своїх місцях в пам’яті, проте їх ідентифікатори посилаються тепер на одну й ту саму область, що ми і бачимо при виводі першого масиву. Посилання на перший масив тепер втрачене і в певний час він буде знищений з пам’яті спеціальною системою збору «сміття» GC – Garbage Collector (детальніше про це див. далі)
using System;
namespace Array_3
{
class Program
{
static void Main(string[] args)
{ // Визначаємо та ініціалізуємо перший масив
int[] iArray1 = {1, 2, 3, 4, 5};
Console.WriteLine("Перший масив");
for (int i = 0; i < iArray1.Length; i++)
Console.WriteLine(
"Елемент масиву [{0}] = {1}", i, iArray1[i]);
Console.WriteLine("Другий масив");
// Визначаємо та ініціалізуємо другий масив
int[] iArray2 = { 6, 7, 8, 9, 10 };
for (int i = 0; i < iArray2.Length; i++)
Console.WriteLine(
"Елемент масиву [{0}] = {1}", i, iArray2[i]);
// Присвоєння ідентифікаторів масиву -
// тепер перший ідентифікатор вказує на другий масив
// посилання на перший масив - втрачене
iArray1 = iArray2;
Console.WriteLine("Ще раз другий масив");
// Друкуємо другий масив ще раз
for (int i = 0; i < iArray2.Length; i++)
Console.WriteLine(
"Елемент масиву [{0}] = {1}", i, iArray2[i]);
}
}
}
Важливо наголосити також, що С# суворо контролює значення індексів елементів масиву. Якщо значення індексу виводить за межі виділеної для масиву області пам’яті – виникає помилка типу «index out of range». Таким чином хорошим стилем програмування є використання конструкцій типу try ... catch для обмеження можливих випадків виходу за межі масиву.
System.Array
Клас System.Array містить низку властивостей та методів, які зручно використовувати при роботі з масивами. До деяких з них ми уже звертались у прикладах. Так властивість Length визначає кількість елементів масиву (для багатовимірних масивів – загальну кількість елементів), метод GetLength()– повертає кількість елементів масиву по вказаному виміру. Серед інших можна відзначити деякі наступні. Властивість Rank дає кількість вимірів даного масиву, Метод Array.Sort() дозволяє відсортувати одновимірний масив (за замовчуванням – у порядку зростання, або обираючи певний ключ з допомогою інтерфейсу IComparable), метод Array.Reverse() переставляє елементи одновимірного масиву у зворотному порядку, метод Array.Clone() створює копію масиву, метод Array.Clear() заповнює нулями вказані елементи масиву. Розглянемо простий приклад використання цих методів.
using System;
namespace Array_4
{
class Program
{
static void Main(string[] args)
{
const int SIZE = 10; // Розмір масивів
int[] iArray = new int[SIZE];
Console.WriteLine("Введiть {0} цiлих чисел", SIZE);
for (int i = 0; i < SIZE; i++)
{
Console.Write ("[{0}] = ", i);
iArray [i] = int.Parse(Console.ReadLine());
}
Console.WriteLine("Створюємо копiю масиву:");
// Копію необхідно привести до відповідного типумасиву
int[] iCloneArray = (int[])iArray.Clone();
Console.WriteLine("Сортуємо цю копiю позростанню");
Array.Sort(iCloneArray); // Сортування
for (int i = 0; i < SIZE; i++)
Console.WriteLine("iCloneArray [{0}] = {1}",i,
iCloneArray[i]);
Console.WriteLine("Переставляємо елементи");
Array.Reverse(iCloneArray); //Перестановка
for (int i = 0; i < SIZE; i++)
Console.WriteLine("iCloneArray [{0}] = {1}", i, iCloneArray[i]);
Console.WriteLine("Зануляємо 5 елементiв,
починаючи з iндекса 3");
Array.Clear(iCloneArray, 3, 5); // Занулення елементів
for (int i = 0; i < SIZE; i++)
Console.WriteLine("iCloneArray [{0}] = {1}", i,
iCloneArray[i]);
}
}
}
System.Console
Класи в мові С#
Визначення класу описує його члени, в першу чергу дані та методи – функції, які обробляють та керують цими даними. Клас може містити деякі спеціальні члени – статичні поля та методи, властивості, події, тощо. Для початку познайомимось із деякими основними членами класу. Синтаксис визначення класу вимагає використання службового слова class, за яким слідує власне блок визначення членів класу.
Отже, синтаксис визначення класу наступний (взагалі порядок визначення членів класу може бути довільним):
class <ідентифікатор_класу> {
// декларації даних-членів класу
<специфікатор_доступу> <тип> <ідентифікатор_змінної_1>;
<специфікатор_доступу> <тип> <ідентифікатор_змінної_2>;
//...
// декларації методів-членів класу
<специфікатор_доступу> <тип_результату>
<ідентифікатор_методу_1> (<параметри>)
{
// код методу
}
//...
<специфікатор_доступу> <тип_результату>
<ідентифікатор_методу_N> (<параметри>)
{
// код методу
}
}
Зауваження. <�Специфікатор_доступу> визначає право використання даного члену класу поза його межами і може мати наступні значення: public – для відкритих членів класу, protected та private – для закритих членів класу (різницю між ними буде з’ясовано дещо пізніше). Відкриті члени класу можуть використовуватись в усіх фрагментах програмного коду, яким доступне визначення класу. Закриті члени класу доступні лише членам самого класу. Якщо специфікатор доступу не вказаний, він матиме значення private за замовчуванням.
Отже, визначення класу – це визначення нового типу даних (reference-type), а об’єктом є конкретний екземпляр даного класу, подібно до того, як тип int є одним із стандартних типів даних, а змінна val типу int – це конкретний екземпляр (об’єкт) цілого типу. Для створення екземпляру даного класу необхідно використати оператор new . Розглянемо деякі приклади.
using System;
namespace Class_Student
{
class Student
{ // Відкриті дані-члени класу
public string name;
public string surname;
public byte course;
public byte group;
public double module_mark;
}
class Program
{
static void Main()
{
Student s1, s2; // декларація двох екземплярів Student
s1 = new Student(); // створюємо першого студента
s2 = new Student(); // створюємо ще одного студента
s1.name = "Oleg"; // заповнюємо дані першого студента
s1.surname = "Petrenko";
s1.course = 1;
s1.group = 1;
s1.module_mark = 30;
s2.name = "Maria"; // заповнюємо дані другого студента
s2.surname = "Pushkina";
s2.course = 2;
s2.group = 1;
s2.module_mark = 60;
Console.WriteLine("Перший студент:");
Console.WriteLine(
"{0} (1} {2} курс {3} група {4} балів", s1.name,
s1.surname, s1.course, s1.group, s1.module_mark);
Console.WriteLine("Другий студент:");
Console.WriteLine(
"{0} (1} {2} курс {3} група {4} балів", s2.name,
s2.surname, s2.course, s2.group, s2.module_mark);
}
}
}
Проанализуємо уважно цей приклад. Програмний код включає 2 класи – Student та Program. Перший з них містить 5 змінних – name, surname, course, group та module_mark. Це дані-члени класу Student і оскільки всі вони визначені із специфікатором public, доступ до них можливий із інших класів програми. У класі Program, точніше у його єдиній основній функціїї Main, спочатку декларуються, а потім і створюються 2 екземпляри класу Student – s1 та s2 з допомогою оператору new. Кожний з цих об’єктів має свій власний набір даних name, surname, course, group та module_mark. Їх називають даними екземпляру. Доступ до даних конкретного екземпляру відбувається із вказанням обох ідентифікаторів: і екземпляру, і члену класу, відокремлених крапкою. Власне, такі «складені імена» ми вже використовували, наприклад, при звертанні до методів ReadLine або WriteLine класу Console. В операторі «крапка» ліворуч завжди вказується ідентифікатор об’єкту, а праворуч – ідентифікатор члену цього об’єкту. Таким чином, далі всі члени об’єктів s1 та s2 одержують певні значення, які і виводяться на екран. Проте в цьому першому прикладі наш класс Student є «пасивним», адже члени даного класу використовуються відкрито «без участі та нагляду» класу.
Конструктор
Те, що було зроблено у прикладах з класами Student та Polar_Point, коли дані екземпляру задавались «вручну» припустимо лише для прикладу, адже з одного боку можливо «забути» проініціалізувати деяку змінну екземпляру, а далі використати її (за замовчуванням проініціалізовану компілятором!), з іншого боку хотілося б взагалі мінімізувати «ручне» маніпулювання при створенні екземплярів класів. Іншими словами роботу по створенню та ініціалізації екземплярів треба перекласти на компілятор. Тому метод, подібний до OurMetod, має викликатись автоматично при створенні кожного екземпляру класу OurClass. Такий метод класу називається конструктором класу. Синтаксис його декларації наступний:
<специфікатор_доступу> <ідентифікатор_класу> (<параметри конструктора>)
{
// код конструктора
}
Наприклад, конструктор для класу з останнього прикладу міг би бути наступним:
public OurClass(double x_, int i_, char c_)
{
x = x_;
i = i_;
c = c_;
}
Зазвичай конструктору встановлюють специфікатор public, оскільки екземпляри створюються поза межами класу, отже, конструктор має бути відкритим. Зверніть увагу, ідентифікатор конструктора збігається з ідентифікатором класу, а тип результату у нього – відсутній, не вказується навіть службове слово void. Оскільки в нашому прикладі конструктор ініціалізує 3 даних-члени класу OurClass, список його параметрів складається з трьох. При створенні екземпляру класу OurClass тепер необхідно вказати в дужках список із трьох аргументів, якими конструктор проініціалізує дані-члени свого об’єкту. Пригадаймо, що раніше, коли ми ще не обговорювали конструктори, при створенні екземпляру після імені класу ми писали круглі дужки. Тепер стає зрозумілим зміст такого синтаксису. Адже конструктор для класу викликається при створенні екземпляру незалежно від того, визначений у класі конструктор, чи ні. Просто в останньому випадку спрацьовує так званий конструктор за замовчуванням, який не має параметрів та присвоює відповідні нульові значення всім членам класу value-типу та значення null (нульовий вказівник) членам класу reference-типу. Проте, як тільки у класі створений явний конструктор, конструктор за замовчуванням стає недоступним. Перетворимо попередній приклад та проаналізуємо результат роботи програми.
using System;
namespace Param_Metod
{
class OurClass
{
double x; // Всі дані-члени цього класу - закриті!
int i;
char c;
// Конструктор ініціалізує дані-члени класу значеннями
// аргументів; x_, i_, c_ - параметри конструктора OurClass
public OurClass(double x_, int i_, char c_)
{
x = x_;
i = i_;
c = c_;
}
public double Get_x()
{ return x; }
public int Get_i()
{ return i; }
public char Get_c()
{ return c; }
}
class Program
{
static void Main()
{ // Екземпляр створює конструктор з аргументами
OurClass cl = new OurClass(1, 1, 'A');
Console.WriteLine("x = {0}\ti = {1}\tc = {2}",
cl.Get_x(), cl.Get_i(), (char)cl.Get_c());
// Інший екземпляр з іншими аргументами
OurClass another_cl = new OurClass(1.5, 10, 'Z');
Console.WriteLine(
"x = {0}\ti = {1}\tc = {2}", another_cl.Get_x(),
another_cl.Get_i(), another_cl.Get_c());
// Тепер створити екземпляр без аргументів неможливо!
OurClass bad_cl = new OurClass();// Помилка!
}
}
}
Підведемо підсумки.
Кожен клас має конструктор – метод одноіменний з класом, для якого не вказується тип результату. Конструктор автоматично викликається в момент створення екземпляру (об’єкту) класу. Аргументи для конструктора вказуються у круглих дужках.
Якщо клас не містить явно визначеного конструктора, то викликається конструктор за замовчуванням (by default) з порожнім списком аргументів. Він зануляє дані-члени класу.
Якщо в класі явно визначений конструктор, то конструктор за замовчуванням компілятором не використовується.
Безпосередньо викликати конструктор неможливо – це прерогатива компілятора, який звертається до конструктора при створенні об’єкту класу.
|