Alocação dinâmica de matrizes C ++ com exemplo

O que é um array dinâmico?

Uma matriz dinâmica é bastante semelhante a uma matriz regular, mas seu tamanho pode ser modificado durante a execução do programa. Os elementos DynamArray ocupam um bloco contíguo de memória.

Depois que um array é criado, seu tamanho não pode ser alterado. No entanto, uma matriz dinâmica é diferente. Uma matriz dinâmica pode expandir seu tamanho mesmo depois de ser preenchida.

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

Neste tutorial C ++, você aprenderá

O que é um array dinâmico?
Fatores que afetam o desempenho de matrizes dinâmicas
A nova palavra-chave
Inicializando matrizes alocadas dinamicamente
Redimensionando matrizes
Excluindo matrizes dinamicamente

Fatores que afetam o desempenho de matrizes dinâmicas

O tamanho inicial da matriz e seu fator de crescimento determinam seu desempenho. Observe os seguintes pontos:

Se um array tiver um tamanho pequeno e um fator de crescimento pequeno, ele continuará realocando a memória com mais frequência. Isso reduzirá o desempenho do array.
Se uma matriz tiver um tamanho grande e um grande fator de crescimento, ela terá uma grande quantidade de memória não utilizada. Devido a isso, as operações de redimensionamento podem demorar mais. Isso reduzirá o desempenho do array.

A nova palavra-chave

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

Sintaxe:

A nova palavra-chave assume a seguinte sintaxe:

pointer_variable = new data_type;

O ponteiro_variable é o nome da variável do ponteiro.

O data_type deve ser um tipo de dados C ++ válido.

A palavra-chave então retorna um ponteiro para o primeiro item. Depois de criar o array dinâmico, podemos excluí-lo usando a palavra-chave delete.

Exemplo 1:

#includeusing namespace std;int main() {int x, n;cout << "Enter the number of items: << "\n";cin >>n;int *arr = new int(n);cout << "Enter " << n << " items" << endl;for (x = 0; x < n; x++) {cin >> arr[x];}cout << "You entered: ";for (x = 0; x < n; x++) {cout << arr[x] << " ";}return 0;}

Resultado:

Aqui está uma captura de tela do código:

Explicação do código:

Inclua o arquivo de cabeçalho iostream em nosso programa para usar suas funções.
Inclua o namespace std em nosso programa para usar suas classes sem chamá-lo.
Chame a função main (). A lógica do programa deve ser adicionada ao corpo da função.
Declare duas variáveis inteiras x e n.
Imprima algum texto no console solicitando que o usuário insira o valor da variável n.
Leia a entrada do usuário no teclado e atribua-a à variável n.
Declare uma matriz para conter um total de n inteiros e atribuí-la à variável de ponteiro * arr.
Imprima uma mensagem solicitando que o usuário insira um número n de itens.
Use um loop for para criar uma variável de loop x para iterar sobre os itens inseridos pelo usuário.
Leia os elementos inseridos pelo usuário e armazene-os no array arr.
Fim do corpo do loop for.
Imprima algum texto no console.
Use um loop for para criar uma variável de loop x para iterar sobre os itens da matriz.
Imprima os valores contidos na matriz chamada arr no console.
Fim do corpo do loop for.
O programa deve retornar um valor após a conclusão bem-sucedida.
Fim do corpo da função main ().

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

Inicializando matrizes alocadas dinamicamente

É fácil inicializar uma matriz dinâmica para 0.

Sintaxe:

int *array{ new int[length]{} };

Na sintaxe acima, o comprimento denota o número de elementos a serem adicionados ao array. Uma vez que precisamos inicializar a matriz para 0, isso deve ser deixado em branco.

Podemos inicializar um array dinâmico usando uma lista de inicializadores. Vamos criar um exemplo que demonstra isso.

Exemplo 2:

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

Resultado:

Aqui está uma captura de tela do código:

Explicação do código:

