Alocação dinâmica de memória

A alocação dinâmica de memória é uma forma do programador controlar melhor o momento em que cada variável do programa deve ser criada, e ocupar espaço na memória, e quando elas devem ser deletadas para liberar espaço na memória ram.

O processo de alocação dinâmica busca espaços livres na memória do computador, e quando espaços vazios são encontrados, o endereço de memória é guardado em uma variável ponteiro. Através do ponteiro é possível trabalhar com este endereço de memória. E quando o endereço não for mais útil, é possível liberar essa memória, desocupando espaço na memória ram.

O processo de liberar memória é extremamente importante, e deve-se ter cuidado de sempre executá-lo na hora adequada. A não-liberação de memória é um problema conhecido como Vazamento de Memória, e pode gerar um consumo excessivo de recursos computacionais, levando a lentidão nos processos, e até pode resultar em falhas nos programas.

Bora lá, pessoal.

Essa questão quer que a gente crie um array dinâmico, preencha e exiba essa array. Você só precisa ter uma coisa em mente quando for trabalhar com arrays dinâmicas: Elas trabalham parecido com as arrays normais!

Então, sem enrolação, vamos começar com o cabeçalho do código:

Primeiro de tudo, a gente precisa criar a nossa array dinâmica.

Pra criar uma array dinâmica, primeiro a gente declara um ponteiro, e em seguida utiliza o operador para efetuar a alocação de memória, da seguinte forma:

A questão pede pra criar um vetor com cinco espaços, então o será 5. No código nós fazemos assim:

Na linha 07 nós criamos um ponteiro chamado que será usado para armazenar o endereço de memória do nosso vetor dinâmico. Na linha 08 nós efetuamos a alocação dinâmica de memória.

Show! Fizemos a alocação dinâmica 😎! A partir de agora o ponteiro pode ser tratado com uma array, e podemos trabalhar com ele utilizando os colchetes da forma como já estamos acostumados.

Com a alocação já feita, vamos preencher o vetor. Vamos mandar uma mensagem pra informar ao usuário que ele deve preencher o vetor:

A variável é um ponteiro. Porém, depois que a memória é alocada, a gente pode trabalhar com o de forma muito parecida com as arrays comuns. Da até pra usar os colchetes para acessar os elementos.

Então, pra preencher uma array dinâmica, a gente pode utilizar um loop que a cada iteração pede pro usuário inserir um dos elementos da array.

Na linha 12 nós iniciamos um loop que fará 5 voltas. A cada iteração, na linha 14, nós exibimos uma mensagem solicitando um valor pro usuário.

Na linha 15 usamos o para guardar o valor inserido na posição do . Pra acessar essa posição é só a gente utilizar os colchetes .

O próximo passo é exibir o conteúdo do vetor. Novamente, vou te lembrar que a gente usa um array dinâmica igual usamos uma array normal. Então pra exibir os elementos de uma array é só usar um loop:

Na linha 19 imprimimos a mensagem “Exibindo o vetor: ” e saltamos uma linha. Na linha 20 a 23 criamos um loop que a cada iteração vai exibir a posição do e saltar uma linha.

Sempre que a gente trabalhar com alocação dinâmica de memória, no último passo sempre devemos liberar a memória.

Para liberar a memória vamos usar o operador para apagar o vetor dinâmico que criamos:

E prontinho! A questão está finalizada.

Vamos nessa, galera.

Uma das vantagens dos arrays dinamicamente alocados é que podemos, de forma segura, pedir pro usuário escolher o tamanho das arrays. E essa questão quer que a gente use isso!

Então vamos lá, vamos começar com o cabeçalho do código:

E vamos precisar declarar duas variáveis. A primeira é a variável inteira que vai receber do usuário o tamanho do array que vamos criar. E a segunda é o ponteiro para floats , que vai ser o ponteiro que vamos usar para alocar a memória dinamicamente.

Primeiro de tudo, a gente precisa saber qual vai ser o tamanho da nossa array dinâmica. Então vamos perguntar pro usuário e guardar o valor na variável tamanho:

Beleza. Agora já temos um ponteiro e o tamanho, temos tudo que é preciso pra criar uma array dinâmica.

Lembre-se, pra criar uma array dinâmica a gente utiliza o operador para efetuar a alocação de memória, e guardar o endereço da memória alocada em um ponteiro, da seguinte forma:

No nosso código o ponteiro é o , o tipo é e o tamanho do array está contido na variável Então, o código fica assim:

E assim temos uma array alocada com sucesso!

A partir de agora o podemos utilizar os colchetes no ponteiro para acessar os elementos contidos na memória alocada dinamicamente.

