Sobrecarga de operadores

No C++ nós temos diversos operadores que ajudam a realizar diversas operações com os tipos primitivos da linguagem. Alguns operadores são binários (exemplo: ) e recebem dois parâmetros, outros são unários (exemplo: ) e recebem somente um parâmetro, e outros podem ter comportamento binário ou unário dependendo da quantidade de parâmetros (exemplo: )

A sobrecarga de operadores é uma forma de adaptar estes operadores para funcionar com as classes customizadas que criamos. Basicamente, para executar uma sobrecarga de operadores tudo que precisamos fazer é escrever uma função utilizando a palavra-chave e o símbolo do operador como nome da função.

A sobrecarga é muito útil pois facilita o uso das classes e objetos, deixando a escrita e leitura do código mais simples, ajudando o programador a desenvolver classes melhores, principalmente quando as boas práticas são executadas.

Vamos lá pessoal. Essa é uma questão de sobrecarga de operadores.

O exercício já nos deu uma classe e quer que a gente implemente as sobrecargas para os operadores binários e

Então, pra começar, vamos escrever a classe que a questão deu pra gente:

Vamos sobrecarregar cada um dos operadores, um de cada vez. Vamos começar com o operador de adição .

Para sobrecarregar um operador é parecido com criar uma função, porém o nome da função é formado pela palavra chave e o símbolo do operador.

Para sobrecarregar o operador binário precisaremos receber dois parâmetros do tipo , e a função deve retornar um resultado do tipo

No código teremos:

Em seguida fazemos o corpo da sobrecarga.

Primeiro precisamos de uma variável de apoio do tipo chamada . Depois, somamos os componentes e dos pontos e , e guardamos os resultados nas componentes de . E por fim, usamos o comando para retornar o ponto .

O próximo operador é o binário, que vai receber dois pontos como parâmetros e efetuar uma subtração entre os pontos.

No código teremos:

O desenvolvimento do corpo da sobrecarga é muito similar ao anterior, precisamos de uma variável de apoio , onde vamos guardar o resultado da subtração dos componentes e de . Usamos o comando para retornar o ponto .

O último operador é o binário, que executa o produto dos componentes de dois pontos:

No código:

E vamos construir o corpo da operação mais uma vez. Criamos uma variável do tipo , e nas componentes de guardamos o resultado do produto das componentes de e :

E isso finaliza a nossa classe e nossas sobrecargas.

Vamos lá pessoal. A questão pede pra gente sobrecarregar os operadores e .

Então, pra começar, vamos escrever a classe que a questão deu pra gente:

Olha que legal, a classe já possui um protótipo chamado , então podemos desenvolver esse método e depois a gente usa na hora de sobrecarregar o operador .

Vamos começar desenvolvendo o método .

Este método é uma função-membro da nossa classe, então vamos usar o antes do nome do método.

Essa função apenas vai imprimir os valores contidos nos componentes e da função.

Show, agora vamos pra parte principal da questão, a sobrecarga do operador

Lembre-se que o é um objeto da classe , e teremos que levar isso em consideração na hora de sobrecarregar o nosso operador.

A forma padrão para sobrecarregar o operador para uma classe qualquer é a seguinte

Já o corpo da sobrecarga é composto por uma sucessão de usos do . Porém, nós já fizemos o método , então podemos só invocar este método

Um detalhe é que o parâmetro pode ter qualquer nome, o importante é que seja retornado no final da sobrecarga.

O próximo passo é sobrecarregar o operador , mas não esqueça que o é um objeto da classe .

Então, para sobrecarregar o operador para a classe devemos fazer assim:

Importante: não esqueça de passar o objeto por referência usando o . Passar por referência é necessário para poder alterar o objeto e inserir o valor no objeto.

No corpo da sobrecarga nós utilizamos o objeto para inserir os valores digitados nos atributos adequados da classe.

O nome do parâmetro também pode ser modificado, o importante é que esse parâmetro seja retornado no fim da sobrecarga.

