Auto, extern, register, static, mutable 10 страница

{

if (i>=0 && i<10)

return vals[i]; // Повертаємо посилання на i-й елемент.

else {

cout << "Помилка порушення меж масиву!\n";

return error; // Повертаємо посилання на error.

}

}

// Функція зчитування значення з масиву.

int get (int i)

{

if (i>=0 && i<10)

return vals[i]; // Повертаємо значення i-го елемента,

else {

cout << "Помилка порушення меж масиву!\n";

return error; // Повертаємо значення змінної error.

}

}

Результат, отриманий у процесі виконання цієї програми, має такий вигляд:

10 20 30 Помилка порушення меж масиву!

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

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

8.2.5. Поняття про незалежні посилання

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

Незалежне посилання – це просто ще одна назва для змінних дещо іншого типу.

Незалежне посилання повинно вказувати на певний об'єкт. Отже, незалежне посилання повинно ініціалізуватися під час її оголошення. У загальному випадку це означає, що їй буде присвоєно адресу раніше оголошеної змінної. Після цього ім'я такої посилальної змінної можна застосовувати скрізь, де може бути використано змінну, на яку вона посилається. І справді, між посиланням і змінною, на яку вона посилається, практично немає ніякої різниці. Розглянемо, наприклад, таку програму:

Код програми 8.8. Демонстрація механізму використання незалежного посилання

#include <iostream> // Для потокового введення-виведення

using namespace std; // Використання стандартного простору імен

int main ()

{

int jzm, kzm;

int &izm = jzm; // незалежне посилання

jzm = 10;

cout << jzm << " " << izm; // Виводиться: 10 10

kzm = 121;

izm = kzm; // Копіює в змінну jzm значення змінної kzm,

// а не адресу змінної kzm.

cout << "\n" << jzm; // Виводиться значення: 121

getch (); return 0;

}

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

10 10

Адреса, яку містить посилальна змінна, є фіксованою і її не можна змінити. Отже, у процесі виконання настанови izm = kzm в змінну jzm (що адресується посиланням izm) копіюється значення змінної kzm, а не її адреса. Як ще один приклад зазначимо, що після виконання настанови izm++ посилальна змінна izm не стане містити нову адресу, як це можна було б припустити. У цьому випадку на 1 збільшиться вміст змінної jzm.

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

8.2.6. Врахування обмежень під час використання посилань

На застосування посилальних змінних накладаються такі обмеження:

● не можна посилатися на посилальну змінну;

● не можна створювати масиви посилань;

● не можна створювати покажчик на посилання, тобто не можна до посилання застосовувати оператор "&";

● посилання не дозволено використовувати для бітових полів структур[33].

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

У цьому розділі ми дізнаємося про одну з найдивовижніших можливостей мови програмування C++ – перевантаження функцій. У мові C++ декілька функцій можуть мати однакові імена, але за умови, що їх параметри будуть різними. Таку обставину називають перевантаженням функцій (function overloading), а імена функцій, які в ній задіяно, перевантаженими (overloaded) функціями. Перевантаження функцій – один із способів реалізації поліморфізму у мові програмування C++.

Перевантаження функцій – це механізм, який дає змогу двом спорідненим функціям мати однакові імена.

Розглянемо простий приклад перевантаження функцій.

Код програми 8.9. Демонстрація "триразового" перевантаження функції fun()

#include <iostream> // Для потокового введення-виведення

using namespace std; // Використання стандартного простору імен

void fun(int izm); // Один цілочисельний параметр

void fun(int izm, int jzm); // Два цілочисельні параметри

void fun(double kzm); // Один параметр типу double

int main ()

{

fun(10); // Виклик функції fun(int)

fun(10, 20); // Виклик функції fun(int, int)

fun(12.23); // Виклик функції fun(double)

getch (); return 0;

}

void fun(int izm)

{

cout << "У функції fun(int) індекс izm дорівнює " << izm << "\n";

}

void fun(int izm, int jzm)

{

cout << "У функції fun(int, int) індекс izm дорівнює " << izm;

cout << ", jzm дорівнює " << jzm << "\n";

}

void fun(double kzm)