Agora vamos pedir pro usuário preencher o vetor. Com o vamos imprimir uma mensagem pra informar ao usuário que ele deve preencher o vetor:

Para preencher o é igual a preencher um array comum, vamos usar um loop que a cada iteração solicita um valor para o usuário:

Na linha 18 nós iniciamos um loop , a quantidade de iterações vai ser igual ao tamanho do array dinâmico. Na linha 21 usamos o para guardar o valor inserido na posição do . Pra acessar essa posição é só a gente utilizar os colchetes .

O próximo passo é exibir o conteúdo do vetor. Lembre-se que um array dinâmico se comporta igual a um array comum. Então pra exibir os elementos de uma array é só usar um loop:

Na linha 25 imprimimos a mensagem “Exibindo o vetor: ” e saltamos uma linha. Nas linhas 26 a 28 criamos um loop que a cada iteração vai exibir a posição do e saltar uma linha.

Sempre que a gente trabalhar com alocação dinâmica de memória, no último passo sempre devemos liberar a memória.

Para liberar a memória vamos usar o operador para apagar o vetor dinâmico que criamos:

E prontinho! A questão está finalizada.

Bora lá, galera.

O que essa questão quer é que a gente exercite como criar funções que recebem vetors dinâmicas. O que você precisa perceber é que com as vetors dinâmicas são ponteiros. Apesar de a gente poder trabalhar com as vetors dinâmicas como se fossem vetors comuns, você deve ter sempre em mente que o que estamos fazendo de verdade é usar um ponteiro para acessar uma parte da memória alocada como um vetor.

Ou seja, uma função que quer receber um vetor dinâmica, na verdade vai receber um ponteiro.

Mas antes de construir essas funções propriamente ditas, vamos escrever o cabeçalho do código.

Então vamos começar criando uma função que preencha os elementos de um vetor dinâmica.

Vamos chamar essa função de e ela vai precisar receber dois argumentos o ponteiro que aponta pro vetor que vamos trabalhar, e o tamanho desse vetor.

É importante que a gente receba o ponteiro que aponta para o vetor, pois quando a gente trabalha com vetors dinâmicas a gente não tem acesso o vetor em si, a gente só tem acesso ao ponteiro que aponta para o vetor. Ou seja, precisamos realizar uma passagem por ponteiro.

Lembre-se que passagens por ponteiro alteram diretamente no local de memória, ou seja, não vamos precisar retornar nenhum valor, pois o vetor dinâmico já está sendo alterado.

Agora que estamos dentro da função, podemos trabalhar com o vetor dinâmico normalmente, usando os colchetes. Vamos usar um que acessa todas as posições do vetor, e com o e vamos solicitar que o usuário preencha o vetor

O próximo passo é construir uma função capaz de imprimir um vetor dinâmico. Para criar uma função que recebe um vetor dinâmico, devemos receber um ponteiro que aponta para o local dinamicamente alocado!

Vamos criar a função que recebe o ponteiro que aponta para um vetor e o tamanho do vetor a ser impresso:

Depois de receber o ponteiro que aponta para o vetor dinâmico, podemos trabar com o vetor dinâmico normalmente. Com um loop acessamos os elementos do vetor e imprimimos com o

As funções estão construídas, agora vamos pra nossa .

Primeiro de tudo, a questão pede que a gente receba um valor do usuário e crie um vetor dinâmico com posições. Então vamos precisar declarar uma variável inteira para receber o valor do usuário, e um ponteiro para chamado que usaremos para apontar para a memória alocada dinamicamente.

Em seguida, vamos receber do usuário o tamanho do vetor que vamos criar:

Agora vamos criar o vetor dinâmico.

Para realizar alocação dinâmica de um vetor nós utilizamos o operador para alocar memória de um tipo pré-derterminado e entre colchetes informamos a quantidade de espaços de memória que devem ser alocados. O resultado do processo de alocação deve ser armazenado em um ponteiro.

No nosso programa vamos utilizar o operador para alocar memória do tipo , e entre os colchetes vamos informar que queremos que sejam alocados espaços. O endereço dessa alocação deve ser armazenado no ponteiro :

Agora que já temos o nosso array dinâmico, só precisamos utilizar as funções que já desenvolvemos.

Primeiro vamos preencher o vetor usando a função

Em seguida vamos exibir o seu conteúdo com a função

E esse é um exercício de alocação dinâmica de memória. Então você nunca pode esquecer que a memória deve ser liberada!

Para liberar memória é só a gente aplicar o no ponteiro que aponta pro vetor alocado dinamicamente

E prontinho! Finalizamos a questão!

