Object Oriented Programming COP3330 / CGS5409
Arithmetic Operator Overloading Increment (++) / Decrement (--) In-class exercise
There are many operators available that work on built-in types, like int and double. Operator overloading Operator overloading -- is the creation of new versions of these operators for use with user- defined types. An operator operator in C++ is just a function function that is called with special notation (usually more intuitive or familiar notation). Overloading an operator simply involves writing a function. Operator overloading is done for the purpose of using familiar operator notation on programmer- programmer- defined defined types (classes).
Overloading an operator cannot change its precedence. Overloading an operator cannot change its associativity. It is not possible to create new operators -- only new versions of existing ones. Operator meaning on the built-in types cannot be changed.
Some operators can be written as member functions of a class Some operators can be written as stand-alone functions -- it's common to use friend on these Some operators can be written either way (your choice) A binary operator has two operands ◦ Written as a stand-alone function, both operands would be sent as parameters, so it would be a function with two parameters ◦ Written as a member function, the first operand would be the calling object , and the other would be sent as a parameter (i.e. a function with one parameter) A unary operator has one operand ◦ As a stand-alone function, the operand is sent as a parameter ◦ As a member function, one calling object, no parameters
An operator is just a function. This means that it must be created with a return type, a name, and a parameter list The rules above give some restrictions on the parameter list The name of an operator is always a conjunction of the keyword operator and the operator symbol itself. Examples: operator+ operator++ operator<< operator==
So the format of an operator overload declaration is just like that of a function, with the keyword operator as part of the name: returnType operator OperatorSymbol ( parameterList );
Consider the arithmetic operators. int x = 3, y = 6, z; float a = 3.4, b = 2.1, c; z = x + y; c = a / b; Now consider this notation. 1/2 + 1/3 // evaluates to 5/6 2/3 - 1/3 // evaluates to 1/3
Now, what about using arithmetic operators on our Fraction class (a user-defined type): Fraction n1, n2, n3; n3 = n1 + n2; // will the compiler accept this? It should be clear that this would not not make sense to the compiler. Fraction is a programmer-defined type. How would the computer know about common denominators, etc? These code statements would be nice to use, however, because it's the same way we use other numeric types (like int and double). Operator overloading makes this possible
The arithmetic operators can be overloaded either as: stand-alone functions or member functions.
To add objects, we could write a function called Add, of course. Recall this example: friend Fraction Add(Fraction f1, Fraction f2); With this function prototype, a sample call would be: Fraction n1, n2, n3; n3 = Add(n1, n2);
The + notation would certainly be more convenient. The operator version just has a different name: friend Fraction operator+(Fraction f1, Fraction f2); The usual function style call would look like this: n3 = operator+(n1, n2); While this is legal, the advantage is being able to use the more common infix notation: n3 = n1 + n2; // this becomes legal
Here's a full definition of the + operator for class Fraction. Note that this is also a possible definition for the Add function: Fraction operator+(Fraction f1, Fraction f2) { Fraction r; // declare a Fraction for result // load result Fraction with sum numerators r.numerator = (f1.numerator*f2.denominator) + (f2.numerator*f1.denominator); // load result with the common denominator r.denominator = f1.denominator * f2.denominator; return r; // return the result Fraction }
Once this operator overload is defined, then the following is is legal. Note that cascading also works (because the operation returns a Fraction). Now we have the standard intuitive use of + Fraction n1, n2, n3, n4, n5; n5 = n1 + n2 + n3 + n4; // now it is legal! Note: This function could also be written with const reference parameters friend Fraction operator+(const Fraction& f1, const Fraction& f2);
One member function version of Add was: Fraction Add(const Fraction& f) const; A sample call to this function: Fraction n1, n2, n3; n3 = n1.Add(n2);
The corresponding operator overload. Again, we change the name to operator+ Fraction operator+(const Fraction& f) const; Again, we could use typical function notation, and the dot- operator: n3 = n1.operator+(n2); But the whole point is to be able to use the more familiar notation, which still works, and no dot-operator required: n3 = n1 + n2; // n1 is calling object, n2 is argument
A full definition of this version of operator+ Fraction Fraction::operator+(const Fraction& f2) const { Fraction r; // result r.numerator = (numerator * f2.denominator) + (f2.numerator * denominator); r.denominator = (denominator * f2.denominator); return r; }
There are two two versions of ++, pre-increment and post-increment The pre-increment operator: Has one operand, which can be the calling object (member function) or a parameter (for non-member function implementation) Performs the increment, then returns the newly incremented object. The post-increment operator: Has one operand, officially. But to distinguish it from the pre- increment, an extra dummy parameter (int) is included. Performs the increment, but returns a copy of the object's previous value.
operator+= It is a binary operator. In this example, it's written as a member function, so it has one parameter. The second parameter is "added" to the calling object. Note that this is a shortcut assignment, so the left side (the calling object) is is changed. The right side (the parameter) is not not changed -- hence the parameter is passed as a const reference Note that the function returns *this. The keyword this is a pointer to the calling object (from inside a member funtion). So *this is the target -- i.e. the calling object itself Note that the return from this operator is an IntPair object, returned by reference by reference.
IntPair class IntPair v2 Version 2 uses the +=
Recommend
More recommend
