Основні поняття

1. Стандарт мови. Мову програмування С++ на початку 80-х років створив Бьяртні Страуструп на базі популярної серед професіоналів - програмістів мови С, яку розробив Деніс Рітчі. Мова одержала назву від С та операції інкременту (++), визначеної лише у ній. Така операція збільшує на одиницю значення змінної, до якої її застосовують.

С++ є розширенням мови С. окрім стандартних команд, сюди увійшли засоби для об’єктно – орієнтованого й узагальненого програмування. С++ - це перша у світі мова об’єктно – орієнтованого програмування, суть якого полягає в об’єднанні даних та алгоритмів їх опрацювання у єдине ціле.

Узагальнене програмування, яке також підтримується мовою С++, - це ще один спосіб програмування, де код програми створюють незалежно від типу даних, що суттєво, наприклад, для задач упорядкування даних, об’єднання списків тощо.

Оскільки С++ є розширенням мови С, то всі програми, складені мовою С, коректно транслюються компілятором С++, тому що бібліотеки, які належать до складу мови С, є також і в С++.

Текст будь-якої програми складається з команд, описів змінних, сталих, приєднань бібліотек тощо. Такий текст часто називають програмним кодом. Програмний код необхідно перекласти на внутрішню мову комп’ютера, тобто створити машинний код. Цю операцію виконує компілятор мови програмування.

Для комп’ютерів різних класів, а також для різних операційних систем створено багато компіляторів мови С++.

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

2. Алфавіт і ключові слова. Мови програмування, як і розмовні, мають власний алфавіт – набір допустимих символів. Алфавіт мови С++ складається з:

• великих і малих літер латинського алфавіту: «А», …, «Z», «а», …, «z»;

• цифр 0, 1, …, 9;

• спеціальних символів: “ ‘ ( ) [ ] { } < > . , ; : ? ! ~ * + - = / \ | # % $ & ^ @ та символу підкреслення _.

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

Слова поділяються на ключові слова й ідентифікатори. Ідентифікатор – це назва (ім’я), яку користувач надає об’єктам, наприклад, змінним, сталим, функціям. Усі слова можуть складатися з рядків чи прописних літер англійського алфавіту, цифр, а також містити символ підкреслення. Ідентифікатор завжди починається з букви або із символу підкреслення.

Зауваження 1. Однакові за змістом малі та великі літери у мові С++ вважаються різними символами. Наприклад, імена MyName та myname позначають різні об’єкти.

Зарезервовані ідентифікатори називаються ключовими словами. Вони використовуються для написання команд. Змінити призначення ключового слова у програмі не можна. Основні ключові слова мови С++:

asm	double	mutable	switch
auto	else	new	template
bool	enum	operator	this
break	explicit	private	throw
case	extern	protected	try
catch	float	public	typedef
char	for	register	typename
class	friend	return	union
const	goto	short	unsigned
continue	if	signed	virtual
default	inline	sizeof	void
delete	int	static	volatile
do	long	struct	while

3. Директиви препроцесора. Препроцесор – це програма, яка опрацьовує директиви. Директиви препроцесора – це команди компілятора відповідної мови програмування, які виконуються на початку компіляції програми. Директиви мови С++ починаються із символу #. Розглянемо декілька типів директив.

Директива #include означає, що до програми необхідно приєднати програмний код із зазначеного після неї файлу.

Файли, які приєднують директивою #include, називаються файлами заголовків (header-файлами, бібліотеками, модулями). У таких файлах зазвичай оголошують сталі й змінні, заголовки (сигнатури) функцій тощо.

Усі стандартні команди та функції мови С++ визначенні у файлах заголовків. Щоб приєднати модуль до програми користувача, директиву препроцесора необхідно зазначити на початку програми так:

#include <назва файлу.розширення>

або так:

#include «шлях до файлу\назва файлу.розширення»

Зазвичай усі стандартні бібліотеки розміщені у папці INCLUDE середовища С++. У такому випадку назва файлу є параметром директиви, її зазначають у кутових дужках <назва>, наприклад

#include <math.h>.

Якщо ж потрібний файл розміщений не у папці INCLUDE, то назву файлу із зазначенням шляху пишуть у лапках «…». Наприклад, якщо деякий файл MyBib.h є у папці stud на диску d:, то треба писати так:

#include «d:\ stud\ MyBib.h».

Зауваження 2. Згідно зі стандартом ISO/ANSІ файли заголовків у директиві #include прийнято записувати без розширення, наприклад #include <math>. Файли заголовків мови С, які використовуються у С++ - програмах, починаються з літери с, наприклад #include <cstdio>. Ця можливість реалізована у сучасних компіляторах мови.

Директива #define має подвійне значення. По-перше, вона може задати стале значення (оголошує сталу). Наприклад, якщо у програмі задано #define N25, то N під час виконання програми матиме значення 25. По-друге, вона дає змогу описати макрос – короткі команди (переозначити команди) чи записати функції, наприклад, так:

#define D(a, b, c) ((b) * (b) – 4 * (a) * (c)).

Тепер скрізь для обчислення дискримінанта замість команди

d = b * b – 4 * a * c

можна записувати

d = D(a, b, c).

директива #undef скасовує дію директиви #define. Наприклад,

#define D(a, b, c) ((b) * (b) – 4 * (a) * (c))

#undef D

#define D(a, b, c) ((a) * (b) * (c))

4. Перша програма. Суттєвою особливістю мови С++ порівняно з іншими мовами є те, що програми складаються з функцій, які відіграють роль підпрограм в інших мовах. Головна функція, яка має бути у кожній програмі, - це функція вигляду

main(void) { тіло функції з командою return 0; }

де main() – заголовок функції. Ключове слово void означає, що функція не залежить від параметрів, його записувати не обов’язково. Функцію з параметрами розглядатимемо нижче. У тілі функції містяться команди та виклики інших функцій. Команди одну від одної відокремлюють символом « ; » (крапка з комою). Текст функції закінчується командою повернення return. Тіло функції (усі команди після заголовка) записується у фігурних дужках { }.

Розглянемо програму, у результаті виконання якої на екран буде виведено повідомлення: Привіт, студенте! Я С++!

