УЗАГАЛЬНЕНЕ ПРОГРАМУВАННЯ

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

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

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

Слід зазначити, що засоби узагальненого програмування до теперішнього часу (2004 рік) відсутні у всіх інших мовах програмування, окрім мови C++.

8.1 Шаблони функцій

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

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

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

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

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

Наприклад, якщо потрібна функція, що повертає абсолютну величину значення як типу int, так і типу double, то потрібно було написати дві перевантажені функції:

 

int Abs(int N)

{

return N < 0 ? -N: N;

}

 

double Abs(double N)

{

return N < 0.0 ? –N: N;

}

 

Використовуючи шаблон мови C++, можна створити єдине визначення, що автоматично оброблює значення типу int, double або будь-якого іншого придатного типу. Такий шаблон виглядає наступним чином:

 

template<class T> T Abs(T N)

{

return N < 0 ? –N: N;

}

 

У цьому визначенні ідентифікатор T є параметром типу (type parameter). Він перевизначає тип змінної або константи, що передається при виклику функції. Якщо програма викликає функцію Abs() і передає їй значення типу int, наприклад:

 

cout << "Абсолютне значення -5 = " << Abs(-5);

 

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

 

int Abs(int N)

{

return N < 0 ? -N: N;

}

 

Аналогічно, якщо програма викликає функцію Abs() і передає їй значення типу double, наприклад:

 

double D = -2.54;

cout << "Абсолютне значення D = " << Abs(D);

 

то компілятор згенерує версію функції, в якій ідентифікатор типу T буде замінений на double, і додасть в програму виклик даної функції. Ця заново згенерована версія функції еквівалентна наступній:

 

double Abs(double N)

{

return N < 0 ? –N: N;

}

 

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

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

8.1.1 Створення екземпляра функції за шаблоном

Генерація нової версії функції за заданим шаблоном називається створенням екземпляра (instantiating) шаблону функції.

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

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

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

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

Розглянемо ще один приклад шаблону функції:

 

template<class Т> Т Мах(Т А, Т В)

{

return А > В ? А: В;

}

 

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

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

 

cout << "Більше з 10 та 5 = " << Max(10, 5)<< 'n';

cout << "Більше з 'A' та 'M' = " << Max('A', 'M') << 'n';

cout << "Більше з 2.5 та 2.6 = " << Max(2.5, 2.6) << 'n';

 

А наступний виклик є неприпустимим:

 

cout << "Більше з 15.5 та 10 = " << Max(15.5, 10) << 'n'; // помилка

 

Тут потрібно звернути увагу на те, що компілятор не перетворить другий аргумент int в double для приведення типів, хоча це приведення є стандартним.

Щоб передавати аргументи різних типів, потрібно визначити шаблон функції таким чином:

 

template<class Typel, class Type2> Typel Max(Typel A, Type2 B)

{

return Typel(A > B ? A: B);

}

 

В даному шаблоні Typel позначає тип значення, що передається як перший, а Туре2 – як другий аргумент. Для нової версії шаблону наступна інструкція є допустимою і видає на екран значення 15.5:

 

cout << "Більше з 15.5 та 10 = " << Max(15.5, 10)<< 'n'; // правильно

 

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

 

return Typel (А > В ? А: В);

 

 

Взагалі, в мові C++ параметр типу можна використовувати в будь-якому місці коду шаблону, в якому використовується ім'я типу.

Оскільки значення, яке повертається функцією, приводиться до типу першого аргументу, то при зміні порядку аргументів попереднього прикладу:

 

cout << "Більше з 15.5 та 10 = " << Max(10, 15.5)<< 'n';

 

отриманий результат порівняння 15.5 буде закруглений і складе 15.

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

 

// список аргументів функції повинен включати Туре2

// як параметр типу

template<class Typel, class Type2> Typel Max(Typel A, Typel B)

{

return A > B ? A: B;

}

 

При такому визначенні компілятор, зустрівши виклик функції, не зможе визначити значення ідентифікатора Туре2. Це - помилка, навіть якщо ідентифікатор Туре2 не використовується в тілі функції.

8.1.2 Спеціалізація шаблонів функцій

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

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

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

 

CMoney Max(CMoney A, CMoney В)

