Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Industrial programming >> Linguagem C

Dominando Alocação Dinâmica de Arrays em C++: Guia Prático com Exemplos de Código

O que é um Array Dinâmico?

Um array dinâmico é bastante semelhante a um array regular, mas seu tamanho é modificável durante a execução do programa. Elementos de array dinâmico ocupam um bloco contíguo de memória.

Uma vez que um array foi criado, seu tamanho não pode ser alterado. No entanto, um array dinâmico é diferente. Um array dinâmico pode expandir seu tamanho mesmo após ter sido preenchido.

Durante a criação de um array, é alocada uma quantidade predeterminada de memória. Este não é o caso com um array dinâmico, pois ele aumenta seu tamanho de memória por um certo fator quando há necessidade.

Neste tutorial C++, você aprenderá:

Fatores que Impactam a Performance de Arrays Dinâmicos

O tamanho inicial do array e seu fator de crescimento determinam sua performance. Observe os seguintes pontos:

  1. Se um array tem tamanho pequeno e fator de crescimento pequeno, ele continuará realocando memória com mais frequência. Isso reduz a performance do array.
  2. Se um array tem tamanho grande e fator de crescimento grande, ele terá um grande pedaço de memória não utilizada. Devido a isso, operações de redimensionamento podem demorar mais. Isso reduz a performance do array.

A Palavra-chave new

Em C++, podemos criar um array dinâmico usando a palavra-chave new. O número de itens a serem alocados é especificado dentro de um par de colchetes. O nome do tipo deve preceder isso. O número solicitado de itens será alocado.

Sintaxe:

A palavra-chave new tem a seguinte sintaxe:

ponteiro_variavel = new tipo_dado[tamanho];

Exemplo 1:

#include <iostream>
using namespace std;
int main() {
    int x, n;
    cout << "Digite o número de itens:" << "\n";
    cin >> n;
    int *arr = new int[n];
    cout << "Digite " << n << " itens" << endl;
    for (x = 0; x < n; x++) {
        cin >> arr[x];
    }
    cout << "Você digitou: ";
    for (x = 0; x < n; x++) {
        cout << arr[x] << " ";
    }
    delete[] arr; // Importante: liberar memória
    return 0;
}

Nota: No exemplo acima, o usuário pode especificar qualquer tamanho para o array durante a execução. Isso significa que o tamanho do array é determinado em tempo de execução.

Inicializando Arrays Alocados Dinamicamente

É fácil inicializar um array dinâmico com zeros.

Sintaxe:

int *array = new int[tamanho]{};

Na sintaxe acima, o tamanho denota o número de elementos a serem adicionados ao array. Como precisamos inicializar o array com zeros, isso deve ser deixado vazio.

Podemos inicializar um array dinâmico usando uma lista de inicialização. Vamos criar um exemplo que demonstra isso.

Exemplo 2:

#include <iostream>
using namespace std;
int main(void) {
    int x;
    int *array = new int[5]{ 10, 7, 15, 3, 11 };
    cout << "Elementos do array: " << endl;
    for (x = 0; x < 5; x++) {
        cout << array[x] << endl;
    }
    delete[] array;
    return 0;
}

Redimensionando Arrays

O comprimento de um array dinâmico é definido durante o tempo de alocação.

No entanto, C++ não tem um mecanismo embutido de redimensionar um array uma vez que foi alocado.

Você pode, no entanto, superar este desafio alocando um novo array dinamicamente, copiando os elementos, então apagando o array antigo.

Nota: esta técnica é propensa a erros, portanto, tente evitá-la. Em C++ moderno, prefira std::vector que gerencia redimensionamento automaticamente.

Excluindo Arrays Dinamicamente

Um array dinâmico deve ser deletado da memória do computador uma vez que seu propósito é cumprido. A instrução delete pode ajudar a realizar isso. O espaço de memória liberado pode então ser usado para armazenar outro conjunto de dados. No entanto, mesmo se você não deletar o array dinâmico da memória do computador, ele será deletado automaticamente quando o programa terminar.

Nota Importante:

Para deletar um array dinâmico da memória do computador, você deve usar delete[], em vez de delete. Os [] instruem a CPU a deletar múltiplas variáveis em vez de uma variável. O uso de delete em vez de delete[] ao lidar com um array dinâmico pode resultar em problemas. Exemplos incluem vazamentos de memória, corrupção de dados, crashes, etc.

Exemplo 3:

#include <iostream>
using namespace std;
int main() {
    int x, n;
    cout << "Quantos números você vai digitar?" << "\n";
    cin >> n;
    int *arr = new int[n];
    cout << "Digite " << n << " números" << endl;
    for (x = 0; x < n; x++) {
        cin >> arr[x];
    }
    cout << "Você digitou: ";
    for (x = 0; x < n; x++) {
        cout << arr[x] << " ";
    }
    cout << endl;
    delete[] arr;
    return 0;
}

Resumo:

Linguagem C

  1. Dominando Arrays em C#: Declaração, Inicialização e Operações
  2. Como Passar Arrays para Funções em C++: Guia Prático
  3. Alocação Dinâmica de Memória em C: Dominando malloc, calloc, realloc e free
  4. Arrays em C++ Desmistificados: Declaração, Inicialização e Técnicas com Ponteiros
  5. Operadores em C++ Explicados: Tipos, Exemplos e Programas Práticos
  6. Dominando Switch-Case em C++: Sintaxe, Uso e Exemplos Práticos
  7. Structs em C++ Explicadas com Exemplo Prático
  8. Dominando std::list em C++: Sintaxe, Funções e Exemplos Práticos
  9. C++ Struct vs Class: Diferenças Principais, Sintaxe e Melhores Casos de Uso
  10. Selection Sort em Java: Exemplo Passo a Passo e Código Completo