// Моя перша програма мовою С++

#include <iostream.h>

int main()

{

cout << “Привіт, студенте! Я С++!”;

return 0;

}

Розглянемо елементи програми. У першому рядку є коментар. Коментар – це фрагмент тексту програми, який слугує для пояснення призначення програми чи окремих команд і не впливає на виконання команд. Його записують так: //текст коментарю або так: /* текст коментарю */. У першому випадку коментар має бути або у кінці рядка, або єдиним у рядку. Другий спосіб більш універсальний: коментар можна записувати будь-де, не розриваючи лексем.

Директива #include <iostream.h> під’єднує бібліотечний файл iostream.h. саме у цьому файлі описані функції, які дають змогу виконувати операції введення-виведення даних.

Далі у програмі записана обов’язкова функція main(). Ключове слово int означає, що функція main() повертатиме у точку виклику результат цілого типу.

Конструкція cout << забезпечує виведення на екран монітора повідомлення «Привіт, студенте! Я С++!».

Команда return слугує для виходу з функції main(). Числовий параметр після return є результатом (значенням) функції (у цій програмі - 0).

Зауваження 3. Функцію main() можна застосувати так:

void main() { тіло функції; }

Така функція називається функцією main() типу void. Вона не повертає у програму жодних значень, тому команду return писати не треба.

5. Загальна структура програми. Найпростіша програма мовою С++ має такий загальний вигляд:

//коментарі #include <назва бібліотечного файлу> void main() { <тіло функції>; }

Зауваження 4. Ви вже знаєте, що в кутових дужках < > записують значення параметра директиви, які у програмі пропускати не можна. Крім цього, у кутових дужках описуватимемо словами загальні конструкції мови, замість яких у реальній програмі будуть конкретні команди. У цьому разі у програмі кутові дужки не пишуть.

Зазвичай складніші програми містять значну кількість функцій та додаткових елементів. Тому у загальному випадку програма мовою С++ має такий вигляд:

//коментарі #include <назва бібліотечного файлу 1> … #include <назва бібліотечного файлу N> <інші директиви препроцесора> … <оголошення глобальних змінних>; <оголошення глобальних сталих>; <оголошення та створення функцій користувача>; … <тип результату функції> main(опис формальних параметрів) { <оголошення локальних змінних>; <оголошення локальних сталих>; <команди>; }

Розрізняють глобальні та локальні дані. Дані, визначені для всіх функцій, тут називатимемо глобальними, а дані, які використовуються лише в окремих функціях чи блоках, - локальними.

6. Сталі та змінні. Змінна чи стала – це пойменована ділянка оперативної пам’яті комп’ютера, де зберігається значення величини.

Змінні і сталі (їх прийнято називати даними) мають такі властивості : назву (ім’я), значення, тип. Назву дає програміст.

Для роботи з даними слід зарезервувати певний обсяг оперативної пам’яті комп’ютера, де зберігатимуться їхні значення. Тому всі дані, які використовуються у програмі, потрібно заздалегідь описати (оголосити), оскільки компілятор розподіляє пам’ять згідно з описами.

Якщо значення деякої величини (даного) не змінюватиметься протягом виконання усієї програми, то таке дане варто задати як сталу (константу, const). Це можна зробити так:

const <назва сталої 1> = <значення сталої 1>;

або так:

const <тип> <назва сталої 2> = <значення сталої 2>;

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

Приклад 1. Оголосити три сталі

const vik = 20, rist = 176;

const float g = 2.78;

Для сталої g задано тип – float і значення 2,78.

Зауваження 5. У С++ є такі стандартні сталі: число π є сталою М_PI, π/2 – M_PI_2, π/4 – M_PI_4, 1/π – M_1_PI, 1/ - M_I_SQRTPI тощо. Ці сталі можна безпосередньо використовувати у програмі, заздалегідь підключивши модуль math.h.

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

<тип змінних> <назва змінної 1> = <значення 1>, …, <назва змінної N> = <значення N>, <список інших змінних>;

Типи даних

1. Типи даних. Усі дані, які беруть участь у розв’язанні задач, ретельно класифікуються за типами. Тип визначає допустимі значення даного, операції, які можна над ним виконувати, й обсяг оперативної пам’яті, який резервується для нього.

Зауваження 1. Обсяг може залежати також від різновиду операційної системи комп’ютера.

Визначити, який обсяг пам’яті компілятор надає даному того чи іншого типу, можна за допомогою команди sizeof(<назва типу>). Наприклад, команда cout<<sizeof(short int) виведе на екран монітора цифру 2. Це означає, що дане типу short int займає у пам’яті комп’ютера 2 байти.

У табл. 1, 2 наведені назви основних числових типів, обсяги пам’яті, які резервуються для екземплярів даних цих типів, і діапазони допустимих значень даних.

Числові дані поділяють на цілочисельні (цілі) та дійсні.

2. Цілі типи. Цілі типи описані в табл. 1.

Таблиця 1. Дані цілочисельних типів

Назва типу	Обсяг, байтів	Діапазон допустимих значень
Int	2 або 4	-32768 … 32767 або -2147483648 … 2147483647
short int	2	-32768 … 32767
unsigned short int	2 або 4	0 … 65535 або 0 … 4294967295
long int	4	-2147483648 … 2147483647
unsigned long int	4	0 … 4294967295

Приклад 1. Оголосимо три змінні цілого типу:

int x, y; short int z;

На етапі компіляції для змінних x, y, z буде надано певний обсяг оперативної пам’яті.

Надати значення цим змінним можна на етапі виконання програми за допомогою команд присвоєння, наприклад, так: x = 157, y = -68, z = 15;. У ділянку пам’яті, надану для змінної х, буде занесено число 157, для y - -68, а для z – 15.

Під час виконання програми значення змінних можна змінювати. Наприклад, команда присвоєння х = 2003 занесе у відповідну для змінної х ділянку пам’яті число 2003 (попереднє значення 157 вилучається автоматично).

Приклад 2. Сталі цілого типу можна оголосити так:

const int a = 145;

const long int b = 365978.

