Аргументи за умовчанням

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

Розглянемо як приклад функцію друку цілого числа. Цілком розумно застосувати як необов'язковий аргумент основу системи числення числа, що друкується, хоча в більшості випадків числа друкуватимуться як десяткові цілі значення. Наприклад:

 

void printb(int value, int base =10); // основа за умовчанням рівна 10

 

void F()

{

printb(63);

printb(63,10);

printb(63,16);

printb(63,2);

}

 

Оскільки другий аргумент функції printb() має припустиме| значення, його можна не задавати при виклику функції на виконання. Аргументи з припустимими| значеннями називаються аргументами за умовчанням.

Функція F() після виклику надрукує такі представлення числа 63:

 

63 63 3f 111111

 

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

 

void printb(int value, int base);

inline void printb(int value){printb(value,10);}

 

Проте в останньому варіанті текст програми не так явно демонструє бажання мати одну функцію printb(), і при цьому забезпечити зручну і коротку форму виклику для простого випадку.

Тип аргументу за умовчанням перевіряється при компіляції оголошення функції, а значення цього аргументу обчислюється у момент виклику функції на виконання.

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

 

int f1(int, int =0, char* =0); // нормально

int f2(int =0, int =0, char*); // помилка

int f3(int =0, int, char* =0); // помилка

 

Потрібно відзначити, що в списку аргументів наявність пробілу між символами * та = вельми істотна, оскільки *= є оператором комбінованого присвоювання:

 

int f4(char*=0); // синтаксична помилка

 

3.3.4 Неоголошені аргументи

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

 

int printf(const char* ...);

 

При виклику printf обов'язково повинен бути вказаний аргумент типу char*, проте можуть бути (а можуть і не бути) ще й інші аргументи. Наприклад:

 

printf("Hello, worldn");

printf("Моє ім’я - %s %sn", first_name, second_name);

printf("%d + %d = %dn", 2, 3, 5);

 

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

У випадку функції printf() перший аргумент є рядком, що специфікує формат виводу значень наступних фактичних аргументів. Цей рядок може містити спеціальні символи, які дозволять функції правильно обробляти подальші аргументи. Наприклад, %s означає, що черговий фактичний аргумент буде типу char*, %d означає, що черговий фактичний аргумент буде типу int. Компілятору вся ця інформація недоступна, і тому він не може переконатися, що потрібні аргументи дійсно присутні у виклику і мають відповідні типи. Наприклад, наступний виклик:

 

printf("Моє ім’я - %s %sn",2);

 

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

Очевидно, що якщо аргументи не оголошені, то компілятор не має відомостей для контролю і стандартних приведень типів цих аргументів. Тому всі такі аргументи компілятор приводить до ширшого типу: аргументи типів char або short передаються як int, float - як double.

 

3.4 Значення, що повертається функцією

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

Наприклад:

 

int f(){ } // помилка

void g(){ } // нормально

 

Значення, що повертається, вказується в інструкції return в тілі функції. Наприклад:

 

int fac(int n) {return (n>1) ? n*fac(n-1) : 1;}

 

У тілі функції може бути декілька операторів return:

 

int fac(int n)

{

if (n > 1)

return n*fac(n-1);

else

return 1;

}

 

Подібно до передачі фактичних аргументів, за сенсом операція повернення значення з функції еквівалентна ініціалізації. Можна вважати, що інструкція return ініціалізує безіменну змінну, що має тип значення, що повертається.

 

3.5 Рекурсивні функції

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

Поширеним прикладом рекурсивної функції є функція, що обчислює факторіал. Факторіалом цілого позитивного числа n називається множення всієї послідовності цілих чисел від 1 до n (у математиці це записується коротко як n!).

Нижче приводяться тексти двох функцій обчислення факторіалу - однієї рекурсивної та іншої не рекурсивної, яка обчислює факторіал за допомогою ітеративного циклу:

 

// Рекурсивна функція

