1 / 26

Aula 3

Aula 3. Listas e iteradores (cont.). class ListaDeInt { public: typedef int Item; class Iterador; ListaDeInt(); Item const& frente() const; Item const& trás() const; int comprimento() const; bool estáVazia() const; bool estáCheia() const;.

thora
Download Presentation

Aula 3

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Aula 3 Listas e iteradores (cont.)

  2. class ListaDeInt { public: typedef int Item; class Iterador; ListaDeInt(); Item const& frente() const; Item const& trás() const; int comprimento() const; bool estáVazia() const; bool estáCheia() const; void põeNaFrente(Item const& item); void põeAtrás(Item const& item); void tiraDaFrente(); void tiraDeTrás(); void insereAntes(Iterador& iterador, Item const& item); void remove(Iterador& iterador); void esvazia(); Iterador primeiro(); Iterador último(); Iterador início(); Iterador fim(); ListaDeInt: interface Programação Orientada para Objectos

  3. ListaDeInt: implementação class ListaDeInt { … private: static int const número_máximo_de_itens = 100; Item itens[número_máximo_de_itens]; int número_de_itens; bool cumpreInvariante() const; friend class Iterador; }; return 0 <= número_de_itens and número_de_itens <= número_máximo_de_itens; Programação Orientada para Objectos

  4. ListaDeInt::Iterador:interface class ListaDeInt::Iterador { public: explicit Iterador(ListaDeInt& lista_associada); Item& item() const; bool operator==(Iterador const& outro_iterador) const; bool operator!=(Iterador const& outro_iterador) const; Iterador& operator++(); Iterador& operator--(); Iterador operator++(int); Iterador operator--(int); Programação Orientada para Objectos

  5. ListaDeInt::Iterador: implementação class ListaDeInt::Iterador { … private: ListaDeInt& lista_associada; int índice_do_item_referenciado; bool cumpreInvariante() const; friend class ListaDeInt; }; return -1 <= índice_do_item_referenciado; Programação Orientada para Objectos

  6. class Aluno { public: Aluno(string const& nome = “”, int número = 0); string const& nome() const; int número() const; private: string nome_; int número_; }; Aluno::Aluno(string const& nome, int const número) : nome_(nome), número_(número) {} string const& Aluno::nome() const { return nome_; } int Aluno::número() const { return número_; } Aluno Programação Orientada para Objectos

  7. Listas de outros tipos • Alterar • Nome da lista e respectivo construtor • Alterar typedef • Exemplo: • ListaDeInt para ListaDeAluno • typedef int Item; passa atypedef Aluno Item; Programação Orientada para Objectos

  8. Utilização de listas int main() { ListaDeAluno lista; for(int i = 0; i != 100; ++i) { string nome; // uma só palavra! int número; cin >> nome >> número; Aluno aluno(nome, número); // Inserir por ordem… } for(ListaAluno::Iterador i = lista.primeiro(); i != lista.fim(); ++i) cout << i.item().nome() << ' ' << i.item().número() << endl; } Programação Orientada para Objectos

  9. Inserir por ordem int main() { ListaDeAluno lista; for(int i = 0; i != 100; ++i) { string nome; // uma só palavra! int número; cin >> nome >> número; Aluno aluno(nome, número); ListaDeAluno::Iterador i = lista.primeiro(); while(i != lista.fim() and i.item().nome() < nome) ++i; lista.insereAntes(i, aluno); } for(ListaAluno::Iterador i = lista.primeiro(); i != lista.fim(); ++i) cout << i.item().nome() << ' ' << i.item().número() << endl; } Programação Orientada para Objectos

  10. número_de_itens: int 5 índice_do_item_referenciado: int Diagrama lista : ListaDeAluno itens: Item[100] itens[0]: itens[1]: itens[2]: itens[3]: itens[4]: itens[5]: itens[6]: itens[99]: Ana 12345 Berto 11111 Carlos 22222 Duarte 33333 Xico 12121 ... i: ListaDeAluno.Iterador lista_associada: ListaDeAluno& Programação Orientada para Objectos

  11. Cadeia simplesmente ligada class ListaDeInt { … private: … struct Elo { Item item; int seguinte; }; Elo elos[número_máximo_de_itens]; … }; Programação Orientada para Objectos

  12. Diagrama:cadeia simplesmente ligada elos[0]: elos[13]: item: Aluno item: Aluno Ana 11111 Berto 12345 seguinte: seguinte: 13 1 Programação Orientada para Objectos

  13. ListaDeInt::insereAntes() void ListaDeInt::insereAntes(Iterador const& iterador, Item const& item) { assert(cumpreInvariante()); assert(not estáCheia()); assert(iterador != início()); ++número_de_itens; ? assert(cumpreInvariante()); } int const elo_reservado = reservaElo(); elos[elo_reservado].item = item; elos[elo_reservado].seguinte = iterador.elo_do_item_referenciado; Programação Orientada para Objectos

  14. Cadeia duplamente ligada class ListaDeInt { … private: … struct Elo { Item item; int anterior; int seguinte; }; … }; Programação Orientada para Objectos

  15. Diagrama:cadeia duplamente ligada elos[45]: elos[10]: item: Aluno item: Aluno Ana 11111 Berto 12345 anterior: anterior: 33 10 seguinte: seguinte: 45 11 Programação Orientada para Objectos

  16. ListaDeInt::insereAntes() void ListaDeInt::insereAntes(Iterador const& iterador, Item const& item) { assert(cumpreInvariante()); assert(not estáCheia()); assert(iterador != início()); ++número_de_itens; int const elo_reservado = reservaElo(); elos[elo_reservado].item = item; elos[elo_reservado].seguinte = iterador.elo_do_item_referenciado; ? assert(cumpreInvariante()); } int const anterior = elos[iterador.elo_do_item_referenciado].anterior; elos[anterior].seguinte = elo_reservado; Programação Orientada para Objectos

  17. ListaDeInt::insereAntes():completo (I) void ListaDeInt::insereAntes(Iterador const& iterador, Item const& item) { assert(cumpreInvariante()); assert(not estáCheia()); assert(iterador != início()); ++número_de_itens; int const elo_reservado = reservaElo(); (continua) Programação Orientada para Objectos

  18. ListaDeInt::insereAntes():completo (II) (continuação) elos[elo_reservado].item = item; elos[elo_reservado].anterior = elos[iterador.elo_do_item_referenciado].anterior; elos[elo_reservado].seguinte = iterador.elo_do_item_referenciado; int const anterior = elos[iterador.elo_do_item_referenciado].anterior; elos[anterior].seguinte = elo_reservado; elos[iterador.elo_do_item_referenciado].anterior = elo_reservado; assert(cumpreInvariante()); } Programação Orientada para Objectos

  19. Cadeia duplamente ligada com guardas class ListaDeInt { … private: … struct Elo { Item item; int anterior; int seguinte; }; … Elo elos[número_máximo_de_itens + 2]; static int const inicial = número_máximo_de_itens; static int const final = número_máximo_de_itens + 1; … }; Programação Orientada para Objectos

  20. ListaDeInt: construtor ListaDeInt::ListaDeInt() : número_de_itens(0) { elos[inicial].seguinte = final; elos[final].anterior = inicial; ? // falta aqui qualquer coisa... assert(cumpreInvariante()); } Programação Orientada para Objectos

  21. ListaDeInt::remove() (I) inline void ListaDeInt::remove(Iterador& iterador) { assert(cumpreInvariante()); assert(not estáVazia()); assert(iterador != início() and iterador != fim()); --número_de_itens; int const elo_a_remover = iterador.elo_do_item_referenciado; ++iterador; // Avançar iterador! (continua) Programação Orientada para Objectos

  22. ListaDeInt::remove() (II) (continuação) elos[elos[elo_a_remover].anterior].seguinte = elos[elo_a_remover].seguinte; elos[elos[elo_a_remover].seguinte].anterior = elos[elo_a_remover].anterior; libertaElo(elo_a_remover); assert(cumpreInvariante()); } Programação Orientada para Objectos

  23. A fazer… • reservaElo() • libertaElo() • Saber quais os elos livres • Implementar os restantes métodos • Implementar classe Lista.Iterador Programação Orientada para Objectos

  24. elos[0]: elos[7]: elos[10]: elos[100]: elos[101]: item: Aluno Ana 11111 anterior: anterior: anterior: anterior: anterior: 100 10 seguinte: seguinte: seguinte: seguinte: seguinte: 7 43 101 10 número_de_itens: int elo_inicial: int elo_final: int 1 100 101 primeiro_elo_livre: int 0 Diagrama:cadeia duplamente ligada com guardas Programação Orientada para Objectos

  25. Interface vs. implementação • Alteração da implementação não implica alteração da interface • Programas que usavam Lista não precisam de ser alterados Programação Orientada para Objectos

  26. Aula 3 • Utilização de listas • Fazendo inserções ordenadas • Melhorando a implementação das listas e iteradores: • Identificando problemas de eficiência • Noções de cadeia simplesmente ligada, cadeia duplamente ligada e cadeia duplamente ligada com guardas • Necessidade de distinguir posições livres • Implementação parcial do módulo • Reflexão sobre interfaces e implementação: • Vantagens de definir uma boa interface Programação Orientada para Objectos

More Related