Vamos lá pessoal. Essa questão é um pouquinho mais cabeluda, mas com calma a gente vai fazê-la com tranquilidade.

O objetivo é criar uma função que amplie uma array. A vantagem é que a questão já explicou os passos que temos que seguir, basicamente vamos fazer uma cópia da array antiga em uma array nova com mais espaço.

Vamos iniciar com o cabeçalho do código:

Vamos começar criando algumas funções auxiliares.

A primeira função auxiliar que vamos precisar é uma que imprima os valores contidos no vetor dinâmico. Então vamos criar a função .

Lembre-se que a gente não tem acesso a array, mas sim a um ponteiro que aponta para essa array. Assim, a função vai receber como parâmetro o ponteiro que aponta para a memória alocada dinamicamente. Vamos precisar também de um parâmetro que contenha o tamanho da array que vamos chamar de , para que possamos imprimi-la corretamente:

Dentro da função, vamos usar um loop para iterar sobre os elementos da array e com o vamos imprimir cada um dos elementos.

A segunda função auxiliar que vamos precisar é uma função que preencha o vetor com valores inseridos pelo usuário. Essa função vai ser chamada .

A função vai precisar acessar e modificar os valores contidos no vetor dinâmico, o que vai ser fácil de resolver pois uma array dinâmica sempre é passada por ponteiro. Então o primeiro parâmetro da função é um ponteiro que aponta pra memória alocada dinamicamente chamado . Vamos precisar também de um parâmetro inteiro que represente o tamanho da array que vamos chamar de , para que possamos imprimi-la corretamente:

Para efetuar o preenchimento da array vamos utilizar um loop para acessar cada um dos elementos da array e usando e podemos guardar o valor inserido pelo usuário na posição adequada.

Vamos desenvolver agora a terceira função auxiliar. Vamos criar uma função que copia todos os dados de uma array para outra.

Pra essa função funcionar vamos precisar de três parâmetros. Primeiro é necessário receber a array atual, e segundo vamos precisar receber a nova array para onde os valores serão copiados, e terceiro é preciso conhecer o tamanho da array atual, para podermos executar um loop sobre a array atual.

O algoritmo da função de cópia consiste em usar um loop para acessar cada um dos elementos da e copiar esse elemento para a mesma posição na :

Com todas as funções auxiliares prontas, podemos nos dedicar a função mais importante do programa: executar a ampliação de uma array.

Vamos construir a declaração da função.

A função vai se chamar , que vai efetuar a cópia de uma array e retornar o endereço de memória de uma nova array dinâmica. Ou seja, essa função vai retornar um ponteiro, e por isso deve ser do tipo . O primeiro parâmetro é o valor do elemento a ser adicionado. O segundo parâmetro é o endereço de memória da array dinâmica que vai ser ampliada. E o terceiro parâmetro é o tamanho da array e vai ser passado por referência para que a gente possa atualizar o valor do tamanho da array.

Vamos passo a passo construir o algoritmo da função. O primeiro passo é alocar dinamicamente uma nova array dinâmica, com o detalhe de que o tamanho deve ser um espaço maior.

Em seguida, vamos copiar os valores da array atual para a nova array utilizando a função que nós criamos anteriormente.

Agora vamos acessar o último elemento da nova array e guardar o conteúdo de na nova array.

Pronto. Agora não precisamos mais da array antiga, e podemos deletá-la:

E para que a gente possa continuar sabendo o tamanho da array, vamos atualizar a variável

E para finalizar a função, vamos retornar o endereço de memória da array expandida.

Show de bola. Agora vamos criar uma que faça uso das funções que criamos.

Pra começar, vamos precisar de um ponteiro do tipo inteiro que vai conter o endereço da array dinâmica. Também vamos precisar declarar uma variável que receba contenha o tamanho da array, e uma variável em que o usuário possa inserir o novo elemento da array.

Vamos pedir pro usuário inserir o tamanho que ele deseja para a array

E com isso poderemos utilizar o operador para criar um novo vetor dinâmico do tipo inteiro.

Usando a função vamos pedir pro usuário colocar valores na array criada.

E agora vamos efetuar a ampliação da array. Primeiro vamos pedir pro usuário inserir o valor do novo elemento que vai ser adicionado na array. Em seguida, na linha 60, usamos a função para efetuar o processo de ampliação. Note que o resultado vai ser guardado dentro do mesmo ponteiro.

Agora que a array foi ampliada, podemos imprimir o seu conteúdo utilizando a função .

Antes de finalizar a questão, não podemos esquecer de deletar o array dinâmico. A array velha foi deletada dentro da função , porém temos que deletar a nova array que foi criada.

