Friend functions, operator overloading

1
Friend functions, operator overloading

• Friend functions, operator overloading

2
Its good to have friends

• A friend function of a class is defined outside
  the classs 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 ltlt and gtgt for I/O.

3
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.

4
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.

5
Friends (a few gory details)

• Friendship is not inherited, transitive, or
  reciprocal.
• Derived classes dont receive the privileges of
  friendship (more on this when we get to
  inheritance in a few classes)
• The privileges of friendship arent transitive.
  If class A declares class B as a friend, and
  class B declares class C as a friend, class C
  doesnt necessarily have any special access
  rights to class A.
• If class A declares class B as a friend (so class
  B can see class As 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).

6
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

7
Operator Overloading

• So far, weve 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.

8
Operator overloading

• C actually has this built into the language,
  and youve 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.

9
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, lets say we have a class called
  simpleExample. What does the following code do?
• simpleExample se1(54,3), se2(43,3)
• se1se2

10
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.

11
Restrictions on overloading

• Most operators can be overloaded. A few of them
  cant the . (dot) operator, the . operator,
  the unary scope operator, the ? operator, and
  the sizeof() call, which is technically an
  operator.
• You cant change the precedence of operators.
• You cant create your own operators (some people
  would like to overload to do exponation you
  cant).

12
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

13
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.

14
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.

15
Overloading why/when

• Choosing The Best Overload Operator
• 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.

16
Overloading why/when

• Overload new
• 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".