Programa detalhado
 Sumário
- 
Modularização: física e em pacotes.
- 
Noções de modularização física e compilação
separada:
  - 
Vantagens.
- 
Fases da construção dum programa (pré-processamento,
compilação, fusão).
- 
Compilação: análises lexical, sintáctica e
semântica, optimização e geração de código
máquina.
- 
Noções sobre ficheiros de interface (.H), fonte
(.C), objecto (.o), biblioteca ou arquivo (.a),
e executável.
- 
Regra da definição única. O que se deve colocar nos
ficheiros fonte e nos ficheiros de interface respectivos.
- 
A excepção das funções e procedimentos inline.
 
- 
Noções sobre espaços nominativos (namespaces). 
Modularização em pacotes.
  - 
Utilidade.
- 
Sintaxe.
- 
Utilização: directivas e declarações.
 
Aula prática 1.  Capítulo
9 das Folhas Teóricas.
- 
Noção de lista e iterador.
  - 
Listas como sequências de itens com ordem relevante.
- 
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.
- 
Utilização de listas: pequeno programa fazendo inserções
ordenadas.
- 
Melhorando a implementação das listas e iteradores:
  - 
Identificando problemas de eficiência.
- 
Como inserir a meio sem necessidade de "empurrar" os itens para a frente?
- 
Como remover do meio sem necessidade de "puxar" os itens para trás?
- 
Noções de cadeia simplesmente ligada e cadeia duplamente
ligada.
- 
Como inserir a meio?  Justificação para a existência
de guardas (concretização da noção de item
fictício).
- 
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.
Aula prática 3.  Capítulo
10 das Folhas Teóricas.  Ainda
incompleto.
  - 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 atipo* nomena
    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).membroequivalente aponteiro->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.
  - Memória livre e instâncias dinâmicas:
    
      - Criação de instâncias dinâmicas com o operador new: e
        se não houver memória?  Excepçãobad_allocou
        operador especialnothrow.
- Destruição de instâncias dinâmicas com o operador delete.
- Princípio: quem constrói responsabiliza-se por destruir.
- Problemas comuns com instâncias dinâmicas.
- Construtores e destrutores: quando são invocados.
- Matrizes dinâmicas com os operadores new[]edelete[].
 
- Introdução à memória dinâmica em classes:
    
      - Construtores e destrutores.
- 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.
- 
Classes que reservam recursos externos:
  - 
Problemas comuns.
- 
Construtores e destrutores.
- 
Construção por cópia.  Fornecimento automático.
- 
Semântica de valor vs. semântica de referência.
- 
Atribuição por cópia.  O problema da auto-atribuição.
- 
O exemplo das pilhas.
- Recomendação das três operações
 
- 
Introdução às excepções
e tratamento de erros:
- 
Definindo excepções: excepções
são de diferentes tipos.
- 
Lançando excepções.
- 
Capturando excepções.
- 
Excepções com dados.
- 
A excepção bad_alloc.
- 
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.
- 
Herança: derivação de classes
- 
Herança pública: relação
é um. 
Se B é um A, então B pode ser usado onde se espera
um A.
- 
A relação tem um.  A relação é composto por um. 
Agregação vs. composição vs.
herança.
- 
Ponteiros, referências e corte (slicing).
- 
Derivação: classe base e classe derivada.
- 
Construtores e destrutores com herança.
- 
Ocultação.
- 
Hierarquias de classes: derivações de derivações.
- 
Possibilidade de herança múltipla.
- 
Problemas por resolver: necessidade de polimorfismo.
- 
Herança privada: redução/alteração de
interfaces.
- 
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.
- 
Categorias de acesso: acesso protegido
- 
Polimorfismo e operações polimórficas ou virtuais
- 
Operações polimórficas
- 
Destrutores polimórficos
- 
Ligação estática vs. dinâmica
- 
Invocação estática explícita
- 
Distinção entre operação e método
- 
Classes e operações abstractas
- 
Operações abstractas ou puramente virtuais
- 
Classes abstractas
- 
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)
- 
Introdução
- 
 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)
!!Colocar aqui itens do resumo
!!Falta guião da teórica (je)
!!Falta resumo (je)
- 
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.
!!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.
- 
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 assertdurante o teste do programa.
- 
Desligando o efeito de assertsem retirar as instruções
do código.
- 
Efeitos de uma asserção falhada: ficheiro coree
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)