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
