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.
Crie também um método que permita acessar qualquer elemento do vetor.
Passo 1
Vamos nessa, pessoal.
Quando tratamos de classes que possuem alocação dinâmica, a gente deve sempre lembrar que uma alocação dinâmica, precisa de uma liberação dinâmica. Ou seja, se usamos o operador vamos ter que usar o operador .
Uma ideia interessante que podemos aplicar é usar o construtor para alocar a memória e depois usar o destruidor para liberar memória. Fazendo desse jeito a gente garante que o vetor dinâmico vai estar sempre disponível dentro da classe, e que quando a classe for destruída, a memória será liberada junto com a destruição da classe.
Então, vamos começar com o cabeçalho da classe:
![]()
Passo 2
Então vamos declarar a classe , e dentro da classe vamos declarar o protótipo de todos os métodos.
Primeiro criamos a classe:
![]()
E dentro do encapsulamento privado, vamos criar os atributos necessários: o ponteiro que vai armazenar o endereço de memória do array dinâmico, e o atributo 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!
![]()
Agora vamos para o encapsulamento público. Aqui vamos criar o protótipo de todas os nossos métodos
O primeiro método é o construtor, um método sem tipo com o mesmo nome da classe, que vai receber um único parâmetro , pois dentro desse método a gente vai criar a array dinâmica.
![]()
O segundo método necessário é o destruidor um método iniciado com , sem tipo, sem parâmetros e com o mesmo nome da classe, que vai ser responsável por liberar a memória.
![]()
E o último método será o que vai receber o valor do índice que queremos acessar, e vai retornar o item correspondente.
![]()
Pronto. O protótipo da nossa classe está desenvolvido. O próximo passo é desenvolver o conteúdo dos métodos.
Passo 3
Vamos desenvolver o construtor.
O construtor da classe terá três funções.
A primeira função é inicializar o atributo tamanho. O parâmetro do método e o atributo da classe tem o mesmo nome, então vamos usar o para evitar ambiguidades.
![]()
A segunda função do construtor é iniciar o array dinâmico. Então, vamos usar o operador para alocar dinamicamente um espaço com o tamanho , e o endereço de memória vai ser guardado no atributo ponteiro .
![]()
Prontinho! O array dinâmico foi criado com sucesso. Agora, vamos usar um loop para pedir pro usuário preencher cada uma das posições do vetor:

Passo 4
Agora vamos desenvolver o nosso destruidor.
A função do destruidor vai ser liberar a memória que foi alocada dinamicamente.
Para isso vamos desenvolver o método que vai utilizar o operador para apagar o conteúdo do endereço de memória apontado por .

E é só isso. O destruidor está prontinho!
Passo 5
Já desenvolvemos uma forma de criar e destruir um vetor dinâmico. Mas até agora, não temos nenhuma forma de acessar esse vetor.
Vamos desenvolver o método que vai dar acesso aos itens contidos na array dinâmica. Esse método vai receber o valor do índice do vetor e vai retornar o conteúdo daquele índice:

E prontinho. A classe está concluída.
Passo 6
Agora só falta a gente testar pra garantir que tudo funciona!
Vamos criar um objeto do tipo e vamos inicia-lo com tamanho . Assim que o objeto for criado o construtor vai entrar em ação, e vai pedir que a gente preencha o vetor. Depois vamos exibir o conteúdo de uma posição qualquer.

E pronto, vamos rodar o programa:

E o programa rodou tranquilamente. E veja só a última mensagem: é o destruidor entrando em ação.
Usando uma classe como essa a gente pode criar um montão de vetores dinâmicos sem nos preocuparmos em ficar usando o e o toda vez. É só criar um objeto e pronto!
E por hoje é isso! Até a próxima!
Resposta
