Exercícios Resolvidos de Sobrecarga de operadores

Ver Teoria

Enunciado

Crie uma classe que representa um vetor de inteiros. O tamanho desse vetor deve ser definido dinamicamente no momento da criação do objeto. Efetue a sobrecarga do operador colchetes   para que a gente possa acessar facilmente um elemento do vetor.

Passo 1

Vamos nessa, pessoal.

Nesse exercício vamos trabalhar várias coisas.

A questão pede pra criar uma classe que represente um vetor, então vamos chamar essa classe de V e t o r .

Dentro da classe V e t o r vamos ter que usar um array para armazenar os elementos do nosso vetor. O detalhe é que esse array dentro da classe deve ser alocado. Se você se lembrar, a melhor forma de fazer isso é alocando a array dentro do construtor, e liberando a memória dentro do destruidor. Assim, nós garantimos que a memória dinâmica só vai existir enquanto um objeto da classe estiver ativo.

Mas além disso, esse também é um exercício de sobrecarga de operador, pois vamos sobrecarregar o operador   , pra gente poder acessar os elementos da array de forma direta.

Então vamos começar com o cabeçalho da classe:

Passo 2

Então vamos declarar a classe V e t o r , 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 * 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.

A questão pede que eles sejam do tipo inteiro.

Agora vamos para o encapsulamento público. Aqui vamos criar o protótipo de todas os nossos métodos

Primeiro declararmos o construtor, que vai efetuar a alocação dinâmica da array, e para isso vai receber o parâmetro t a m a n h o . Lembre-se que um construtor é um método sem tipo, com o mesmo nome da classe:

Depois declaramos o destruidor que vai liberar a memória alocada dinamicamente. Lembrando que um destruidor um método iniciado com ~ , sem tipo, sem parâmetros e com o mesmo nome da classe.

Agora vamos pensar na sobrecarga do operador   . O primeiro detalhe é que esse operador só pode ser sobrecarregado como função-membro da classe.

t i p o   o p e r a t o r   S i m b o l o D o O p e r a d o r   (   p a r a m e t r o s   )

O símbolo do operador é   , e o parâmetro que vamos receber é o índice a ser acessado. O segundo detalhe é que o tipo da função será i n t & !

Mas não perca a calma, que eu já te explico porque esse & apareceu aí...

Pronto. O protótipo da nossa classe está desenvolvido. O próximo passo é desenvolver o conteúdo dos métodos.

Passo 3

O primeiro método que vamos desenvolver é o construtor. Primeiro ele vai inicializar o parâmetro t a m a n h o :

Em seguida, alocamos no ponteiro p n t V e c t o r um array dinâmico com a dimensão t a m a n h o :

Prontinho! O array dinâmico foi criado com sucesso. Agora, vamos usar um loop f o r para pedir pro usuário preencher cada uma das posições do array:

Passo 4

Agora vamos desenvolver o destruidor, que tem função de liberar a memória que foi alocada dinamicamente. Para isso vamos usar 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 .

E é só isso. O destruidor está prontinho!

Passo 5

Agora vamos dar uma olhada detalhada na sobrecarga do operador   .

A principal função desse operador é mostrar o conteúdo existente um uma posição do array. Dentro do colchete a gente escreve um índice, e o operador sobrecarregado retorna a posição correspondente do array.

Ok, mas agora eu vou te explicar qual o motivo de usar o i n t & . Acontece que quando adicionamos o & estamos retornando uma referência ao endereço de memória! E isso é importante pois permite que a gente altere o conteúdo da array.

Veja os exemplos abaixo:

E é só isso! Usando o & no retorno da sobrecarga a gente possibilita mais usos do operador [   ] .

Com isso a classe está concluída, e só falta a gente testar.

Passo 6

Agora só falta a gente testar pra garantir que tudo funciona!

Vamos criar um objeto do tipo V e t o r e vamos inicia-lo com tamanho 5 . Assim que o objeto for criado o construtor vai entrar em ação, e vai pedir que a gente preencha o vetor.

Para fins de testes, vou imprimir o conteúdo da posição 3 . Em seguida vamos mudar o conteúdo da posição 3 para o valor 10 . E finalizamos comparando o conteúdo das posições 3 e 4 :

E pronto, vamos rodar o programa:

E o programa rodou tranquilamente. Logo de cara o construtor é acionado e podemos preencher o nosso array.

Mas o mais legal é que a gente pode visualizar, alterar e realizar operações com um elemento qualquer do vetor usando apenas o operador   , o que deixa o código muito mais limpo e simples de ler!

E veja só a última mensagem: é o destruidor entrando em ação.

E por hoje é isso! Até a próxima!

Resposta