CIS 3142 — Operator OverloadingLecture 4

CISC 3142
Programming Paradigms in C++
Operator Overloading

Overview

Operator overloading allows user-defined types to be used a naturally as predefined types:

<< can be defined (and used conveniently) on any type

rational and complex numbers can use the usual (and familiar) arithmetic operators:

Rational 
	r1(10, 3),	// 10/3
	r2 = 5;		// 5/1

Rational r3 = r1 + r2;			// overloaded + … instead of r1.add(r2)
cout << r3 << endl;	// overload <<

various containers can use familiar operators:

set s1, s2;		// sets of integers — similar high-level semantics to Java's generics

s1 += 5;				// 'in-place' insertion of 5 into s1 ... Java doesn't have this
s2 = s1 + 5;			// creates a new set adding 5 to s1 and assigns it to s2 … instead of s2 = s1.add(5);

A Trivial Integer Class

Reminiscent of Java's Integer Wrapper Class
- C++ has no need for such wrapper classes:
  - integer-manipulating functions can be written as non-member (C-style) functions, so there is no need to have a class to contain them
  - when we discuss templates, we'll see there's no need to wrap primitives in order to place them in containers
Essentially useless class developed and presented merely for the purpose of a simple introduction to operator overloading.
We'll start with a simple implementation and incrementally expand it's 'user-friendliness'.
- Reminiscent of Java's Integer Wrapper Class
  - C++ has no need for such wrapper classes:
    - integer-manipulating functions can be written as non-member (C-style) functions, so there is no need to have a class to contain them
    - when we discuss templates, we'll see there's no need to wrap primitives in order to place them in containers
- Essentially useless class developed and presented merely for the purpose of a simple introduction to operator overloading.

Version 1

Most basic functionality:
- Single arg constructor passed the valued to be placed in the val data member
- A print function that sends the object's value to a single output, cout
  - The function is declared as having a const receiver since printing an object doesn't change it
- An add function that produces and returns a new Integer object containing the sum of the values of the receiver and argument
  - The receiver is passed as a const since it is not being modified
  - The argument is passed by const-reference since it's an object that is not being modified.
  - The result is returned by-value, since it is a local object that will be going out of scope.
  - The function:
    - declares a local Integer object named result (which will be destroyed upon exit), passing the constructor the value of the val data member of the receiver.
    - adds to result's val data member the value of the val data member of the parameter other
    - returns result; a full copy of the object it made since the function uses return by-value

Operators

C++ treats operators as simply functions with symbolic names prefixed by the keyword operator
Here is a complete list of operators in C/C++.

