Deduceți tipul de returnare al unei funcții șablon. Șabloane

Crearea unui șablon de securitate Pentru a crea un șablon de securitate bazat pe orice alt șablon, selectați comanda Salvare ca din meniul contextual al șablonului. Consola de management Microsoft vă va solicita apoi să furnizați un nume pentru noul șablon, după care va apărea în

10.2. Specificarea unui șablon de funcție Un șablon de funcție descrie modul în care anumite funcții ar trebui să fie construite atunci când sunt date mai multe tipuri sau valori reale. Procesul de proiectare se numește instanțiere șablon. Se execută implicit, ca efect secundar al apelului

10.11. Exemplu de șablon de funcție Această secțiune oferă un exemplu care arată cum pot fi definite și utilizate șabloanele de funcție. Aceasta definește șablonul sort(), care este apoi folosit pentru a sorta elementele matricei. Matricea în sine este reprezentată de șablonul de clasă Array (vezi

16.1. Definirea unui șablon de clasă Să presupunem că trebuie să definim o clasă care acceptă un mecanism de așteptare. O coadă este o structură de date pentru stocarea unei colecții de obiecte; sunt plasate la sfârșitul cozii și recuperate de la început. Este descris comportamentul cozii

Puteți crea prototipul unui șablon de funcție declarându-l în prealabil. Această declarație informează compilatorul despre prezența șablonului și, de asemenea, informează compilatorul despre parametrii așteptați. De exemplu, prototipul șablonului funcției de sortare ar arăta astfel:

șablon void Sort (matrice T, dimensiune Tsize);

Este posibil ca numele parametrilor formali ai unui șablon să nu fie aceleași în predeclararea și definirea șablonului. Deci, de exemplu, în următorul fragment, atât prototipul șablonului, cât și definiția șablonului se referă la aceeași funcție:

șablon T max(T, T);

șablon

Tip max(Tip a, tip b)

dacă (a > b) returnează a; altfel returnează b;

Utilizarea unui șablon de funcție

Un șablon de funcție descrie modul în care o anumită funcție poate fi construită pe baza unuia sau mai multor tipuri reale. Compilatorul creează automat un reprezentant al corpului de funcție pentru tipurile specificate în apel. Acest proces se numește specificație. Apare atunci când este apelată o funcție șablon.

De exemplu, în exemplul următor, funcția min() este instanțiată de două ori: o dată cu tipul int și o dată cu tipul double:

șablon

Tastați min (Tip a, Tip b)

în cazul în care o< b) return a; else return b;

int x = 4, y = 5, z;

dublu t = 6,56, r = 3,07, p;

Specializare șablon de funcție

O funcție de șablon specializată este o funcție obișnuită al cărei nume este același cu cel al funcției din șablon, dar care este definită pentru parametri de anumite tipuri. Funcțiile de șablon specializate sunt definite atunci când un șablon generic nu este potrivit pentru un anumit tip de date. De exemplu, funcția șablon min

șablon

Tastați min (Tip a, Tip b)

în cazul în care o< b) return a; else return b;

nu poate fi folosit pentru șiruri de caractere (pentru tipul char*), deoarece codul generat de compilator va compara pur și simplu pozițiile lor de memorie (adresele). Pentru a compara corect șirurile de caractere, puteți defini o funcție specializată:

char* min(char* s1, char* s2)

dacă (strcmp(s1,s2)>0) returnează s2; altfel returnează s1;

Apoi puteți accesa o astfel de funcție în același mod ca o funcție șablon:

int i1 = 3, i2 = 5;

cout<< “max int = ” << max(i1, i2) << endl;

char* s1 = „Vulturul de Aur”;

char* s2 = „Șoim perigrin”;

cout<< “max str = “ << max(s1, s2) << endl;

Șabloane de clasă

Șablon de clasă oferă o definiție generală a unei familii de clase folosind tipuri sau constante arbitrare. Modelul definește membri de date șablonȘi funcții de membru șablon. Odată ce un șablon de clasă a fost definit, puteți instrui compilatorului să genereze o nouă clasă pe baza acestuia pentru un anumit tip sau constantă.

