Operator Overloading:
In an OOP language like C#, Operator Overloading provides a Much More Natural way of Implementing the Operations on custom types. Suppose we have two Numbers, and we want to add these two Numbers, how to do it? well actually, it’s really simple to add two numbers using +(plus) Operator. but how about, if we want to add two objects? can we do it using +(plus) Operator? No, we can't, so in this case, we need overload this +(plus) Operator to perform addition on Objects.
Operator overloading provides a much natural abstraction for the types. When we think about a possible operation on some data type we can think of binary operators, unary operators, relational operators and perhaps some conversion operations to and from the basic types. In C# achieving all this is possible using operator overloading.
“
The mechanism of giving a special meaning to a standard C# operator with respect to a user-defined data type such as classes or structures is known as operator overloading.
How to Overload the Operator?
operator Overloading can be done by Implementing a Method which can be a Member Method of class, Non-member Method of class, or a Friend Method of class. but in this tutorial, we will Implement the Method as Member Method of class. To overload an Operator, we need to define a special Operator Method With Special Keyword operator followed by the symbol for the operator being denied. just similar to any other method, an overloaded operator has a return type and a parameter list. The basic Syntax for Operator Overloading:
Access-specifier Method-Name operator + ( Parameterlist)
{
//Method body
}
Let's have an Example here, where we will try to make addition of Objects. we will overload plus(+) Operator. and will apply on Object to add some numbers.
/*Example - Operator Overloading - InfoBrother*/
using System;
namespace OperatorOverloading
{
class Program
{
int L, M, N;
public Program() //constructor
{
L = M = N = 0;
}
//Constructor with parameter.
public Program(int X, int Y, int Z)
{
L = X;
M = Y;
N = Z;
}
//Method to overload Plus(+) Operator.
public static Program operator +(Program Obj1, Program Obj2)
{
Program result = new Program();
result.L = Obj1.L + Obj2.L;
result.M = Obj1.M + Obj2.M;
result.N = Obj1.N + Obj2.N;
return result;
}
//Method to Display Result:
public void show()
{
Console.WriteLine(L + " | " + M + " | " + N);
}
//main method:
static void Main(string[] args)
{
//Object Creation:
Program objA = new Program(5, 5, 5);
Program objB = new Program(10, 20, 30);
Program objC;
//Value of ObjA:
Console.WriteLine("The value of ObjA: ");
objA.show();
Console.WriteLine();
//Value of ObjB
Console.WriteLine("The value of ObjB: ");
objB.show();
Console.WriteLine();
//Addition of Object:
objC = objA + objB;
Console.WriteLine("Result of ObjA + ObjB: ");
objC.show();
Console.WriteLine();
Console.ReadKey();
}
}
}
Operator Overloading:
The value of ObjA: 5 | 5 | 5 The value of ObjB: 10 | 20 | 30 Result of ObjA + ObjB: 15 | 25 | 35
Overloadable and Non-Overloadable Operators.
In C# we can Overload some Operators, and some operators can't be overloaded. the following table describes the Overload Ability of the Operators in C#:
| Operators | Description |
|---|---|
We Can Overload These Operators: |
|
| +, -, !, ~, ++, --, true, false | These Unary Operators take one Operand and can be Overloaded. |
| +, -, *, /, %, &, |, ^, <<, >> | These Binary Operators take one Operand and can be Overloaded. |
| ==, !=, <, >, <=, >= | The comparison Operators can be Overloaded. |
| &&, || | The conditional logical operators cannot be overloaded, but they are evaluated using & and |, which can be overloaded. |
We Can Not Overload These Operators: | |
| [] | The Array Indexing Operator can't be Overloaded, but we can define indexers. |
| (T)x | The Cast Operator can't be Overloaded. but we can define new conversion Operators. |
| +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= | Assignment operators cannot be overloaded, but +=, for example, is evaluated using +, which can be overloaded. |
| =, (dot)., ?:, ??, ->, =>, f(x), as, checked, unchecked, default, delegate, is, new, sizeof, typeof | These Operators can't be Overloaded. |
Let's take an example here, where we will try to overload some more Operators.
/*Example - Operator Overloading - InfoBrother*/
using System;
namespace OperatorOvlApplication
{
class Box
{
private double length; // Length of a box
private double breadth; // Breadth of a box
private double height; // Height of a box
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;
}
// Overload + operator to add Boxes Object.
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;
}
// Overload == operator to compare two Boxes Object.
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;
}
// Overload != operator to Compare Boxes Object.
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;
}
// Overload < operator to Compare Boxes Object.
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;
}
// Overload > operator to Compare Boxes Object.
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;
}
// Overload <= operator to Compare Boxes Object.
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;
}
// Overload >= operator to Compare Boxes Object.
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 override string ToString()
{
return String.Format("({0}, {1}, {2})", length, breadth, height);
}
}
class Tester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // Declare Box1 of type Box
Box Box2 = new Box(); // Declare Box2 of type Box
Box Box3 = new Box(); // Declare Box3 of type Box
Box Box4 = new Box(); // Declare Box4 of type Box
double volume = 0.0; // Store the volume of a box here
// box 1 specification
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 specification
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
//displaying the Boxes using the overloaded ToString():
Console.WriteLine("Box 1: {0}", Box1.ToString());
Console.WriteLine("Box 2: {0}", Box2.ToString());
// volume of box 1
volume = Box1.getVolume();
Console.WriteLine("Volume of Box1 : {0}", volume);
// volume of box 2
volume = Box2.getVolume();
Console.WriteLine("Volume of Box2 : {0}", volume);
// Add two object as follows:
Box3 = Box1 + Box2;
Console.WriteLine("Box 3: {0}", Box3.ToString());
// volume of box 3
volume = Box3.getVolume();
Console.WriteLine("Volume of Box3 : {0}", volume);
//comparing the boxes
if (Box1 > Box2)
Console.WriteLine("Box1 is greater than Box2");
else
Console.WriteLine("Box1 is greater than Box2");
if (Box1 < Box2)
Console.WriteLine("Box1 is less than Box2");
else
Console.WriteLine("Box1 is not less than Box2");
if (Box1 >= Box2)
Console.WriteLine("Box1 is greater or equal to Box2");
else
Console.WriteLine("Box1 is not greater or equal to Box2");
if (Box1 <= Box2)
Console.WriteLine("Box1 is less or equal to Box2");
else
Console.WriteLine("Box1 is not less or equal to Box2");
if (Box1 != Box2)
Console.WriteLine("Box1 is not equal to Box2");
else
Console.WriteLine("Box1 is not greater or equal to Box2");
Box4 = Box3;
if (Box3 == Box4)
Console.WriteLine("Box3 is equal to Box4");
else
Console.WriteLine("Box3 is not equal to Box4");
Console.ReadKey();
}
}
}
Operator Overloading:
Box 1: (6, 7, 5) Box 2: (12, 13, 10) Volume of Box1 : 210 Volume of Box2 : 1560 Box 3: (18, 20, 15) Volume of Box3 : 5400 Box1 is greater than Box2 Box1 is less than Box2 Box1 is not greater or equal to Box2 Box1 is less or equal to Box2 Box1 is not equal to Box2 Box3 is equal to Box4