int fac(int n)

{

return ((n == 1) ? 1: n*fac(n – 1));

}

// Не рекурсивна функція

int facn(int n)

{

int fact = 1;

for(int m = 1; m <= n; m++)

fact *= m;

return fact;

}

 

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

Рекурсивний варіант функції fac(), якщо викликається з аргументом 1, повертає значення 1; інакше він повертає вираз n*fac(n – 1). Щоб обчислити останній вираз, функціяfac() буде викликана ще n – 1 раз, поки значення аргументу n не стане рівним 1.

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

Як тільки аргумент стане рівним 1, почнеться розкручування стека викликів у зворотному напрямку. Функція послідовно почне повертати значення 1, 2*1, 3*2*1 і т. д., аж до n*(n-1) *...3*2*1.

Рекурсивні варіанти більшості функцій виконуються повільніше, ніж їх ітеративні (не рекурсивні) варіанти, оскільки при рекурсії витрачається час на виклики функцією самої себе.

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

3.6 Перевантаження функцій

Зазвичай має сенс давати різним функціям різні імена. Якщо ж декілька функцій виконують одну і ту ж дію над об'єктами різних типів, то зручніше дати однакові імена всім цим функціям.

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

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

Наприклад:

 

void print(int); // друк цілого

void print(const char*); // друк рядка символів

 

Для компілятора в таких перевантажених функціях спільне тільки одне - ім'я. Можливо, що по виконуваній роботі такі функції можуть бути схожі, але сама мова не сприяє і не перешкоджає написанню подібних між собою функцій. Таким чином, оголошення перевантажених функцій служить, перш за все, для зручності запису. Але для функцій з такими традиційними іменами, як sqrt, print або open, не можна цією зручністю нехтувати. Якщо ж саме ім'я грає важливу семантичну роль, наприклад, в таких операціях як +, * або /, то така зручність стає істотним чинником.

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

 

void print(double);

void print(long);

void f()

{

print(1L); // print(long)

print(1.0); // print(double)

print(1); // помилка - незрозуміло, що викликати:

// print(long(1)) або print(double(1))

}

 

При виклику функції на виконання для вибору перевантаженої функції застосовуються наступні правила, перелічені в порядку убування їх пріоритетів:

1. Точна відповідність типів, тобто повна відповідність або відповідність, яка досягається тривіальними приведеннями типів (наприклад, імені масиву у вказівник, імені функції у вказівник на функцію, типу T в const T).

2. Відповідність, що досягається приведеннями до інтегрального типу з розширеними можливостями (наприклад, bool в int, char в int, short в int та їх unsigned аналоги), float в double та double в long double.

3. Відповідність, що досягається шляхом стандартних приведень (наприклад, int в double, double в int, вказівників на похідні типи у вказівники на базові типи, вказівників на похідні типи в void*, unsigned int в int).

4. Відповідність, що досягається визначеними користувачем приведеннями.

5. Відповідність, що досягається за рахунок трьох крапок в оголошенні функції.

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

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

Нехай будуть такі оголошення функції print():

 

void print(int);

void print(const char*);

void print(double);

void print(long);

void print(char);

 

Тоді результати викликів функції print() на виконання будуть наступними:

 

void h(char c, int i, short s, float f)

{

print(c); // точна відповідність - викликається print(char)

print(i); // точна відповідність - викликається print(int)

print(s); // приведення до інтегрального типу з розширеними

// можливостями - викликається print(int)

print(f); // приведення до інтегрального типу з розширеними

// можливостями - викликається print(double)

print('a'); // точна відповідність - викликається print(char)

print(49); // точна відповідність - викликається print(int)

print(0); // точна відповідність - викликається print(int)

print("а"); // точна відповідність - викликається print(const char*)

}

 

Відзначимо, що результат розв'язання перевантаження не залежить від порядку оголошення перевантажених функцій.

