Apontadores e memória

Copiar seta ou objeto?

int a = 3, b = 8;
int* p = &a;
int* q = p;   // copia o endereço, não o inteiro
*q += 2;      // a passa a 5
p = &b;       // só p muda de destino
*p -= 1;      // b passa a 7; *q continua 5

Declaração	Muda destino?	Altera por esse acesso?
int*	Sim	Sim
const int*	Sim	Não
int* const	Não	Sim
const int* const	Não	Não

• nullptr testa-se, não se desreferencia.
• const int* não congela um original modificável: outro acesso pode alterá-lo.
• A conversão que retira const não é, por si, comportamento indefinido. Escrever através do acesso obtido é indefinido se o objeto era originalmente const.

Limites e vida

• p + i avança i elementos no mesmo array. p[i] é *(p + i).
• [inicio, fim) inclui o início e exclui o fim. O fim marca, não se lê.
• Automático morre no fim do bloco. Dinâmico vive até o dono destruir.
• Devolver &local deixa endereço pendente.
• p->campo é (*p).campo. Nós ligam-se por seguinte, não por p + 1.

Libertar lista dinâmica: guarda o seguinte antes de apagar o atual.

while (atual != nullptr) {
    No* seguinte = atual->seguinte;
    delete atual;
    atual = seguinte;
}

Quem liberta?

Reserva	Libertação
new T(...)	delete
new T[n]	delete[]

• Trocar as formas é indefinido. new normal lança bad_alloc se falha.
• Não apliques delete a automáticos. delete nullptr não faz nada.
• Depois de delete p, os outros acessos a esse objeto ficam pendentes. Atribuir p = nullptr só limpa esse nome.

RAII: o dono liberta na saída do âmbito, incluindo por exceção.

auto primeiro = std::make_unique<int>(7);
int* observador = primeiro.get();  // só observa
auto segundo = std::move(primeiro);  // segundo passa a dono

unique_ptr não se copia. shared_ptr partilha com custo. weak_ptr observa sem prolongar.

Transferência de propriedade.