Ponteiros com classes e objetos

Ver Todos os Exercícios

Teoria

E aí pessoal, aqui é o Juan do Responde Aí, e hoje vamos falar um pouco de como os ponteiros se relacionam com a Programação Orientada a Objetos

Ponteiros que apontam para objetos

Para criar um ponteiro a gente vem usando a seguinte forma:

t i p o * n o m e P o n t e i r o = & n o m e V a r i a v e l ;

Quando a gente trabalha com objetos, fazemos a mesmas coisas, porém o t i p o que vai ser trabalhado é a própria classe.

n o m e C l a s s e * n o m e P o n t e i r o = & n o m e O b j e t o

Os operadores de endereço & e de desreferenciação * continuam funcionando do mesmo jeito. Então, na hora de acessar o conteúdo de um objeto primeiro devemos usar o operador * para acessar o objeto, e em seguida usar o operador ponto . para acessar ao conteúdo:

* n o m e P o n t e i r o . n o m e A t r i b u t o * n o m e P o n t e i r o . n o m e M e t o d o ( )

É necessário usar os parêntesis para que o processo ocorra na ordem correta: primeiro acessar o objeto, depois acessar os métodos e atributos.

Exemplo: Crie um ponteiro que acesse um atributo e um método de um objeto.

Pra começar, vamos criar uma classe que tenha um atributo e um método quaisquer:

Vamos criar uma instância desse objeto:

E em seguida vamos criar um ponteiro para o tipo C l a s s e E x e m p l o

Usando o operador de endereço, vamos fazer o p n t O b j e t o apontar para o b j e t o E x e m p l o

A gente pode usar o * para acessar o objeto, e em seguida usar operador ponto . para acessar os métodos e atributos.

Operador seta - >

Você pode ter notado que a forma de acessar um atributo ou método através de um ponteiro é chata e trabalhosa: o operador * precisa ir dentro de parêntesis, e depois temos que usar o operador ponto 😵‍💫... pode ficar um pouco confuso...

Porém, com o operador seta - > podemos acessar os atributos e métodos através de um ponteiro rapidamente:

n o m e P o n t e i r o   - > n o m e A t r i b u t o n o m e P o n t e i r o   - > n o m e M e t o d o ( )

Ou seja, sempre que você vir ou usar o operador - > você sabe que está usando um ponteiro para acessar o conteúdo de um objeto.

Podemos reescrever o último segmento do exemplo anterior assim:

Ponteiro t h i s

O C++ possui alguns detalhes especiais que podem ajudar na escrita do seu código. Um deles é o ponteiro t h i s .

Esse é um ponteiro especial que pode ser usando dentro da classe para se referir aos elementos internos.

Na grande maioria dos casos, o uso do t h i s é opcional. Porém, uma situação em que o uso do t h i s é obrigatório é quando você tiver um parâmetro de método que tenha o mesmo nome que um atributo da classe. Olha esse exemplo.

Alocação dinâmica de objetos.

Uma coisa que você não pode esquecer é que a principal vantagem trazida pelos ponteiros é a alocação dinâmica de memória. E é claro que o C++ permite a alocação dinâmica de objetos!

O processo é o mesmo da alocação dinâmica de variáveis. Criamos um ponteiro para a classe desejada, e depois usamos o operador n e w   para encontrar um lugar disponível na memória. E quando o objeto não for mais necessário poderemos deletá-lo utilizando o d e l e t e

n o m e C l a s s e * n o m e P o n t e i r o ; n o m e P o n t e i r o = n e w   n o m e C l a s s e ;

d e l e t e   n o m e P o n t e i r o ;

Se for necessário, podemos criar uma array dinâmica de objetos utilizando os operadores n e w     e d e l e t e    

n o m e C l a s s e * n o m e P o n t e i r o ; n o m e P o n t e i r o = n e w   n o m e C l a s s e   10 ;

d e l e t e       n o m e P o n t e i r o ;

Ponteiros dentro de uma classe