Типи значень, що повертаються перевантаженими функціями, взагалі не враховуються при розв'язанні перевантаження.

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

Функції, оголошені в різних областях видимості, не є перевантаженими. Наприклад:

 

void f(int);

void g()

{

void f(double);

f(1); // викликається f(double), а не f(int)

}

 

3.7 Вказівники на функцію

Можливі тільки дві операції з функціями: виклик функції на виконання та взяття адреси функції. Вказівник, одержаний за допомогою останньої операції, можна згодом використовувати для виклику функції. Наприклад:

 

void error(char* p) { /* ... */ } // функціявидачі повідомлень про помилки

void (*pf)(char*); // оголошений вказівник на функцію

void f()

{

pf = &error; // pf вказує на функцію error()

(*pf)("Помилка №1"); // виклик error() через вказівник pf

}

 

Для виклику функції за допомогою вказівника (pf в нашому прикладі) треба спочатку застосувати операцію розіменування вказівника - *pf.

Оскільки пріоритет оператора виклику функції () вище, ніж пріоритет оператора розіменування *, не можна писати просто *pf("Помилка №1"). Це означатиме *(pf("Помилка №1")), що є неправильним. З тієї ж причини дужки потрібні і при оголошенні вказівника на функцію. Проте, писати просто pf("Помилка №1") можна, оскільки компілятор розуміє, що pf є вказівником на функцію, і генерує інструкції, що здійснюють виклик необхідної функції.

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

При присвоюванні вказівнику на функцію потрібна точна відповідність типів вказівника на функцію і присвоюваної функції. Не обов'язково при цьому використовувати оператор узяття адреси &.

Наприклад:

 

void (*pf)(char*); // вказівник на void(char*)

void f1(char*); // функціяvoid(char*);

int f2(char*); // функціяint(char*);

void f3(int*); // функціяvoid(int*);

 

void f()

{

pf = &f1; // правильно

pf = &f2; // помилка - не той тип значення,

// яке повертає функція

pf = &f3; // помилка - не той тип аргументу

(*pf)("asdf"); // правильний виклик

(*pf)(1); // помилка - не той тип аргументу

int i = (*pf)("qwer"); // помилка - void присвоюється int

}

 

Правила передачі аргументів однакові як для звичайного виклику функції, так і для її виклику через вказівник.

Часто буває зручно за допомогою оголошення typedef присвоїти нове ім'я типу вказівника на функцію, і користуватися цим ім'ям замість того, щоб весь час використовувати синтаксично достатньо складну форму запису вказівника на функцію. Наприклад:

 

typedef int (*SIG_TYP)(int); // з файлу <signal.h> системи UNIX

typedef void (SIG_ARG_TYP)(int);

SIG_TYP signal(int, SIG_ARG_TYP);

 

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

 

typedef void (*PF)(); // вказівник на функцію

PF edit_menu[] = { // масив вказівників на функції

// обробки команд редагування

&cut,

&paste,

&copy,

&search

};

PF file_menu[] = { // масив вказівників на функції

// управління файлами

&open,

&close,

&append,

&write

};

 

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

 

PF* button1 = edit_menu;

PF* button2 = file_menu;

 

Коли користувач вибирає пункт меню, наприклад, команду close (закрити) з меню file, виконується виклик функції обробки цієї команди через вказівник:

 

button2[1]();

 

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

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

3.8 Функція main()

Як вже мовилося, в будь-якій програмі на мові С++ повинна бути одна і лише одна функціяmain(), з якої починається виконання програми. Функція main(), як це було продемонстровано раніше, часто не має аргументів. Проте якщо при запуску програми їй потрібно передати які-небудь| дані, тоді може використовуватися перевантажений варіант функції main() з наступним профілем:

 

int main(int argc, char* argv[]);

 

Аргументи цієї функції - argc та argv[] – дозволяють програмі приймати аргументи під час завантаження або з командного рядка.