Operators can be invoked either using operator notation (e.g., a + b) or the more conventional function notation (e.g., a.operator +(b) (for a member operator) or operator +(a, b) (for a non-member operator) — here are some examples:

Operator Symbol Function Name Operator notation Member Function Notation Non-member Functional Notation

+ operator + a + b a.operator +(b) operator +(a, b)
++ operator ++ ++a a.operator ++() operator ++(a)
= operator = a = b a.operator =(b)
== operator == a == b a.operator ==(b) operator ==(a, b)
[] operator [] a[i] a.operator[](index)
() operator () a(i) a.operator()(...)
-> operator -> a -> b a.operator ->()

Operator Symbol	Function Name	Operator notation	Member Function Notation	Non-member Functional Notation
+	operator +	a + b	a.operator +(b)	operator +(a, b)
++	operator ++	++a	a.operator ++()	operator ++(a)
=	operator =	a = b	a.operator =(b)
==	operator ==	a == b	a.operator ==(b)	operator ==(a, b)
[]	operator []	a[i]	a.operator[](index)
()	operator ()	a(i)	a.operator()(...)
->	operator ->	a -> b	a.operator ->()

Note that some operators cannot be declared as non-members;

The 'hard' part is understanding how the parameters 'fit in'
- For example, what is the signature of the () operator, how is it invoked, and how might it be useful
The number of parameters as well as the precedence cannot be changed

Motivation for Various Operators

<<
- Allows user-defined objects to be output in a manner identical to fundamental types
==
- Allows for equality testing of user-defined objects
+, +=
- Allows classes like Complex, Matrix to employ conventional notation
- No intrinsic semantic relationship between a simple operator and its compound assignment counterpart; any such relationship is the responsibility of the class designer.
=
- Allows user-defined semantics for assignment to an object of a class
[]
- Allows various container classes (vector and map) to employ a natural syntax for modifying/accessing elements
*, ++
- Provides appropriate syntax for smart pointers and iterators
()
- Permits functor classes — classes whose objects can be called as if they were functions.

Member vs Non-member Operator overloading

as a member: an object of the class is the receiver of the function
- 'familiar' operators have one fewer parameter: int C::operator +(int i)
as a non-member: the operator (function) is a C-like function, i.e., it does not belong to any class.
Both member and non-member versions use the same operator notation; it's the function form that differs.
Unary operators should be made member functions
Binary operators:
- Should be made non-member (friend) if the semantics call for operand symmetry

Semantic Consistency Between Binary Operators and Their Compound Assignment Counterparts

No reason to 'primitively' implement both
- why go through the bother
- implementing one using the other maintains consistency of the operation's semantics

The return signatures are a direct consequence of the discussion above

Assuming the following class C:

class C {
	friend C operator +(const C &c1, const ∓c2);
public:
	…
	C &operator +=(const C &rhs);
private:
	int val;
};

we code the above operators in the following manner:

C &C::operator +=(const C &rhs) {
	val += rhs.val;
	return *this;
}

friend C operator +(const C &c1, const C &c2) {
	C temp = c1;
	return temp += c2;
}

more generally, given operators θ and θ=, which are semantically related; i.e., the latter performs the same operation as the former, but stores the result into the left hand operand, rather than resulting in a new object):
```
C &C::operator θ=(const C &c) {
	// perform the semantics of the operation
	return *this;
}
```
```
friend C operator θ(const C &c1, const C &c2) {
	C temp = c1;
	return temp θ= c2;
}
```

Practical Rules for Operator Overloading

We'll state the relevant rules, even for those operators we don't introduce until later

You cannot change the precedence or number of operands of an operator when overloading it
An overloaded operator cannot have default arguments
The following operators must be member functions:
- assignment (=)
- subscripting ([])
- (pointer-based) member selection (->)
- function call (())
You can overload most of C++'s remaining operators as either member or non-member functions
In general:
- Make non-assignment binary operators non-member functions
- assignment (simple and compound), and unary operators member functions
Compound assignment operators typically return a reference, the 'non-special' binary/unary usually return by-value
Keep binary operators and their corresponding compound assignment operators semantically consistent

The increment/decrement (++/--) operators each have two forms -- prefix and postfix. To distinguish them, the language requires that you supply a dummy int parameter to the prototype of the postfix (x++) version:

//as non-members
class C1 {...};

void operator ++(C1 &) {...} 		// e.g. ++c1 	
void operator ++(C1 &, int) {...} 	// e.g. c1++

// as members
class C2 {
	...
	void operator ++() {...} 	// e.g. ++c2	
	void operator ++(int) {...} 	// e.g. c2++
};

And, as discussed above, you can usually easily define the binary operator in terms of the corresponding compound assignment operator:
```
class C {
	...
	C &operator @=(const C &other) {		// operator @= (e.g. +=, *=, etc) 
		.....
	}
};

C operator @(const C &c1, const C &c2) {
	C result = c1;
	return c1 @= c2;    // same as c1.operator @=(c2)
}
		
```
- The reference to the local variable is automatically converted to a value by virtue of the by-value return for the @ operator.

Other Uses and Advantages of Leveraging/Delegating Functions/Operators

C++ programmers will often try to find ways to minimize friend functions in or to maximize encapsulation (i.e., protecting the class' state from outside manipulation).
Some example approaches:
- We've already seen implementing the simple binary operators as delegation methods calling the compound assignment operators.
  - Doing this enables us to no longer have to declare them as friend functions
- We can often write a single workhorse function that performs a fundamental operation and call that from several delegating functions
  - For example, writing a compare function that returns <0, 0, or >0 as the result of a comparison, and then calling that function from overloaded ==, !-, <, etc operators
  - If the workhorse can be declared public, all the better — no friendship need be declared for the operators.
  - Similarly for << — if we have public print method, this operator does not have to be declared as a friend.

CISC 3142 Programming Paradigms in C++ Operator Overloading