Você deve se lembrar que ponteiros nada mais são do que um tipo especial de variável que guarda um endereço de memória. Então se você quiser criar um ponteiro que seja membro da classe, então é só declarar este ponteiro dentro da classe:

c l a s s   n o m e C l a s s e { a a a a t i p o * a t r i b u t o P o n t e i r o ; } ;

Os principais usos de ponteiros-membro é possibilitar que a classe utilize variáveis dinamicamente alocadas. Caso você use alocação dinâmica dentro de uma classe, não se esqueça de que vai precisar deletar a memória alocada em algum momento!

Bem, e por hoje é isso pessoal! Vamos agora para os exercícios de fixação!

Operador seta - >

Ponteiro t h i s

Alocação dinâmica de objetos.

Ponteiros dentro de uma classe

Exercícios Resolvidos

Exercício Resolvido #1

Crie uma classe chamada T e s t e que tenha um atributo público v a l o r . Crie um ponteiro que aponte para uma instância dessa classe, e sete o atributo v a l o r para 150 através do ponteiro. Utilizando o ponteiro imprima o atributo.

Passo 1

Vamos lá, galera.

Essa é uma questão que já dá o passo-a-passo pra gente. Ela quer que a gente crie uma classe, e use um ponteiro pra trabalhar com a classe.

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

Passo 2

O passo seguinte é desenvolver a classe T e s t e . É uma classe simples que contém apenas um único atributo público chamado v a l o r

Começamos declarando a classe:

Determinamos o escopo como público:

E declaramos o atributo:

E a classe está finalizada.

Passo 3

Belezinha. Vamos agora pra nossa m a i n (   ) . Para utilizar um ponteiro, vamos precisar criar um objeto da classe T e s t e e em seguida um ponteiro que aponte para esse objeto.

Primeiro, vamos criar um objeto:

Em seguida, vamos criar um ponteiro para T e s t e

E fazemos com que o ponteiro p n t O b j e t o aponte para o b j e t o

Passo 4

Show de bola! Com o ponteiro apontando para o objeto, só nos resta acessar o atributo v a l o r e modificá-lo

E em seguida vamos poder imprimir o número contido em v a l o r :

E prontinho! Terminamos a questão!

Resposta

Exercício Resolvido #2

Crie uma classe C i r c u l o com os atributos privado r a i o . Crie um método setter e um método para imprimir este atributo usando o ponteiro t h i s

Passo 1

Lets go!

Essa questão quer que a gente exercite o uso do ponteiro t h i s . Pra isso a gente vai criar uma classe com um atributo privado e usar o t h i s para desenvolver métodos.

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

Passo 2

Vamos lá desenvolver a classe. Começamos usando a palavra chave c l a s s para declarar a classe C i r c u l o

Então, dentro do contexto privado, vamos declarar o atributo r a i o :

Vamos continuar a construção dessa classe no próximo passo.

Passo 3

Beleza. Temos nossa classe com um atributo privado.

Ainda dentro da nossa classe vamos mudar para o contexto público e construir o nosso setter: uma função que não precisa de retorno e que recebe do usuário o valor do raio.

Usando o ponteiro t h i s e o operador - > podemos acessar o atributo r a i o e guardar o valor inserido pelo usuário nesse atributo.

Note que o atributo r a i o e o parâmetro r a i o têm o mesmo nome. Quando isso acontece, o uso do ponteiro t h i s é obrigatório!

No próximo passo a gente vai continuar trabalhando essa classe

Passo 4

Agora temos que desenvolver um método que acesse o valor do atributo r a i o e imprima na tela.

Vamos criar o método p r i n t R a i o que não retorna nem recebe nada.

Utilizando o comando c o u t vamos imprimir uma mensagem “Raio: v a l o r ” para o usuário.

Para acessar o valor do atributo r a i o podemos usar o ponteiro t h i s e o operador seta:

Nesse caso, o uso do ponteiro t h i s é opcional.

E prontinho. A classe está pronta.

Resposta

Exercício Resolvido #3

O código abaixo possui erros. Identifique e corrija os erros:

Passo 1

Questões de encontrar erros é sempre bom a gente analisar linha por linha.

