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 em um determinado fator quando há necessidade.

Neste tutorial C ++, você aprenderá

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:

  1. Se um array tiver um tamanho pequeno e um fator de crescimento pequeno, ele continuará realocando a memória com mais freqüência. Isso reduzirá o desempenho do array.
  2. 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:

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

Saída:

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

Explicação do código:

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

Saída:

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

Explicação do código:

  1. Inclua o arquivo de cabeçalho iostream em nosso programa para usar suas funções.
  2. Inclua o namespace std em nosso programa para usar suas classes sem chamá-lo.
  3. Chame a função main (). A lógica do programa deve ser adicionada ao corpo da função.
  4. Declare uma variável inteira chamada x.
  5. 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.
  6. Imprima algum texto no console. O endl é uma palavra-chave C ++ que significa linha final. Ele move o cursor para a próxima frase.
  7. Use um loop for para iterar sobre os elementos da matriz.
  8. Imprima o conteúdo do array denominado array no console.
  9. Fim do corpo do loop for.
  10. O programa deve retornar um valor após a conclusão bem-sucedida.
  11. 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 armazenar 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 assim que 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:

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

Saída:

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

Explicação do código:

  1. Inclua o arquivo de cabeçalho iostream em nosso programa para usar suas funções.
  2. Inclua o namespace std em nosso programa para usar suas classes sem chamá-lo.
  3. Chame a função main (). A lógica do programa deve ser adicionada ao corpo da função.
  4. Declare duas variáveis ​​x e n do tipo de dados inteiro.
  5. Imprima algum texto no console. O texto pedirá ao usuário para indicar o número de números que ele irá inserir.
  6. Leia a entrada do usuário no teclado. O valor de entrada será atribuído à variável n.
  7. Declare uma variável de ponteiro * arr. A matriz arr reservará alguma memória para armazenar um total de n inteiros.
  8. Imprima uma mensagem no console solicitando que o usuário insira n números.
  9. Crie um loop for e a variável de loop x para iterar sobre os números inseridos pelo usuário.
  10. Leia os números inseridos pelo usuário e armazene-os no array arr.
  11. Fim do corpo do loop for.
  12. Imprima algum texto no console.
  13. Use um loop for e a variável de loop x para iterar sobre o conteúdo do array arr.
  14. Imprima os valores da matriz no console.
  15. Fim do corpo do loop for.
  16. Imprima uma linha vazia no console.
  17. Libere a memória do array arr.
  18. O programa retornará o valor quando for concluído com sucesso.
  19. 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 '='.