O endereço dessa nova array esta contido no ponteiro . Então vamos usar o operador para liberar a memória:

E prontinho! Acabou o exercício.

Vambora!

A questão quer que a gente receba dois arrays do usuário, e depois aloque um array dinâmico que contenha a os números que pertencem às duas arrays originais. Então a gente vai precisar realizar loops para preencher as arrays, e um loop que vai procurar os números iguais nas duas arrays.

Então vamos começar declarando as variáveis necessárias. Primeiro uma array de inteiros chamada que vai conter os seis números da loteria. Depois uma outra array de inteiros chamada que vai conter os seis números que o usuário escolheu.

Para criar uma array dinâmica, a gente precisa saber quantos números o usuário acertou, então vamos criar uma variável inteira chamada que vamos usar pra contar a quantidade de acertos do usuário. O endereço de memória do array dinâmico precisa ser armazenado em um ponteiro, que vamos chamar de . E, por último, vamos precisar de duas variáveis e que vamos usar para criar os loops!

Primeiro de tudo, vamos perguntar pro usuário quais foram os números sorteados na loteria. Ou seja, vamos pedir pra ele preencher a array .

Pra isso vamos criar um loop de seis voltas, que a cada iteração vai pedir pro usuário inserir um número, e armazenar o valor digitado na posição correspondente da array.

E em seguida, vamos fazer o mesmo processo para preencher o array que contém os números que o usuário escolheu:

Certo, agora vamos pra uma parte mais complicadinha da questão. Vamos precisar contabilizar a quantidade de acertos do usuário. Pra isso vai ser necessário um loop aninhado e uma estrutura condicional.

O primeiro loop vai percorrer os seis valores da array , dentro desse loop vamos criar um segundo loop que percorre os seis valores da array .

Dentro do loop vamos estabelecer uma condição de que se o número apostado atual, for igual ao número sorteado atual, então a gente aumenta o valor da variável .

Uma coisa interessante de se lembrar é que numa loteria não é possível que o mesmo número seja sorteado ou apostado duas vezes! Então podemos usar o comando para interromper o loop de números sorteados, e partir para o próximo número apostado!

Prontinho! Agora que já temos a quantidade de acertos, podemos criar o nosso array dinâmico com o tamanho adequado!

Vamos usar o operador para iniciar um array de inteiros com o tamanho da variável

Pronto! Agora vamos poder utilizar o ponteiro para acessar os endereços do array alocado dinamicamente!

Agora precisamos preencher o array dinâmico com os números acertados pelo usuário.

Pra isso vamos usar novamente a mesma estrutura de loops aninhados com estrutura condicional.

O primeiro loop vai percorrer os seis valores da array , dentro desse loop vamos criar um segundo loop que percorre os seis valores da array .

Só que dessa vez, se o número apostado atual, for igual ao número sorteado atual, então a gente vai armazenar esse valor na posição do array dinâmico !

Agora só precisamos imprimir os números contidos no array dinâmico!

Pra isso é só a gente criar um loop que vai iniciar em zero e avançar até o número de um em um. E a cada iteração vai exibir o conteúdo da posição do array dinâmico.

Estamos quase acabando. Mas antes de finalizar a questão, temos que lembrar que sempre que usamos alocação dinâmica, temos que liberar a memória!

Então vamos utilizar o operador para apagar o array alocado dinamicamente

E finalizamos a questão!

Vamos nessa!

Pessoal, criar uma matriz dinâmica com C++ é uma tarefa um pouco mais complicada. Se você simplesmente tentar usar o operador new com duas chaves, vamos obter um erro:

O que vamos precisar fazer é usar o operador várias vezes consecutivas. A primeira utilização vai criar as linhas da matriz. Depois, dentro de cada linha vamos criar as colunas da matriz.

Vamos começar. Primeiro de tudo, vamos precisar de três variáveis.

Vamos precisar de duas variáveis inteiras para armazenar a quantidade de linhas e colunas.

E também vamos precisar de um ponteiro duplo que vai armazenar o endereço de memória da matriz dinâmica.

E em seguida, vamos precisar receber do usuário a quantidade de linhas e colunas da matriz

Beleza, agora vamos pro coração da questão.

O que vamos fazer aqui é um uso inteligente dos ponteiro. Primeiro, pegar o ponteiro duplo e alocar um “array de ponteiros”. E depois, vamos usar cada um dos ponteiros alocados dinamicamente, e usar esses ponteiros para alocar espaços na memória. O efeito disso será uma matriz.

Primeiro, vamos iniciar as colunas da nossa matriz. Para isso vamos usar o operador . Uma coisa que você deve notar é que é um ponteiro