Vamos começar observando o código da classe C o i s a . Aqui temos a declaração de dois atributos do tipo f l o a t e o desenvolvimento de um método i n i c i a l i z a C o i s a

Note o seguinte: os nomes dos parâmetros do método são iguais aos nomes dos atributos da classe. Quando isso acontece devemos usar o ponteiro t h i s para evitar ambiguidades.

Nas linhas 09 e 10 falta utilizar o ponteiro t h i s !

Corrigindo o código fica:

Passo 2

Agora vamos olhar a m a i n (   ) com carinho. Observando o plano geral vemos que na m a i n (   ) é instanciado um objeto e um ponteiro, o objeto é utilizado para inicializar os atributos e o ponteiro é usado para acessar estes atributos.

Agora vamos olhar linha por linha:

Nas linhas 16 e 17 é declarado um objeto o b j e t o C o i s a e apontamos o ponteiro p n t C o i s a para este objeto. Até aqui tudo certo.

Em seguida objeto o b j e t o C o i s a utiliza a função i n i c i a l i z a C o i s a , porém na linha 19 temos o uso errado do operador seta -   > . Este operador só pode ser utilizado com ponteiros, e o b j e t o C o i s a não é um ponteiro!

Na linha 19 temos o uso errado do operador seta.

Corrigindo, vamos substituir o operador seta pelo ponto:

Passo 3

Antes de continuar, você precisa lembrar que existem duas formas de usar um ponteiro para acessar um membro do objeto.

A primeira usa os operadores de desreferenciação * e ponto .

* n o m e P o n t e i r o . n o m e A t r i b u t o

E a segunda forma usa o operador seta -   > n o m e P o n t e i r o - > n o m e A t r i b u t o

Agora vamos dar uma olhada nos c o u t das linhas 21 e 22.

O primeiro c o u t tentou utilizar a primeira forma de acessar o atributo. Porém faltaram os parêntesis, e sem eles o código segue na precedência errada. Já o segundo c o u t fez uma mistura das duas formas de acessar, porém se a gente apagar o * vamos conseguir acessar pela segunda forma.

Na linha 21 falta o uso dos parêntesis, e na linha 22 o uso de * é desnecessário.

Corrigindo vamos ter:

E prontinho! Corrigimos todos os erros!

Resposta

Linhas 09 e 10 falta utilizar o ponteiro t h i s !

Linha 19 temos o uso errado do operador seta.

Linha 21 falta o uso dos parêntesis

Linha 22 o uso de * é desnecessário.

Exercício Resolvido #4

Crie uma classe C i r c u l o com os atributos privado r a i o . Usando o ponteiro t h i s crie um método setter e um método para imprimir o valor da área do círculo.

Em seguida, aloque dinamicamente um objeto da classe C i r c u l o , peça pro usuário o valor do raio e imprima a área.

Passo 1

Bora?! Pois vambora!

A questão quer que a gente crie uma classe simples que represente um círculo, e em seguida aloque um objeto dinâmico.

Então vamos começar com o cabeçalho do código. Vamos adicionar a c m a t h pois será útil para calcular o raio.

Passo 2

Vamos lá desenvolver a classe.

Começamos usando a palavra chave c l a s s para declarar a classe C i r c u l o . Então, dentro do contexto privado, vamos declarar os atributos r a i o e a r e a :

Mudando para o contexto público vamos construir um setter para alterar o valor do atributo r a i o , esse s e t t e r não precisa de retorno (tipo v o i d ) e recebe do usuário o valor do raio. Usando o ponteiro t h i s e o operador - > podemos acessar o atributo r a i o e guardar o valor inserido pelo usuário nesse atributo.

Note que o atributo r a i o e o parâmetro r a i o têm o mesmo nome. Quando isso acontece, o uso do ponteiro t h i s é obrigatório!

Agora temos que desenvolver um método que calcule a área e imprima o valor na tela.