Значення даних a та b у програмі змінювати не можна.

3. Дійсні типи. Дійсні типи описані в табл. 2.

Таблиця 2. Дійсні типи

Назва типу	Обсяг, байтів	Діапазон значень
Float	4	± … ± ; 0
Double	8	± … ± ; 0
long double	10	± … ± ; 0

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

Приклад 3. Розглянемо фрагмент програми

float h, pi = 3.1415926; double v = 365.976;

const float w = -12, h = 23.4;

Тут оголошено дві змінні (h, pi) типу float і змінну v типу double, а також сталі w = -12, h = 23.4 типу float.

Дійсні числа можна записувати у форматі з фіксованою крапкою, наприклад -2.3, 5.0041, або у науковому форматі (у форматі з рухомою крапкою), наприклад, -0.2е+2 (це є число - 20), 3.27е-3 (це є 0,00327).

Запис пе ± т означає множення числа п на 10 у степені ± т, тобто за означенням

ne ± m = n ×

Знак «+» можна не зазначати, знак «-» писати обов’язково.

4. Символьний тип (char). Символьний тип – це множина символів кодової таблиці комп’ютера ASCII. Символьна стала – це один символ (1 байт), узятий у лапки на зразок апострофа, або число у 8-, 10- чи 16-й системі числення, яке є кодом символу у таблиці ASCII.

Приклад 4. Розглянемо описи символьних змінних, де змінним m1, m2, m3 і m4 надамо значення латинської літери ´А´ чотирма способами:

char m1 = ‘A’, m2 = 0101, m3 = 65, m4 = 0x41;

Число 65 – це десятковий код символу ‘A’, 101 – вісімко вий, 41 – шістнадцятко вий. На початку останніх двох кодів (101, 41) записують префікс «0» чи «0х» відповідно.

Приклад 5. Розглянемо спосіб визначення десяткового ASCII-коду деякого символу, наприклад ‘A’:

char c = ‘A’; int n = c;

Змінна n набуде значення 65.

5. Логічний тип (bool). Логічний тип характеризується двома значеннями даних: false (хибність) і true (істина). Наприклад, bool b = true. Змінні цього типу займають 1 байт у пам’яті комп’ютера. У С++ значення змінних типу int можна асоціювати з логічними значеннями: нулю відповідає значення false, усім іншим числам – true.

Зауважимо, що не всі компілятори підтримують тип даних bool. Тому, перед тим як його використовувати, варто з’ясувати можливості компілятора.

6. Службове слово void. Службове слово void дописують до назв функцій, які не повертають значення у точку виклику або до функцій без параметрів.

7. Типи користувача. Крім вище описаних стандартних типів даних, можна створювати типи користувача

typedef <опис типу> <назва нового типу>;

Приклад 6. Опишемо тип kilkist для позначення коротких цілих даних без знаку:

typedef unsigned short int kilkist;

Змінні (kil1, kil2) цього типу у програмі можна оголосити так: kilkist kil1, kil2;

Присвоєння

1. Проста програма. Програма – це послідовність команд, з допомогою яких записують алгоритми розв’язування конкретної задачі.

Задача 1 (про прямокутний трикутник). Нехай задано катети прямокутного трикутника a = 3, b = 4. Знайти периметр і площу трикутника.

//Програма Трикутник 1

#include <iostream.h>

#include <math.h>

void main()

{

int a = 3, b = 4, c, p, s; //Задаємо довжини сторін

c = sqrt(a * a + b * b) //Обчислюємо гіпотенузу

p = a + b + c; //Обчислюємо периметр

s = a * b / 2; //Обчислюємо площу

cout << “p =” << p << “\n”; //Виводимо значення периметра

cout << “s =” << s << “\n”; //та площі на екран

cout << “Виконав Квакін В.”;

}

Символ «*» позначає операцію множення, а «/» - ділення. Функція sqrt() призначена для обчислення квадратного кореня. Ця функція визначена у бібліотеці math.h, яку під’єдують на початку програми. Після виконання програми на екрані отримаємо

p = 12

s = 6

Виконав Квакін В.

2. Команда присвоєння. Правила узгодження типів. Команда присвоєння має такий загальний вигляд:

<назва змінної> = <вираз>

або

<назва змінної 1> = <назва змінної 2> = … = <назва змінної N> = <вираз>

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

Розглянемо приклади написання команд присвоєння:

a = 8 – 2;

c = d = a +4;

e = d / 5 + c;

Змінна і вираз не обов’язково повинні бути одного типу. Крім того, у виразі можуть бути дані різних числових типів (змішані вирази). Якщо тип змінної не збігається з типом виразу, то у С++ відбувається автоматичне перетворення (узгодження) типів.

Розрізняють явне та неявне узгодження типів, з якими ознайомимося на приклдах.

Надалі поза командами імена змінних подаватимемо курсивом.

Приклад 1. Розглянемо програму, де значення змінної а типу int треба помножити на значення змінної с типу float (відповідні числа вводитимемо з клавіатури) і результат надати змінній b типу int:

//Множення чисел

#include <iostream.h>

void main()

{

int b, a; float c;

cout << “Введіть ціле число \n”;

cin >> a; //Вводимо значення а з клавіатури

cout << “Введіть дійсне число \n”;

cin >> c; //Вводимо значення с з клавіатури

b = c * a;

cout << “a =” << a<< “\n”;

cout << “c =” << c<< “\n”;

cout << “b =” << b<< “\n”;

}

Для введення значення змінної з клавіатури використовується конструкція cin >>.

Якщо ввести дані так: а = 2, с = 3.8, то після виконання програми на екрані отримаємо

а = 2

с = 3.8

b = 7

Спочатку відбулося множення (с · а = 3.8 · 2 = 7.6). оскільки змінна b цілого типу, то дробову частину числа 7,6 було відкинуто і змінній b надано значення 7. Відбулося неявне перетворення типів (перетворення за замовчуванням). Якщо у попередній програмі змінну b оголосити як змінну типу float, то отримаємо b = 7,6.

Для явного перетворення типів новий тип задають у круглих дужках перед змінною або виразом. Якщо у програмі вище записати команду

b = (int)c * a;