{

long GrivnasA, GrivnasB;

int CopecksA, CopecksB;

A.GetAmount(&GrivnasA, &CopecksA);

B.GetAmount(&GrivnasB, &CopecksB);

if(GrivnasA>GrivnasB||GrivnasA==GrivnasB&&CopecksA > CopecksB)

return A;

else

return B;

}

 

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

 

CMoney Bucksl(29, 95);

CMoney Bucks2(31, 47);

Max(Bucksl, Bucks2).PrintAmount();

 

Результатом буде:

 

Г31.47

 

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

8.2 шаблони класів

Щоб згенерувати сімейство споріднених класів для роботи з різними типами даних, необхідно оголосити єдиний шаблон класу.

При оголошенні шаблону класу можна використовувати параметри типів і параметри-константи замість конкретних типів або констант.

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

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

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

 

class IntList

{

public:

IntList();

int SetItem (int Index, const int &Item);

int GetItem (int Index, int &Item);

private:

int Buffer [100];

};

 

Цілочисельні значення зберігаються в закритому масиві Buffer, а спеціально написаний конструктор за умовчанням ініціалізує нулями всі елементи цього масиву. Функції-члени SetItem() і GetItem() використовуються для присвоювання або отримання значень вказаних елементів.

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

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

 

template<class T, int I> class CList

{

public:

int SetItem (int Index, const T &Item);

int GetItem (int Index, T &Item);

private:

T Buffer[I];

};

 

В цьому оголошенні Т є параметром типу, а I — параметром – константою (точніше, в даному прикладі I — це параметр-константа типу int). Фактичні значення для параметрів Т та I встановлюються при створенні конкретного об'єкту класу.

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

В шаблон класу можна включати список з будь-якого числа параметрів, обмежених символами "<" та ">". Список в кутових| дужках має містити хоча б один параметр.

Параметри - константи можуть мати будь-який допустимий тип; не обов'язково int, як в наведеному вище прикладі. Всередині оголошення класу параметр типу може знаходитися в будь-якому місці програми, в якому допустимо використання специфікації типу, а параметр-константа - в будь-якому місці програми, в якому допустимо застосування константного виразу оголошеного типу (в прикладі - int).

Функцию-член SetItem() можна визначити таким чином:

 

template<class T, int I> int CList<T, I>::SetItem(int Index, const T &Item)

{

if (Index < 0 || Index > I - 1)

return 0; // завершення в випадку помилки

Buffer[Index]= Item;

return 1; // успішне завершення

}

 

Тут потрібно звернути увагу, що функціяповертає значення 1 при вдалому завершенні і 0, якщо задане значення індексу неприпустимо.

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

1. Визначення повинне починатися специфікатором template, за яким слідує такий же список параметрів у кутових дужках, як і у визначенні шаблону класу (у приведеному прикладі template <class T, int I>).

2. За ім'ям класу, що передує операції розширення області видимості, має слідувати список імен параметрів шаблону (в нашому прикладі — CList<Т, I>). Список використовується для повного завдання типу класу, до якого належить функція.

Метод шаблону класу GetItem() можна по аналогії з SetItem() визначити таким чином:

 

template <class T, int I> int CList<T, I>::GetItem (int Index, T &Item)

{

if (Index < 0 || Index > I - 1)

return 0;

Item = Buffer[Index];

return 1;

}

8.2.1 Роздільна реалізація функцій – членів шаблонів

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

8.2.2 Створення об'єктів за шаблоном класів

При створенні об'єкту за шаблоном класу потрібно точно задати значення параметрів шаблону.

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

 

CList<int, 100> IntList;

 

Це оголошення описує IntList як об'єкт версії шаблону класу CList, в якій кожне входження параметра Т замінено типом int, а кожне входження параметра I - константою 100. В результаті, в одержаному об'єкті елемент Buffer буде оголошений як масив зі 100 цілочисельних значень типу int, а відповідно до другого параметра функціям-членам SetItem() і GetItem() будуть передані посилання на значення типу int.

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

 

<class Т, int I>

 

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

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

Таким чином, для об'єкту IntList в метод SetItem() потрібно передати два значення int:

 

IntList.Setltem(0, 5); // першому елементу списку

// присвоюється ціле число 5

 

Щоб створити об'єкт для зберігання списку рядків, об'єкт CList можна оголосити так:

 

CList<char *, 25> StringList;

 

Тоді для присвоювання рядка якому-небудь елементу списку необхідно функції Setltem() як другий аргумент передати вказівник на масив типу char:

 