{

cout << "У функції fun(double) індекс kzm дорівнює " << kzm << "\n";

}

У процесі виконання ця програма відображає такі результати:

У функції fun(int) індекс izm дорівнює 10

У функції fun(int, int) індекс izm дорівнює 10, jzm дорівнює 20

У функції fun(double) індекс kzm дорівнює 12.23

Як бачимо, функція fun() перевантажується три рази. Перша версія приймає один цілочисельний параметр, друга – два цілочисельні параметри, а третя – один double -параметр. Оскільки переліки параметрів для всіх трьох версій функцій є різними, то компілятор володіє достатньою інформацією, щоб викликати правильну версію кожної функції. У загальному випадку для створення перевантаження деякої функції достатньо оголосити різні її версії.

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

Щоб краще зрозуміти виграш від перевантаження функцій, розглянемо три функції із стандартної бібліотеки: abs (), labs () і fabs (). Вони були вперше визначені у мові С, а потім заради сумісності включено у стандарт мови C++. Функція abs () повертає абсолютне значення (модуль) цілого числа, функція labs () повертає модуль довгого цілочисельного значення (типу long), а fabs () – модуль значення з плинною крапкою (типу double). Оскільки мова C не підтримує перевантаження функцій, то кожна функція повинна мати власне ім'я, хоча всі три функції виконують, по суті, одну і ту саму дію. Це робить ситуацію складнішою, ніж вона є насправді. Іншими словами, при одних і тих самих діях програмісту необхідно пам'ятати імена всіх трьох (у цьому випадку) функцій замість одного. Але у мові програмування C++, як це показано в наведеному нижче прикладі, можна використовувати тільки одне ім'я для всіх трьох функцій.

Код програми 8.10. Демонстрація створення функцій myAbs() – перевантаженої
версії функції abs()

#include <iostream> // Для потокового введення-виведення

using namespace std; // Використання стандартного простору імен

// Функція myAbs() перевантажується трьома способами

int myAbs(int izm);

double myAbs(double dzm);

long myAbs(long lzm);

int main ()

{

cout << myAbs(-10) << "\n";

cout << myAbs(-11.0) << "\n";

cout << myAbs(-9L) << "\n";

getch (); return 0;

}

int myAbs(int izm)

{

cout << "Використання int -функції myAbs(): ";

if (izm<0) return -izm;

else return izm;

}

double myAbs(double dzm)

{

cout << "Використання double-функції myAbs(): ";

if (dzm<0.0) return -dzm;

else return dzm;

}

long myAbs(long lzm)

{

cout << "Використання long-функції myAbs(): ";

if (lzm<0) return -lzm;

else return lzm;

}

Результати виконання цієї програми є такими:

Використання int -функції myAbs(): 10

Використання double-функції myAbs(): 11

Використання long-функції myAbs(): 9

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

Кожна версія перевантаженої функції може виконувати будь-які дії. Іншими словами, не існує правила, яке б зобов'язувало програміста пов'язувати перевантажені функції загальними діями. Проте з погляду стилістики перевантаження функцій все-таки передбачає певну "спорідненість" його версій. Таким чином, незважаючи на те, що одне і те саме ім'я функції можна використовувати для перевантаження не взаємопов'язаних між собою загальними діями функцій, цього робити не варто. Наприклад, у принципі можна використовувати ім'я sqr для створення функції, яка повертає квадрат цілого числа, і функції, яка повертає значення квадратного кореня з дійсного числа (типу double). Але, оскільки ці операції фундаментально різні між собою, застосування механізму перевантаження методів у цьому випадку зводить нанівець його первинну мету[34]. На практиці перевантажувати функції має сенс тільки для тісно пов'язаних операцій.

8.2.8. Поняття про ключове слово overload

Ще на початку розроблення мови програмування C++ перевантажені функції необхідно було безпосередньо оголошувати такими за допомогою ключового слова keyword. Це ключове слово більше не потрібне у стандарті мови програмування C++. Насправді стандартом мови C++ воно навіть не включене в перелік ключових слів. Проте час від часу воно може траплятися у будь-якому С++-коді програми, особливо в старих книгах і статтях.

Загальна форма використання ключового слова overload є така:

overload func_name;

У цьому записі елемент func_name є іменем перевантажуваної функції. Ця настанова повинна передувати оголошенням перевантажених функцій[35]. Наприклад, якщо функція Counter() є перевантаженою, то у програму може бути поміщено такий рядок:

overload Counter;

Якщо Вам трапиться overload -оголошення під час роботи із старими програмами, то їх можна просто видалити: вони більше не потрібні. Оскільки ключове слово overload є анахронізмом, то його не варто використовувати в нових С++-програмах. Насправді більшість компіляторів його просто не сприймуть.

8.3. Передача аргументів функції за замовчуванням

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

Завдання аргументів, що передаються функції за замовчуванням, синтаксично є аналогічним ініціалізації змінних. Розглянемо наведений нижче приклад, у якому оголошується функція myFunc(), що приймає один аргумент типу double з діючим за замовчуванням значенням 0.0 і один символьний аргумент з діючим за замовчуванням значенням 'X'.

void myFunc(double num = 0.0, char ch = 'X')

{

...

}

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

myFunc(198.234, 'А'); // Передаємо безпосередньо задані значення.

myFunc(10.1); // Передаємо для параметра num значення 10.1,

// а для параметра ch дозволяємо застосувати

// аргумент, що задається за замовчуванням ('X').

myFunc(); // Для обох параметрів num і ch дозволяємо застосувати

// аргументи, що задаються за замовчуванням.

Під час першого виклику параметру num передається значення 198.234, а параметру ch – символ 'А'. Під час другого виклику параметру num передаєтьсязначення 10.1, а параметру ch за замовчуванням встановлюється значення, що дорівнює символу 'X'. Нарешті, внаслідок третього виклику як параметр num, так і параметр ch за замовчуванням встановлюються такими значення, що задаються в оголошенні функції.

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

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

8.3.1. Можливі випадки передачі аргументів функції за замовчуванням

Наскільки корисна можливість передачі аргументів функції за замовчуванням, показано на прикладі функції clrscr(), представленої у наведеному нижче коді програми. Функція clrscr() очищає екран шляхом виведення послідовності символів нового рядка (це не найефективніший спосіб, але він надзвичайно підходить для даного прикладу). Оскільки в найбільш часто використовуваному режимі представлення відеозображень на екран дисплея виводиться 25 рядків тексту, то як аргумент за замовчуванням використовується значення 25. Але оскільки в інших відеорежимах на екрані може відображатися більше або менше ніж 25 рядків, то аргумент, що діє за замовчуванням, можна перевизначити, безпосередньо вказавши потрібне значення.

Код програми 8.11. Демонстрація механізму передачі аргументів функції за замовчуванням

#include <iostream> // Для потокового введення-виведення

using namespace std; // Використання стандартного простору імен

void clrscr(int size=25); // Очищаємо 25 рядків.

int main ()

{

int i;

for (i=0; i<30; i++) cout << i << "\n";

clrscr(); // Очищаємо 25 рядків.

for (i=0; i<30; i++) cout << i << "\n";

clrscr(10); // Очищаємо 10 рядків.

getch (); return 0;

}

void clrscr(int size)

{

for (; size; size--) cout << "\n";

}

Як видно з коду цієї програми, якщо значення, що діє за замовчуванням, відповідає ситуації, під час виклику функції clrscr() аргумент вказувати не потрібно. Але в інших випадках аргумент, що діє за замовчуванням, можна перевизначити і передати параметру size потрібне значення.

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

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

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

void fun(int a = 1, int b); // Неправильно!

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

int myFunc(float f, char *str, int izm=10, int jzm); // Неправильно!

Оскільки для параметра izm визначено значення за замовчуванням, то для параметра jzm також потрібно задати значення за замовчуванням.

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

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

Допустимо, що Ви назвали свої функції іменем myStrcpy() і запропонували такий варіант їх прототипів:

void myStrcpy(char *s1, char *s2, int len);

void myStrcpy(char *s1, char *s2);

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

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

Код програми 8.12. Демонстрація можливості передачі аргументів функції за замовчуванням з її перевантаженням

#include <iostream> // Для потокового введення-виведення