то під час обчислення виразу спочатку відбудеться перетворення даного с до цілого типу (3), а потім – множення (с · а = 3 · 2 = 6). Отримаємо а = 2, с = 3.8, b = 6.

Якщо ж у програмі цю команду записати так:

b = (int)(c * a);

то спочатку відбудеться множення (с · а = 3.8 · 2 = 7,6), а пізніше результат буде перетворений до цілого числа (b = 7). Отримаємо а = 2, с = 3.8, b = 7.

Отже, у випадку використання явного перетворення типів потрібно стежити, до яких елементів виразу воно застосовується. Узгодження типів у виразах відбувається з урахуванням пріоритетів типів. Зазначимо пріоритети типів за їхнім спаданням: double, float, long, int, short. за замовчуванням результат перетворюється до старшого типу.

Вирази

1. Арифметичні операції над даними наведені в табл. 3.

Таблиця 3. Арифметичні операції

Пріоритет	Операції	Зміст операції
1	+, -	Присвоєння знака
2	*, /, %	Множення, ділення, остача від ділення
3	+, -	Додавання, віднімання
4	==, !=, <, <=, >, >=	Порівняння (відношення)

Розглянемо операції порівняння. Операція == означає дорівнює, != - не дорівнює, <= - менше або дорівнює, >= - більше або дорівнює.

Виконання кожної операції здійснюється з урахуванням їхніх пріоритетів (тут 1 - найвищий). Для зміни звичайного порядку виконання операцій використовують круглі дужки.

Приклад 1. Розглянемо результати виконання операцій

2 * -5 + 4 = -6; 2 * (-5 + 4)= -2; 7 % 3 = 1;

12 / 4 – 2 = 1; 12 / (4 - 2)= 6; 7 % 3 * -5 = -5.

Приклад 2. Нехай х = 3, у = 5. Дано вираз х == у. значення цього виразу буде false (хибний), оскільки значення змінних х та у не рівні між собою, а значенням виразу х != у – true (істина), значеннями виразу х > у, х <= (у - 2) – відповідно false та true.

2. Операції інкременту (++) та декременту (--). Операції інкременту і декременту існують у двох формах – перфіксній та постфіксній. Якщо символи ++ (--) записані перед змінною – то це інкремент (декремент) у префіксній формі, а якщо після змінної – у постфікс ній. Операція інкременту має такий вигляд:

++<змінна> або <змінна>++

Дія операції. Значення змінної збільшується на одиницю. Команда ++а, а++ рівносильні команді а = а + 1. Форма інкременту (декременту) впливає на порядок виконання операцій у виразах. Розглянемо це на прикладах.

Приклад 3. Результат виконання команд

a = 2;

b = 3 * ++a;

будуть такими : а = 3, b = 3 · 3 = 9. Туту використано операцію інкременту у префіксній формі: спочатку збільшується значення змінної а на одиницю, а пізніше обчислюється вираз.

Приклад 4. Розглянемо команди

c = 5; d = (c++) +4;

Тут спочатку обчислюється вираз (для d) з с = 5, а потім збільшується значення змінної с на одиницю. Тобто d = с + 4 = 5 + 4 = 9, с = с + 1 = 5 + 1 = 6 (це операція інкременту у постфіксній формі). Оскільки у виразі записано три знаки плюс «+» підряд, то для однозначного задання порядку операцій використано круглі дужки.

Аналогічно операція декременту має такий вид:

--<змінна> або <змінна>--

Значення змінної зменшується на одиницю. Команда --а та а-- діють як і команда а = а – 1.

Приклад 5. Результати виконання команд

х = 4;

у = 15 / --х;

будуть такими: х = 3, у = 15 / 3 = 5.тут спочатку значення змінної х зменшується на одиницю, а пізніше обчислюється вираз для у.

Приклад 6. Під час виконання команд

f = 20;

g = (f--) – 10;

змінним f , g будуть надані значення 19 і 10 відповідно.

3. Команда присвоєння, суміщена з арифметичною операцією. Щоб надати значення змінній, можна скористатися командою присвоєння, суміщеною з деякою арифметичною операцією, а саме: +=, -=, *=, /=, %=. Загальний вигляд команди присвоєння, суміщеної з арифметичною операцією, такий:

<змінна> <символ арифметичної операції> = <вираз>

Зауважимо, що між символом арифметичної операції та символом «=» пропуск не допускається (це лексема).

Наприклад, команди

а = а + 10 та а += 10

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

а += 10. А замість команди b = 4 * b можна писати b *= 4.

4. Математичні функції. Усі стандартні математичні функції у С++ описані у бібліотеці math.h. Тому, якщо вони використовуються, на початку програми необхідно записати рядок під’єднання потрібного файлу заголовків

#include <math.h>

Основні математичні функції бібліотеки math.h наведені у табл. 4. Аргументи функцій записують у круглих дужках.

Таблиця 4. Математичні функції

Назва функції	Математичний запис	Назва функції	Математичний запис
abs(x)	|x|	fabs(x)	|x|
cos(x)	cos(x)	acos(x)	arcos(x)
sin(x)	sin(x)	asin(x)	arcsin(x)
tan(x)	tg(x)	atan(x)	arctg(x)
log(x)	ln(x)	ceil(x)	Заокруглює число х до більшого цілого
pow(x, y)		floor(x)	Відкидає дробову частину числа х
sqrt(x)		fmod(x, y)	Обчислює остачу від ділення числа х на число у
exp(x)
pow10(x)
log10(x)	lg(x)

Усі наведені функції, крім abs(x) і pow10(x), мають тип аргументу і результату double. Для функцій abs(x) та pow10(x) типом аргументу і результату є int.

Приклад 7. Нехай оголошено змінні

int x = -2, x1, a = 3;

float pi = 3.1415926, m = 16, kut, k;

Тоді у результаті виконання команд

x1 = abs(x); a = pow10(a);

kut = cos(2 * pi);

k = pow(m, 1. / 4);

m = sgrt(m);

змінним х1, а, kut, k, m будуть надані наступні значення:

x1 = abs(-2) = |-2| = 2;

a = pow10(3) = = 1000;

