C++ Academy · Aula

Alocação no heap com new/delete

Gerencie a memória dinâmica

Alocação no heap com new/delete é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Memória dinâmica com new

O operador new aloca um objeto na memória dinâmica (armazenamento livre) e retorna um ponteiro para ele. Os objetos na memória dinâmica permanecem até que você os libere explicitamente.

#include <iostream>

int main() {
    int* p = new int(42);   // heap allocation
    std::cout << *p << "\n";
    delete p;               // release it
}

Liberando com delete

Cada new deve corresponder exatamente a um delete. Esquecê-lo causa um vazamento de memória; usá-lo duas vezes corrompe a memória dinâmica.

#include <iostream>

int main() {
    double* d = new double(3.5);
    std::cout << *d << "\n";
    delete d;     // exactly once
}

Matrizes: new[] e delete[]

Para matrizes, use new[] e o delete[] correspondente. Misturar new[] com um delete simples resulta em comportamento indefinido.

#include <iostream>

int main() {
    int* arr = new int[3]{1, 2, 3};
    for (int i = 0; i < 3; ++i) std::cout << arr[i] << "\n";
    delete[] arr;   // note the [ ]
}

Por que usar a memória dinâmica

Use a memória dinâmica quando um objeto precisar sobreviver à função que o criou ou quando seu tamanho só for conhecido em tempo de execução. Caso contrário, prefira a pilha.

O tempo de vida da memória dinâmica é manual

Ao contrário da pilha, a memória dinâmica não libera objetos automaticamente. Você controla exatamente quando a memória é liberada — e é responsável por isso.

#include <iostream>

int* makeCounter() {
    return new int(0);   // survives the function
}

int main() {
    int* c = makeCounter();
    std::cout << *c << "\n";
    delete c;
}

Defina os ponteiros como nullptr após delete

Depois de excluir, defina o ponteiro como nullptr para que uma reutilização acidental falhe de forma evidente, em vez de acessar memória liberada.

#include <iostream>

int main() {
    int* p = new int(9);
    delete p;
    p = nullptr;     // now p is safe to check
    if (!p) std::cout << "freed\n";
}

A alocação pode falhar

Se o sistema ficar sem memória, new lançará std::bad_alloc. Para alocações muito grandes, isso é uma possibilidade real.

Áreas de armazenamento de tamanho definido em tempo de execução

Matrizes na memória dinâmica podem usar um tamanho calculado em tempo de execução — algo que matrizes na pilha não podem fazer de modo portável.

#include <iostream>

int main() {
    int n = 5;
    int* buf = new int[n];
    for (int i = 0; i < n; ++i) buf[i] = i * i;
    std::cout << buf[4] << "\n";
    delete[] buf;
}

Prefira ponteiros inteligentes

O C++ moderno evita new/delete brutos. std::unique_ptr e std::make_unique liberam a memória automaticamente quando o ponteiro sai do escopo.

#include <iostream>
#include <memory>

int main() {
    auto p = std::make_unique<int>(42);
    std::cout << *p << "\n";
}   // freed automatically

O custo da memória dinâmica

A alocação na memória dinâmica é mais lenta que na pilha: ela procura um bloco livre e atualiza os registros de controle. Alocações pequenas e frequentes podem prejudicar o desempenho.

Associe cada new

A regra de ouro: cada new precisa de um delete, e cada new[] precisa de um delete[]. Melhor ainda: deixe os ponteiros inteligentes cuidarem disso.

Verificação rápida

Teste sua compreensão da alocação na memória dinâmica.

Recapitulação

Você aprendeu a alocar na memória dinâmica com new/new[] e liberar com delete/delete[]. Os objetos na memória dinâmica sobrevivem ao escopo, mas exigem limpeza manual. Faça corresponder cada alocação, defina como nulos os ponteiros liberados e prefira std::unique_ptr no código moderno.

Perguntas Frequentes

A aula “Alocação no heap com new/delete” é grátis?

Sim — o texto completo de “Alocação no heap com new/delete” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Alocação no heap com new/delete”?

Gerencie a memória dinâmica Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Alocação no heap com new/delete”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy