Мова програмування С++ дає можливість реалізувати концепцію структурного аналізу алгоритмів. Структурний аналіз полягає у попередньому опрацюванні складної задачі чи громіздкого алгоритму та поділі його на окремі простіші частини. УС++ ці частини реалізуються за допомогою функцій. Окремі функції об’єднують у спільну програму. У відкомпільованому вигляді така програма утворює модуль. Головна функція, що обов’язково входить до кожної програми, - main(). Розрізняють стандартні функції та функції користувача. Стандартні функції мови описані (визначені) у бібліотеках. До таких функцій, зокрема, належать математичні функції sin(), cos() з бібліотеки math.h, функція очистки екрана clrscr() з бібліотеки conio.h та багато інших.
Функція користувача – це поіменована група команд, яка оголошена у файлі заголовків (або в основній програмі) та описана у модулі (в основній програмі). До функції можна звертатись (викликати) з будь-якого місця програми необхідну кількість разів.
Прості програми, які розглядалися вище, не потребують використання функцій користувача.
1. Оголошення функцій користувача. Кожну функцію користувача перед першим викликом передусім необхідно оголосити (задекларувати, створити прототип, сигнатуру). За стандартом ISO/ANSI прототип функцій оголошують у спеціальних файлах заголовків. У програму ці файли приєднують за допомогою директиви #include, наприклад:
#include<conio.h>
#include“MyHeader.h”
Прототипи стандартних функцій розміщені у папці INCLUDE. Синтаксис мови дає змогу розмістити прототип також і в основній програмі. Функцію користувача оголошують так:
| <тип функції> <назва функції> (<список формальних параметрів>);
|
де тип функції – це тип даного, який функція повертає в основну програму. Тип функції можна не зазначати. За замовчуванням функція повертає у програму дане цілого типу int. Функцію, яка не повертає у програму жодного результату, оголошують з типом void. Для функції, яка не залежить від жодних параметрів, у круглих дужках записують службове слово void.
Назву функції надає користувач за правилом створення ідентифікаторів.
У списку формальних параметрів через кому записують змінні, зазначаючи їхні типи. Тип необхідно зазначати для кожної змінної окремо. Імена змінних можна опускати. Якщо функція не набуває жодних значень, то список формальних параметрів може бути відсутній. Круглі дужки опускати не можна.
Приклад 1. Розглянемо сигнатури функцій
floatSuma(intkil, floatcina);
void dilennya(float, float);
kod(int k1, int k2);
double loto(void);
У цьому випадку оголошена функція Suma типу float, яка залежить від двох змінних: перша змінна цілого типу int, друга – типу float. Функція dilennya залежить від двох змінних дійсного типу float і не повертає у програму жодного значення. Ціла функція kod залежить від двох змінних цілого типу, дійсна функція loto типу double не залежить від жодних параметрів.
Під час оголошення можна відразу ініціалізувати формальні параметри функції, тобто надавати їм певних значень. Такі значення називаються значеннями за замовчуванням. Їх записують у кінці списку. Значення таких параметрів у програмі можна змінювати. Враховуючи це, розглянемо ще один спосіб оголошення функцій, наведених у прикладі 1.
floatSuma(intkil, floatcina = 2.5);
void dilennya(float v = 1.2, float n = 3);
kod(int k1, int k2 = 5);
2. Опис функцій користувача. Опис функції складається із заголовка без крапки з комою і тіла функції, записаного у фігурних дужках, а саме:
| <тип функції> <назва функції>(<список формальних параметрів>)
{
<тіло функції>;
return (<назва змінної 1>);
}
|
У тілі функції записують команди, які задають дію функції. Результат виконання функції повертається в основну програму (у точку виклику) за допомогою змінної 1 командою return. Тип змінної 1 має збігатися з типом функції. У тілі функцій типу void команду return не зазначають. У команді return круглі дужки можна не писати.
Зауваження 1. Функцію можна описувати і на початку програми. У такому випадку декларувати її не потрібно.
Приклад 2. Функція Suma і dilennya, оголошені у прикладі 1, у деякій програмі можна описати так:
floatSuma(intkil, float cina) // Заголовок функції
{
floats = kil * cina;
return(s); // Значення, яке повертає функція в основну програму
}
//---------------------------------------------------------------
voiddilennya (float v, float n)
{
cout<<”\n dilennya = ” << v \n;
}
Якщо потрібно проініціалізувати значення змінних, що входять у функцію, то це можна зробити у сигнатурі функції. Тоді в описі у заголовка функції значення за замовчуванням не задають.
Приклад 3. Сигнатуру функції, яка обчислює периметр k-кутної правильної фігури зі стороною r, можна оголосити так:
floatperymetr (int k = 4, float r = 2.5);
а описати власне функцію так:
floatperymetr (int k, float r)
{
floatp;
p = k * r;
return (p);
}
3. Виклик функцій користувача. До функції користувача звертаються з розділу команд основної програми (функції main()) або з іншої функції. Виклик функцій можна виконати двояко: або командою виклику, або з виразів так:
| <назва функції>(<список фактичних параметрів>)
|
Список фактичних параметрів може містити сталі, змінні, посилання, вказівники, вирази. Списки формальних і фактичних параметрів мають бути узгодженими за типами та кількістю елементів. Якщо у списку формальних параметрів є проініціалізовані змінні, то у списку фактичних параметрів ці змінні можуть бути відсутні, їм будуть надані значення за замовчування.
Приклад 4. Розглянемо сигнатуру з прикладу 3.
floatperymetr (int k = 4, float r = 2.5);
До цієї функції можна звернутись одним із способів:
рerymetr (7, 2.8);
perymetr (8);
perymetr ();
У першому випадку змінній k буде присвоєне значення 7, а змінній r – 2.8; у другому випадку
k = 8, r = 2,5; в третьому k = 7, r = 2,5.
У списку фактичних параметрів не можна пропускати змінні з середини списку, тобто не можна функцію Myfunc() викликати так: Myfunc(1.65);, оскільки тут пропущено ініціалізацію першої змінної k.
Задача 1 (про товарний чек). Використовуючи функцію користувача, скласти програму для виведення на екран товарного чеку для купівлі п штук товару за ціною т гривень за одну штуку. Ціну та кількість купленого товару ввести самостійно у режимі діалогу.
#include<iostream.h>
#include<conio.h>
floatSuma(int, float);
voidmain()
{
clrscr();
float m; intn;
cout<< “Введіть ціну за 1 шт. \n”; cin >> m;
cout<< “Введіть кількість купленого товару \n”; cin>> n;
clrscr();
cout<< “\t ТОВАРНИЙ ЧЕК \n”;
cout<< “Ціна за 1 шт. - ”<< m << “ грн \n”;
cout<< “За ”<< n << “ штук необхідно сплатити ”;
cout<< Suma(n,m) << “ грн \n”; // Виклик функції Suma
cout<< “\t Дякуємо за покупку!”; getch();
}
//-----------------------------------------------------------------------
floatSuma(int kil, float cina) // Опис функції Suma
{
floats;
s = kil * cina;
return s;
}
4. Посилання.До даних можна звертатись за допомогою імен або посилань. Посилання слугує для надання ще одного імені (псевдоніма, синоніма, аліасу) даному. Посилання утворюють так:
| <тип даного> &<назва посилання> = <назва змінної>;
|
Наприклад,
float &cina = suma;
У цьому випадку посилання cina і змінна suma вказуватимуть на одну і ту саму адресу в пам’яті комп’ютера. Для посилань не резервується додаткова оперативна пам’яті.
У С++ можна утворювати посилання на дані, але не на їхні типи. Значення посилання ініціалізують відразу під час його оголошення, тобто на етапі компіляції. У нашому прикладі посилання cina проініціалізоване змінною suma. Отже, якщо suma = 11, то і значення посилання cina також буде 11.
Під час зміни значення посилання змінюється значення змінної, на яке це посилання вказує. Отже, якщо у програмі записати команду cina = 15.7, то змінна suma також набуде значення 15.7.
Змінювати (переадресовувати) посилання у програмі не можна. Посилання завжди вказує на одну і ту саму адресу в оперативній пам’яті. Це використовують під час створення та виклику функцій. Під час виклику функції копії усіх її фактичних параметрів заносяться у спеціально організовану область пам’яті. Потім виконуються відповідні команди функції і результат повертається у програму командою return. Оскільки всі дії відбуваються з копіями параметрів, а не із самими параметрами (копії та власне параметри розміщені у різних ділянках пам’яті), то значення фактичних параметрів в основній програмі не змінюються. Як параметри функції можна використовувати посилання або вказівники. Тоді значення фактичних параметрів у основній програмі змінюватимуться, оскільки функція буде повертати значення в основну програму не тільки через змінні з команди return, а й через відповідні посилання та вказівники, бо вони вказують на ту саму ділянку пам’яті, де розміщені фактичні параметри.
Щоб передати посилання чи вказівники у функцію як параметри і не змінити значення фактичних параметрів, треба в оголошенні функції до кожного параметра дописати ключове слово const. Наприклад, intsort(const int*p, const int*g);
У С++ посилання може бути не тільки змінна чи стала, а і функція
| <тип>& <назва функції>(<список формальних параметрів>)
|
Така функція повертає синонім імені комірки, у яку занесено результат (посилання на змінну певного типу). Функція-посилання має двояке призначення. По-перше, як і звичайна функція, вона може повертати значення в основну програму. По-друге, їй самій можна надавати значення, що є унікальним випадком у програмуванні.
Приклад 5. Оголосимо змінну та вказівник на дійсний тип float *prt, u; та опишемо функцію
float<em(float* a, int i) {return *(a + i);}
Виділимо ділянку пам’яті для зберігання значень десяти дійсних чисел prt = new float[10]; Викликати цю функцію можна звичайно: u = ltem(prt, 3); Тоді змінній u буде надано значення четвертого елемента. Уведемо значення п’ятого числа так:
ltem(prt, 4) = 10.
У цьому разі функції ltem() надаємо значення, тобто у ділянку пам’яті буде занесено число 10.
Задача 2 (про гуртову покупку). Нехай знижки на гуртові залежать від суми, на яку зроблено замовлення, а саме: під час купівлі товару на суму до 200 грн покупець має сплатити 100% від вартості товару, на суму від 200 до 500 грн йому надається знижка 10%, а на суму понад 500 грн – 20%. Ввести з клавіатури суму, на яку зроблено замовлення, і вивести суму, яку необхідно сплатити з урахування системи знижок. Використати функцію користувача, аргументами якої є посилання на змінні.
#include<iostream.h> // Гуртове замовлення
#include<conio.h>
void Suma(float &t); // Оголошення функції Suma
voidmain()
{
clrscr();
float S;
float &pS = S;
cout<< “Введіть суму замовлення \n”; cin >> S;
cout<< “\t Вам необхідно сплатити \n”;
Suma(pS); // Виклик функції
cout<< S << “ грн”;
getch();
}
//-------------------------------------------------------------------------------
voidSuma(float &t) // Опис функції Suma
{ // Зміна значення посилання t
if(t >= 200.0 && t < 500) t *= 0.9;
if (t >= 500.0) t *= 0.8;
}
У цьому випадку функція Suma() повертає у програму значення через посилання рS.
5. Рекурсія. Рекурсією називається алгоритмічна конструкція, де підпрограма викликає сама себе. Рекурсія дає змогу записувати циклічний алгоритм, не застосовуючи команд циклу. Типовий приклад використання рекурсії – обчислення факторіала числа. Нагадаємо, що факторіал числа – це добуток цілих чисел від одиниці до певного заданого числа. Отже, n! = n · (n - 1) · (n - 2) ·… · 1. Рекурсивна властивість факторіала: п! = п · (п - 1)!.
Приклад 4. Скласти функцію для обчислення п!, використовуючи рекурсію, можна так:
longfactorial (int n)
{
longfact;
if (n > 1) fact = n * factorial(n - 1);
elsefact = 1;
returnfact;
}
Зауваження 2. Оскільки навіть для невеликих чисел значення факторіала є досить великим, то у цьому прикладі для функції factorial задано тип long. Це дає змогу обчислити факторіали чисел від 1 до 16. Для визначення факторіалів чисел більших від 16 необхідно використати алгоритми "довгої арифметики".
Обчислимо функцію factorial(5) = 5 · factorial(4) = 5 · 4 · factorial(3) = 5 · 4 · 3 · factorial(2) = 5 · 4· · 3 · 2 · factorial(1) = 5 · 4 · 3 · 2 · 1 = 120.
Приклад 6. Рекурсивна функція обчислення суми цілих чисел від а до b має вигляд
intSuma (int a, intb)
{
intS;
if(a == b) S = a;
elseS = b + Suma(a, b - 1);
returnS;
}
Зауваження 3. Застосовуючи рекурсію, потрібно правильно скласти стоп-умови, які забезпечують закінчення циклічних обчислень.
Глобальні та локальні змінні. Операція видимості. Під час оголошення змінних в оперативній пам’яті комп’ютера резервується місце для зберігання їхніх значень. Обсяг наданої пам’яті залежить від типів змінної та компілятора. Кожна змінна характеризується областю дії та областю видимості. Область дії – це частина програми, де змінна придатна для повноцінного опрацювання. Область видимості – це частина програми, де змінна оголошується або, де до неї можна отримати доступ за допомогою операції надання видимості, що позначається "::". Змінні можна оголошувати у блоці команд, у тілі деякої функції або поза всіма функціями (глобальні змінні). Області дії та можливої видимості, час дії змінної у певній програмі залежать від того, де і як оголошені змінні.
Змінні, які оголошені у тілі деякої функції або у блоці, називаються локальними. Область дії локальних змінних поширюється лише на відповідну функцію чи блок. Під час виходу із функції (блока) частина оперативної пам’яті, відведеної під локальні змінні, вивільняється, тобто закінчується область дії змінної. Тому у різних функціях можна використовувати змінні з однаковими іменами.
Приклад 1. Скласти програму з використанням функції, яка знаходить максимальне серед трьох введених чисел.
| #include<iostream.h>
#include<conio.h>
floatMax(float, float, float); // Оголошення функції
voidmain()
{
clrscr();
floatmax, x1, x2, x3; // Оголошення змінних
cout<< “Уведіть три числа\n”;
cin >> x1 >> x2 >> x3;
max = Max(x1, x2, x3); // Обчислюємо максимальне серед уведених чисел
cout << “\n Максимальне серед чисел ”<< x1 << “, ” << x2 << “, “ << x3;
cout << “ є” << max;
getch();
}
//-------------------------------------------------------------------------------------------
floatMax(floata, floatb, floatc) // Опис функції Max
{
floatmax;
if(a > b && a >c) max = a;
else
if(b > a && b >c) max = b;
elsemax = c;
returnmax;
}
|
Зауважимо, що у цій програмі змінна max оголошена відразу у двох функціях max() і Мax().
Змінні, які описані поза всіма функціями, тобто на початку програми або у файлі заголовка, називаються глобальними. Вони видимі та доступні під час виконання всієї програми. До таких змінних можна звертатись з будь-якої функції чи блока.
Функція може повертати значення у основну програму за допомогою команди return, вказівників, посилань або через глобальні змінні. Значення глобальних змінних можна змінювати у тілі функцій. З огляду на це у великій програмі важко проаналізувати значення глобальної змінної на певному етапі її виконання. Тому варто якомога менше використовувати глобальні змінні, бо це ускладнює розуміння програми.
Деяка змінна може бути доступною, але в певний момент невидимою. Наприклад, якщо глобальна та локальна змінні мають однакове ім’я, то глобальна змінна у області дії відповідної локальної змінної буде невидимою. Тобто локальна змінна в області своєї визначеності перекриває дію глобальної змінної. Для того, щоб звернутись (доступитись) до глобальної змінної у деякому блоці чи функції, використовують операцію надання видимості ::. У цьому випадку до імені змінної зліва дописують два символи двокрапки. Наприклад, ::prybutok, ::day тощо.
Приклад 2. Відомо, що потяг проїхав 5 (k) станцій зі сталою швидкістю v км/год. Час, затрачений на переїзд між станціями, та швидкість потягу треба ввести з клавіатури у режимі діалогу. Використовуючи функцію, визначити загальний шлях, який пройшов потяг, і відстані між станціями.
| #include<iostream.h> // Про локальні та глобальні змінні
#include<conio.h>
floatd = 0; // Оголошення глобальної змінної d
voidmain()
{
intk = 5; float v, t;
cout << “Уведіть швидкість потягу \n”; cin>> v;
for(intn = 1; n <= k; n++)
{
cout << “\n Уведіть час, який затратив потяг”;
cout << “ на переїзд між зупинками ” << n;
cout << “ та ” << (n+1) << “\n”;
cin >> t;
float d; // Оголошення локальної змінної d
d = t * v;
cout << “Відстань від станції ” << n << “ до ”
<< (n+1) << “ є ” << d << “км”;
::d = ::d + d; // Звертання до глобальної змінної
}
cout << “\n Загальний шлях ”<< d << “ км ”;
}
|
У цьому випадку змінна d, яка оголошена на початку програми, є глобальною. У блоці команди for оголошена локальна змінна d.
Зауваження 1. Для динамічних змінних не діють правила видимості та доступності. Динамічні змінні видимі та доступні у всіх функціях та блоках програми протягом усього часу їх визначеності.
6. Класи пам’яті. Для того, щоб безпосередньо вказати комп’ютеру як і де у його пам’яті мають зберігатися значення змінних чи функцій, як можна отримати доступ до цих даних, як визначити область видимості цих даних, використовують специфікатори класу пам’яті. Є п’ять специфікаторів (табл. 9).
| Клас пам’яті
| Час дії змінної
| Області видимості та дії змінної
|
| auto
| Тимчасова
| Локальна
|
| register
| Тимчасова
| Локальна
|
| extern
| Тимчасова
| Локальна
|
| static
| Постійна
| Локальна
|
| static
| Постійна
| Глобальна
|
| volatile
| Постійна
| Глобальна
|
Розглянемо дії цих специфікаторів.
Специфікатор auto для локальних змінних застосовується за замовчуванням, тому зазначати його не обов’язково. Область видимості таких змінних обмежена блоком, у якому вони оголошені. Під час виходу з блока пам’ять, яка відведена для цих змінних, автоматично вивільняється, а змінні знищуються.
Специфікатор register вказує компілятору, що значення змінної слід зберігати у регістрах. Це зменшує час доступу до змінної і прискорює виконання програми. Якщо не можливо розмістити змінну у регістрі, то змінна буде збережена зі специфікатором auto, обмежені блоком, у якому вони оголошені.
Специфікатор static можна застосовувати як до локальних, так і до глобальних змінних. На відміну від змінних зі специфікаторами auto та register значення локальної статичної змінної зберігається після виходу з блока чи функції, де ця змінна оголошена. Під час повторного виклику функції змінна зберігає своє попереднє значення. Якщо змінна явно не ініціалізована, то за замовчуванням їй надається значення 0.
Приклад 3. Обчислити суму або добуток перших п цілих додатних чисел.
Обчислимо спочатку суму чисел.
| // Обчислення суми
#include<iostream.h>
#include<conio.h>
cc(intn);
voidmain()
{
clrscr();
intn, S;
cout<< “Уведіть число”;
cin >> n;
for(int i = 1; i <= n; i++) S = cc(i);
cout << S;
getch();
}
//---------------------------------------------------------------------
cc(int n)
{ // Цей рядок буде виконано лише один раз
static intS = 0; // під час першого виклику функції
S += n;
returnS;
}
|
Функція сс призначена для обчислення суми чисел. Якщо ж потрібно обчислити добуток чисел, то функція main() залишиться без змін, а замість функції сс слід записати таку функцію:
| cc(int n)
{
static intS = 1;
S *= n;
returnS;
}
|
Глобальні статичні змінні ініціалізуються під час запуску програми. Області їх дії та видимості розповсюджуються лише на той файл, де оголошена ця змінна.
Часто, якщо програма складається з декількох файлів, виникає потреба передавати значення змінних з одного файлу в інший. У такому випадку до змінної застосовують специфікатор extern. Він дає змогу оголошувати глобальні змінні, дія яких поширюється на всі файли, з яких складається програма.
Специфікатор volatile застосовують до глобальних змінних, значення яких можуть надходити від периферійних пристроїв, наприклад, якщо змінна набуває значення від системного таймера.
7. Перевантаження функцій. У мові С++ допускається використовувати одне і те саме ім’я функції для різних наборів аргументів. Це називається перевантаженням функцій, або поліморфізмом. Перевантаження використовують, коли необхідно викликати функцію з аргументами різних типів, або коли функція залежить від різної кількості аргументів. У таких випадках необхідно кожну функцію оголосити й описати окремо. Під час її виклику компілятор автоматично проаналізує сигнатури та виконає коди відповідної функції.
Приклад 4. Використовуючи перевантаження функції, скласти програму для упорядкування трьох уведених даних або символьного, або цілого типу.
| #include<iostream.h>
voidSort(int n1, int n2, int n3);
voidSort(char n1,char n2, char n3);
voidmain()
{
inti1, i2, i3, k;
charc1, c2, c3;
cout << “Уведіть 1 для впорядкування символів, 2 – для чисел\n”;
cin>> k;
if(k == 1)
{
cout << “Уведіть три символи”;
cin>> c1 >> c2 >>c3;
Sort(c1, c2, c3);
}
if (k == 2)
{
cout<< “Уведіть три числа”;
cin >> i1 >> i2 >> i3;
Sort(i1, i2, i3);
}
}
//---------------------------------------------------------------------------
voidSort(int n1, int n2, int n3)
{
intc;
if(n1 > n2) {c = n1; n1 = n2; n2 = c;}
if(n2 > n3) {c = n2; n2 = n3; n3 = c;}
if(n1 > n2) {c = n1; n1 = n2; n2 = c;}
cout<< n1 << “\t” << n2 << “\t” << n3;
}
|
Зауваження 2. Для функцій, які відрізняються типом значення, яке вони повертають, і мають однаковий набір аргументів, перевантаження у мові С++ не визначено, тобто їм надавати однакові імена не можна.
8. Шаблони функцій. Перевантаження функцій, описане у попередньому пункті, часто буває корисним, але не завжди зручним. Як видно, один і той самий програмний код довелося записувати окремо для змінних символьного типу, а потім для цілих чисел. У мові С++ є змога уникнути таке дублювання за допомогою шаблонів. Шаблон функції – це опис функції, яка залежить від даних довільного типу. Крім того, така функція може повертати в основну програму результат довільного типу. Тобто користувач створює сигнатуру й описує функцію з аргументами деякого загального типу. Під час виклику такої функції компілятор автоматично проаналізує тип фактичних аргументів, згенерує для них програмний код і виконає відповідні дії. Це називається неявним створенням екземпляра шаблона. Такий підхід у програмуванні називається узагальненим програмуванням, оскільки він дає змогу створити функцію узагальненого типу.
Сигнатуру шаблону функції можна описати так:
| template<class<назва узагальненого типу>>
<тип функції> <назва функції>(<список формальних параметрів>);
|
У списку формальних параметрів замість стандартних конкретних типів даних зазначають назву узагальненого типу. Правила для описування шаблона функції такі самі, як і для функції користувача.
Зауваження 3. У стандарті ISO/ANSI замість ключового слова class прийнято записувати typename.
Якщо для деякого типу даних функцію необхідно описати окремо, то створюють явну специфікацію функції. Тоді у списках формальних параметрів шаблона зазначають конкретні типи аргументів.
Приклад 5. Переробимо програму з прикладу 4 для упорядкування трьох введених даних заздалегідь невідомого типу, використовуючи шаблони.
| #include<iostream.h>
#include<conio.h>
// Оголошення шаблона функції
template<classMytype>
voidSort(Mytype n1,Mytype n2, Mytype n3);
voidmain()
{
clrscr();
inti1, i2, i3, k;
charc1, c2, c3;
cout << “Уведіть 1 для впорядкування символів, 2 – для чисел\n”;
cin>> k;
if(k == 1)
{
cout << “Уведіть три символи”;
cin>> c1 >> c2 >>c3;
Sort(c1, c2, c3);
}
if (k == 2)
{
cout<< “Уведіть три числа”;
cin >> i1 >> i2 >> i3;
Sort(i1, i2, i3);
}
getch();
}
//--------------------------------------------------------------------------------
template<classMytype> // Опис шаблона функції
voidSort(Mytype n1, Mytype n2, Mytype n3)
{
Mytypec;
if(n1 > n2)
{c = n1; n1 = n2; n2 = c;}
if(n2 > n3)
{c = n2; n2 = n3; n3 = c;}
if(n1 > n2)
{c = n1; n1 = n2; n2 = c;}
cout<< n1 << “\t” << n2 << “\t” << n3;
}
|
9. Вбудовані функції. Під час виконання програми генеруються коди для всіх функцій користувача. Коли відбувається звертання до тієї чи іншої функції, здійснюється виклик відповідного коду. Якщо до деякої функції звертаються багато разів, то робота програми сповільнюється. Щоб цього уникнути, можна використовувати так звані вбудовані функції. Коди таких функцій вставляються компілятором у кожну точку виклику в основному коді. Це ви вимагає додаткового обсягу оперативної пам’яті, проте прискорює процес виконання програми. Щоб створити вбудовану функцію, потрібно до її оголошення додати ключове слово inline.
Приклад 6. Використовуючи вбудовані функції, скласти програму для обчислення добутку
Використання функції тут має ілюстративний характер.
| #include<iostream.h>
#defineN 10
inline floatdob(int a);
voidmain()
{
floatD;
for(int k = 1; k <= N; k++) D = dob(k);
cout <<“Добуток дорівнює = ” << D;
}
//-------------------------------------------------------------------------
floatdob(int a)
{
static floatd = 1;
d = d * (5 * a + 2) / (a – 15);
return d;
}
|
Виконавши програму, одержимо значення добутку 28380,5.
10. Функція main() з параметрами.Функція, яка має бути у кожній програмі, - це функція main(). Досі вона використовувалась без параметрів: main(). Як і інші функції, ця функція може мати аргументи. Вони називаються аргументами командного рядка. Їх зазначають під час запуску програми (ехе-файлу) у командному рядку операційної системи.
Загальний вигляд функції main такий:
| intmain(intargc, char*argv, char*env[])
|
де argc – число аргументів функції + 1 (назва програми теж вважається аргументом), які задають у командному рядку. Параметр argv – це вказівник на масив символьного типу. Параметр env[] служить для передачі параметрів для операційної системи, у якій виконується програма. Його використовують, наприклад, тоді, коли програму потрібно виконати в різних операційних системах.
Приклад 7. Нехай треба знайти мінімальне або максимальне значення функції 
, де х змінюється на проміжку [1; 2] з кроком h = 0,1.
| #include<iostream.h> // Використання функції main() з параметрами
#include<conio.h>
#include <process.h>
#include<math.h>
#define h 0.1
#define b 2
floatMin(floaty); floatMax(floaty);
intmain(intargc, char*argv[])
{
if(argc < 2) // Якщо параметр не задано
{
cout<< “Недостатньо аргументів\n”;
cout<< “Уведіть параметр min та max”;
exit (1); // Достроково виходимо з програми
}
floatx, y;
cout<< “X \ t Y \ n”; // Табулюємо функцію
for(x = 1; x <= b; x += h)
{
y = x * x *sin(x);
cout<< x <<”\t” << y << “\n”;
}
// Перевіримо, чи другий параметр є min
if(*argv[1] == ‘m’ && *(argv[1]+1) = ‘i’ && *(argv[1]+2) == ‘n’)
cout<< “Min = ” << Min(y);
else
// Перевіримо, чи другий параметр є max
if(*argv[1] == ‘m’ && *(argv[1]+1) = ‘a’ && *(argv[1]+2) == ‘x’)
cout<< “Max = ” << Max(y);
else cout<< “Параметр не визначено”;
getch(); return0;
}
//-----------------------------------------------------------------------------------------------------------
floatMin(floaty)
{
floatx = 1, m;
m = x * x * sin(x);
for( ; x <= 2; x +=h)
{
y = x * x * sin(x);
if(m > y) m = y;
}
returnm;
}
//----------------------------------------------------------------
floatx = 1, m;
m = x * x *sin(x);
for( ; x <= 2; x += h)
{
y = x * x * sin(x);
if (m < y) m = y;
}
returnm;
}
|
З бібліотеки process.h використано функцію exit (), яка дає змогу достроково завершити виконання програми.