E depois vamos acessar cada uma das linhas, e em cada uma delas vamos inicializar a quantidade de colunas:

Na prática, o que fazemos na linha 14 é criar uma “array de ponteiros”. E depois no loop, acessamos cada um dos ponteiros e alocamos um array de . O resultado é que temos uma quantidade de arrays dinâmicos, e cada um desses arrays dinâmicos possui uma quantidade de espaços.

Por exemplo, se o usuário digitar uma quantidade de 4 linhas, e 5 colunas, vamos ter a seguinte organização na memória:

Prontinho! Nossa matriz dinâmica foi alocada! E pra usar ela é só a gente utilizar as duplas chaves para acessar cada elemento, assim como faríamos com as matrizes que estamos acostumados:

Então vamos preencher todos os elementos com zeros. Pra isso vamos utilizar um loop aninhado para acessar todas as linhas e colunas.

Faremos um loop externo que vai percorrer as linhas da matriz, e um loop interno que percorre as colunas de cada linha. E para cada posição da matriz vamos preencher com zero:

E agora vamos exibir a matriz!

Vamos fazer um outro loop aninhado igualzinho ao anterior. Mas dessa vez, ao invés de alterar o conteúdo da matriz, vamos exibir o conteúdo.

Faremos um loop externo que vai percorrer as linhas da matriz, e um loop interno que percorre as colunas de cada linha. Um detalhe a mais é que, após terminar o último elemento de uma linha, vamos imprimir um para saltar uma linha

E antes de finalizar a questão, precisamos liberar a memória alocada dinamicamente.

Perceba o seguinte: se foi necessário usar um loop para alocar a memória, então vai ser preciso um loop para liberar a memória também!

Vamos acessar cada uma das linhas da matriz, e liberar o vetor dinâmico existente nesta coluna.

Na prática, o que estamos fazendo é acessando cada um dos ponteiros da “array de ponteiro” e liberando a memória apontada por estes ponteiros.

E antes de finalizar totalmente a questão, lembre-se que a “array de ponteiros” foi alocada dinamicamente também. Então é necessário liberá-la:

E prontinho! Questão concluída.

Essa questão está pedindo pra gente criar funções que facilitem a criação e liberação de matrizes dinâmicas.

Pra começar, vamos escrever uma função chamada .

Essa função vai receber como parâmetro as dimensões da matriz, e vai retornar um ponteiro para o endereço da matriz. Uma matriz é alocado com um ponteiro duplo para float, então tipo da função será .

Para criar uma matriz dinamicamente nós precisamos de um ponteiro duplo. Vamos então criar um ponteiro duplo chamado :

O primeiro passo para criar um ponteiro dinâmico é inicializar as linhas dessa matriz. Em termos técnicos, o que estamos fazendo é inicializando uma array dinâmica de ponteiros. Para criar uma array dinâmica de ponteiros nós usamos o operador new junto com o tipo e o operador , e armazenamos o resultado em um ponteiro duplo.

Para criar uma array de ponteiros fazemos:

No código, vamos alocar ponteiros dinâmicos:

Ok. Depois que temos uma array dinâmica de ponteiros, podemos acessar cada um dos ponteiros, e fazer com que cada um deles aponte para um novo espaço alocado dinamicamente.

Pra isso, a gente pode usar um loop que vai acessar cada um dos elementos da array dinâmica de ponteiros, e para cada um dos ponteiros a gente utiliza novamente o operador e aloca um novo espaço dinâmico com espaços.

E prontinho. A matriz está alocada dinamicamente.

Agora, para concluir essa função, vamos retornar o ponteiro duplo.

Mas se temos uma função para alocar uma memória dinamicamente, então vamos precisar de uma função para liberar essa memória!

Essa função não precisa retornar nada. Tudo que ela precisa fazer é receber o ponteiro da matriz dinâmica e deletar os espaços alocados dinamicamente.

O detalhe, é que vai ser necessário criar um loop para acessar todas as linhas da matriz. Então também vamos precisar receber as dimensões da matriz.

Assim, vamos criar uma função chamada , do tipo (pois não precisa retornar nada) e que recebe como parâmetro o ponteiro duplo que aponta pra matriz dinâmica, e as dimensões dessa matriz.

E agora precisamos liberar a memória. Quando alocamos, nós utilizamos um loop que acessava todas as linhas e alocava a memória. Agora usaremos o mesmo loop novamente, mas dessa vez vamos utilizar o operador para liberar cada uma das colunas de cada linha.

E antes de finalizar a função, também precisamos liberar a array dinâmica de ponteiros.

E prontinho! Concluímos a segunda função, e terminamos a questão!