List templates considerar a lista ligada (singly linked list) O objecto da classe slink O objecto da classe slink O objecto da classe slink NULL next next slink() { next = 0; } slink(slink* p) { next = p; } ct slink { ink* next; ink() { next=0; } ink(slink* p) { next=p; } };
42
Embed
List templates Vamos considerar a lista ligada (singly linked list) O objecto da classe slink O objecto da classe slink O objecto da classe slink NULL.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
List templatesVamos considerar a lista ligada (singly linked list)
Agora podemos definir a classe slist_base que pode conter osobjectos de qualquer classe derivada de slink:
class slist_base {slink* last; // last->next é a cabeça da lista
public:void insert(slink* a); // incluir na cabeça da listavoid append(slink* a); // incluir no final da listaslink* get(); // retornar e remover a cabeçavoid clear() { last = 0; }slist_base() { last = 0; } // o primeiro construtorslist_base(slink* a) { last = a->next = a; }
// o segundo construtorclass bad_last {}; // a classe de excepçõesfriend class slist_base_iter; // a classe iterador
};
O nome slist_base significa que a classe vai ser usada como a basepara (classes de listas ligadas) singly linked list classes.
Vamos considerar a implementaçãodas funções diferentes pertencentes à classe slist_base. Elas são
insert, append e get.void slist_base::insert(slink* a){ if(last)
a->next = last->next;else last = a;last->next = a;
}
void slist_base::insert(slink* a){ if(last)
a->next = last->next;else last = a;last->next = a;
}
last
next
last->next é a cabeça da lista
next
a
last=0
next
a
next
a=last
else last = a;last->next = a;
void slist_base::insert(slink* a){ if(last)
a->next = last->next;else last = a;last->next = a;
}
last0
a->next = last->next;
last->next = a;
next
a
next
last
next
last
next
void slist_base::insert(slink* a){ if(last)
a->next = last->next;else last = a;last->next = a;
{ if(last) a->next = last->next; last = last->next = a; else last = a->next = a; }
void slist_base::append(slink* a)
a->next = last->next;
last->next = a;
last
last = a;
O primeiro objecto
last->next
last
a insertO primeiro objecto
a->next = a
last
appenda
last=a
last
newincluir nacabeça
newincluir nofinal
last
lasta a
A seguinte figura mostra como as funções insert e append funcionam.
slink* slist_base::get(){ if (last == 0) throw bad_last();
slink* f = last->next;if ( f == last)
last = 0;else
last->next = f->next;return f;
}
last
retornar
slink* slist_base::get(){ if (last == 0) throw bad_last();
slink* f = last->next;if ( f == last) // remover o
// ultimo elementolast = 0;else
last->next = f->next; return f; }
f
Para usar a classe slist_base podemos derivar da classe slink aclasse nova. Por exemplo, vamos considerar o elemento name queprecisamos de incluir na lista:
Neste caso o objecto pode ser incluído na Islist se este objecto forderivado da slink. Por isso, nós não podemos definir Islist,
por exemplo, de inteiros. Vamos considerar uma lista que não requer esta restrição.
template<class T> struct Tlink : public slink {T info;Tlink(const T& a) : info(a) { }
A classe Tlink<T> tem a cópia do objecto do tipo T e ligaçãofornecida através da classe base slink. Agora podemos declarar
a classe Slist.
template<class T> class Slist_iter; // vamos considerar esta linha // um pouco mais à frente
template<class T> class Slist : private slist_base {public: void insert(const T& a) { slist_base::insert(new Tlink<T>(a) ); } void append(T& a) { slist_base::append(new Tlink<T>(a) ); } T get(); friend class Slist_iter<T>; // vamos considerar esta linha
// um pouco mais à frente };
template<class T> T Slist<T>::get(){ Tlink<T>* lnk = (Tlink<T>*) slist_base::get();
T i = lnk->info;delete lnk;return i;
}
O uso da classe Slist é tão fácil como o uso da classe Islist. A diferençaé que é possível definir o objecto da classe Slist sem necessidade de o
derivar da respectiva classe slink. Mas intrusive list, tais comoIslist, têm a vantagem na eficiência em termos de execução e
frequentemente em compacidade. Cada vez que o objecto for passado na Slist esta lista precisa de reservar o objecto do tipo Tlink e
copiar o tipo. Como resultado duas coisas podem ser feitas.Primeiro, Tlink é um bom reservador de memória. Segundo,
isto é boa ideia guardar objectos na “primary list” que é intrusive eusar a lista não intrusive apenas quando é necessário o membership
de algumas listas.
void f(name* p){ Islist<name> lst1;
Slist<name*> lst2;lst1.insert(p); // ligação através do objecto ‘*p’lst2.insert(p); // o uso do objecto separado para guardar ‘p’
}
Slist é uma classe boa para pequenos objectos, tais como inteiros eponteiros. Para grandes objectos é melhor guardar ponteiros para
estes objectos na lista.
IteraçãoA classe não fornece qualquer possibilidade para olhar para dentroda lista. Mas ela declara a classe amiga (friend) slist_base_iter. Por
isso, nós podemos declarar o iterador:
class slist_base_iter {slink* ce; // o elemento correnteslist_base* cs;// a lista corrente
ce = cs->last; }slink* slist_base_iter::operator()()
// retornar 0 para indicar o final do iteração{ slink* ret = ce ? (ce=ce->next) : 0;
if (ce == cs->last) ce =0;return ret;
}
last
next
CS
ce cece ce ce
Para um dado iterador todos os iteradores para Slist e Islist podem serconstruídos. Primeiro devemos declarar os iteradores como friends
para as classes deles.
template<class T> class Islist_iter;template<class T> class Islist : private slist_base {public:
friend class Islist_iter<T>;};
template<class T> class Slist_iter;template<class T> class Slist : private slist_base {public:
friend class Slist_iter<T>;};
De notar que os nomes dos iteradores foram introduzidos sem definiras suas classes template. Isto apresenta a possibilidade de usardependências entre templates. Agora vamos definir iteradores.
template<class T> class Islist_iter : private slist_base_iter {public:
1. Os templates são uma das capacidades do C++ para a reutilizaçãode código.2. Existem dois tipos de template: class template e function template.É permitido usar templates para as funções globais e para asfunções locais pertencentes a qualquer classe.3. Template permite passar um ou mais tipos dentro da classecomo parâmetros. O tipo pode ser ou qualquer tipo predefinido nalinguagem ou qualquer tipo novo definido pelo utilizador.4. O argumento de function template deve definir o tipo com pelo menos um argumento na função. Isto permite garantir que a própriaversão da função vai ser seleccionada com a ajuda da avaliação dostipos dos argumentos desta função.5. Os parâmetros de template devem ser fornecidos em símbolostais como (< >). Alguns parâmetros dentro de (< >) podem sertambém símbolos < >. Para evitar ambiguidade precisamos deinserir o espaço entre os símbolos respectivos.
SWAP<int,comp<int> >::swap(my_array);
6. Templates permitem construir os programas que foramcompostos de partes relativamente independentes. Uma parte éorientada na construção do interface e a outra - na realizaçãode funções diferentes. Finalmente esta possibilidade dá novos meiospara suportar o encapsulamento e os tipos abstractos,particularmente para separar o interface e a implementação.7. As regras adoptadas na linguagens C/C++ para converter ostipos dos argumentos não podem ser usadas para templates.8. Function template pode ser redefinida nas seguintes ocasiões:existem outras funções que têm o mesmo nome ou existem outrasfunctions template que têm o mesmo nome.9. Podemos usar as expressões constantes como argumentos detemplate.10. Ao declarar os objectos de qualquer classe definidos com aajuda de templates podemos dizer que dois objectos são objectosda mesma classe se eles tiveram o mesmo template ou todos osargumentos tiverem os mesmos valores.
11. Dois tipos construídos do mesmo template são diferentesindependentemente da possibilidade das conversões automáticasadoptadas na linguagem C++.12. Os argumentos de template podem ser só expressões constantes(i.e. neste caso eles não são tipos).13. Ao definir os argumentos de template como classes bases ederivadas nós vamos perder muitas conversões definidas nalinguagem para objectos destas classes.14. Existe uma relação entre templates e a herança. Templatespermitem mostrar abstracções comuns entre tipos diferentes. Aherança permite apresentar interfaces comuns para classes diferentes.15. O uso de templates e herança dá-nos os meios para separar ointerface da implementação.16. A declaração de template só pode ser global.17. Cada classe ou função geradas de acordo com o template têmcopias únicas dos seus componentes estáticos.
template<class T> struct Tlink : public slink {T info;Tlink(const T& a) : info(a) { }
};
class slist_base {slink* last; // last->next é a cabeça da lista
public:void insert(slink* a); // incluir na cabeça da listavoid append(slink* a); // incluir no final da listaslink* get(); // retornar e remover a cabeçavoid clear() { last = 0; }slist_base() { last = 0; } // o primeiro construtorslist_base(slink* a) { last = a->next = a; }
// o segundo construtorclass bad_last {}; // a classe de excepçõesfriend class slist_base_iter; // a classe iterador
};
template<class T> class Slist : private slist_base {public: void insert(const T& a) { slist_base::insert(new Tlink<T>(a) ); } void append(T& a) { slist_base::append(new Tlink<T>(a) ); } T get(); friend class Slist_iter<T>;
};
template<class T> class Islist : private slist_base {public:
void insert(T* a) { slist_base::insert(a); }void append(T* a) { slist_base::append(a); }T* get() { return (T*) slist_base::get(); }friend class Islist_iter < T >;