kut = cos(2 * 3.1415926) = 1;

k = pow(16, 1. / 4) = = 2;

m = sgrt(16) = = 4.

Приклад 8. Нехай у програмі оголошені змінні b, b1, b2 типу double і нехай b = 7.6. Тоді після виконання команд

b1 = ceil(b);

b2 = floor(b);

змінна b1 набуде значення 8, а змінна b2 – значення 7.

Усі інші математичні функції можна виразити через основні. Наприклад, ctgs = 1 / tgx, = = ln(a) / lm (b) тощо.

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

1. обчислюються значення всіх функцій, які входять у вираз;

2. виконуються операції присвоєння знака, множення, ділення та остачі від ділення;

3. виконуються операції додавання та віднімання.

Операції одного рівня виконуються послідовно зліва на право. Для зміни порядку виконання операцій використовують круглі дужки. Спочатку обчислюються вирази у дужках – найперше у внутрішніх, пізніше – у зовнішніх. Кількість відкритих і закритих дужок у виразі повинна бути однаковою.

Усі елементи виразів (дроби, показник степеня, індекси) записують у горизонтальному рядку. У багатьох випадках їх беруть у дужки. Вирази можна записувати у декількох рядках. «Розривати» вирази можна, наприклад, після символу арифметичної операції. Власне символ дублювати не потрібно.

Приклад 9. Складемо програму, яка обчислює значення функції y= - |x - 5| + для х = 2.

#include <iostream.h> //Обчислення виразу

#include <math.h>

void main()

{

const float pi = 3.1415926;

float x = 2, y;

y = pow(x * x + 7.2, 1. / 5) – fabs(x – 5) + sin(pi * x / 3);

cout << “\n y =” << y << “\n”;

}

Результат виконання програми такий: у = -0.512748.

Потоки. Введення – виведення даних

1. Потоки. У С++ немає вбудованих команд уведення – виведення даних. Для організації введення – виведення тут реалізована концепція потоків, яка визначена у спеціальних модулях. У модулі istream.h описані команди введення, у модулі ostream.h – команди виведення, а у модулі iostream.h – команди виведення в введення.

Під потоком розуміють процес уведення – виведення інформації у файл. Периферійні пристрої введення – виведення, такі як клавіатура, монітор, принтер, розглядаються як текстові файли. Під час виконання будь-якої програми автоматично підключаються стандартні потоки для введення даних з клавіатури (cin), виведення на екран (cout), виведення повідомлення про помилки (cerr) і допоміжний потік (clog).

Стандартні потоки використовують команди введення (>>) ти виведення (<<) даних. За замовчуванням стандартним пристроєм для потоків виведення даних і повідомлень про помилки є монітор користувача, а для потоку введення даних – клавіатура. Однак потоки можна перенаправляти, наприклад, можна зчитувати вхідну інформацію для програми не з клавіатури, а з деякого текстового файлу на диску.

2. Команда введення даних. Надавати значення змінним можна двома способами: за допомогою команди присвоєння, наприклад х = 3.1, або команди уведення даних із клавіатури. Команда уведення даних із клавіатури дає змогу виконувати програму для різних вхідних даних, що робить її більш універсальною (масовою). Команда введення >> описана у бібліотеці iostream.h (istream.h) і має такий загальний вигляд:

cin << <змінна>;

Дія команди. Виконання програми зупиняється. Система переходить у режим очікування введення даного (екран темний, миготить курсор). Користувач набирає на клавіатурі значення змінної і натискає на клавішу вводу. У результаті виконання цієї команди змінній буде присвоєно конкретне значення (те, яке користувач уведе з клавіатури).

Якщо необхідно ввести значення відразу для декількох змінних, то можна або використати декілька потоків введення, або записати усі змінні в одному потоці cin, застосувавши для цього декілька команд «>>», а саме:

cin >> <змінна 1> >> <змінна 2> >> … >> <змінна N>;

Розглянемо програму Трикутник1. Значення сторін можна ввести, наприклад, так:

int a, b, c;

cin >> a;

cin >> b;

cin >> c;

Під час виконання програми на клавіатурі набираємо

3 (натискаємо на клавішу Enter)

4 (натискаємо на клавішу Enter)

5 (натискаємо на клавішу Enter)

У результаті виконання команд змінні набувають таких значень: a = 3, b = 4, c = 5. Значення змінних також можна вводити через пропуск. Тобто на клавіатурі можна набрати 3 4 5 (натискаємо на клавішу Enter). Одним потоком змінним можна надати значення так:

cin >> a >> b >> с;

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

Програми необхідно складати так, щоб ними могли користуватись не лише укладачі, але й інші особи. Тобто програми мають бути масовими і зрозумілими. Перед командою введення даних варто записувати команду виведення на екран текстового повідомлення-підказки про те, що саме слід ввести. Наприклад, у програмі Трикутник1 можна вивести повідомлення «Уведіть сторони трикутника» або «а, b, с = » тощо, а вже після цього записувати команду введення:

cout << “Уведіть сторони трикутника”;

cin >> a >> b >> c;

3. Команда виведення даних. Для виведення на екран повідомлень і результатів обчислень використовують стандартний потік виведення cout і команду << , які визначені у бібліотеці iostream.h (ostream.h):

cout << <вираз 1> << <вираз 2> << … << <вираз N>;

У списку виведення можуть бути сталі, змінні або вирази. Елементи списку у потоці cout відокремлюють командами <<.

Дія команди. Сталі, значення змінних та виразів виводяться на екран у вікно виведення. Це вікно можна переглядати за допомогою команд Window → User screen головного вікна компілятора або комбінації клавіш Alt + F5.

Текстові повідомлення у команді виведення записують у лапках. Лапки на екран виводитися не будуть.

Результати виконання програми Трикутник (периметр і площу) можна вивести, наприклад, так:

cout << “Периметр =” << p;

cout << “Площа =” << s;

На екрані одержимо

Периметр = 12Площа = 6

Як бачимо, результати зливаються. Для того, щоб дані виводили у потрібному для користувача вигляді, використовують керуючі послідовності.

