Programa detalhado

Sumário

• Aula 1

• Aula 2

• Aula 3

• Aula 4

• Aula 5

• Aula 6

• Aula 7

• Aula 8

• Aula 9

• Aula 10

• Aula 11

• Aula 12

• Aula 13

Aula 1

• Modularização: física e em pacotes.
• Noções de modularização física e compilação separada:
  1. Vantagens.
  2. Fases da construção dum programa (pré-processamento, compilação, fusão).
  3. Compilação: análises lexical, sintáctica e semântica, optimização e geração de código máquina.
  4. Noções sobre ficheiros de interface (.H), fonte (.C), objecto (.o), biblioteca ou arquivo (.a), e executável.
  5. Regra da definição única. O que se deve colocar nos ficheiros fonte e nos ficheiros de interface respectivos.
  6. A excepção das funções e procedimentos inline.
• Noções sobre espaços nominativos (namespaces).  Modularização em pacotes.
  1. Utilidade.
  2. Sintaxe.
  3. Utilização: directivas e declarações.

Aula prática 1.  Capítulo 9 das Folhas Teóricas.

Aula 2

• Noção de lista e iterador.
  1. Listas como sequências de itens com ordem relevante.
  2. Iteradores como ferramenta para percorrer e referenciar itens em listas.
• Operações com listas e iteradores.
• Implementação parcial em C++.
• Classes embutidas.

Aula prática 2.  Capítulo 10 das Folhas Teóricas.

Aula 3

• Utilização de listas: pequeno programa fazendo inserções ordenadas.
• Melhorando a implementação das listas e iteradores:
  1. Identificando problemas de eficiência.
  2. Como inserir a meio sem necessidade de "empurrar" os itens para a frente?
  3. Como remover do meio sem necessidade de "puxar" os itens para trás?
  4. Noções de cadeia simplesmente ligada e cadeia duplamente ligada.
  5. Como inserir a meio?  Justificação para a existência de guardas (concretização da noção de item fictício).
  6. Necessidade de distinguir posições livres.
  7. Implementação parcial do módulo.
• Reflexão sobre interfaces e implementação: vantagens de definir uma boa interface.

Aula prática 3.  Capítulo 10 das Folhas Teóricas.  Ainda incompleto.

Aula 4

• Instâncias de um programa C++: memória, unidade básica de memória e conceito de endereço.
• Instâncias que contêm o endereço de outra variável: ponteiros.
• Definição de ponteiros.
• Inicialização de ponteiros: o operador endereço (& unário).
• Acesso indirecto a variáveis: o operador conteúdo (* unário).
• Símbolos * e & em declarações (ponteiro e referência) e em expressões (conteúdo e endereço, quando unários).
• Relação de ponteiros com matrizes: ponteiros para elementos da matrizes.
• Ponteiro para elemento fictício final de matriz.  Assimetria: não há ponteiro para elemento fictício inicial.
• Soma ou subtracção de ponteiros com inteiros: avanço ou recuo na matriz.
• Indexação de ponteiros: X[I] equivalente a *(X + I).
• Nome de matriz equivalente a ponteiro para o primeiro elemento numa expressão.
• Matrizes como argumento.  Passado o ponteiro para primeiro elemento: tipo nome[] equivalente a tipo* nome na definição de parâmetros.
• Matrizes não são passadas por referência: passado por valor ponteiro para o primeiro elemento.
• Relação de ponteiros com classes: (*ponteiro).membro equivalente a ponteiro->membro.
• Ponteiros e matrizes multi-dimensionais (matrizes de matrizes).

Aula prática 4.  Capítulo 11 das Folhas Teóricas.  Ainda por disponibilizar.  Entretanto recomenda-se a leitura do Resumo da Aula 4.

Aula 5

• Memória livre e instâncias dinâmicas:
  1. Criação de instâncias dinâmicas com o operador new: e se não houver memória?  Excepção bad_alloc ou operador especial nothrow.
  2. Destruição de instâncias dinâmicas com o operador delete.
  3. Princípio: quem constrói responsabiliza-se por destruir.
  4. Problemas comuns com instâncias dinâmicas.
  5. Construtores e destrutores: quando são invocados.
  6. Matrizes dinâmicas com os operadores new[] e delete[].
• Introdução à memória dinâmica em classes:
  1. Construtores e destrutores.
  2. Problema da cópia e da atribuição: construtor por cópia e atribuição por cópia automáticos.

Aula prática 5.  Capítulo 11 das Folhas Teóricas.  Ainda por disponibilizar.  Entretanto recomenda-se a leitura do Resumo da Aula 5.

Aula 6

• Classes que reservam recursos externos:
  1. Problemas comuns.
  2. Construtores e destrutores.
  3. Construção por cópia.  Fornecimento automático.
  4. Semântica de valor vs. semântica de referência.
  5. Atribuição por cópia.  O problema da auto-atribuição.
  6. O exemplo das pilhas.
  7. Recomendação das três operações
• Introdução às excepções e tratamento de erros:
1. Definindo excepções: excepções são de diferentes tipos.
2. Lançando excepções.
3. Capturando excepções.
4. Excepções com dados.
5. A excepção bad_alloc.
6. Segurança face a excepções.

Aula prática 6.  Capítulo 11 das Folhas Teóricas.  Ainda por disponibilizar.  Entretanto recomenda-se a leitura do Resumo da Aula 6.

Aula 7

