C++ Alocação Dinâmica de Matrizes com Exemplo

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

Fatores que afetam o desempenho de Dynamic Arrays

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

In 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 assume a seguinte sintaxe:

pointer_variable = new data_type;

O pointer_variable é o nome do variável de ponteiro.

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

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.

1 exemplo:

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

1. Inclua o arquivo de cabeçalho iostream em nosso programa para usar seu 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 ao usuário que insira o valor da variável n.
6. Leia a entrada do usuário no teclado e atribua-a à variável n.
7. Declare um array para conter um total de n inteiros e atribua-o à 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. Ler os elementos inseridos pelo usuário e armazená-los no array arr.
11. Fim do corpo do para laço.
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 no array denominado arr no console.
15. Fim do corpo do loop for.
16. O programa deve retornar o valor após a conclusão bem-sucedida.
17. 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 matrizes alocadas dinamicamente

É fácil inicializar um array dinâmico com 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, ele deve ser deixado em branco.

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

2 exemplo:

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

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 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.
6. Imprima algum texto no console. O final é um C++ palavra-chave que significa linha final. Ele move o cursor para a próxima frase.
7. Use um loop for para iterar sobre os elementos do array.
8. Imprima o conteúdo do array denominado array no console.
9. Fim do corpo do loop for.
10. O programa deve retornar o 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.

O Mercado Pago não havia executado campanhas de Performance anteriormente nessas plataformas. Alcançar uma campanha de sucesso exigiria C++ não possui um mecanismo interno para redimensionar uma matriz depois de alocada.

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

Nota: 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 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.

Nota:

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 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 de tais problemas incluem vazamentos de memória, corrupção de dados, travamentos, etc.

3 exemplo:

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

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 solicitará ao usuário que indique a quantidade de números que 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. O array 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 do array arr 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á 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 depois de declarado.
• Com esses tipos de arrays, 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 arrays dinâmicos, o tamanho é determinado durante o tempo de execução.
• Matrizes dinâmicas em C++ são declarados usando a palavra-chave new.
• Usamos colchetes para especificar o número de itens a serem armazenados na matriz dinâmica.
• Uma vez concluído o array, podemos liberar 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 integrado para redimensionar C++ matrizes.
• Para inicializar um array usando um inicializador de lista, não usamos o operador “=”.