StringList.SetItem(0, "Mike"); // присвоює рядок "Mike"

// першому елементу списку

 

Вказівник на об'єкт, а потім і об'єкт в динамічній пам'яті для зберігання списку значень типу double створюється таким чином:

 

CList<double, 25> *DoubleList;

DoubleList = new CList<double, 25>;

 

При оголошенні вказівника DoubleList, так само як і при завданні типу в операторі new, разом з ім'ям шаблону слід задавати список його параметрів <double, 25>.

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

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

 

// оголошення структури Record на глобальному рівні

struct Record

{

char Name[25];

char Phone[15];

}

 

void main ()

{

// створення об'єкту для зберігання списку, що містить

// не більше 50 структур типу Record

CList<Record, 50> RecordList;

// створення та ініціалізація екземпляра структури Record

Record Rec =

{

"Іванов",

"7-981-119"

};

//копіювання об'єкту Rec в перший елемент списку

RecordList.SetItem(0, Rec);

// продовження функції main()

}

 

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

8.2.3 Конструктори та деструктори шаблонів класів

Для ініціалізації елементів списку в шаблон CList слід додати конструктор. Щоб ініціалізувати масив Buffer, конструктор має одержати параметр типу T. Конструктор не може просто ініціалізувати елементи масиву Buffer стандартними значеннями, наприклад 0, оскільки йому не відомий тип даних цих елементів, а значить, і що таке 0 для цього типу елементів.

Наприклад, конструктор може бути оголошений в розділі public класу CList таким чином:

 

CList(T InitValue);

 

Конструктор поза оголошенням класу можна реалізувати так:

 

template<class T, int I> CList<T, I>::CList (T InitValue)

{

for (int N = 0; N<I; ++N)

Buffer[N]= InitValue;

}

 

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

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

 

CList<int, 100> IntList(0);

 

Так само в наступному фрагменті програми створюється і ініціалізується об'єкт для зберігання списку структур типу Record:

 

struct Record

{

char Name [25];

char Phone [15];

};

Record Rec = {"", ""};

CList<Record, 50> RecordList(Rec);

 

У знов створеному об'єкті кожен елемент списку є структурою Record, в обох полях якої записані порожні рядки.

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

 

CList(){};

 

Деструктор для шаблону класів оголошується з використанням синтаксису, подібного до синтаксису конструктора. Наприклад, деструктор класу CList можна оголосити в оголошенні шаблону як:

 

~CList();

 

і реалізувати поза оголошенням шаблону таким чином:

 

template<class T, int I> CList<T, I>::~CList ()

{

// код деструктора

}

 

Нижче приводиться повний текст оголошення шаблону класу CList і визначення його методів зі всіма внесеними до них змінами:

 

// CList.h - файл заголовків шаблону класу CList

template<class T, int I> class CList

{

public:

CList(){};

CList(T InitValue);

int SetItem(int Index, const T &Item);

int GetItem(int Index, T &Item);

private:

T Buffer [I];

};

template<class T, int I> CList<T, I>::CList (T InitValue)

{

for (int N = 0; N < I; ++N)

Buffer[N] = InitValue;

}

template<class T, int I> int CList<T, I>::SetItem (int Index, const T &Item)

{

if (Index < 0 || Index > I - 1)

return 0;

Buffer[Index] = Item;

return 1;

}

template<class T, int I> int CList<T, I>::GetItem (int Index, T &Item)

{

if (Index < 0 || Index > I - 1)

return 0;

Item = Buffer [Index];

return 1;

}

8.2.4 Конкретизація і спеціалізація шаблонів класів

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

- кожен параметр типу class T замінюється в шаблоні класу на ім'я фактичного типу, заданого у відповідному елементі списка в кутових| дужках;

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

Приклад конкретизації бібліотечного шаблону класу міститься в наступному підрозділі (див. 8.3).

Спеціалізацією шаблону класу називається розробка спеціалізованих реалізацій якихось функцій - членів для деяких значень параметрів типів або констант шаблону класу. Наприклад, можна було б написати спеціальну реалізацію конструкторів і функцій – членів GetItem() і SetItem() для приведеного вище шаблону класу CList для того, щоб цей шаблон міг використовуватися для роботи з грошовими сумами, що представляються об'єктами класу CMoney.