Vamos criar o método p r i n t A r e a que não retorna nem recebe nada. Esse método acessa o atributo r a i o e calcula a área do círculo utilizando a função p o w ( ) e guarda o resultado no atributo A r e a . Para acessar o valor os atributos r a i o e A r e a podemos usar o ponteiro t h i s e o operador seta:

t h i s - > A r e a = 3.1415 * p o w ( t h i s - > r a i o , 2 )

Em seguida utiliza o comando c o u t para imprimir uma mensagem com o valor da área.

Nesse caso, o uso do ponteiro t h i s é opcional, pois poderíamos acessar o atributo A r e a sem utilizá-lo.

Passo 3

Show de bola. Agora vamos pra parte legal.

Vamos iniciar a m a i n (   ) . Dentro dela vamos precisar de uma variável que vai receber o valor do raio do usuário. O objetivo da questão é alocar um objeto dinamicamente. Então vamos precisar criar um ponteiro para a classe C i r c u l o

O próximo passo é criar o objeto dinâmico. Para isso vamos utilizar o operador n e w para encontrar um endereço de memória disponível onde poderemos alocar dinamicamente um objeto do tipo C i r c u l o

Passo 4

Agora é só alegria. O mais difícil já passou.

Vamos usar o c o u t e c i n para receber o valor do raio do usuário:

Passo 5

E agora a gente pode usar o ponteiro c i r para acessar o endereço de memória que foi alocado, e através do ponteiro vamos poder trabalhar com o objeto.

Usando o ponteiro e o operador seta podemos utilizar o método s e t R a i o para inicializar o valor do raio do círculo

E da mesma forma podemos usar o método p r i n t A r e a (   )

E dessa forma a questão tá praticamente pronta, pois conseguimos alocar um objeto dinâmico e acessá-lo através de um ponteiro.

Passo 6

Mas antes de finalizar a questão, nunca devemos nos esquecer de deletar os objetos criados dinamicamente:

E prontinho! Questão terminada.

Resposta

Exercício Resolvido #5

Crie uma classe que receba um valor inteiro do usuário e guarde este valor em uma variável alocada dinamicamente. A alocação dinâmica só deve ocorrer depois que o usuário inserir o valor desejado.

Passo 1

Vamos nessa, galerinha.

A questão tem um enunciado bem direto. Pra gente ter uma variável alocada dinamicamente, nós vamos precisar declarar um ponteiro dentro da nossa classe. Para evitar que o ponteiro seja usado fora da classe, esse ponteiro deverá ser privado.

Vamos precisar de um método que receba o valor do usuário, efetue a alocação dinâmica, e depois guarde o valor recebido dentro do espaço alocado.

Já que o ponteiro é privado, vamos precisar de um método g e t t e r que retorne o valor contido no espaço alocado.

E por último, e muito importante, a gente precisa de uma forma de deletar o espaço alocado quando ele deixar de ser útil. Então vamos precisar de um método que delete o espaço alocado.

Passo 2

Então vamos começar. Primeiro de tudo, vamos iniciar a nossa classe, que vamos chamar de D i n a m i c a

E dentro do contexto privado vamos declarar um ponteiro para inteiro chamado p n t V a r . Para criar um ponteiro dentro de uma classe é só a gente fazer do mesmo jeito que faria com um ponteiro qualquer:

t i p o * n o m e P o n t e i r o ;

No código fica:

Esse ponteiro vai ser utilizado no momento de alocar memória dinamicamente.

Vamos continuar a desenvolver a classe no próximo passo.

Passo 3

Agora vamos trabalhar os métodos.

Vamos mudar o contexto para público e começar um método que vai receber um valor inteiro do usuário e guardar esse valor em um espaço dinâmico na memória.

Dentro dessa função vamos começar alocando o espaço do tipo inteiro utilizando o operador n e w

E depois que o espaço estiver alocado, podemos armazenar o valor inserido no espaço. Pra isso, vamos acessar o espaço alocado através do ponteiro:

Passo 4

Lembre-se que o ponteiro que criamos é privado. Então precisamos de um método para acessar o valor armazenado dentro do ponteiro. Vamos então criar um método getter.

