Sumários das aulas teóricas

Aula Sumário Turma Data Hora Alunos
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.
 IA2 2002/3/12 8:00-9:20 37
ETIA1 13:00-14:20 50
IA1 2002/3/14 8:00-9:20 45
ETIA2 14:30-15:50 41
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.
 IA2 2002/3/19 8:00-9:20 38
ETIA1 13:00-14:20 52
IA1 2002/3/21 8:00-9:20 53
ETIA2 14:30-15:50 Manuel
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.
 IA2 2002/4/9 8:00-9:20 28
ETIA1 13:00-14:20 34
IA1 2002/4/11 14:30-15:50 43
ETIA2 8:00-9:20 41
4
  • Variáveis de um programa C++: memória, unidade básica de memória e conceito de endereço.
  • Variáveis 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).
 IA2 2002/4/16 8:00-9:20 31
ETIA1 13:00-14:20 36
IA1 2002/4/18 8:00-9:20 44
ETIA2 14:30-15:50 37
5
  • Memória livre e variáveis dinâmicas:
    1. Criação de variáveis 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 variáveis dinâmicas com o operador delete.
    3. Princípio: quem constrói responsabiliza-se por destruir.
    4. Problemas comuns com variáveis 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.
 IA2 2002/4/23 8:00-9:20 41
ETIA1 13:00-14:20 31
ETIA2 2002/4/24 8:00-9:20 12
IA1 14:30-15:50 29
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.
 IA2 2002/4/30 8:00-9:20 29
ETIA1 13:00-14:20 37
IA1 2002/5/2 8:00-9:20 39
ETIA2 14:30-15:50 19
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.  Composição vs. herança.
    3. Ponteiros, referências e slicing.
    4. Derivação: classes base e classe derivada.
    5. Construtores, construtores por omissão e cópia e atribuição por cópia
    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
 IA2 2002/5/7 8:00-9:20 25
ETIA1 13:00-14:20 35
IA1 2002/5/9 8:00-9:20 25
ETIA2 14:30-15:50 18
8
  • Polimorfismo e funções ou procedimentos virtuais
    1. Funções ou procedimentos virtuais
    2. Destrutores virtuais
    3. Ligação estática vs. dinâmica
  • Classes abstractas e funções ou procedimentos puramente virtuais
    1. Classes abstractas
    2. Classes concretas
 IA2 2002/5/14 8:00-9:20 23
ETIA1 13:00-14:20 25
IA1 2002/5/16 8:00-9:20 41
ETIA2 14:30-15:50 21
9
  • Esclarecimento de dúvidas sobre o e o Trabalho Final.
  • Discussão das relações entre as classes.
  • Pequena introdução ao UML: diagramas de classes.
 IA2 2002/5/21 8:00-9:20 20
ETIA1 13:00-14:20 21
IA1 2002/5/23 8:00-9:20 43
ETIA2 14:30-15:50 21
10
  • Introdução ao UML:
    1. Diagramas de classe.
    2. Características: atributos e operações.
    3. Visibilidade.
    4. Tipos de operações: inspecção, abstractas, de classe.
    5. Relações e associações.  Composição, agregação, derivação.  Multiplicidade.  Nomes de papeis.
    6. Notas: código C++.
    7. Diagramas de objectos.
    8. Instâncias de classes: objectos.  Instâncias de associações: ligações.
    9. Representação de ligações em C++.
 IA2 2002/5/28 8:00-9:20 34
ETIA1 13:00-14:20 Ricardo
ETIA2 2002/5/29 8:00-9:20 6
IA1 14:30-15:50 15
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.
 IA2 2002/6/4 8:00-9:20 15
ETIA1 13:00-14:20 15
IA1 2002/6/6 8:00-9:20 28
ETIA2 14:30-15:50 23
12
  • 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.
 IA2 2002/6/11 8:00-9:20 12
ETIA1 13:00-14:20 11
ETIA2 2002/6/12 8:00-9:20 12
IA1 14:30-15:50 2