Після отримання управління функцією main() перший аргумент argc містить кількість переданих аргументів, а другий аргумент argv[] - це масив символьних рядків. Елемент цього масиву з індексом 0 є ім'ям програмного файлу з розширенням .exe, який містить дану функцію main(), а елементи з індексами 1 до argc -1 містять передані програмі символьні параметри, з якими був запущений файл .exe на виконання.

При завершенні роботи функціяmain() повинна повертати нульове значення у разі успішного завершення і ненульове значення - інакше.

3.8.1 Перехід від main() до _tmain()

У середовищі Microsoft Visual Studio .NET 7.1 програми на мові C++, що розробляються в рамках консольного проекту Win32, повинні починати своє виконання не з функції main(), а з функції _tmain(). Прототип цієї функції наступний:

 

int _tmain(int argc, _TCHAR* argv[]);

 

Як видно з формату функції, змінилося не тільки ім'я функції, але і тип другого аргументу: тип char замінений на макрос _TCHAR.

Ці зміни прототипу дають можливість програмі працювати з широкими символами в стандарті Unicode.

Аналогічні зміни фірмою Microsoft були зроблені і для програм, що розробляються на C++ в рамках консольного проекту платформи NET. Нижче приведений текст каркасу прикладної програми, автоматично формованого при створенні нового проекту цього типу:

 

// This is the main project file for VC++ application project

// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()

{

// TODO: Please replace the sample code below with your own.

Console::WriteLine(S" Добридень, мир!");

Console::ReadLine();

return 0;

}

3.9 Внутрішня реалізація викликів і повернень з функцій

При виклику функцій на виконання всі значення переданих їй фактичних аргументів компілятор Visual C++ приводить до 32-розрядного представлення. Перед передачею управління функції, що викликається, аргументи розміщуються в автоматичній пам'яті (стеку потоку) в порядку, зворотному їх появі в списку аргументів, тобто справа наліво.

Значення, яке повертається з функції також розширюються до 32 розрядів і повертаються в регістрі процесора EAX. Виключенням з цього правила є структури та 8-байтні | значення, які повертаються в парі регістрів процесора EDX:EAX. Великі структури повертаються з використанням регістра EAX, в якому міститься вказівник на структуру, розміщену в прихованій від програми ділянці оперативної пам'яті.

Крім процесорних інструкцій, що забезпечують розміщення аргументів в стеку перед викликом функції і повернення результуючого значення з функції, компілятор генерує інструкції збереження значень регістрів ESI, EDI, EBX і EBP перед входом у функцію і інструкції відновлення їх значень після виходу з функції.

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

3.9.1 Ключові слова __cdecl, __stdcall та __fastcall

Спосіб розміщення аргументів в регістрах або в стеку перед викликом функції, а також спосіб видалення аргументів із стеку (визивною програмою чи функцією, що викликається) при виході з функції визначається одним із ключових слів __cdecl, __stdcall або __fastcall, яке може бути розміщене перед ім'ям функції при її оголошенні. Якщо ключове слово перед ім'ям функції при її оголошенні відсутнє, припускається ключове слово __cdecl. В табл. 3.1 перелічені згадані ключові слова і відповідні їм варіанти визивних послідовностей, які використовує компілятор при трансляції виклику.

 

Таблиця 3.1

Угоди по реалізації визивних послідовностей

Ключове слово	Спосіб передачі аргументів функції, який використовується	Сторона, що видаляє аргументи зі стеку
__cdecl	Аргументи засилаються в стек в порядку, зворотному їх розміщенню в списку аргументів, тобто справа наліво	Програма, яка викликала функцію
__stdcall	Аргументи засилаються в стек в порядку, зворотному їх розміщенню в списку аргументів, тобто справа наліво	Викликана функція
__fastcall	Перші один або два аргументи передаються в регістрах ECX та EDX, інші, якщо є, засилаються в стек в порядку, зворотному їх розміщенню в списку аргументів, тобто справа наліво	Викликана функція