A classe está construída e as sobrecargas estão feitas. Agora vamos testar!

Dentro da função vamos instanciar um objeto da classe

Como os operadores estão sobrecarregados, podemos pedir pro usuário inserir dois valores, e usar o diretamente para armazenar os valores no objeto , como fazemos na linha 32.

E como os operadores estão sobrecarregados também podemos usar o para imprimir diretamente o objeto , como na linha 33.

O resultado é:

Vamos lá, galera.

A questão quer que a gente crie uma classe que represente os funcionários. Para inicializar o objeto no momento que é instanciado, vamos precisar criar um construtor.

Mas o ponto principal da questão é que ela pede que a gente sobrecarregue os operadores binários e para comparar o atributo salário.

Mas vamos começar com o cabeçalho: vamos inserir a classe para facilitar nossa vida.

Vamos construir a classe chamada .

Criamos os atributos privados: do tipo , e do tipo

Em seguida, vamos pro contexto público da nossa classe e vamos desenvolver o construtor. Criamos uma função sem tipo com o mesmo nome da classe (), e esta função receberá os parâmetros e (linha 12).

No corpo do construtor, vamos guardar os parâmetros recebidos nos atributos da classe (linhas 13 e 14).

Seguindo em frente, é hora da sobrecarga!

O objetivo é sobrecarregar os operadores e para comparar com o atributo , que é um atributo privado.

Para que os operadores tenham acesso ao atributo privado, o ideal é que eles sejam métodos da função! Então vamos sobrecarregar como função membro, para que a sobrecarga tenha acesso aos membros privados da classe.

Criamos a sobrecarga dentro da classe. A operação que queremos realizar deve retornar ou , então o tipo da sobrecarga é . Em seguida usamos a palavra chave seguida do símbolo .

O operador é binário, e por isso utiliza dois parâmetros. Mas como estamos criando a sobrecarga como função-membro, o primeiro parâmetro, por definição, é um objeto da própria classe . Então só precisamos adicionar um único parâmetro, que será outro objeto da classe

Dentro do método de sobrecarga, vamos comparar o atributo da classe com o atributo do objeto . O resultado dessa comparação é um valor booleano (1 ou 0), que vamos retornar.

Vamos efetuar o mesmo processo com o operador

E isso finaliza a nossa classe!

Mas antes de fechar a questão, vamos testar a nossa classe.

Dentro da vamos instanciar dois objetos, eu criei dois funcionários com nomes e salários aleatorios

E vamos imprimir uma comparação entre esses dois empregados:

O resultado que obtemos é:

Beleza, pessoal. A questão quer que a gente desenvolva uma classe que instancie um círculo usando um construtor, e que use o operador para verificar interseção entre dois círculos.

Para verificar se dois círculos se interceptam precisamos considerar a distância entre os centros e os raios e das circunferências:

Mas vamos começar pelo cabeçalho!

Vamos incluir a para facilitar as contas que vamos fazer.

Beleza, partimos agora pra criação da classe

Usamos o comando e para desenvolver uma classe chamada . No contexto privado dessa classe vamos declarar três atributos, para o raio e e para a posição do centro da circunferência:

Ainda dentro do contexto privado vamos desenvolver um método chamado que calcula a distância entre este círculo e um segundo círculo.

Nós já temos acesso aos dados de um dos círculos, mas vamos precisar receber o segundo círculo como argumento da função.

Matematicamente, a distância entre o centro dos dois círculos é dada por:

Vamos implementar isso no nosso código. Criamos as variáveis auxiliares e que armazenam a subtração dos atributos dos dois círculos.

Em seguida usamos as funções e (contidas no cabeçalho ) para calcular a distância, e armazenamos na variável auxiliar . O método é finalizado retornando o resultado de

Show de bola, agora vamos mudar nossa classe pro contexto público, e vamos desenvolver um construtor.