• Herança: derivação de classes
1. Herança pública: relação é um.  Se B é um A, então B pode ser usado onde se espera um A.
2. A relação tem um.  A relação é composto por um.  Agregação vs. composição vs. herança.
3. Ponteiros, referências e corte (slicing).
4. Derivação: classe base e classe derivada.
5. Construtores e destrutores com herança.
6. Ocultação.
7. Hierarquias de classes: derivações de derivações.
8. Possibilidade de herança múltipla.
9. Problemas por resolver: necessidade de polimorfismo.
10. Herança privada: redução/alteração de interfaces.
11. Políticas de acesso.

Aula prática 7.  Capítulo 12 das Folhas Teóricas.  Ainda por disponibilizar.  Entretanto recomenda-se a leitura do Resumo da Aula 7.

Aula 8

• Categorias de acesso: acesso protegido
• Polimorfismo e operações polimórficas ou virtuais
1. Operações polimórficas
2. Destrutores polimórficos
3. Ligação estática vs. dinâmica
• Invocação estática explícita
4. Distinção entre operação e método
• Classes e operações abstractas
1. Operações abstractas ou puramente virtuais
2. Classes abstractas
3. Classes concretas

Aula prática 8.  Capítulo 12 das Folhas Teóricas.  Ainda por disponibilizar.  Entretanto recomenda-se a leitura do Resumo da Aula 8.

!!Falta completar resumo com auto_ptr (rr)

Aula 9

• Introdução
  • UML
• Diagramas de classes
  • Classes
    • Características: atributos e operações
    • Visibilidade.
    • Notas, comentários e restrições
    • Operações: inspecção, modificação, abstractas, de classe
    • Métodos
    • Atributos
  • Relações
    • Generalização
    • Amizade
    • Associação
      • Associação simples
      • Agregação
      • Composição
• Diagramas de objectos
  • Objectos ou instâncias de classes
  • Ligações ou instâncias de associações
• Representação em C++

Aula prática 9.  Capítulo 13 das Folhas Teóricas.  Ainda por disponibilizar.  Entretanto recomenda-se a leitura do Resumo da Aula 9.

!!Falta guião da teórica (je)

Aula 10

!!Colocar aqui itens do resumo

!!Falta guião da teórica (je)

!!Falta resumo (je)

Aula 11

• Genericidade.  O que é.
• Suportando genericidade com hierarquias de classes.  Objectos de classes derivadas podem ser tratados como se de objectos da classe base da hierarquia se tratassem.
• Exemplos em que a herança não é suficiente.
• Conceito de rotina genérica:
• Sintaxe.
• Utilização.
• Instanciação.
• Dedução automática de parâmetros.
• Conceito de classe genérica:
• Sintaxe.
• Rotinas membro (operações) também são genéricas.  Sintaxe.
• Utilização.
• Instanciação.
• Validação implícita dos parâmetros!  Necessidade de comentários!
• Parâmetros por omissão.  Utilização.
• Notação UML para classes genéricas, seus parâmetros, parâmetros por omissão, e instâncias.
• Construção de uma classe ou rotina genérica.  Identificação dos tipos e constantes que variam.  Passagem a parâmetros do modelo.
• Regras para modularização física com classes e rotinas genéricas.

Aula prática 11.  Capítulo 14 das Folhas Teóricas.  Ainda por disponibilizar.  Entretanto recomenda-se a leitura do Resumo da Aula 11.

Aula 12

!!Colocar aqui itens do resumo

!!Falta guião da teórica (rr)

!!Falta resumo (rr)

Aula prática 12.  Capítulo 14 das Folhas Teóricas.  Ainda por disponibilizar.  Entretanto recomenda-se a leitura do Resumo da Aula 12.

Aula 13

• Tratamento básico de erros ocorridos durante a execução de programas não críticos:
• Origens dos erros: lógicos, utilizador, recursos externos.
• Tratamento de erros: instruções usuais (condicionais, de selecção, de iteração), asserções e excepções.
• Origens humanas imediatas (programador e utilizador) vs. recursos externos (e.g., formato de ficheiros, existência de ficheiros, limitações de memória, etc.).
• Papeis do humano: programador produtor, programador consumidor e utilizador final.
• Protecção contra erros lógicos (do programador):
• Utilização de asserções.
• Os erros devem ser detectados.  São corrigidos pelo programador e não pelo próprio programa.
• Vantagens da utilização de assert.  Pré-condições: o programador produtor simplifica a vida do programador consumidor.  Condições objectivo e invariantes (de ciclos ou de classe): o programador produtor simplifica a sua própria vida.
• Utilização de assert durante o teste do programa.
• Desligando o efeito de assert sem retirar as instruções do código.
• Efeitos de uma asserção falhada: ficheiro core e sua utilidade.
• Protecção contra erros do utilizador:
• Princípio: o utilizador enganar-se-á muitas vezes e quando os efeitos forem mais nefastos.  O utilizador é humano: repetição como solução típica.
• Os erros são detectados e corrigidos localmente.
• Protecção contra erros com origem em recursos externos:
• Filosofia: os recursos estão disponíveis e sem problemas excepto em casos excepcionais.
• Utilização de excepções.
• Os erros são detectados e são lançadas excepções.
• Só captura a excepção quem sabe lidar com o erro.
• A captura das excepções pode ser feita "muito longe" do código que as origina.
• Efeito de uma excepção não capturada: de novo o ficheiro core.
• Classes para excepções.  Hierarquias de erros e polimorfismo.

Aula prática 13.  Capítulo 15 das Folhas Teóricas.  Ainda por disponibilizar.  Entretanto recomenda-se a leitura do Resumo da Aula 13.

!!Rever os itens acima de acordo com o novo guião e resumo

!!Falta guião da teórica (rr)

!!Falta resumo (rr)