Array alocada dinamicamente C ++

Matrizes são uma estrutura de dados muito importante em C ++ que serve ao objetivo de manter tipos semelhantes de elementos. As matrizes são divididas principalmente em dois tipos diferentes i.e. estático e dinâmico. As matrizes estáticas são aquelas cujo tamanho é predefinido no código, enquanto as matrizes dinâmicas são as que o tamanho é definido no tempo de execução. Neste artigo, falaremos explicitamente sobre as matrizes dinâmicas em C++. Além disso, prestaremos atenção especial à sua alocação e desalocação compartilhando um exemplo detalhado com você no Ubuntu 20.04.

Matrizes alocadas dinamicamente em C++

Já afirmamos que o tamanho de uma matriz dinâmica é definida no tempo de execução. No entanto, pode -se questionar por que precisamos das matrizes dinamicamente alocadas em primeiro lugar quando podemos usar convenientemente as matrizes estáticas? Bem, às vezes, você encontra essas situações em que o tamanho de uma matriz não é conhecido inicialmente. Nesses casos, você pode adquirir o tamanho da matriz como entrada do usuário no tempo de execução.

Mas isso não é possível com as matrizes estáticas, pois o tamanho de uma matriz estática uma vez definida dentro de um código não pode ser alterada. É aqui que as matrizes alocadas dinamicamente entram em jogo que podem definir as matrizes de qualquer tamanho desejado no tempo de execução. As matrizes dinâmicas em C ++ podem ser facilmente criadas com a "nova" palavra -chave. A sintaxe exata será esclarecida mais adiante neste artigo.

No entanto, um ponto importante a ser observado aqui é que as matrizes estáticas são sempre criadas na pilha do seu sistema e seu próprio sistema assume a responsabilidade de liberar sua pilha quando o seu programa terminar. Por outro lado, as matrizes alocadas dinamicamente são sempre criadas na pilha e você precisa liberar manualmente a memória ocupada por uma matriz dinâmica. Agora, você precisa ver o exemplo discutido abaixo para entender o uso das matrizes alocadas dinamicamente.

Usando as matrizes alocadas dinamicamente em C ++ no Ubuntu 20.04

Neste exemplo, queremos ensinar a você o uso das matrizes alocadas dinamicamente em C++. Vamos lhe contar como você pode declarar e inicializar uma matriz dinâmica em tempo de execução. Em seguida, exibiremos os elementos da matriz alocada dinamicamente. Por fim, mostraremos como você pode negociar a memória ocupada pela matriz dinâmica em c++. Para aprender tudo isso, você terá que ver o código mostrado na imagem a seguir:

Neste programa C ++, temos nossa função "main ()" na qual definimos um número inteiro "num". Este número inteiro corresponderá ao tamanho de nossa matriz dinâmica que vamos criar mais tarde. Em seguida, exibimos uma mensagem no terminal pedindo ao usuário que insira qualquer tamanho de sua escolha para a matriz dinâmica. Depois disso, tomamos esse tamanho como entrada do usuário. Então, com a ajuda da declaração "int *array = new int (num)", declaramos uma matriz dinâmica no tempo de execução, que tem o tamanho igual à variável "num". "Array" refere -se ao nome desta matriz.

Depois disso, exibimos uma mensagem no terminal novamente pedindo ao usuário que insira os elementos dessa matriz. Esta mensagem é seguida por um loop "para" que itera até o tamanho da matriz eu.e. num. Dentro desse loop, pegamos os elementos dessa matriz dinâmica como entrada do usuário.

Depois que a matriz dinâmica foi preenchida, queríamos exibir seus elementos no terminal para os quais exibimos uma mensagem com a ajuda da declaração "cout". Então, temos outro loop "para" que novamente itera o tamanho da matriz dinâmica. Dentro deste loop, simplesmente exibimos os elementos da matriz no terminal. Depois disso, queríamos negociar a memória ocupada por essa matriz dinâmica para a qual usamos a declaração "excluir [] matriz". Finalmente, por estar do lado seguro, usamos a declaração "Array = NULL" para também excluir a referência nula da matriz dinâmica cuja memória acabamos de negociar.

Depois de escrever este código, quando o compilamos e executamos, fomos solicitados a inserir o tamanho da matriz dinâmica. Queríamos que nossa matriz dinâmica fosse de tamanho "5", como mostrado na imagem abaixo:

Assim que entramos no tamanho de nossa matriz dinâmica, fomos convidados a preencher. Para isso, inserimos os números de 1 a 5, como mostrado na imagem a seguir:

Assim que pressionamos a tecla Enter depois de preencher nossa matriz dinâmica, seus elementos foram impressos no terminal. Além disso, a desalocação da memória dinâmica também ocorreu por causa da qual uma notificação sobre isso também apareceu no terminal, como mostrado na imagem abaixo:

Agora, vamos ajustar o mesmo código ligeiramente. Até agora, aprendemos como podemos inicializar uma matriz dinâmica em C ++ e exibir seus elementos no terminal. Embora, também incorporamos o código para negociar essa memória em nosso programa, no entanto, ainda não temos certeza se a memória dinâmica ocupada foi desalocada com sucesso ou não. Para fazer isso, tentaremos acessar uma parte dessa memória dinâmica depois de negociá -la. Se for acessado com sucesso, isso significa que a desalocação de memória não ocorreu corretamente.

No entanto, se encontrarmos alguma mensagem de erro ao acessar essa memória após negociá -la, isso significará que nossa memória dinâmica ocupada foi desalocada com sucesso. Você precisa dar uma olhada no seguinte código modificado para entender o seguinte:

Neste código C ++ modificado, simplesmente adicionamos uma linha no final do nosso programa I.e. cout<

Quando compilamos e executamos esse código, ele teve um desempenho perfeitamente bem, no entanto, assim que essa última linha foi executada, um erro foi gerado referindo -se a uma falha de segmentação que, de fato, significa que você está tentando acessar um local de memória que não existe mais. Isso é exibido na imagem em anexo.

Isso significa que a desalocação de nossa matriz dinâmica ocorreu com sucesso. Esta saída também implica que a tentativa de acessar um local de memória que não existe mais apenas resulta em um erro de tempo de execução e não em um erro de compilação. Isso significa que esse código sempre será compilado com sucesso e você não poderá receber esse erro até que você realmente execute seu código.

Conclusão

Este artigo teve como objetivo ensinar o uso das matrizes alocadas dinamicamente em C ++ no Ubuntu 20.04. Para isso, primeiro destacamos a necessidade de usar as matrizes alocadas dinamicamente em C++. Em seguida, orientamos você através de um exemplo detalhado que explicava como você pode criar e lidar com matrizes dinâmicas em c++. Além disso, também compartilhamos o método de negociar as matrizes dinâmicas. Depois de passar por este guia, você certamente terá uma compreensão básica de lidar com matrizes dinâmicas em C++.