|
template
sinf _nomi tipini_qaytarish ::
funksiya_nomi (funksiya_parametrlari_ro’yxati)
Funksiya sarlavhasida qolip parametrlarini tavsifi sinf qolipiga mos kwlishi lozim, bunda parametrlar nomlari ustma-ust tushmasligi mumkin. Qolip usullari tavsifi sintaksisini misolda qarab chiqish osonroq:
template void List::print()
{ / * funksiya tanasi */ }
Bu yerda - qolip parametri tavsifi, void – funksiya qaytaradigan qiymat tipi, List – sinf nomi, - qolip parametri, print – parametrlarsiz funksiyaning nomi.
Bir nechta parametr holida ularni parametrlar va qolip parametrlari tavsifida joylashish tartibi bir xil bo’lishi lozim, masalan:
template struct A{
void f1();
};
template void A : : f l ( ) { ... }
Quyida qoliplarni tavsiflash qoidalari sanab o’tilgan:
Lokal sinflar o’z elementrlari sifatida qoliplarni o’z ichiga olishi mumkin emas.
Usullar qoliplari virtual bo’lishi mumkin.
Sinflar qoliplari statik elementlari, do’st funksiya va sinflarni o’z ichiga olishi mumkin.
Qoliplar qoliplar hamda oddiy sinflar hosilasi bo’lishi mumkin, hamda qoliplar va oddiy sinflar uchun bazaviy bo’lishi mumkin.
Qolip ichida friend – qoliplar aniqlash mumkin emas.
Qolipga misol sifatida ikki bog’lamli ro’yxatning parametrlashgan sinfini to’liq tavsifini qaraymiz:
template class List{
class Node{
public:
Data d;
Node *next, *prev;
Node(Data dat = 0){d = dat; next = 0; prev = 0;}
};
Node *pbeg, *pend;
public:
List(){pbeg = 0; pend = 0;}
~List();
void add(Data d);
Node * find(Data i);
Node * insert(Data key, Data d);
bool remove(Data key);
void print();
void print_back();
};
// -------------------------
template
List ~List(){
if (pbeg != 0){
Node *pv = pbeg:
while (pv){
pv = pv->next; delete pbeg;
pbeg = pv;}
}
}
// -------------------------
template
void List ::print(){
Node *pv = pbeg;
cout << endl << "list: ";
while (pv){
cout << pv->d << ' ':
pv = pv->next;}
cout << endl;
}
// -------------------------
template
void List ::print_back(){
Node *pv = pend;
cout << endl << " list back: ";
while (pv){
cout << pv->d << ' ';
pv = pv->prev;}
cout << endl;
}
// -------------------------
template
void List ::add(Data d){
Node *pv = new Node(d);
if (pbeg == 0)pbeg = pend = pv;
else{
pv->prev = pend;
pend->next = pv;
pend = pv;}
}
// -------------------------
template
Node * List ::find(Data d){
Node *pv = pbeg;
while (pv){
if(pv->d == d)break;
pv = pv->next;
}
return pv;
}
// -------------------------
template
Node * List ::insert(Data key, Data d)(
if(Node *pkey = find(key)){
Node *pv = new Node(d);
pv->next = pkey->next;
pv->prev = рkеу;
pkey->next = pv:
i f ( рkеу != pend)(pv->next)->prev = pv;
else pend = pv;
return pv;}
return 0;
}
// -------------------------
template
bool List ::remove(Data key){
if(Node *pkey = find(key)){
if (pkey == pbeg){
pbeg = pbeg->next; pbeg->prev = 0;}
else if (pkey == pend){
pend = pend->prev; pend->next;= 0:}
else {
(pkey->prev)->next = pkey->next;
(pkey->next)->prev = pkey->prev;}
delete pkey; return true;}
return false;
}
Agar List qolipni ichiga joylashmagan foydalanuvchi aniqlagan tipdagi ma’lumotlarni saqlash uchun foydalanish talab etilsa, bu tip tavsifiga oqimga chiqarish amalini qayta yuklashni va tenglikka taqqoslashni qo’shish zarur, agar uning maydonlari uchun xotirani dinamik ajratishda foydalanilsa, u holda qiymat berish amali ham qo’shiladi.
Qolip sintaksisini aniqlashda aytildiki, unga tip va qoliplardan tashqari o’zgaruvchilar ham uzatilishi mumkin. Ular butuni yoki sanab o’tish tipida, hamda obyekt funksiyaga ko’rsatgichlar bo’lishi mumkin. Qolip tanasida ular constant sifatida foydalanish mumkin bo’lgan ixtiyoriy joyda foydalanilishi mumkin. Misol sifatida ma’lum uzunlik va tipdagi xotira blokini o’z ichiga olgan sinf qolipini yaratamiz:
template
class Block{
public:
Block(){p = new Type [kol];}
~Block(){delete [] p;}
operator Type * ( );
protected:
Type * p;
};
template
Block :: operator Type *(){
return p;
}
Sinf qoliplarini yaratish va sozlashdan so’ng ularni sarlavha fayllarga joylashtirish qulay hisoblanadi.
Do'stlaringiz bilan baham: |