Inclua o arquivo de cabeçalho iostream em nosso programa para usar suas funções.
Inclua o namespace std em nosso programa para usar suas classes sem chamá-lo.
Chame a função main (). A lógica do programa deve ser adicionada ao corpo da função.
Declare uma variável inteira chamada x.
Declare um array dinâmico denominado array usando uma lista de inicializadores. A matriz conterá 5 elementos inteiros. Observe que não usamos o operador entre o comprimento da matriz e a lista de inicializadores.
Imprima algum texto no console. O endl é uma palavra-chave C ++ que significa linha final. Ele move o cursor para a próxima frase.
Use um loop for para iterar sobre os elementos da matriz.
Imprima o conteúdo do array denominado array no console.
Fim do corpo do loop for.
O programa deve retornar um valor após a conclusão bem-sucedida.
Fim do corpo da função main ().

Redimensionando matrizes

O comprimento de uma matriz dinâmica é definido durante o tempo de alocação.

No entanto, C ++ não tem um mecanismo interno para redimensionar um array depois de alocado.

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

Nota: que esta técnica está sujeita a erros, portanto, tente evitá-la.

Excluindo matrizes dinamicamente

Uma matriz dinâmica deve ser excluída da memória do computador uma vez que sua finalidade seja cumprida. A instrução delete pode ajudá-lo a fazer isso. O espaço de memória liberado pode então ser usado para conter outro conjunto de dados. No entanto, mesmo se você não excluir a matriz dinâmica da memória do computador, ela será excluída automaticamente quando o programa terminar.

Observação:

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

Exemplo 3:

#includeusing namespace std;int main() {int x, n;cout << "How many numbers will you type?" << "\n";cin >>n;int *arr = new int(n);cout << "Enter " << n << " numbers" << endl;for (x = 0; x < n; x++) {cin >> arr[x];}cout << "You typed: ";for (x = 0; x < n; x++) {cout << arr[x] << " ";}cout << endl;delete [] arr;return 0;}

Resultado:

Aqui está uma captura de tela do código:

Explicação do código:

Inclua o arquivo de cabeçalho iostream em nosso programa para usar suas funções.
Inclua o namespace std em nosso programa para usar suas classes sem chamá-lo.
Chame a função main (). A lógica do programa deve ser adicionada ao corpo da função.
Declare duas variáveis x e n do tipo de dados inteiro.
Imprima algum texto no console. O texto pedirá ao usuário para indicar o número de números que ele irá inserir.
Leia a entrada do usuário no teclado. O valor de entrada será atribuído à variável n.
Declare uma variável de ponteiro * arr. A matriz arr reservará alguma memória para armazenar um total de n inteiros.
Imprima uma mensagem no console solicitando que o usuário insira n números.
Crie um loop for e a variável de loop x para iterar sobre os números inseridos pelo usuário.
Leia os números inseridos pelo usuário e armazene-os no array arr.
Fim do corpo do loop for.
Imprima algum texto no console.
Use um loop for e a variável de loop x para iterar sobre o conteúdo do array arr.
Imprima os valores da matriz no console.
Fim do corpo do loop for.
Imprima uma linha vazia no console.
Libere a memória do array arr.
O programa retornará um valor quando for concluído com êxito.
Fim do corpo da função main ().

Resumo:

Matrizes regulares têm um tamanho fixo. Você não pode modificar seu tamanho uma vez declarado.
Com esses tipos de matrizes, o tamanho da memória é determinado durante o tempo de compilação.
Matrizes dinâmicas são diferentes. Seus tamanhos podem ser alterados durante o tempo de execução.
Em matrizes dinâmicas, o tamanho é determinado durante o tempo de execução.
Matrizes dinâmicas em C ++ são declaradas usando a nova palavra-chave.
Usamos colchetes para especificar o número de itens a serem armazenados na matriz dinâmica.
Uma vez feito o array, podemos liberar a memória usando o operador delete.
Use o operador delete com [] para liberar a memória de todos os elementos da matriz.
Uma exclusão sem [] libera a memória de apenas um único elemento.
Não há mecanismo interno para redimensionar matrizes C ++.
Para inicializar um array usando um inicializador de lista, não usamos o operador .