Esse getter vai simplesmente retornar o valor contido no ponteiro p n t V a r . Cuidado pra não esquecer do operador   * , pois é ele que acessa o valor contido no endereço de memória.

Passo 5

A gente tá trabalhando com uma variável alocada dinamicamente com o operador n e w . Então não podemos esquecer de que vamos precisar deletar o espaço alocado em algum momento.

Vamos criar uma função que vai ser responsável por isso. Essa função não precisa retornar nada, e nem precisa receber parâmetros. Porém, quando a função for chamada ela vai aplicar o d e l e t e sobre o ponteiro, para liberar o espaço alocado.

E com isso a classe está pronta, e a questão concluída!

Resposta

Exercício Resolvido #6

Considere a classe P e s s o a abaixo:

Escreva um programa em C++ que receba um valor n de entrada e, em seguida:

  • Aloque espaço dinamicamente na memória para criar um array de P e s s o a de n elementos.
  • Preencha o array criado com valores digitados pelo usuário;
  • Imprima o array preenchido na tela
  • Libere o espaço de memória alocado.

Passo 1

E aí, tranquilidade? Essa questão vai ser um pouco grandinha, mas você vai ver que é tranquila.

Antes de mais nada, observando a classe P e s s o a do enunciado vemos que temos uma variável do tipo s t r i n g . Então vai ser necessário adicionar o cabeçalho < s t r i n g >

Agora vamos falar um pouco sobre a questão. Ela quer que a gente crie um array dinâmico que armazena objetos da classe P e s s o a , imprima o conteúdo do array dinâmico, e depois apague o array dinâmico.

Pra facilitar a nossa vida, vai ser legal que a gente mexa um pouco na classe P e s s o a e adicione alguns métodos pra facilitar a nossa vida na hora de preencher e imprimir os atributos da classe.

Depois que a classe tiver adaptada, a gente vai pedir o valor de n pro usuário, e criar um array dinâmico com o tamanho n . E usando loops vamos preencher e imprimir cada um dos objetos armazenados no array

Passo 2

Ok, com o cabeçalho do código já feito, vamos adicionar a classe do enunciado ao nosso programa:

Show. Agora vamos mudar para o contexto público, e dentro dele vamos criar um método que nos ajude na hora de preencher essa classe.

Vamos criar o método p r e e n c h e P e s s o a , é bem simples, esse método vai usar o c o u t e c i n para pedir que o usuário preencha valores, e armazenar os valores inseridos nos atributos adequados. Esse método não precisa receber nenhum parâmetro, e não retornará nada, portanto será v o i d :

Ainda no espaço público, vamos criar um outro método que vai nos ajudar a imprimir o conteúdo da classe, chamado i m p r i m e P e s s o a que vai imprimir cada um dos atributos junto com uma mensagem adequada:

E pronto. Com isso a gente pode concluir a classe e partir pra m a i n (   )

Passo 3

Dentro da m a i n (   ) vamos começar declarando uma variável n e um ponteiro para P e s s o a chamado v e c P e s s o a .

E em seguida perguntamos pro usuário o valor de n :

E com o valor de n obtido podemos alocar dinamicamente um espaço na memória, com a seguinte sintaxe:

p o n t e i r o = n e w   n o m e C l a s s e [   t a m a n h o   ]

Ou seja, usaremos o operador n e w para alocar n espaços do tipo P e s s o a na memória, e guardar o endereço de memória desse espaço no ponteiro v e c P e s s o a :

E assim, a memória foi alocada dinamicamente.

Passo 4

Agora vamos preencher cada uma das pessoas.

Pra isso vamos usar um loop para acessar cada uma das posições do array v e c P e s s o a , e usando o operador ponto . vamos poder acessar os métodos contidos dentro do objeto. Ou seja, poderemos usar o método p r e e n c h e P e s s o a (   )

Iniciamos um loop que vai de 0 até n de um em um:

E em cada iteração vamos acessar a posição i de v e c P e s s o a e utilizar o método p r e e n c h e P e s s o a

E finalizamos o loop.

Passo 5