4. Керуючі послідовності. Керуючі послідовності – це комбінації спеціальних символів, які використовуються для введення та виведення даних. Керуюча послідовність складається із символу слеш «\» і спеціального означеного символу. Вони призначені для форматованого виведення результатів обчислень на екран, наприклад, для переходу на новий рядок, подання звукового сигналу, а також для виведення на екран деяких спеціальних символів: апострофа, лапок тощо. Основні керуючі послідовності наведені у табл. 5.

Таблиця 5. Керуючі послідовності

Символи керуючих послідовностей	Коментар
\a, \7	Подати звуковий сигнал
\b	Повернути курсор на один символ назад (знищити попередній символ)
\f	Перейти на нову сторінку
\n	Перейти на новий рядок
\r	Повернути курсор на початок рядка
\t	Перевести курсор до наступної позиції табуляції
\v	Вертикальна табуляція
\\	Вивести символ похилої риски
\’	Вивести символ апострофа
\”	Вивести символ лапок
\?	Вивести знак запитання

Керуючі послідовності разом з коментарями записують у лапках. Розглянемо дію цих послідовностей на прикладі. Якщо записати команди

cout << “Увага! \a\n”; cout << “Дане \”a\” введено некоректно \n”;

cout << “Виконайте програму ще раз”;

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

Увага!

Дане «а» введено некоректно

Виконайте програму ще раз

Якщо використати послідовність, невизначену у мові С++ (наприклад, \u), то компілятор пропустить символ послідовності (похилу риску) в виведе на екран лише символ, записаний після риски (у нашому випадку літеру u).

Зауваження 1. Замість керуючої послідовності \n можна використовувати команду endl – кінець рядка. Наприклад, ці дві команди рівносильні:

cout << “f =” << f << “\n”;

cout << “f =” << f << endl;

Зауваження 2. Значення дійсних чисел (тип float) можна виводити на екран у стандартному або науковому форматах. Якщо значення даного необхідно заокруглити до п значущих цифр, то перед командою виведення треба записати cout.precision(n). Для подання результатів у науковому форматі необхідно під’єднати файл заголовка iomanip.h і перед командою виведення записати

cout << setiosflags(ios::scientific);

Задача 1 (про трикутник, заданий координатами вершин). Дано координати трьох вершин трикутника А(1; 1), В(2; 2) та С(-1; 2). Обчислити медіану і радіус описаного кола r.

#include <iostream.h> #include <math.h> #include <conio.h> void main() { cirscr(); float x1, x2, x3, y1, y2, y3; cout << “”; cin >> x1 >> y1; cout << “”; cin >> x2 >> y2; cout << “”; cin >> x3 >> y3; float a, b, c, x, y, mb, p, s, r; a = sgrt(pow((x3 – x2), 2) + pow((y3 – y2), 2)); b = sgrt(pow((x1 – x3), 2) + pow((y1 – y3), 2)); c = sgrt(pow((x1 – x2), 2) + pow((y1 – y2), 2)); x = (x1 + x3) / 2; y = (y1 + y3) / 2; mb = sgrt(pow((x – x2), 2) + pow((y – y2), 2)); p = (a + b + c) / 2; s = sgrt(p * (p – a) * (p – b) * (p – c)); r = a * b * c / (4 * s); cout << “mb =” << mb << “\n”; cout << “r =” << r << “\n”; getch(); }

//Трикутник2 //Бібліотека математичних функцій //Очищаємо екран //Оголошуємо змінні та вводимо дані //Оголошуємо додаткові змінні //Обчислюємо довжину сторін трикутника //Обчислюємо координати //середини сторони b //Обчислюємо медіану mb //Обчислюємо периметр //Обчислюємо площу //Обчислюємо радіус //Виводимо значення медіани //Виводимо радіус //Затримуємо результати на екрані

Під час виконання програми функція cirscr() зітре з екрана усі результати та повідомлення попередніх програм (якщо такі були), і на чистому екрані матимемо

mb = 2.061553

r = 1.581139

У програмі Трикутник2 описано під’єднання бібліотеки conio.h, де визначена функція clrscr() – очищення екрана та функція getch(), яка дає змогу затримувати на екрані результат виконання програми, доки не буде натиснута довільна клавіша на клавіатурі.

Довідка. Для розв’язання типових задач про трикутник наведемо формули обчислення деяких величин:

відстань d між мочками ( ), ( ):

d = ;

координати середини відрізка: x = /2, y = /2;

півпериметр трикутника: p = (a + b + c) / 2;

площа трикутника: s = ;

висота трикутника: / a, 2s / b, 2s / c;

бісектриса трикутника: ,

, ;

радіус описаного кола: R = abc / (4s);

радіус вписаного кола: r = s / p ,

де a, b, c – сторони, а α, β, γ – відповідні кути трикутника.

5. Пере направлення потоків уведення-виведення у MS DOS. Іноді вхідні дані для ехе-файлу програми зручно зчитувати з деякого файлу, а не вводити кожного разу вручну з клавіатури. Для цього необхідно перенаправити потік уведення, увівши у командному рядку

<назва ехе-файлу> < <назва файлу з вхідними даними>

Приклад 1. Нехай програма Трикутник2 зберігається у файлі tyrik.exe, а у файлі dani.txt записано шість дійсних чисел – координат вершин трикутника. Тоді виконати програму і зчитати для неї дані з файлу dani.txt можна так:

tyrik.exe < dani.txt

Щоб вивести результати виконання програми у файл, у командному рядку слід увести

<назва ехе-файлу> > <назва файлу з результатами>

Командою tyrik.exe > res1.txt. результати програми tyrik.exe будуть занесені у файл res1.txt.

Можна одночасно перенаправляти два потоки, тобто зчитувати дані з одного файлу та виводити їх у інший:

<назва ехе-файлу> < <назва файлу з вхідними даними> > <назва файлу з результатами>

Якщо результати файлу file1 необхідно використати як вхідні дані файлу file2, то стандартне введення однієї програми можна з’єднати каналом із стандартним виведенням іншої так:

file1 | file2

Адреси даних. Вказівники. Динамічна пам’ять