#include <cstring> // Для роботи з рядковими типами даних

using namespace std; // Використання стандартного простору імен

void myStrcpy(char *s1, char *s2, int len = -1);

int main ()

{

char str1[80] = "Це тест.";

char str2[80] = "0123456789";

myStrcpy(str1, str2, 5); // Приєднуємо 5 символів.

cout << str1 << "\n";

strcpy (str1, "Це тест."); // Відновлюємо str1.

myStrcpy(str1, str2); // Приєднуємо весь рядок.

cout << str1 << "\n";

getch (); return 0;

}

// Призначена для користувача версія функції strcpy().

void myStrcpy(char *s1, char *s2, int len)

{

// Знаходимо кінець рядка s1.

while (*s1) s1++;

if (len == -1) len = strlen (s2);

while (*s2 && len) {

*s1 = *s2; // Копіюємо символи.

s1++;

s2++;

len--;

}

*sl = '\0'; // Завершуємо рядок s1 нульовим символом.

}

У цій програмі функція myStrcpy() приєднує len символів рядка, який адресується покажчиком s2, до кінця рядка, яка адресується покажчиком s1. Але, якщо значення len дорівнює -1, як і у разі дозволу передачі цього аргументу функції за замовчуванням, то функція myStrcpy() приєднає до рядка s1 весь рядок, яка адресується покажчиком s2. Іншими словами, якщо значення len дорівнює -1, то функція myStrcpy() діє подібно до стандартної функції strcpy (). Використовуючи для параметра len можливість передачі аргументу функції за замовчуванням, обидві операції можна об'єднати в одній функції.

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

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

Хоча передача аргументів функції за замовчуванням, є дуже могутнім засобом програмування (за умови їх коректного використання), з ними можуть іноді виникати проблеми. Їх призначення дає змогу функції ефективно виконувати свою роботу, забезпечуючи при всій простоті цього механізму значну гнучкість. У цьому сенсі всі передані аргументи функції за замовчуванням повинні відображати спосіб найбільш загального використання функції або альтернативного її застосування. Якщо не існує деякого єдиного значення, яке звичайно присвоюється тому або іншому параметру, то і немає сенсу оголошувати відповідний аргумент за замовчуванням. Насправді оголошення аргументів, що передаються функції за замовчуванням, при недостатній для цього підставі деструктуризує програмний код, оскільки такі аргументи здатні збити з пантелику будь-кого, кому доведеться розбиратися в такій програмі. Нарешті, основним принципом використання аргументів за замовчуванням повинен бути, як у лікарів, принцип "не нашкодити". Іншими словами, випадкове використання аргументу функції за замовчуванням не повинно призвести до незворотних негативних наслідків. Адже такий аргумент можна просто забути вказати під час виклику деякої функції, і, якщо це трапиться, то подібний промах не повинен викликати, наприклад, втрату важливих даних!

8.4. Перевантаження функцій і неоднозначності,
що при цьому виникають

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

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

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

int myFunc(double d);

...

cout << myFunc('с'); // Помилки немає, виконується перетворення типів

Як зазначено в коментарі, помилки тут немає, оскільки мова C++ автоматично перетворить символ 'c' в його double -еквівалент. Взагалі кажучи, у мові програмування C++ заборонено достатньо мало видів перетворень типів. Незважаючи на те, що автоматичне перетворення типів – це дуже зручно, воно, проте, є головною причиною неоднозначності. Розглянемо таку програму.

Код програми 8.13. Демонстрація неоднозначності внаслідок перевантаження функцій

#include <iostream> // Для потокового введення-виведення

using namespace std; // Використання стандартного простору імен

float myFunc(float izm);

double myFunc(double izm);

int main ()

{

// Неоднозначності немає, викликається функція myFunc(double)

cout << myFunc(10.1) << " ";

// Виникнення неоднозначності.

cout << myFunc(10);

getch (); return 0;

}

float myFunc(float izm)

{

return izm;

}

double myFunc(double izm)

{

return -izm;

}

У цій програмі завдяки перевантаженню функція myFunc() може приймати аргументи або типу float, або типу double. У процесі виконання рядка коду програми

Дата добавления: 2014-11-29