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

O que é uma matriz dinâmica?

Uma matriz dinâmica é bastante semelhante a uma matriz normal, mas seu tamanho é modificável durante o tempo de execução do programa. Os elementos DynamArray ocupam um bloco contíguo de memória.

Uma vez que uma matriz foi criada, seu tamanho não pode ser alterado. No entanto, uma matriz dinâmica é diferente. Um array dinâmico pode expandir seu tamanho mesmo depois de preenchido.

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 aumenta seu tamanho de memória em um determinado fator quando há necessidade.

Neste tutorial de C++, você aprenderá

O que é uma matriz dinâmica?
Fatores que afetam o desempenho de matrizes dinâmicas
A nova palavra-chave
Inicializando arrays alocados dinamicamente
Redimensionando matrizes
Exclusão dinâmica de matrizes

Fatores que afetam o desempenho de matrizes dinâmicas

O tamanho inicial do array 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 memória com mais frequência. Isso reduzirá o desempenho da matriz.
Se um array tiver um tamanho grande e um fator de crescimento grande, ele 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 da matriz.

A nova palavra-chave

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 nova palavra-chave usa a seguinte sintaxe:

pointer_variable = new data_type;

A variável_ponteiro é o nome da variável 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<iostream>
using 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;
}

Saída:

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 um array para conter um total de n inteiros e atribua-o à 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 o valor após a conclusão bem-sucedida.
Fim do corpo da função main().

NOTA:No exemplo acima, o usuário pode 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 arrays alocados dinamicamente

É fácil inicializar um array dinâmico para 0.

Sintaxe:

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

Na sintaxe acima, o comprimento denota o número de elementos a serem adicionados ao array. Como precisamos inicializar o array com 0, isso deve ser deixado em branco.

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

Exemplo 2:

#include <iostream>
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:

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 chamado array usando uma lista de inicializadores. A matriz conterá 5 elementos inteiros. Observe que não usamos o operador "=" entre o comprimento do array e a lista de inicializadores.
Imprima algum texto no console. O endl é uma palavra-chave C++ que significa linha final. 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 chamado array no console.
Fim do corpo do loop for.
O programa deve retornar o 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, o C++ não possui um mecanismo interno de redimensionamento de uma matriz depois de alocada.

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 é propensa a erros, portanto, tente evitá-la.

Exclusão dinâmica de matrizes

Uma matriz dinâmica deve ser excluída da memória do computador assim que sua finalidade for 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 que você não exclua 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 excluir várias 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 de tais problemas incluem vazamentos de memória, corrupção de dados, falhas, etc.

Exemplo 3:

#include<iostream>
using 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;
}

Saída:

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 solicitará ao usuário que indique o número de números que ele 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. O array 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 do array arr no console.
Fim do corpo do loop for.
Imprima uma linha vazia no console.
Libere a memória do array arr.
O programa retornará o valor quando for concluído com êxito.
Fim do corpo da função main().

Resumo:

As matrizes regulares têm um tamanho fixo. Você não pode modificar seu tamanho depois de declarado.
Com esses tipos de matrizes, o tamanho da memória é determinado durante o tempo de compilação.
As 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 palavra-chave new.
Usamos colchetes para especificar o número de itens a serem armazenados na matriz dinâmica.
Uma vez feito com 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 do array.
Uma exclusão sem [] libera a memória de apenas um único elemento.
Não há mecanismo interno para redimensionar matrizes C++.
Para inicializar uma matriz usando um inicializador de lista, não usamos o operador "=".

Manipulação de Exceções C++:Try, Catch, Throw Exemplo Ponteiros C++ com exemplos

Linguagem C