# Chapter 12. Operator Overloading

One of the goals of C# is to allow you to create new classes that
have all the functionality of built-in types such as integer (int)
and Boolean (bool). (See Chapter 5 for a
discussion of these intrinsic types.) For example, suppose you define
a type (Fraction) to represent fractional numbers. The following
constructors establish two Fraction objects, the first representing
^{1}/_{2}
and the second representing
^{3}/_{4}:

Fraction firstFraction = new Fraction(1,2); // create^{1}/_{2}Fraction secondFraction = new Fraction(3,4); // create^{3}/_{4}

The assumption here, of course, is that the first parameter will represent the numerator, and the second parameter will represent the denominator.

Ensuring that the Fraction class has all the functionality of the built-in types means that you must be able to perform arithmetic on instances of your fractions (e.g., add two fractions, multiply, etc.) and to convert fractions to and from built-in types such as int.

Hypothetically, you could implement methods for each of these operations. For example, for your Fraction type you might create an Add( ) method and invoke it by writing a statement such as:

// add^{1}/_{2}and^{3}/_{4}Fraction theSum = firstFraction.Add(secondFraction);

Although this will work, it is ugly and not how the built-in types are used. It would be much better to be able to write:

// add^{1}/_{2}and^{3}/_{4 }using + operator Fraction theSum = firstFraction + secondFraction;

Statements that use operators (in this case the plus sign) ...

Get *Learning C#* now with O’Reilly online learning.

O’Reilly members experience live online training, plus books, videos, and digital content from 200+ publishers.