English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutorial Básico de C#

Tutorial Avançado de C#

C# Orientado a Objetos (OOP)

Sobrecarga de operadores no C#

Você pode redefinir ou sobrecarregar os operadores embutidos no C#. Portanto, os programadores também podem usar os operadores de tipos personalizados. A sobrecarga de operadores é uma função com nome especial, acessada pela palavra-chave operator definidos seguidos pelo símbolo do operador. Como outras funções, a sobrecarga de operadores tem tipo de retorno e lista de parâmetros.

Por exemplo, veja a função a seguir:

public static Box operator+　(Box b, Box c)
{
　　　Box box = new Box();
　　　box.length = b.length　+　c.length;
　　　box.breadth = b.breadth　+　c.breadth;
　　　box.height = b.height　+　c.height;
　　　return box;
}

A função acima implementa o operador de adição para a classe Box personalizada do usuário (+）。Ele adiciona os atributos de dois objetos Box e retorna o objeto Box somado.

Implementação de sobrecarga de operadores

O seguinte programa demonstra a implementação completa:

using System;
namespace OperatorOvlApplication
{
　　　class Box
　　　{
　　　　　　private double length;　　　　　　//　comprimento
　　　　　　private double breadth;　　　　　//　largura
　　　　　　private double height;　　　　　　//　altura
　　　　　　public double getVolume()
　　　　　　{
　　　　　　　　　return length　*　breadth　*　height
　　　　　　}
　　　　　　public void setLength(double len)
　　　　　　{
　　　　　　　　　length = len;
　　　　　　}
　　　　　　public void setBreadth(double bre)
　　　　　　{
　　　　　　　　　breadth = bre;
　　　　　　}
　　　　　　public void setHeight(double hei)
　　　　　　{
　　　　　　　　　height = hei;
　　　　　　}
　　　　　　//　sobrecarga　+　operador para somar dois objetos Box
　　　　　　public static Box operator+　(Box b, Box c)
　　　　　　{
　　　　　　　　　Box box = new Box();
　　　　　　　　　box.length = b.length　+　c.length;
　　　　　　　　　box.breadth = b.breadth　+　c.breadth;
　　　　　　　　　box.height = b.height　+　c.height;
　　　　　　　　　return box;
　　　　　　}
　　　}
　　　class Tester
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　Box Box1　= new Box();　　　　　　　　　//　declarar Box1de tipo Box
　　　　　　　　　Box Box2　= new Box();　　　　　　　　　//　declarar Box2de tipo Box
　　　　　　　　　Box Box3　= new Box();　　　　　　　　　//　declarar Box3de tipo Box
　　　　　　　　　double volume = 0.0;　　　　　　　　　　//　volume
　　　　　　　　　//　Box1　detalhamento
　　　　　　　　　Box1.setComprimento(6.0);
　　　　　　　　　Box1.setLargura(7.0);
　　　　　　　　　Box1.setHeight(5.0);
　　　　　　　　　//　Box2　detalhamento
　　　　　　　　　Box2.setComprimento(12.0);
　　　　　　　　　Box2.setLargura(13.0);
　　　　　　　　　Box2.setHeight(10.0);
　　　　　　　　　//　Box1　volume do Box
　　　　　　　　　volume = Box1.getVolume();
　　　　　　　　　Console.WriteLine("Box1　volume: {0}
　　　　　　　　　//　Box2　volume do Box
　　　　　　　　　volume = Box2.getVolume();
　　　　　　　　　Console.WriteLine("Box2　volume: {0}
　　　　　　　　　//　somar dois objetos
　　　　　　　　　Box3　Igual a Box1　+　Box2;
　　　　　　　　　//　Box3　volume do Box
　　　　　　　　　volume = Box3.getVolume();
　　　　　　　　　Console.WriteLine("Box3　volume: {0}
　　　　　　　　　Console.ReadKey();
　　　　　　}
　　　}
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Box1　Volume:　210
Box2　Volume:　1560
Box3　Volume:　5400

Operadores sobrecarregáveis e não sobrecarregáveis

A tabela a seguir descreve as capacidades de sobrecarga de operadores no C#:

OperadorDescrição
+, -, !, ~, ++, --Esses operadores unários têm apenas um operando e podem ser sobrecarregados.
+, -, *, /, %Esses operadores binários têm dois operandos e podem ser sobrecarregados.
==, !=, <, >, <=, >=Esses operadores de comparação podem ser sobrecarregados.
&&, ||Esses operadores lógicos de condição não podem ser sobrecarregados diretamente.
+=, -=, *=, /=, %=Esses operadores de atribuição não podem ser sobrecarregados.
=, ., ?:, ->, new, is, sizeof, typeofEstes operadores não podem ser sobrecarregados.

exemplo online

Para expandir o exemplo discutido acima, vamos sobrecarregar mais operadores:

using System;
namespace OperatorOvlApplication
{
　　　　class Box
　　　　{
　　　　　　　private double length;　　　　　　//　comprimento
　　　　　　　private double breadth;　　　　　//　largura
　　　　　　　private double height;　　　　　　//　altura
　　　　　　
　　　　　　　public double getVolume()
　　　　　　　{
　　　　　　　　　return length　*　breadth　*　height
　　　　　　　}
　　　　　　public void setLength(double len)
　　　　　　{
　　　　　　　　　　length = len;
　　　　　　}
　　　　　　public void setBreadth(double bre)
　　　　　　{
　　　　　　　　　　breadth = bre;
　　　　　　}
　　　　　　public void setHeight(double hei)
　　　　　　{
　　　　　　　　　　height = hei;
　　　　　　}
　　　　　　//　sobrecarga　+　operador para somar dois objetos Box
　　　　　　public static Box operator+　(Box b, Box c)
　　　　　　{
　　　　　　　　　　Box box = new Box();
　　　　　　　　　　box.length = b.length　+　c.length;
　　　　　　　　　　box.breadth = b.breadth　+　c.breadth;
　　　　　　　　　　box.height = b.height　+　c.height;
　　　　　　　　　　return box;
　　　　　　}
　　　　　　
　　　　　　public static bool operator ==(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.length == rhs.length && lhs.height == rhs.height　
　　　　　　　　　　　　　&& lhs.breadth == rhs.breadth)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator !=(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.length != rhs.length || lhs.height != rhs.height　
　　　　　　　　　　　　　　|| lhs.breadth != rhs.breadth)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator <(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.comprimento < rhs.comprimento && lhs.altura　
　　　　　　　　　　　　　　< rhs.height && lhs.largura < rhs.largura)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator >(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.comprimento > rhs.comprimento && lhs.altura　
　　　　　　　　　　　　　　> rhs.height && lhs.largura > rhs.largura)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator <=(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.comprimento <= rhs.comprimento && lhs.altura　
　　　　　　　　　　　　　　<= rhs.height && lhs.largura <= rhs.largura)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public static bool operator >=(Box lhs, Box rhs)
　　　　　　{
　　　　　　　　　　bool status = false;
　　　　　　　　　　if (lhs.comprimento >= rhs.comprimento && lhs.altura　
　　　　　　　　　　　　　>= rhs.height && lhs.largura >= rhs.largura)
　　　　　　　　　　{
　　　　　　　　　　　　　　status = true;
　　　　　　　　　　}
　　　　　　　　　　return status;
　　　　　　}
　　　　　　public override string ToString()
　　　　　　{
　　　　　　　　　　return String.Format("({0}, {1}, {2})", comprimento, largura, altura);
　　　　　　}
　　　
　　　}
　　　　
　　　class Tester
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　Box Box1　= new Box();　　　　　　　　　　//　declarar Box1de tipo Box
　　　　　　　　Box Box2　= new Box();　　　　　　　　　　//　declarar Box2de tipo Box
　　　　　　　　Box Box3　= new Box();　　　　　　　　　　//　declarar Box3de tipo Box
　　　　　　　　Box Box4　= new Box();
　　　　　　　　double volume = 0.0;　　　//　volume
　　　　　　　　//　Box1　detalhamento
　　　　　　　　Box1.setComprimento(6.0);
　　　　　　　　Box1.setLargura(7.0);
　　　　　　　　Box1.setHeight(5.0);
　　　　　　　　//　Box2　detalhamento
　　　　　　　　Box2.setComprimento(12.0);
　　　　　　　　Box2.setLargura(13.0);
　　　　　　　　Box2.setHeight(10.0);
　　　　　　　//　usar o ToString() sobrecarregado para mostrar os dois caixas
　　　　　　　　Console.WriteLine("Box1: {0}1.ToString());
　　　　　　　　Console.WriteLine("Box2: {0}2.ToString());
　　　　　　　　
　　　　　　　　//　Box1　volume do Box
　　　　　　　　volume = Box1.getVolume();
　　　　　　　　Console.WriteLine("Box1　volume: {0}
　　　　　　　　//　Box2　volume do Box
　　　　　　　　volume = Box2.getVolume();
　　　　　　　　Console.WriteLine("Box2　volume: {0}
　　　　　　　　//　somar dois objetos
　　　　　　　　Box3　Igual a Box1　+　Box2;
　　　　　　　　Console.WriteLine("Box3: {0}3.ToString());
　　　　　　　　//　Box3　volume do Box
　　　　　　　　volume = Box3.getVolume();
　　　　　　　　Console.WriteLine("Box3　volume: {0}
　　　　　　　　//comparando os caixas
　　　　　　　　Se Box1　> Box2)
　　　　　　　　　　Console.WriteLine("Box1　maior que Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Não Maior que Box2");
　　　　　　　　Se Box1　< Box2)
　　　　　　　　　　Console.WriteLine("Box1　Menor que Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Não Menor que Box2");
　　　　　　　　Se Box1　Maior que Box2)
　　　　　　　　　　Console.WriteLine("Box1　Maior ou Igual a Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Não Maior ou Igual a Box2");
　　　　　　　　Se Box1　Menor ou Igual a Box2)
　　　　　　　　　　Console.WriteLine("Box1　Menor ou Igual a Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Não Menor ou Igual a Box2");
　　　　　　　　Se Box1　Diferente de Box2)
　　　　　　　　　　Console.WriteLine("Box1　Diferente de Box2");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box1　Igual a Box2");
　　　　　　　　Box4　Igual a Box3;
　　　　　　　　Se Box3　Igual a Box4)
　　　　　　　　　　Console.WriteLine("Box3　Igual a Box4");
　　　　　　　　else
　　　　　　　　　　Console.WriteLine("Box3　Diferente de Box4");
　　　　　　　　Console.ReadKey();
　　　　　　}
　　　　}
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Box1：(6,　7,　5)
Box2：(12,　13,　10)
Box1　Volume:　210
Box2　Volume:　1560
Box3：(18,　20,　15)
Box3　Volume:　5400
Box1　Não Maior que Box2
Box1　Menor que Box2
Box1　Não Maior ou Igual a Box2
Box1　Menor ou Igual a Box2
Box1　Diferente de Box2
Box3　Igual a Box4
Namespace do C#Polimorfismo do C#