Não se esqueça que para fazer um construtor é só declarar um método sem tipo e com o mesmo nome da classe. 😉

Esse construtor irá receber três parâmetros , e , e usaremos esses argumentos para preencher os valores do objeto.

Agora vamos para a parte principal da questão. Vamos desenvolver uma sobrecarga no operador para informar quando dois círculos possuem intersecção. Para isso o operador é binário.

Note o seguinte, o exercício não pede a quantidade de interseções. Apenas quer saber se as interseções existem ou não, em outras palavras, se a existência de interseção é verdadeira ou falsa. Essa interpretação diz pra gente que o resultado de é um valor booleano.

Outra coisa é que os valores que vamos trabalhar são o raio, e a posição , que são atributos privados. Então vai ser mais fácil desenvolver a sobrecarga como função-membro da classe.

Então, mãos à obra: o método de sobrecarga é do tipo , usamos a palavra-chave e o símbolo para indicar o operador que será sobrecarregado, e recebe um objeto da classe como argumento.

Lembre-se que em sobrecargas como função-membro o primeiro argumento é a própria classe, e por isso só precisamos de um único argumento como parâmetro.

Agora vamos desenvolver o corpo do método de sobrecarga. A questão só quer saber da existência de intersecções, então basta a gente usar um para testar os seguintes dois casos:

Vamos testar os dois casos em que não existe interseção. Caso nenhum deles seja verdadeiro, então a interseção existe.

Mas antes vamos precisar definir qual é o maior e o menor raio. Pra isso usamos as funções e presentes na . E usando o método calculamos a distância entre os centros das circunferências.

E isso finaliza a sobrecarga da classe, e podemos finalizar a classe.

Agora só nos resta testar, pra ver se deu tudo certo.

Vamos criar dois objetos do tipo , com os valores determinados no enunciado da questão: de raio 1 e centro e o de raio e centro .

E agora vamos utilizar a operação . Usando o podemos imprimir uma mensagem e o resultado.

E o resultado é:

Pra não ficar nenhuma dúvida, eu plotei essas circunferências numa calculadora gráfica e temos o seguinte:

O que mostra que nosso programa está funcionando.

E aí, beleza?

A questão pede pra gente desenvolver uma classe com um sobrecarregado. Esse operador é baseado na classe padrão , e por isso a sobrecarga dele é um pouco diferente, como vamos ver.

Mas vamos começar escrevendo o cabeçalho. Vamos inserir a biblioteca para nos ajudar.

Vamos desenvolver a classe .

Em escopo privado vamos declarar três atributos básicos , e .

Para inicializar os atributos privados vamos desenvolver um método construtor. Lembre-se que o construtor é um método sem tipo com o mesmo nome da classe. O construtor vai receber como parâmetro os valores dos atributos.

Vamos desenvolver um método que imprime os atributos da classe. Esse método é útil pois será usado como parte da sobrecarga do operador.

O é um objeto da classe , e por isso o operador deve levar isto em consideração.

O processo da sobrecarga é:

No nosso caso, a classe é e o objeto vamos chamar de .

Dentro do método vamos nós escrevemos todos os que queremos que sejam executados quando a sobrecarga for utilizada.

Porém, a gente foi esperto e já escreveu tudo isso dentro do método , então é só executar esse método dentro da função de sobrecarga:

E pronto! Sobrecarga concluída.

Agora vamos testar o código

Criamos um objeto da classe chamado e usamos o construtor para inicializar o objeto.

Depois executamos o diretamente no objeto

Rodando o código o resultado é:

E é isso! Questão concluída.

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 .

Dentro da classe 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:

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.

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 . 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.

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á !

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.

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

Em seguida, alocamos no ponteiro um array dinâmico com a dimensão :

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 array:

Agora vamos desenvolver o destruidor, que tem função de liberar a memória que foi alocada dinamicamente. Para isso vamos usar o operador para apagar o conteúdo do endereço de memória apontado por .

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

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 . 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.

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.

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

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!