Please enable JavaScript.
Coggle requires JavaScript to display documents.
C++ MM7 - Coggle Diagram
C++ MM7
INHERITANCE
especialização progressiva
A classe derivada incorpora:
todos os membros acessíveis da base
novos membros próprios
Construtores não são herdados:
devem ser explicitamente chamados
Destrutor da base sempre é executado após o da derivada
Controle de acesso na hierarquia
Define visibilidade dos membros herdados:
public -> mantém interface externa
protected -> acessível apenas na hierarquia
private -> oculto da derivada
protected:
reutilização sem exposição externa
Especialização de comportamento (redefinição)
Métodos da base podem ser redefinidos na derivada
Dois comportamentos:
original (base)
especializado (derivada)
Acesso à versão base:
necessário quando extensão não substitui totalmente
Uso de objetos derivados
Um objeto derivado contém:
subobjeto base + extensão própria
Pode ser tratado como:
tipo derivado (completo)
tipo base (parcial)
Isso permite:
reutilização de código
polimorfismo básico
EXCEPTION HANDLING
Limitações do tratamento tradicional
Uso de códigos de erro mistura:
lógica principal
controle de falhas
Falta de propagação automática
Código menos legível
Modelo baseado em exceções
Separação clara:
execução normal
tratamento de erro
Estrutura:
try -> código protegido
throw -> sinalização de erro
catch -> tratamento ()
Fluxo de execução com exceções
Erro ocorre -> throw é executado
Execução normal é interrompida
Controle passa para o handler adequado
Se não tratado:
propagação pela pilha (stack unwinding) ()
Organização dos handlers
Múltiplos catch possíveis
Seleção por tipo
Ordem:
específico -> genérico
catch(...) captura qualquer exceção
Lançamento e tipagem das exceções
Pode lançar:
tipos básicos
objetos
classes específicas
Tipo define qual catch será acionado
Encadeamento e propagação
Exceções podem atravessar várias funções
Tratamento pode ocorrer:
localmente
em níveis superiores
Re-throw permite repassar erro
Captura por valor vs por referência
Por valor (catch(T e))
Cria cópia do objeto lançado
Pode causar object slicing se a exceção for de uma classe derivada
Perde informações específicas da derivada
Por referência (catch(const T& e))
Não cria cópia -> mais eficiente
Preserva o tipo real do objeto (inclusive derivado)
Permite polimorfismo na hierarquia de exceções
Boa prática:
usar catch(const BaseException& e)
evita cópia + evita slicing + mantém comportamento correto
CONVERSÕES DENTRO DA HIERARQUIA
Conversão natural (Derived -> Base)
Conversão implícita automática
Apenas a parte base é considerada
Base pointer/reference pode apontar para objeto derivado
Consequência: perda de informação (object slicing)
Ao copiar objetos:
parte derivada é descartada
Ocorre quando:
objeto derivado é atribuído a objeto base
Ponteiros e referências como solução
Evitam slicing
Permitem manipular objetos derivados via base
Mantêm identidade do objeto original
Conversão inversa (Base -> Derived)
Não é segura implicitamente
Requer cast explícito:
static_cast-> sem verificação
dynamic_cast -> verificação em tempo de execução
Papel da conversão na herança
Permite:
generalização (tratar tudo como base)
especialização controlada (casts explícitos)
Base para polimorfismo e reutilização
Object slicing
Ocorre quando:
Base b = derived;
Apenas a parte base é copiada
Parte derivada é descartada permanentemente
Consequência:
perda de comportamento e estado da derivada
Evitar usando:
ponteiros (Base*)
referências (Base&)
CLASSES DE EXCEÇÂO E HIERARQUIAS
Uso de classes para representar erros
Exceções podem ser modeladas como objetos
Permitem:
encapsular informação
diferenciar tipos de erro
Hierarquia de exceções padrão
Base: std::exception
Derivadas:
bad_alloc
out_of_range
runtime_error ()
Integração com herança
Exceções também seguem hierarquia
Permite:
capturar tipos específicos
ou genéricos via base
Criação de exceções próprias
Definidas pelo usuário
Podem herdar de std::exception
Método comum:
what() para descrição