Exercícios Resolvidos de Alocação dinâmica de memória

Ver Teoria

Enunciado

Em C++ os arrays são estáticos e depois de criados não podem ser ampliados.

Porém, é possível “ampliar” um array dinâmico seguindo os seguintes passos:

  1. Crie um novo array dinâmico com um espaço a mais.
  2. Copie os valores do antigo array para o novo.
  3. Na última posição do novo array, guarde o novo elemento.
  4. Apague o array antigo.

Crie um programa que tenha a função a d i c i o n a r E l e m e n t o que adiciona um novo elemento na última posição de uma array de inteiros.

Dica: Crie uma função auxiliares que realizem: a cópia dos elementos entre dois arrays dinâmicos, que receba os valores de uma array do usuário, e que imprima a array.

Passo 1

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:

Passo 2

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 i m p r i m e A r r a y .

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 i m p r i m e A r r a y vai receber como parâmetro o ponteiro * a r r a y 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 t a m a n h o , para que possamos imprimi-la corretamente:

v o i d   i m p r i m e A r r a y ( i n t   * a r r a y ,   i n t   t a m a n h o )

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

Passo 3

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 p r e e n c h e A r r a y .

A função p r e e n c h e A r r a y 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 * a r r a y . Vamos precisar também de um parâmetro inteiro que represente o tamanho da array que vamos chamar de t a m a n h o , para que possamos imprimi-la corretamente:

v o i d   p r e e n c h e A r r a y ( i n t   * a r r a y ,   i n t   t a m a n h o )

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

Passo 4

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.

v o i d   c o p i a r A r r a y ( i n t   * a r r a y ,   i n t   * n o v o A r r a y ,   i n t   t a m a n h o )

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

Passo 5

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 a d i c i o n a r E l e m e n t o , 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 i n t * . 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.

i n t   *   a d i c i o n a r E l e m e n t o ( i n t   e l e m e n t o ,   i n t   * a r r a y ,   i n t   &   t a m a n h o )

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 c o p i a r A r r a y que nós criamos anteriormente.

Agora vamos acessar o último elemento da nova array e guardar o conteúdo de e l e m e n t o 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 t a m a n h o

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

Passo 6

Show de bola. Agora vamos criar uma m a i n (   ) 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 n e w para criar um novo vetor dinâmico do tipo inteiro.

Usando a função p r e e n c h e A r r a y 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 a d i c i o n a r E l e m e n t 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 i m p r i m e A r r a y .

Passo 7

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 p r e e n c h e A r r a y , porém temos que deletar a nova array que foi criada.

O endereço dessa nova array esta contido no ponteiro a r r a y . Então vamos usar o operador d e l e t e   [   ] para liberar a memória:

E prontinho! Acabou o exercício.

Resposta