Para imprimir o conteúdo de cada um dos objetos vamos fazer a mesma coisa. Vamos acessar cada um dos elementos do array e utilizar o método i m p r i m e P e s s o a

Iniciamos um loop que vai de 0 até n de um em um:

E em cada iteração vamos acessar a posição i de v e c P e s s o a e utilizar o método i m p r i m e P e s s o a

E finalizamos o loop.

Passo 6

Show de bola! O vector dinâmico foi criado, preenchido e impresso!

Por último, mas não menos importante, a gente sempre tem que deletar elementos criados dinamicamente. Então vamos usar o operador d e l e t e   [   ] para deletar o array dinâmico:

E depois de deletar podemos finalizar o programa com segurança!

Resposta

Exercício Resolvido #7

Crie um programa que declare uma classe para o cadastro de alunos.

  • Deverão ser armazenados, para cada aluno: matrícula, nome e ano de nascimento.
  • Ao início do programa, o usuário deverá informar o número de alunos que serão armazenados
  • O programa deverá alocar dinamicamente a quantidade necessária de memória para armazenar os registros dos alunos.
  • O programa deverá pedir ao usuário que entre com as informações dos alunos.
  • Ao final, mostrar os dados armazenados e liberar a memória alocada.

Passo 1

E aí, vamos lá?

Pra resolver essa questão a gente vai precisar criar uma classe que armazene os dados de um aluno, e depois utilizar um array dinâmico para armazenar informações de n alunos

Essa classe vai precisar de três atributos nome, matrícula e ano de nascimento. E pra facilitar nossa vida, vai ser útil criar dois métodos pra ajudar a preencher e imprimir cada um dos objetos.

Depois de criar a classe, vamos perguntar quantos alunos o usuário vai querer cadastrar, e criaremos um vetor dinâmico com a quantidade adequada.

Mas vamos começar pelo cabeçalho do código. Como usaremos um atributo de nome, vai ser útil adicionar o cabeçalho < s t r i n g >

Passo 2

Ok, com o cabeçalho do código já feito, vamos desenvolver a classe. Vamos precisar de três atributos uma string chamada n o m e , um inteiro chamado m a t r i c u l a e outro inteiro chamado a n o N a s c i m e n t o . Todos serão privados, por questão de segurança.

Show. Agora vamos mudar para o contexto público, e dentro dele vamos criar um método que nos ajude na hora de preencher essa classe.

Vamos criar o método p r e e n c h e A l u n o , que utiliza o c o u t e c i n para pedir que o usuário preencha valores, e armazenar os valores inseridos nos atributos adequados.

Depois, vamos criar um método que vai nos ajudar a imprimir o conteúdo da classe, chamado i m p r i m e P e s s o a que vai usar o c o u t para imprimir cada um dos atributos junto com uma mensagem adequada:

E pronto, a classe está feita

Passo 3

Agora vamos para a m a i n (   ) , onde vamos começar declarando uma variável n que vai ser usada para armazenar a quantidade de alunos que o usuário quer cadastrar. E também um ponteiro a r r a y A l u n o que aponta para o tipo A l u n o e usaremos no processo de alocação dinâmica.

E em seguida perguntamos pro usuário o quantos alunos serão cadastrados:

E com o valor de n obtido podemos alocar dinamicamente um espaço na memória, com a seguinte sintaxe:

p o n t e i r o = n e w   n o m e C l a s s e [   t a m a n h o   ]

Ou seja, usaremos o operador n e w para alocar n espaços do tipo A l u n o na memória, e guardar o endereço de memória desse espaço no ponteiro a r r a y A l u n o s :

E assim, a memória foi alocada dinamicamente.

Passo 4

Agora vamos preencher cada um dos alunos.

Pra isso vamos usar um loop para acessar cada uma das posições do array a r r a y A l u n o s , e usando o operador ponto . vamos poder acessar os métodos contidos dentro do objeto. Ou seja, poderemos usar o método p r e e n c h e A l u n o (   )

Iniciamos um loop que vai de 0 até n de um em um:

E em cada iteração vamos acessar a posição i de a r r a y A l u n o s e utilizar o método p r e e n c h e A l u n o