Sintaxa șablonului de clasă

șablon<<список аргументов шаблона>>

clasă<имя класса>

<тело класса>

Cuvântul cheie șablon este urmat de unul sau mai multe argumente (parametri) cuprinse între paranteze unghiulare și separate prin virgule. Fiecare argument poate fi un cuvânt cheie de clasă urmat de un identificator care indică tipul parametrizat. Lista de argumente șablon nu poate fi goală.

Urmează definiția clasei. Este similar cu o definiție de clasă obișnuită, cu excepția faptului că folosește o listă de argumente șablon.

Parametrii șablonului constând din cuvântul cheie de clasă urmat de un identificator sunt adesea numiți parametrii de tip. Cu alte cuvinte, ei informează compilatorul că șablonul așteaptă un tip ca argument.

Am considerat deja un astfel de instrument ca șabloane în C++ când am creat . De ce ar trebui să folosiți șabloane a fost scris în articolul cu șabloane de funcție. Acolo ne-am uitat la prevederile de bază ale șabloanelor în C++. Să le amintim.

Orice șablon începe cu șablonul cuvânt, fie că este un șablon de funcție sau un șablon de clasă. Cuvântul cheie șablon este urmat de paranteze unghiulare −< >, care listează o listă de parametri de șablon. Fiecare parametru trebuie să fie precedat de clasa sau tipul de cuvânt rezervat. Absența acestor cuvinte cheie va fi interpretată de compilator ca . Câteva exemple de declarații șablon:

Șablon

Șablon

Șablon

Cuvântul cheie typename îi spune compilatorului că șablonul va folosi un tip de date încorporat, cum ar fi: int , double , float , char , etc. Și cuvântul cheie class îi spune compilatorului că șablonul de funcție va folosi tipuri de date personalizate ca parametru , adică cursuri. Dar sub nicio formă nu confundați un parametru șablon cu un șablon de clasă. Dacă trebuie să creăm un șablon de clasă cu un parametru de tip int și char , șablonul de clasă va arăta astfel:

Șablon

unde T este un parametru șablon de clasă care poate accepta oricare dintre tipurile de date încorporate, care este ceea ce avem nevoie.

Și dacă parametrul șablonului de clasă trebuie să fie de tip personalizat, cum ar fi Array , unde Array este o clasă care descrie o matrice, șablonul de clasă va arăta astfel:

Șablon Nume clasa (//corp șablon de clasă);

Este mai bine să vă dați seama de acest lucru de la început, astfel încât să nu apară erori mai târziu, chiar dacă șablonul de clasă este scris corect.

Să creăm un șablon de clasă Stack, unde , care stochează elemente de date similare. Puteți împinge și introduce datele în stivă. Un element adăugat stivei este plasat în partea de sus a stivei. Elementele stivei sunt îndepărtate începând de sus. În șablonul de clasă Stack, trebuie să creați principalele metode:

• Apăsaţi— adăugați un element la stivă;
• Pop- scoateți un element din stivă
• printStack— afișarea stivei pe ecran;

Deci, să implementăm aceste trei metode și, în final, vom obține cea mai simplă clasă care implementează funcționarea structurii stivei. Nu uitați de constructori și destructori. Vezi codul de mai jos.

#include „stdafx.h” #include șablon << "Заталкиваем элементы в стек: "; int ct = 0; while (ct++ != 5) { int temp; cin >> << "\nУдаляем два элемента из стека:\n"; myStack.pop(); // удаляем элемент из стека myStack.pop(); // удаляем элемент из стека myStack.printStack(); // вывод стека на экран return 0; } // конструктор template Grămadă ::Stiva(int s) ( dimensiune = s > Grămadă bool Stiva bool Stiva void Stack ::printStack() ( pentru (int ix = dimensiunea -1; ix >= 0; ix--) cout<< "|" << setw(4) << stackPtr << endl; }

// cod Cod::Blocuri

// Cod Dev-C++

#include folosind namespace std; #include șablon class Stack (privat: T *stackPtr; // pointer la dimensiunea stivei int; // dimensiunea stivei T top; // partea de sus a stivei public: Stack(int = 10); // implicit dimensiunea stivei este de 10 elemente ~Stack() ; // destructor bool push(const T // împinge un element în stiva bool pop()); int main() (Stiva myStack(5); // umple stiva<< "Заталкиваем элементы в стек: "; int ct = 0; while (ct++ != 5) { int temp; cin >> temp; myStack.push(temp); ) myStack.printStack(); // imprimă stiva pe ecranul<< "\nУдаляем два элемента из стека:\n"; myStack.pop(); // удаляем элемент из стека myStack.pop(); // удаляем элемент из стека myStack.printStack(); // вывод стека на экран return 0; } // конструктор template Grămadă ::Stack(int s) ( size = s > 0 ? s: 10; // inițializați dimensiunea stivei stackPtr = new T; // alocați memorie pentru partea de sus a stivei = -1; // valoarea -1 indică faptul că stiva gol ) // destructor de șablon Grămadă ::~Stack() ( șterge stackPtr; // șterge stiva ) // elementul este o funcție a clasei Stack pentru plasarea unui element pe stivă // valoarea returnată este adevărată, operația finalizată cu succes // fals, elementul nu a fost adăugat la șablonul de stivă bool Stiva ::push(const T value) ( ​​​​dacă (sus == dimensiune - 1) returnează fals; // stiva este plină top++; stackPtr = valoare; // împinge elementul în stivă returnează adevărat; // finalizare cu succes a operației ) // funcția element Clasa de stivă pentru a elimina un element din stivă // valoarea returnată este adevărată, operația s-a finalizat cu succes // fals, stiva este șablonul gol bool Stiva ::pop() (dacă (sus == - 1) returnează fals; // stiva este goală stackPtr = 0; // elimină un element din partea de sus a stivei--; returnează adevărat; // finalizarea cu succes a operației) // afișează stiva pe șablonul de ecran void Stack ::printStack() ( pentru (int ix = dimensiunea -1; ix >= 0; ix--) cout<< "|" << setw(4) << stackPtr << endl; }

După cum puteți vedea, șablonul de clasă Stack este declarat și definit în fișierul cu funcția principală. Desigur, această metodă de reciclare a șabloanelor nu este bună, dar va funcționa ca exemplu. Rândurile 7 - 20 declară interfața șablonului de clasă. Declarația de clasă se face în mod obișnuit, iar înaintea clasei există o declarație șablon, pe linia 7. Când declarați un șablon de clasă, folosiți întotdeauna această sintaxă.

Rândurile 47 - 100 conțin elementul de funcție șablon al clasei Stack, iar înainte de fiecare funcție este necesar să se declare un șablon, exact la fel ca înainte de clasă - șablon . Adică, se dovedește că elementul funcție al unui șablon de clasă este declarat exact în același mod ca șabloanele de funcție obișnuite. Dacă am descrie implementarea metodelor în interiorul unei clase, atunci antetul șablonului ar fi șablon Nu este nevoie să vă înregistrați pentru fiecare funcție.

Pentru a lega fiecare element de funcție la un șablon de clasă, ca de obicei, folosim operația de rezoluție a domeniului binar - :: cu numele șablonului de clasă - Stivă . Ceea ce am făcut în rândurile 49, 58, 68, 83, 96.

Notați declarația obiectului myStack al șablonului de clasă Stack în funcția principală, linia 24. Parantezele unghiulare trebuie să indice în mod explicit tipul de date utilizat, acest lucru nu a fost necesar în șabloanele de funcție. În continuare, main rulează câteva funcții care demonstrează cum funcționează șablonul de clasă Stack. Rezultatul programului este prezentat mai jos.

Împingem elemente pe stivă: 12 3456 768 5 4564 |4564 | 5 | 768 |3456 | 12 Scoateți două elemente din stivă: | 0 | 0 | 768 |3456 | 12

Șabloanele de funcție, cu alte cuvinte, sunt instrucțiuni conform cărora versiunile locale ale unei funcții șablon sunt create pentru un set specific de parametri și tipuri de date.

De fapt, șabloanele de funcții sunt un instrument puternic în C++ care ușurează mult munca unui programator. De exemplu, trebuie să programăm o funcție care să afișeze elementele unui tablou. Sarcina nu este dificilă! Dar pentru a scrie o astfel de funcție, trebuie să cunoaștem tipul de date al matricei pe care îl vom afișa pe ecran. Și apoi ne spun - există mai mult de un tip de date, dorim ca funcția să scoată matrice de tipuri int, double, float și char.

După cum sa dovedit, sarcina a devenit mai complicată. Și acum înțelegem că trebuie să programăm până la 4 funcții care efectuează aceleași acțiuni, dar pentru diferite tipuri de date. Deoarece nu suntem încă familiarizați cu șabloanele de funcții, vom face acest lucru: vom folosi .

// supraîncărcarea funcției printArray pentru a afișa matricea pe ecran void printArray(const int * array, int count) ( for (int ix = 0; ix< count; ix++) cout << array << " "; cout << endl; } void printArray(const double * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; } void printArray(const float * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; } void printArray(const char * array, int count) { for (int ix = 0; ix < count; ix++) cout << array << " "; cout << endl; }

Astfel, avem 4 funcții supraîncărcate, pentru diferite tipuri de date. După cum puteți vedea, ele diferă doar prin antetul funcției, corpul lor este absolut același. Am scris corpul funcției o dată pentru tipul int și l-am copiat de trei ori pentru alte tipuri de date.

Și, dacă rulați programul cu aceste funcții, acesta va funcționa corect. Compilatorul însuși va determina ce funcție să folosească la apelare.

După cum puteți vedea, a existat destul de mult cod pentru o operație atât de simplă. Ce se întâmplă dacă trebuie să-l programăm ca funcție. Se pare că pentru fiecare tip de date va trebui să vă creați propria funcție. Adică înțelegi tu însuți că același cod va fi în mai multe copii, acest lucru nu ne este de nici un folos. De aceea, C++ a venit cu un astfel de mecanism - șabloane de funcție.

Creăm un șablon în care descriem toate tipurile de date. În acest fel, sursa nu va fi aglomerată cu linii de cod inutile. Mai jos ne vom uita la un exemplu de program cu un șablon de funcție. Deci, să ne amintim condiția: „programați o funcție care ar afișa elementele matricei”.

#include < count; ix++) cout << array << " "; cout << endl; } // конец шаблона функции printArray int main() { // размеры массивов const int iSize = 10, dSize = 7, fSize = 10, cSize = 5; // массивы разных типов данных int iArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; double dArray = {1.2345, 2.234, 3.57, 4.67876, 5.346, 6.1545, 7.7682}; float fArray = {1.34, 2.37, 3.23, 4.8, 5.879, 6.345, 73.434, 8.82, 9.33, 10.4}; char cArray = {"MARS"}; cout << "\t\t Шаблон функции вывода массива на экран\n\n"; // вызов локальной версии функции printArray для типа int через шаблон cout << "\nМассив типа int:\n"; printArray(iArray, iSize); // вызов локальной версии функции printArray для типа double через шаблон cout << "\nМассив типа double:\n"; printArray(dArray, dSize); // вызов локальной версии функции printArray для типа float через шаблон cout << "\nМассив типа float:\n"; printArray(fArray, fSize); // вызов локальной версии функции printArray для типа char через шаблон cout << "\nМассив типа char:\n";printArray(cArray, cSize); return 0; }

// cod Cod::Blocuri

// Cod Dev-C++

#include #include folosind namespace std; // template template printArray template void printArray(const T * array, int count) (pentru (int ix = 0; ix< count; ix++) cout << array << " "; cout << endl; } // конец шаблона функции printArray int main() { // размеры массивов const int iSize = 10, dSize = 7, fSize = 10, cSize = 5; // массивы разных типов данных int iArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; double dArray = {1.2345, 2.234, 3.57, 4.67876, 5.346, 6.1545, 7.7682}; float fArray = {1.34, 2.37, 3.23, 4.8, 5.879, 6.345, 73.434, 8.82, 9.33, 10.4}; char cArray = {"MARS"}; cout << "\t\t Шаблон функции вывода массива на экран\n\n"; // вызов локальной версии функции printArray для типа int через шаблон cout << "\nМассив типа int:\n"; printArray(iArray, iSize); // вызов локальной версии функции printArray для типа double через шаблон cout << "\nМассив типа double:\n"; printArray(dArray, dSize); // вызов локальной версии функции printArray для типа float через шаблон cout << "\nМассив типа float:\n"; printArray(fArray, fSize); // вызов локальной версии функции printArray для типа char через шаблон cout << "\nМассив типа char:\n";printArray(cArray, cSize); return 0; }

Vă rugăm să rețineți că codul a fost redus de 4 ori, deoarece în program este declarată o singură instanță a funcției - șablonul. În principal, am declarat mai multe matrice - patru, pentru tipurile de date: int, double, float, char. După care, în rândurile 26, 28, 30, 32, funcția printArray este apelată pentru diferite matrice. Rezultatul programului este prezentat mai jos.

Șablon pentru afișarea unui tablou pe ecran Matrice de tip int: 1 2 3 4 5 6 7 8 9 10 Matrice de tip dublu: 1.2345 2.234 3.57 4.67876 5.346 6.1545 7.7682 Matricea de tip float 6. 345 73.434 8.82 9.33 10.4 Matrice de tip char: M A R S

După cum puteți vedea, programul funcționează corect și pentru aceasta nu a trebuit decât să definim funcția printArray o singură dată în forma care ne este familiară. Vă rugăm să rețineți că înainte de declararea funcției în sine, pe linia 5, există următoarea intrare de șablon . Această intrare sugerează că funcția printArray este de fapt un șablon de funcție, deoarece primul parametru al printArray conține un tip de date const T*, exact la fel ca în linia 5.

Toate șabloanele de funcție încep cu cuvântul șablon urmat de paranteze unghiulare care listează parametrii. Fiecare parametru trebuie să fie precedat de clasa sau tipul de cuvânt rezervat.

Șablon

Șablon

Șablon

Cuvântul cheie typename îi spune compilatorului că șablonul va folosi un tip de date încorporat, cum ar fi: int , double , float , char , etc. Și cuvântul cheie class îi spune compilatorului că șablonul de funcție va folosi tipuri de date personalizate ca parametru , adică cursuri.

Șablonul nostru de funcție a folosit tipuri de date încorporate, așa că pe linia 5 am scris șablon . În loc de T, puteți înlocui orice alt nume la care vă puteți gândi. Să aruncăm o privire mai atentă la fragmentul de cod din programul de sus, îl voi posta separat.

// template template printArray template void printArray(const T * array, int count) (pentru (int ix = 0; ix< count; ix++) cout << array << " "; cout << endl; } // конец шаблона функции printArray

Linia 2 definește un șablon cu un parametru, T, iar acest parametru va avea unul dintre tipurile de date încorporate deoarece este specificat cuvântul cheie typename.

Mai jos, în rândurile 3 - 8, este declarată o funcție care îndeplinește toate criteriile pentru declararea unei funcții obișnuite, există un antet, există un corp de funcție, antetul conține numele și parametrii funcției, totul este ca de obicei. Dar ceea ce transformă această funcție într-un șablon de funcție este un parametru cu tipul de date T , care este singura conexiune la șablonul declarat mai devreme. Daca am scris

Void printArray(const int * array, int count) (pentru (int ix = 0; ix< count; ix++) cout << array << " "; cout << endl; }

atunci ar fi o funcție simplă pentru o matrice de tip int .

Deci, de fapt, T nici măcar nu este un tip de date, este un loc rezervat pentru orice tip de date încorporat. Adică, atunci când această funcție este apelată, compilatorul analizează parametrul funcției șablon și creează o instanță pentru tipul de date adecvat: int, char și așa mai departe.

Prin urmare, ar trebui să înțelegeți că, chiar dacă cantitatea de cod este mai mică, acest lucru nu înseamnă că programul va consuma mai puțină memorie. Compilatorul însuși creează copii locale ale funcției șablon și, în consecință, cantitatea de memorie consumată este ca și cum ați fi scris singur toate instanțele funcției, așa cum este cazul supraîncărcării.
Sper că v-am transmis ideea principală despre șabloanele de funcții. Pentru a consolida materialul, să ne uităm la un alt exemplu de program folosind un șablon de funcție.

#include „stdafx.h” #include #include < size; ix++) if (max < array) max = array; return max; } int main() { // тестируем шаблон функции searchMax для массива типа char char array = "aodsiafgerkeio"; int len = strlen(array); cout << "Максимальный элемент массива типа char: " << searchMax(array, len) << endl; // тестируем шаблон функции searchMax для массива типа int int iArray = {3,5,7,2,9}; cout << "Максимальный элемент массива типа int: " << searchMax(iArray, 5) << endl; return 0; }

// cod Cod::Blocuri

// Cod Dev-C++

#include #include folosind namespace std; // șablon de funcție pentru găsirea valorii maxime în șablonul matrice T searchMax(const T* array, int size) ( T max = matrice; // valoarea maximă în matrice pentru (int ix = 0; ix< size; ix++) if (max < array) max = array; return max; } int main() { // тестируем шаблон функции searchMax для массива типа char char array = "aodsiafgerkeio"; int len = strlen(array); cout << "Максимальный элемент массива типа char: " << searchMax(array, len) << endl; // тестируем шаблон функции searchMax для массива типа int int iArray = {3,5,7,2,9}; cout << "Максимальный элемент массива типа int: " << searchMax(iArray, 5) << endl; return 0; }

Iată un alt exemplu de utilizare a șabloanelor de funcție. Șablonul funcției este declarat pe rândurile 5-13. Funcția trebuie să returneze valoarea maximă a matricei, deci valoarea returnată este de tip T , deoarece tipul de date al matricei nu este cunoscut în prealabil. Apropo, în interiorul funcției este declarată o variabilă max de tip T; valoarea maximă a matricei va fi stocată în ea. După cum puteți vedea, tipul de date T este folosit nu numai pentru a specifica parametrii funcției, ci și pentru a indica tipul de returnare și poate fi folosit în mod liber pentru a declara orice variabile într-un șablon de funcție.

Element maxim al unui tablou de tip char: s Element maxim al unui tablou de tip int: 9

Șabloanele de funcție pot fi, de asemenea, supraîncărcate cu alte șabloane de funcție prin modificarea numărului de parametri trecuți funcției. O altă caracteristică a supraîncărcării este că funcțiile șablon pot fi supraîncărcate cu funcții obișnuite care nu sunt șablon. Adică este specificat același nume de funcție, cu aceiași parametri, dar pentru un anumit tip de date și totul va funcționa corect.

Eram pe cale să scriu un text despre tot felul de structuri de date interesante și apoi s-a dovedit că încă nu examinasem câteva caracteristici foarte importante ale C++. Șabloanele sunt unul dintre ele.

Șabloanele sunt un instrument foarte puternic. Funcțiile și clasele șablonului pot simplifica foarte mult viața unui programator și pot economisi o cantitate imensă de timp, efort și nervi. Dacă credeți că șabloanele nu sunt un subiect foarte semnificativ de studiat, să știți că vă înșelați.

Funcții de șablon

Un exemplu simplu de funcție șablon:

cod C++ Type square (Tip a) ( Tip b; b = a*a; return b; ) int x = 5; int i; i = pătrat(5); float y = 0,5; plutitor f; f = pătrat(y);

Dacă am creat funcții în mod vechi, atunci ar trebui să scriem două funcții diferite: pentru tipul int și pentru tipul float. Și dacă aveți nevoie de aceeași funcție folosind alte tipuri, ar trebui să o scrieți din nou. Folosind șabloane, vă puteți limita la o singură instanță a unei funcții, lăsând toată munca murdară în seama compilatorului.

În loc să folosească un anumit tip, funcția folosește un tip parametric (sau, cu alte cuvinte, un argument șablon). Aici am numit tipul parametric identificatorul Tip. Acest identificator apare de trei ori într-o funcție: valoarea returnată, argumentul funcției și definiția variabilei s. Adică, Type este folosit ca orice tip obișnuit.

Dar pentru ca codul să funcționeze, trebuie să adăugați următoarea linie înainte de funcție (am arătat mai multe opțiuni de sintaxă, toate funcționează):

cod C++șablon Tastați șablonul pătrat (Tip a). < class Type >Tastați șablonul pătrat (Tip a).< class Type >Tip pătrat (Tip a)

Deci, funcția trebuie să fie precedată de șablonul de cuvinte cheie, iar între paranteze unghiulare trebuie să specificați numele tipului parametric cu clasa de cuvinte cheie. În loc de cuvântul cheie class, puteți folosi type - în general, nu există nicio diferență.

Identificatorul de tip parametric poate fi, de asemenea, orice. Vom folosi adesea acestea: TypeA, TypeB, Datatype, T.

Notă importantă: Funcțiile șablon trebuie să aibă un argument, astfel încât compilatorul să poată determina ce tip să folosească.

Puteți folosi mai multe tipuri parametrice în șabloane și, desigur, puteți amesteca tipurile parametrice cu cele standard (trebuie doar să vă ocupați de turnarea corectă a tipului). Voi da un exemplu care utilizează două tipuri parametrice TypeA, TypeB și tipul de bază int:

cod C++șablon Exemplu_funcție de tip B (TypeA a, TypeB b) ( int x = 5; b = a + x; return b; )

Dar funcțiile șablon nu sunt cel mai interesant lucru la care ne vom uita astăzi.

Clasele șablon

În general, clasele de șablon sunt create în același mod ca și funcțiile șablon - șablonul de cuvinte cheie este scris înainte de numele clasei. Să ne uităm la clasele șabloane folosind o stivă ca exemplu:

cod C++șablon clasă stivă ( private: int top; Type s; public: stack (): top(0) () void push(Type var) ( top++; s = var; ) Type pop(); ); șablon Tip stack::pop() (Tip var = s; top--; return var; ) Aici definim

a împărțit un teanc de zece elemente. Aceste elemente pot fi de orice tip, mai multe despre cele de mai jos.

Singurul lucru asupra căruia vreau să vă atrag atenția este definirea funcțiilor push și pop. Funcția push este definită în interiorul clasei, iar funcția pop este definită în afara acesteia. Pentru toate funcțiile declarate în afara clasei, trebuie specificat cuvântul cheie șablon. Expresia dinaintea numelui funcției este aceeași cu cea dinaintea numelui clasei.

Acum să vedem cum să lucrăm cu clasele șablon:

cod C++ grămadă s1; grămadă s2; s1.push(3); s1.push(2); s1.pop(); s2.push(0,5);

Când creați un obiect, după numele clasei trebuie să puneți paranteze unghiulare în care să indicați tipul dorit. După aceasta, obiectele sunt folosite așa cum ne-am obișnuit.

Clasele șabloane au o caracteristică uimitoare - pe lângă tipurile standard, pot funcționa și cu cele personalizate. Să ne uităm la un mic exemplu. Pentru a face acest lucru, să definim o clasă simplă de războinici:

cod C++ războinic de clasă ( public: int sănătate; războinic () : sănătate(0) () ); grămadă s; războinic w1; războinic w2; războinic w3; s.împinge(w1); s.împinge(w3); s.pop(); s.împinge(w2);

Uite, acum poți pune variabile de tip războinic pe stive!!! Poate că nu mă credeți, dar asta este foarte tare! Puteți vedea cât de tare este acest lucru când creăm grafice și arbori pe baza listelor.

Asta e totul conform șabloanelor deocamdată. Mai târziu ne vom uita la cazuri mai complexe de utilizare a claselor șablon.