Friend functions, operator
overloading
– Friend functions, operator overloading
It’s good to have friends
A friend function of a class is defined outside
the class’s scope (I.e. not member
functions), yet has the right to access the
non-public members of the class.
Single functions or entire classes may be
declared as friends of a class.
These are commonly used in operator
overloading. Perhaps the most common use
of friend functions is overloading << and
>> for I/O.
Friends
Basically, when you declare something as a
friend, you give it access to your private data
members.
This is useful for a lot of things – for very
interrelated classes, it more efficient (faster)
than using tons of get/set member function
calls, and they increase encapsulation by
allowing more freedom is design options.
Friends
A class doesn't control the scope of friend
functions so friend function declarations are
usually written at the beginning of a .h file.
Public and private don't apply to them.
Friends (a few gory details)
Friendship is not inherited, transitive, or reciprocal.
Derived classes don’t receive the privileges of friendship
(more on this when we get to inheritance in a few classes)
The privileges of friendship aren’t transitive. If class A
declares class B as a friend, and class B declares class C as a
friend, class C doesn’t necessarily have any special access
rights to class A.
If class A declares class B as a friend (so class B can see
class A’s private members), class A is not automatically a
friend of class B (so class A cannot necessarily see the
private data members of class B).
Friends
class someClass {
friend void setX( someClass&, int);
int someNumber;
… rest of class definition }
// a function called setX defined in a program
void setX( someClass &c, int val) {
c.someNumber = val; }
// inside a main function
someClass myClass;
setX (myClass, 5); //this will work, since we declared // setX
as a friend
Operator Overloading
So far, we’ve seen that we can overload
functions – two functions that have the same
name can co-exist, as long as the compiler
can tell the difference between them.
This also happens with operators, both unary
(!, ++, etc.) and binary ( +, -, *, %,). The
one ternary operator ( ? ) cannot be
overloaded.
Operator overloading
C++ actually has this built into the language,
and you’ve been using it already.
When you call the addition operator with two
integers, and when you call the addition
operator with two floating point numbers,
calls a completely different function.
Operator overloading
Sometimes, when we are defining a class, it might be
useful to define some addition operators. Note, this
is usually a convenience – the same functionality can
usually be accomplished through simple member
calls.
So, let’s say we have a class called simpleExample.
What does the following code do?
simpleExample se1(54,3), se2(43,3);
se1+=se2;
Operator Overloading
The result of the previous will be whatever
we defined the += operator to do for the
simpleExample class.
One operator ( =, the assignment operator) is
automatically overloaded for classes you
create.
Restrictions on overloading
Most operators can be overloaded. A few of
them can’t – the . (dot) operator, the .*
operator, the unary scope :: operator, the ?:
operator, and the sizeof() call, which is
technically an operator.
You can’t change the precedence of
operators.
You can’t create your own operators (some
people would like to overload ** to do
exponation – you can’t).
Restrictions on overloading
Also note that each operator is unique –
defining an addition (“+”) operator for
your class does not automatically define
“+=“, even though they should do
practically the same work.
Also note that preincrement (++a) and
postincrement (a++) are two separate
operators –
Overloading – when/why
Overloading can be a good thing when
it increases the clarity/ease of which
your class can be used.
Well, overloading the + operator should
be obvious – so this would be a good
use.
Overloading – when/why
Don't use operator overloading just because it can be
done and is a clever trick.
The purpose of operator overloading is to make programs
clearer by using conventional meanings for ==, [], +, etc.
This is purely a convenience to the user of a class.
Operator overloading isn't strictly necessary unless other
classes or functions expect operators to be defined (as is
sometimes the case).
Whether it improves program readability or causes
confusion is more a case of how well you use it. In any
case, C++ programmers are expected to be able to use it
-- it's the C++ way.
Overloading why/when
1. Choosing The Best Overload Operator
2. In C++, overload +,-,*,/ to do things totally unrelated
to addition, subtraction etc. If you overload +, make
sure you do it in a way that i = i + 5; has a totally
different meaning from i += 5; Here is an example of
elevating overloading operator obfuscation to a high art.
Overload the '!' operator for a class, but have the
overload have nothing to do with inverting or negating.
Make it return an integer. Then, in order to get a logical
value for it, you must use '! !'. However, this inverts the
logic, so [drum roll] you must use '! ! !'. Don't confuse
the ! operator, which returns a boolean 0 or 1, with the
~ bitwise logical negation operator.
Overloading why/when
1. Overload new
2. : Overload the "new" operator - much more
dangerous than overloading the +-/*. This can
cause total havoc if overloaded to do
something different from it's original function
(but vital to the object's function so it's very
difficult to change). This should ensure users
trying to create a dynamic instance get really
stumped. You can combine this with the case
sensitivity trick: also have a member function,
and variable called "New".