E finalizamos o loop.

Passo 5

Para imprimir o conteúdo de cada um dos objetos vamos fazer a mesma coisa. Vamos acessar cada um dos elementos do array e utilizar o método i m p r i m e A l u n o

Iniciamos um loop que vai de 0 até n de um em um:

E em cada iteração vamos acessar a posição i de a r r a y A l u n o e utilizar o método i m p r i m e A l u n o

E finalizamos o loop.

Passo 6

E agora o mais difícil já foi: vector dinâmico criado, preenchido e impresso!

Por último, a gente só não pode esquecer de apagar os elementos criados dinamicamente. Então vamos usar o operador d e l e t e   [   ] para deletar o array dinâmico:

E depois de deletar podemos finalizar o programa com segurança!

Resposta

Exercício Resolvido #8

Crie uma classe que tenha como atributo um ponteiro. Essa classe deve ter um método que utiliza este ponteiro para criar um array dinâmico. Se necessário, crie mais métodos e atributos.

Passo 1

E aí, de boas na lagoa? Então vamos lá!

A questão tá pedindo pra gente criar uma classe que utilize array dinâmico. Esse tipo de classe pode ser bem útil quando nosso programa utiliza muitos arrays dinâmicos.

Pra esse tipo de classe funcionar vão ser necessários ao menos dois atributos: o ponteiro que guarda o endereço do array, e um atributo que armazene o tamanho do array.

Além disso, vamos precisar de alguns métodos: um método pra inicializar e preencher o array dinâmico, um método pra gente acessar o conteúdo do array. E claro, se estamos usando array dinâmico, vai ser necessário um método que libere a memória quando o array não for mais necessário, e assim evitaremos vazamento de memória!

Passo 2

Então vamos começar.

Vamos criar uma classe e chamá-la de V e t o r

E dentro do espaço privado, vamos criar os atributos necessários: o ponteiro * p n t V e t o r que vai armazenar o endereço de memória do array dinâmico, e o atributo t a m a n h o que vai armazenar a quantidade de elementos desse array dinâmico.

Nessa questão vamos criar um ponteiro do tipo inteiro. Mas se você quiser, pode criar classes que permitam vetores de qualquer outro tipo!

Passo 3

Agora vamos mudar para o espaço público e vamos criar os métodos.

O primeiro método que vamos criar é um que inicialize o array dinâmico. Vamos chamá-lo de s e t V e t o r , que será do tipo v o i d e vai precisar receber o tamanho do vetor que vai ser alocado.

Dentro desse método vamos alterar o conteúdo do atributo t a m a n h o , linha 09. Em seguida vamos usar o operador n e w para alocar dinamicamente um espaço de inteiros com o tamanho inserido pelo usuário, e o endereço de memória vai ser guardado no atributo ponteiro p n t V e t o r , linha 11.

E após criar o array dinâmico, pedimos pro usuário preencher cada uma das posições, linha 13 a 16.

Passo 4

Ainda no espaço público da nossa classe, vamos precisar de um método que permita a limpeza de memória. Afinal de contas, sempre que trabalhamos com memória alocada dinamicamente, precisamos garantir que a memória seja liberada!

Para isso vamos criar um segundo método chamado l i m p a M e m o r i a que quando chamado utiliza o operador d e l e t e   [   ] para apagar o conteúdo do endereço de memória apontado por p n t V e t o r .

Passo 5

Até agora tudo bem. Mas se você pensar bem, vai perceber que nessa classe não existe nenhuma forma de acessar o conteúdo do vetor! Afinal de contas, o ponteiro p n t V e t o r é um atributo privado.

Então, o que podemos fazer é criar um terceiro método que retorne pra gente o conteúdo de um espaço do vetor.

Vamos chamar esse método de índice. E a função desse método será receber o valor do índice do vetor e retornar o conteúdo daquele índice:

E prontinho! Uma versão básica da classe está criada, e a questão concluída. Mas se quiser se divertir, você pode adicionar mais métodos legais a esta classe 😊

Resposta