Neste artigo, exploraremos outro conceito de orientação a objetos que facilita o manuseio do operador. Ou seja, entraríamos nos detalhes da Operadora Sobrecarga em C ++ . As dicas a seguir serão abordadas neste artigo,
- Sobrecarga em C ++
- Tipos de sobrecarga em C ++
- Por que a sobrecarga do operador é usada?
- Implementando sobrecarga de operador em C ++
- Tipos de abordagens de sobrecarga
- Sobrecarregando Operadores Unários
- Sobrecarregando operadores binários
Portanto, vamos começar com este artigo sobre sobrecarga de operador em C ++.
mensagem pop-up de script java
Sobrecarga em C ++
Se criarmos dois ou mais membros da mesma classe com o mesmo nome, mas diferentes em número ou tipo de parâmetro, isso é conhecido como sobrecarga de C ++.
Em C ++, podemos sobrecarregar:
- métodos
- construtores
- propriedades indexadas
É porque esses membros têm apenas parâmetros.
Continuando com este artigo sobre sobrecarga de operador em C ++.
Tipos de sobrecarga em C ++
- Sobrecarga de função
- Sobrecarga do operador
Continuando com este artigo sobre sobrecarga de operador em C ++.
Por que a sobrecarga do operador é usada?
Os programas C ++ podem ser escritos sem o conhecimento da sobrecarga do operador. Além disso, a operação do operador é profundamente usada pelos programadores para tornar o programa intuitivo. Por exemplo,
Podemos substituir o código como:
cálculo = adicionar (dividir (a, b), multiplicar (a, b))
Para equação
cálculo = (a / b) + (a * b)
A sobrecarga de operador fornece uma maneira simples e fácil de desenvolver novas definições para a maioria dos operadores em C ++. Com conhecimento suficiente, quase podemos criar uma nova linguagem própria pelo uso criativo da função e técnicas de sobrecarga de operador. Podemos sobrecarregar todos os operadores em C ++, exceto o seguinte:
● Operador de escopo (: :)
● Operador de tamanho (Sizeof)
● seletor de membros (.)
● seletor de ponteiro de membro (*)
● operador ternário (? :)
Sintaxe de sobrecarga de operador
return_type class_name:: operator op (argument_list) {// corpo da função}Onde o tipo de retorno é o tipo de valor retornado pela função. class_name é o nome da classe.
Continuando com este artigo sobre sobrecarga de operador em C ++.
Implementando sobrecarga de operador em C ++
A função do operador deve ser não estática (função de membro) ou função de amigo para ficar sobrecarregada. A função de sobrecarga de operador pode ser aplicada em uma função de membro se o operando esquerdo for um objeto dessa classe, mas se o operando esquerdo for diferente, a função de sobrecarga de operador deve ser definida como uma função não membro.
A função de sobrecarga do operador pode se tornar uma função amiga se exigir acesso aos membros privados e protegidos da classe. Por exemplo, o operador op é uma função de operador em que op é o operador que está sendo sobrecarregado e o operador é a palavra-chave. A sobrecarga do operador pode ser alcançada implementando uma função que pode ser função de membro, função de não membro ou função de amigo.
Qual é a diferença entre funções de operador e funções normais?
framework orientado a dados em exemplo de webdriver selênio
As funções do operador são iguais às funções normais. A única diferença é que o nome de uma função do operador é sempre a palavra-chave do operador seguida pelo símbolo do operador e as funções do operador são chamadas quando o operador correspondente é usado.
Continuando com este artigo sobre sobrecarga de operador em C ++.
Tipos de abordagens de sobrecarga
A sobrecarga do operador pode ser feita usando três abordagens, elas são
- Sobrecarregando operador unário.
- Sobrecarregando operador binário.
- Sobrecarregando o operador binário usando uma função de amigo.
Continuando com este artigo sobre sobrecarga de operador em C ++.
Sobrecarregando Operador Unário
Vamos considerar o operador unário ‘-’. Um operador menos, quando usado como unário, requer apenas um operando. Sabemos que este operador muda o sinal de um operando quando aplicado a uma variável de dados básicos. Vamos ver como sobrecarregar esse operador para que ele possa ser aplicado a um objeto da mesma forma que é aplicado a uma variável int ou float. O menos unário, quando aplicado a um objeto, deve diminuir cada um de seus itens de dados.
Exemplo:
#include using namespace std class Height {public: // Member Objects int feet, inch // Construtor para inicializar o valor do objeto Height (int f, int i) {feet = f inch = i} // Operador de sobrecarga (-) para realizar decremento // operação do objeto Height void operator- () {feet-- inch-- cout<< 'Feet & Inches after decrement: ' << feet << ' ' ' << inch < Resultado:
Explicação:
No exemplo acima, sobrecarregamos o operador unário ‘-’ para realizar o decréscimo nas duas variáveis da classe Height. Passamos dois parâmetros para o construtor e salvamos seus valores na variável pés e polegadas. Em seguida, definimos a função de sobrecarga do operador (void operator- ()
) em que as duas variáveis são diminuídas em uma posição.
Quando escrevemos -h1, ele chama a função de sobrecarga do operador e diminui os valores passados para o construtor.
Continuando com este artigo sobre sobrecarga de operador em C ++.
Sobrecarregando o operador binário
É uma sobrecarga de um operador operando em dois operandos. Vamos pegar o mesmo exemplo da classe Height, mas desta vez, adicione dois objetos Height h1 e h2.
Exemplo:
#include using namespace std class Height {public: int feet, inch Height () {feet = 0 inch = 0} Height (int f, int i) {feet = f inch = i} // Operador de sobrecarga (+) para executar adição de // dois objetos de distância usando o operador binário Operador de altura + (Altura & d2) // Chamada por referência {// Cria um objeto para retornar Altura h3 // Executa a adição de pés e polegadas h3.pé = pés + d2.pé h3. inch = inch + d2.inch // Retorna o objeto resultante return h3}} int main () {Height h1 (3, 7) Height h2 (6, 1) Height h3 // Use o operador sobrecarregado h3 = h1 + h2 cout<< 'Sum of Feet & Inches: ' << h3.feet << ''' << h3.inch << endl return 0 } Resultado:
Explicação:
Operador Height + (Height & h2), aqui return_type da função é a classe Height, portanto, ele retorna um objeto h3 da classe Height. Na linha h3 = h1 + h2, h1 chama a função de operador de seus objetos de classe e toma h2 como parâmetro, então aplicamos h3.feet = feet + d2.pé e h3.inch = inch + d2.inch que armazena o soma dos valores das variáveis pés e polegadas nas variáveis associadas ao objeto h3.
Quando a instrução ‘h3 = h1 + h2’ invoca a função sobrecarregada de operador, o objeto h1 assume a responsabilidade de invocar a função e h2 desempenha o papel de argumento que é passado para a função. A instrução de invocação acima é equivalente a h3 = h1.operator + (h2), portanto, o membro de dados de h2 é acessado diretamente e o membro de dados de h2 (que é passado como um argumento) é acessado usando o operador ponto.
Regras para sobrecarga do operador
- Apenas os operadores existentes podem ser sobrecarregados e novos operadores não podem ser sobrecarregados
- O operador sobrecarregado deve conter pelo menos um operando do tipo de dados definido pelo usuário.
- Não usamos uma função de amigo para sobrecarregar certos operadores. No entanto, as funções de membro podem ser usadas para sobrecarregar esses operadores.
- Quando os operadores unários são sobrecarregados por meio de uma função de membro, eles não aceitam argumentos explícitos, mas, se forem sobrecarregados por uma função amiga, levam um argumento.
- Quando os operadores binários são sobrecarregados por meio de uma função de membro, eles usam um argumento explícito e, se são sobrecarregados por meio de uma função amiga, eles usam dois argumentos explícitos.
Assim, chegamos ao fim deste artigo sobre ‘Sobrecarga de operador em C ++’. Se você deseja aprender mais, confira o Treinamento em Java da Edureka, uma empresa confiável de aprendizado online. Edureka's O curso foi desenvolvido para treiná-lo nos conceitos básicos e avançados do Java, juntamente com várias estruturas Java, como Hibernate e Spring.
Tem alguma questão para nós? Mencione isso na seção de comentários deste blog e entraremos em contato com você o mais breve possível.