Arrays dinâmicos

Um array dinâmico em C++ é uma estrutura de dados cujo tamanho pode ser definido em tempo de execução, ao contrário dos arrays estáticos, que têm tamanho fixo determinado na compilação. Arrays dinâmicos são úteis quando não se sabe previamente quantos elementos serão necessários ou quando o tamanho do array pode variar durante a execução do programa.

Como criar um array dinâmico em C++

Para criar um array dinâmico, utiliza-se a palavra-chave new, que aloca memória dinamicamente e retorna um ponteiro para o primeiro elemento do array. Apõs usar o arrayo, é fundamental libertar a memória com delete[] para evitar vazamentos.

Sintaxe básica

tipo *nomeArray = new tipo[tamanho];

tipo: tipo de dado do array (ex: int, float, char)
nomeArray: nome do ponteiro que referencia o array
tamanho: número de elementos, definido em tempo de execução

Exemplo 1: Criar e preencher um array dinâmico de inteiros

#include <iostream>
using namespace std;

int main() {
    int n;
    cout << "Digite o tamanho do array: ";
    cin >> n;

    int *array = new int[n]; // Criação do array dinâmico

    // Preenchendo o array
    for (int i = 0; i < n; i++) {
        cout << "Digite o elemento " << i << ": ";
        cin >> array[i];
    }

    // Exibir os elementos
    cout << "Elementos do array: ";
    for (int i = 0; i < n; i++) {
        cout << array[i] << " ";
    }
    cout << endl;

    delete[] array; // Libertação da memória
    return 0;
}

O tamanho do array é definido pelo usuário em tempo de execução.
Sempre use delete[] para liberar a memória alocada.

Exemplo 2: Inicializar um array dinâmico

Podemos inicializar todos os elementos com zero ao criar o array:

int *array = new int[n](); // Todos os elementos serão zero.

Ou, usando uma lista de inicializadores (para arrays pequenos):

int *array = new int[5]{10, 7, 15, 3, 11};
// array[0]=10, array[1]=7, etc.[1]

Exemplo 3: Array dinâmico de caracteres (string dinâmica)

#include <iostream>
#include <cstring>
using namespace std;

int main() {
    int tamanho = 20;
    char *nome = new char[tamanho];

    strcpy(nome, "Exemplo de string");
    cout << nome << endl;

    delete[] nome;
    return 0;
}

Permite manipular strings de tamanho variável.

Dicas Importantes

Liberte sempre a memória alocada com delete[] após o uso.
O acesso aos elementos é feito por índice, como em arrays estáticos: array[i].
Arrays dinâmicos são essenciais para programas que precisam lidar com grandes volumes de dados ou tamanhos variáveis em tempo de execução.

Resumo

Operação	Sintaxe/Exemplo
Criar array dinâmico	`int *arr = new int[tamanho];`
Acessar elemento	`arr[i]`
Inicializar com zero	`int *arr = new int[tamanho]();`
Libertar memória	`delete[] arr;`

Arrays dinâmicos são uma ferramenta poderosa para tornar seus programas em C++ mais flexíveis e eficientes, especialmente quando o tamanho dos dados não é conhecido previamente.

Adicionar/Remover elementos

Em C++, arrays dinâmicos criados com new têm tamanho fixo após a alocação: não existe um mecanismo nativo para adicionar ou eliminar elementos diretamente como em um std::vector. Para modificar o tamanho de um array dinâmico, é necessário realocar a memória manualmente, copiando os dados para um novo array de tamanho ajustado.

Adicionar um elemento a um array dinâmico

Alocar um novo array com tamanho maior
Copiar os elementos do array antigo para o novo
Adicionar o novo elemento
Libertar a memória do array antigo
Atualizar o ponteiro

#include <iostream>
using namespace std;

int main() {
    int n = 3;
    int* arr = new int[n]{1, 2, 3};

    // Adicionar um novo elemento (por exemplo, 4)
    int novoTamanho = n + 1;
    int* novoArr = new int[novoTamanho];

    // Copiar elementos antigos
    for (int i = 0; i < n; i++) {
        novoArr[i] = arr[i];
    }
    // Adicionar novo elemento
    novoArr[n] = 4;

    delete[] arr; // Libertar memória antiga
    arr = novoArr;
    n = novoTamanho;

    // Exibir resultado
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    delete[] arr; // Libertar memória final
    return 0;
}

Eliminar um elemento de um array dinâmico

Alocar um novo array com tamanho menor
Copiar todos os elementos, exceto o que será removido
Libertar a memória do array antigo
Atualizar o ponteiro

#include <iostream>
using namespace std;

int main() {
    int n = 4;
    int* arr = new int[n]{1, 2, 3, 4};

    int indiceRemover = 1; // Remove o elemento na posição 1 (valor 2)
    int novoTamanho = n - 1;
    int* novoArr = new int[novoTamanho];

    for (int i = 0, j = 0; i < n; i++) {
        if (i != indiceRemover) {
            novoArr[j++] = arr[i];
        }
    }

    delete[] arr;
    arr = novoArr;
    n = novoTamanho;

    // Exibir resultado
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    delete[] arr;
    return 0;
}

Observações importantes

Arrays dinâmicos não redimensionam automaticamente. O processo envolve sempre criar um novo array, copiar e libertar a memória antiga.
Para operações frequentes de inserção/remoção, prefira std::vector, que já gere isso internamente e de forma eficiente.
Lliberte sempre a memória antiga com delete[] para evitar vazamentos de memória.

Essas técnicas são essenciais para manipular arrays dinâmicos em C++. Para maior produtividade e segurança, utilize containers da STL como std::vector sempre que possível.