📚 Usando new e delete com Arrays · C++

📚 Usando new e delete com Arrays

"Os operadores new[] e delete[] permitem alocar e liberar arrays cujo tamanho é determinado em tempo de execução, oferecendo flexibilidade que arrays estáticos não possuem."

Enquanto arrays estáticos têm tamanho fixo definido em tempo de compilação, arrays dinâmicos alocados com new[] podem ter seu tamanho determinado durante a execução do programa. Isso é essencial quando a quantidade de dados a armazenar só é conhecida após o início da execução.

📌 Sintaxe Básica de new[] e delete[]

// Alocação: tipo* nome = new tipo[tamanho];
int tamanho = 10;
int* arr = new int[tamanho];   // Aloca array de 10 inteiros

// Uso do array (sintaxe idêntica a arrays estáticos)
arr[0] = 42;
arr[1] = 100;

// Liberação: delete[] nome;
delete[] arr;      // Libera TODO o array
arr = nullptr;      // Boa prática
  

⚠️ Regra de Ouro: new → delete | new[] → delete[]. Nunca misture! Usar delete em vez de delete[] para liberar um array causa comportamento indefinido e geralmente vazamento de memória.

🎯 Array com Tamanho Definido pelo Usuário

A principal vantagem da alocação dinâmica é poder definir o tamanho do array em tempo de execução.

int n;
cout << "Quantos números deseja armazenar? ";
cin >> n;

// Cria um array exatamente do tamanho necessário
int* numeros = new int[n];

for (int i = 0; i < n; i++) {
    cout << "Número " << i + 1 << ": ";
    cin >> numeros[i];
}

// Processa os dados...

delete[] numeros;
  

📝 Inicialização de Arrays Dinâmicos

Arrays alocados com new[] podem ser inicializados de várias formas.

// 1. Sem inicialização (valores indeterminados)
int* arr1 = new int[5];          // Valores "lixo"

// 2. Inicialização com zero (parênteses vazios)
int* arr2 = new int[5]();       // Todos os elementos = 0

// 3. Inicialização com lista (C++11)
int* arr3 = new int[5]{1, 2, 3, 4, 5};

// 4. Inicialização parcial (restante é zerado)
int* arr4 = new int[5]{1, 2};     // {1, 2, 0, 0, 0}

// 5. Arrays de objetos (requer construtor padrão)
std::string* nomes = new std::string[3]{"Ana", "Bruno", "Carla"};
  

🧮 Arrays Multidimensionais Dinâmicos

Criar matrizes dinâmicas requer um pouco mais de trabalho, pois new não suporta diretamente múltiplas dimensões.

Método 1: Alocação Contígua (Recomendado)

int linhas = 3, colunas = 4;

// Aloca um único bloco contíguo de memória
int* matriz = new int[linhas * colunas];

// Acesso: matriz[i * colunas + j]
for (int i = 0; i < linhas; i++) {
    for (int j = 0; j < colunas; j++) {
        matriz[i * colunas + j] = i * colunas + j;
    }
}

delete[] matriz;   // Apenas um delete[]
  

Método 2: Array de Ponteiros (Mais Intuitivo)

int linhas = 3, colunas = 4;

// Aloca array de ponteiros
int** matriz = new int*[linhas];

// Aloca cada linha
for (int i = 0; i < linhas; i++) {
    matriz[i] = new int[colunas];
}

// Acesso: matriz[i][j] (sintaxe natural)
matriz[1][2] = 42;

// Liberação: ordem inversa!
for (int i = 0; i < linhas; i++) {
    delete[] matriz[i];
}
delete[] matriz;
  

💡 Qual método escolher?

Alocação contígua: Melhor desempenho (cache-friendly), menos fragmentação, um único delete[]. Recomendada para a maioria dos casos.
Array de ponteiros: Sintaxe matriz[i][j] mais natural, permite linhas de tamanhos diferentes (matriz irregular).
Em C++ moderno, prefira std::vector<std::vector<int>> ou std::vector<int> com índice calculado.

🔄 Redimensionando Arrays Dinâmicos

Arrays alocados com new[] não podem ser redimensionados diretamente. É necessário alocar um novo array, copiar os dados e liberar o antigo.

int* redimensionar(int* arrAntigo, int tamAntigo, int tamNovo) {
    int* arrNovo = new int[tamNovo];
    
    // Copia elementos (até o menor tamanho)
    int copiar = (tamAntigo < tamNovo) ? tamAntigo : tamNovo;
    for (int i = 0; i < copiar; i++) {
        arrNovo[i] = arrAntigo[i];
    }
    
    delete[] arrAntigo;
    return arrNovo;
}

// Uso:
int* dados = new int[5]{1, 2, 3, 4, 5};
dados = redimensionar(dados, 5, 10);   // Agora tem 10 elementos
  

Nota: Em C++, std::vector faz tudo isso automaticamente e de forma mais segura. Use new[]/delete[] apenas quando realmente necessário.

⚠️ Armadilhas Comuns

Erro	Consequência	Correção
Usar `delete` em vez de `delete[]`	Comportamento indefinido, vazamento parcial	Sempre usar `delete[]` para arrays
Esquecer de liberar	Memory leak (vazamento de memória)	Garantir `delete[]` para cada `new[]`
Acessar índice fora dos limites	Buffer overflow, corrupção de memória	Validar índices; usar `std::vector::at()`
Liberar duas vezes (double delete)	Crash ou corrupção do heap	Atribuir `nullptr` após `delete[]`

📊 Arrays Dinâmicos vs. std::vector

Característica	new[] / delete[]	std::vector
Redimensionamento	Manual (trabalhoso)	Automático (`resize()`, `push_back()`)
Liberação de memória	Manual (risco de vazamento)	Automática (RAII)
Verificação de limites	Nenhuma (acesso direto)	`at()` verifica e lança exceção
Tamanho conhecido	Não (precisa armazenar separadamente)	`size()` sempre disponível
Controle de baixo nível	Total	Limitado

💡 Boas Práticas

✅ Prefira std::vector a arrays dinâmicos manuais na maioria dos casos.
✅ Use new[]/delete[] apenas quando precisar de controle absoluto sobre a memória ou em código de sistemas embarcados.
✅ Sempre emparelhe new[] com delete[] — considere usar smart pointers (std::unique_ptr<int[]>).
✅ Atribua nullptr após delete[] para evitar dangling pointers.
✅ Para matrizes 2D, prefira alocação contígua (um único new[]) por eficiência.

🛡️ Usando unique_ptr para Arrays (C++11)

#include <memory>

// unique_ptr especializado para arrays (delete[] automático!)
std::unique_ptr<int[]> arr = std::make_unique<int[]>(10);

arr[0] = 42;
arr[1] = 100;

// NÃO precisa de delete[]! Memória liberada automaticamente ao sair do escopo
  

🔗 Conclusão

Os operadores new[] e delete[] fornecem a base para alocação dinâmica de arrays em C++, permitindo criar estruturas de tamanho variável em tempo de execução. Embora sejam ferramentas poderosas, exigem cuidado e disciplina para evitar vazamentos e comportamentos indefinidos. Em C++ moderno, o uso de std::vector e smart pointers é fortemente recomendado, relegando new[]/delete[] a situações específicas de baixo nível.

⏭️ Próximo: Aritmética de ponteiros...