1. Адреси даних. Для розв’язання специфічних для мови С++ задач (робота з масивами, побудова графічних зображень і динамічних ефектів) потрібно знати не тільки значення деякої змінної, але й її адресу в оперативній пам’яті. Для визначення адреси даного у пам’яті є операція визначення адреси

& <назва даного>

Приклад 1. Розглянемо фрагмент програми

int a = 25;

cout << “Значення змінної a =” << a << “\n”;

cout << “Адресою змінної a є” << &a;

У результаті виконання цих команд на екрані одержимо:

Значення змінної а = 25

Адресою змінної а є 0xaf72254

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

2. Вказівники. У мові С++ є ще один засіб визначення адреси даного – це вказівники. Вказівник – це змінна, значенням якої є адреса. Вона вказує на початок області оперативної пам’яті, де зберігається дане. Вказівники дають змогу оперувати не з іменами даних, а з їх адресами. Вказівники утворюють так:

<тип даного> * <назва вказівника>;

Можна створювати вказівники на сталі, змінні, функції, інші вказівники тощо. Особливо ефективною є робота з вказівниками на рядки та масиви.

Наприклад,

int *nomer;

float *rist, *prtA, *prtB;

Тут оголошено вказівник на цілий тип nomer і вказівники на дійсний тип rist, prtA, prtB. Надати значення вказівникам можна так:

<назва вказівника> = <адреса змінної>;

Приклад 2. Нехай у програмі оголошені змінні

int n = 10; float stud1, stud2, stud3;

Тоді можна оголосити вказівники nomer і rist на ці змінні:

nomer = &n;

rist = &stud1;

rist = &stud3;

Отримати вмістиме комірки, на яку вказує вказівник, можна за допомогою конструкції *<вказівник>, наприклад * rist є значенням змінної stud3. Вказівники застосовують також для надання значень змінним:

rist = &stud1;

*rist = 1.65; // У комірку пам’яті для змінної stud1беде занесено число 1.65

Тут вказівник rist вказуватиме на адресу змінної stud1, а власне змінній stud1 буде присвоєно значення 1.65.

Приклад 3.Обчислити довжини (в байтах) вказівників на різні типи даних можна так:

int *prt_i; double *prt_d;

cout << “\nНа цілий тип” << sizeof(prt_i);

cout << “\nНа дійсний тип” << sizeof(prt_d);

cout << “\nНа символьний тип” << sizeof(prt_c);

Переконайтесь, що усі вище описані вказівники у пам’яті комп’ютера мають однаковий обсяг.

Вказівники можна переадресовувати. Зокрема, у прикладі 2 вказівнику rist спочатку присвоєно адресу змінної stud1, а потім – змінної stud3. Це правило не діє, якщо вказівник є сталою. Сталий вказівник, що вказуватимемо на одну і ту ж адресу, оголошують так:

const int *rik;

Для вказівників залежно від операційної системи та версії компілятора резервується 2 або 4 байти в оперативній пам’яті.

Над вказівниками визначені арифметичні операції та операції порівняння, описані в табл. 6.

Таблиця 6. Операції, визначені над вказівниками

Операція	Приклади і пояснення
==, !=, >=, <=, >, <	Порівнює значення двох вказівників (адреси, на які вони вказують). Наприклад, якщо вказівники вказують на одне і те ж саме дане, то результатом порівняння vk1 == vk2 беде істина, інакше – хибність.
-	vk1 - vk2. Використовується для визначення кількості елементів, які наявні між двома вказівниками.
+, -	vk1 + k, vk1 – k. Знаходить вказівник, який зміщений відносно даного на k одиниць.

3. Динамічна пам’ять. Команди new і delete. Значення даних у пам’яті комп’ютера можна зберігати області даних (статична пам’ять), у стеку або в динамічній пам’яті ("на купі"). Усі змінні, які ми розглядали досі, - статичні. Під час їх оголошення система автоматично надає для зберігання їхніх значень певний обсяг оперативної пам’яті, і цей розподіл пам’яті залишається незмінним протягом виконання програми. Пам’ять, надана цим змінним, резервується (фіксується) у середині ехе-файлу відокремлюваної програми. Навіть якщо не всі змінні будуть використані у програмі, пам’ять буде зарезервована, тобто використана неефективно. Пам’ять, надана таким змінним, вивільняється лише після виконання програми. Тому в оперативній пам’яті можна розмістити лише обмежену кількість даних.

Однак є задачі, де заздалегідь невідомо, скільки змінних потрібно для їхнього розв’язування, а, отже, який обсяг пам’яті потрібно зарезервувати, або задачі, у яких, навпаки, заздалегідь відомо, що змінних буде багато, наприклад, задачі опрацювання масивів великих розмірів. У таких випадках застосовують динамічну організацію пам’яті.

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

Для роботи з динамічними змінними використовують вказівники. Для виділення динамічної пам’яті застосовується команда new так:

<тип вказівника> *<назва> = new <тип змінної>;

Дія команди new. Для відповідного типу змінної автоматично надається необхідна неперервна ділянка пам’яті. Команда new повертає обсяг цієї ділянки, а вказівник вказує на її початок. Наприклад, щоб зарезервувати у пам’яті комп’ютера область для зберігання значення цілого типу, застосовують таку команду:

int *prt2 = new float(3.14);

У адресу, на яку показує prt2, буде занесене число 3,14.

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

Після опрацювання динамічних змінних пам’ять необхідно вивільнити, а відповідний вказівник занулити. Якщо цього не зробити, то пам’ять можна вичерпати. Вивільняють пам’ять за допомогою команди

delete <назва вказівника>;

Щоб вказівник не вказував на жодну ділянку пам’яті, його необхідно занулити такою командою:

<назва вказівника> = NULL;

Значенням (адресою) такого вказівника буде нульова адреса 0х00000000. Тут не можна бути розміщене значення жодного даного.

Приклад 8. Розглянемо, як відбувається розподіл пам’яті. Надамо пам’ять для двох змінних цілого типу та присвоїмо їм деякі значення. Пізніше вивільнимо пам’ять.

#include <iostream.h> void main() { int *c1 = new int; *c1 = 5; int *c2 = new int(7); cout << *c1 << “\t” << *c2 << “\n”; c1 = c2; cout << *c1 << “\t” << *c2 << “\n”; delete(c2); cout << *c1 << “\n”; }

// Готуємо пам’ять для цілого числа // Змінна *с1 набуває значення5 // Виділяється пам’ять для с2 і *с2 набуває // значення 7 // Виводимо 5 та 7 // Переадресація – с1 вказуватимемо на ту саму // ділянку пам’яті, що і с2 // Виводимо 7 та 7 // Пам’ять, надану для с2, вивільняємо // Виводимо 7

Довідка 1. У стандарті ANSI мови С у модулях stdlib.h та alloc.h визначені функції malloc і calloc для динамічної пам’яті, а також функція free для вивільнення пам’яті.

Довідка 2. Замість значення NULL можна записати <назва вказівника> = 0.

Файли

Часто виникає потреба опрацьовувати інформацію, розміщену на зовнішніх носіях (на дисках), або виводити результати програми не на екран монітора, а у файл. Прикладами таких даних є інформація про розклад руху транспорту, успішність студентів, наявність товарів у магазинах, адреси, анкетні дані тощо.

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

Існує декілька бібліотечних функцій, які дають змогу зчитувати інформацію з файлу або спрямовувати потік виведення у файл. Функції, які розглядатимемо, описані в бібліотеці fstream.h. Тому для роботи за файлами насамперед необхідно підключити саме цю бібліотеку.

Зауваження1. У модулі fstream.h також містяться описи стандартних потоків cout і cin. Тому, щоб зчитати інформацію з файлу і вивести її на екран монітора, модуль iostream.h підключати не обов’язково.

Для опрацювання файлу його необхідно відкрити, виконати потрібні дії та закрити.

1. Зчитування даних із файлу. Щоб зчитати вхідні дані з файлу, необхідно оголосити файлову змінну та відкрити файл для читання так (розглянемо два способи):

іfstream <назва файлової змінної>(<зовнішня назва>, ознака1 |ознака2| … | ознакаN);

або так:

іfstream <назва файлової змінної>; <назва файлової змінної>.open(<зовнішня назва>);

Дія команд. Підключаємо потік введення даних із файлу та налагоджуємо зв’зок між файловою змінною у програмі та файлом на зовнішньому носії. Назву зовнішнього файлу треба записувати у лапках. Ознаки слугують для визначення прав доступу до файлу. Ознаки зазначати необов’язково. У випадку, коли їх задавати не потрібно, наведені дві форми запису тотожні, і можна обирати одну з них.

Приклад 1. Відкрити зовнішній файл MyText.txt для читання з нього даних можна так:

ifstream MyFile(“MyText.txt”);

або так:

ifstream MyFile; MyFile.open(“MyText.txt”);

Тут MyFile – це файлова змінна, що асоціюється у програмі з відповідним зовнішнім файлом на диску. Введення даних виконують командою введення >>. Наприклад, команда

MyFile >> text;

зчитає одне дане з початку файлу MyText.txt до першого пропуску чи до символу "кінець рядка" у змінну txt. Якщо треба зчитати наступне дане (яке розміщене між першим і другим пропусками), необхідно повторити попередню команду, тобто записати команди MyFile >> text; MyFile >> text1; або використати команду MyFile >> text >> text1;.

Отже, зчитати дані з файлу можна за допомогою команди:

<назва файлової змінної> >> <змінна 1> >> <змінна 2> >> … >> <змінна N>

Після опрацювання файлу його потрібно закрити. Це роблять так:

<назва файлової змінної>.close()

Наприклад, MyFile.close(). Файл MyText.txt буде закрито. Після цього файлову змінну MyFile у разі потреби можна зв’язати з іншим файлом на диску.

Визначити кінець файлу можна за допомогою функції eof() (eof – end of file, кінець файлу) так:

<назва файлової змінної>.eof()

Ця функція повертає нульове значення, якщо досягнуто кінця файлу.

Приклад 2. Нехай у деякому текстовому редакторі створено файли text1.dat та text2.dat. послідовно зчитаємо з них дані та виведемо їх уміст на екран.

#include <fstream.h> void main() { ifstream File1(“text1.dat”); while (!File1.eof()) { char *t = new char[30]; File1 >> t; cout << t << “\n”; delete[] t; } File1.close(); File1.open(“text2.dat”); while (!File1.eof()) { char *t = new char[30]; File1 >> t; cout << t << “\n”; delete[] t; } File1.close(); }

// Виведення інформації із файлів // Поки не досягнуто кінця файлу text1.dat // Знак ! означає операцію не // Надаємо місце в пам’яті для зчитуваного //даного //до 30 символів // Зчитуємо дане з файлу // Виводимо це дане на екран // Вивільняємо пам’ять // Повертаємось на початок команди while // коли досягнуто кінця файлу, закриваємо його // Відкриваємо файл text2.dat для читання // Поки не досягнуто кінця файлу

2. Виведення даних у файл. Відкрити файл для записування у нього даних можна так:

ofstrem <назва файлової змінної>(<зовнішня назва>, ознака1 | ознака2 | … | ознака N)

або так:

ofstrem <назва файлової змінної>; <назва файлової змінної>.open(<зовнішня назва>);

Дія команд. Підключаємо потік виведення у файл і налагоджуємо зв’язок між файловою змінною у програмі та файлом на зовнішньому носії. Ознаки зазначати не обов’язково.

Приклад 3. Відкрити файл MyText1.txt для запису у нього даних можна так (тут FileForZap – файлова змінна):

ofstream FileForZap(“MyText1.txt”);

або так:

ifstream FileForZap; FileForZap.open(“MyText1.txt”);

Щоб занести дані у файл, використовують команду виведення даних <<. Наприклад, після виконання команд

int n = 10; FileForZap << n;

у файл MyText1.txt буде занесено число 10. Занести декілька даних у файл можна так само, як і вивести їх на екран: використовуючи стандартні правила команди << та керуючі послідовності.

Отже, записати дані у файл можна так:

<назва файлової змінної> << <змінна 1> << <змінна 2> << … << <змінна N>