Please enable JavaScript.

Coggle requires JavaScript to display documents.

MM6 - Coggle Diagram

- - - - arrPtr: array dinâmico
      - max: capacidade
      - cnt: tamanho atual
  - - - Duas versões:
        
        leitura
        
        escrita
      - retorna referência (para escrita)
      - faz verificação de limites
    - - append
        
        adiciona elemento
        
        incrementa tamanho
      - remove
        
        remove elemento
        
        desloca dados
  - - - Copia ponteiros, NÃO dados
      - Problemas gerados
        
        double delete
        
        corrupção de dados
        
        acesso inválido
    - - Estratégia
        
        alocar nova memória
        
        copiar dados
      - Criar cópia independente
  - - - copy constructor: criação
      - assignment: objeto já existe
    - - sobrescreve ponteiro
      - perde memória antiga
      - causa leak
    - - proteger self-assignment
      - delete memória antiga
      - alocar nova memória
      - copiar dados
      - return *this
- - - - desperdício de memória (se alocar demais)
      - falta de memória (se alocar de menos)
  - - - criada em runtime
      - liberada manualmente
      - reutilizada
  - - - Fluxo
        
        Reserva memória no heap
        
        Determina tamanho (sizeof)
        
        (Se classe) chama construtor
        
        Retorna endereço (ponteiro)
    - - padrão moderno:
        
        lança exceção (bad_alloc)
      - antigo:
        
        retorna NULL
  - - - chama destrutor (se classe)
      - libera memória
    - - 1. Memory leak
        
        esqueceu de dar delete
        
        memória nunca volta
      - 2. Dangling pointer
        
        deletou, mas ainda usa
      - 3. Double delete
        
        comportamento indefinido
  - - - NÃO pode passar valores na criação
      - precisa de construtor padrão
    - - array cheio
        
        criar novo maior
        
        copiar dados
        
        delete antigo
      - Arrays dinâmicos NÃO crescem automaticamente
      - necessidade de abstração -> classes (FloatArr)
  - - - inserção (deslocamento)
      - remoção (deslocamento)
      - crescimento (realocação)
    - - não contígua
      - cresce dinamicamente
      - acesso sequencial
    - - dados
      - ponteiro para outro elemento do mesmo tipo
    - - Inserção (pushBack)
        
        cria novo nó
        
        conecta ao último
      - Remoção (popFront)
        
        remove primeiro
        
        ajusta ponteiro
    - - memória sob demanda
      - inserção/remoção eficiente
      - sem cópias massivas
- - - - *ptr -> ponteiro
      - **ptr -> valor final
    - - Arrays de ponteiros (ex: estruturas dinâmicas)
      - Funções que recebem/modificam ponteiros
      - Implementação de matrizes dinâmicas
    - - Alocação:
        
        primeiro nível: T** ptr = new T*[n]
        
        segundo nível: ptr[i] = new T[m]
      - Necessário loop para alocar cada subarray independentemente
  - - - Argumentos fixos + variáveis (...)
      - Exige pelo menos um argumento obrigatório
    - - Argumentos armazenados na stack
      - Acesso manual via macros
    - - va_list -> ponteiro para argumentos
      - va_start(argptr, ultimo_param)
      - va_arg(argptr, tipo)
      - va_end(argptr)
    - - Não há verificação de tipo automática
      - Necessário:
        
        marcador final (ex: NULL)
        
        ou contador
  - - - Nome da função = endereço de memória (código executável)
    - - tipo (*ptr)(parametros)
    - - armazenar funções em variáveis
      - passar funções como argumento
      - criar tabelas de funções (jump tables)
    - - ptr = func
      - (*ptr)(args)
  - - - * -> ponteiro
      - [] -> array
      - () -> função
    - - começar pelo identificador
      - analisar direita ([], ())
      - depois esquerda (*)
      - finalizar com tipo base
    - - arrays não podem conter funções
      - funções não retornam arrays/funções (apenas ponteiros)
  - - - cria apelido para um tipo existente
    - - typedef tipo novo_nome
    - - não cria novo tipo real
      - não aloca memória
    - - simplificar tipos complexos
      - melhorar legibilidade
      - isolar dependência de plataforma
  - - - matriz = array de arrays
      - implementada como ponteiro para ponteiro (T**)
    - - nível 1 -> array de ponteiros (linhas)
      - nível 2 -> arrays de elementos (colunas)
    - - mat = new T*[linhas]
      - loop:
        
        mat[i] = new T[colunas]
    - - loop:
        
        delete[] mat[i]
      - delete[] mat
    - - m[i][j]