CS 250 Computer Programming and Problem Solving - FALL 1998 

• variables (means data cannot be changed)
• parameters (means argument cannot be changed)
• member functions in a class (means data members cannot be changed)

• const variableType VariableID = InitialValue;
• functionType functionID(const parameterType...)
• functionMemberType functionMemberID(parameterList) const;

• const int MaxX = 1000;
• searchArray(const int a, int sizeA, int item);
• int getX( ) const;  // guaranteed not to change data members x,y, and display

• const variables MUST have an initial value (it can't be changed later)
• const parameters are most useful for pointer and reference parameters
• const member function must use const in the function defintion as well
• If you forget the const in either the prototype or defintion, the compiler will think they are different functions!

• Private data members of a class can make life difficult sometimes.

• This is especially true if you want them to be truly private and not even provide a "set" modifier or "get" access function to them.
  (Why would you have a private data member with no access function - because you may want to change your mind how you solved a problem and use a different implementation which does not require that data member).

• When you define a class you can declare a function to be a friend function.
  This allows it to access the private data members of the class.

#include <math.h>
friend float distance(Coordinate p1, Coordinate p2) {
   float deltaX = p1.x - p2.x;
   float deltaY = p1.y - p2.y;
   return sqrt(deltaX*deltaX + deltaY*deltaY); // sqrt in math.h
}

• Avoid using friends unnecessarily
• One common use of friend functions is to operate on two or more objects of the same class
  (e.g. addition, concatenation of strings, distance (like in the above example)
• Put the function prototype of the friend in the header file of the class with the modifier friend
• Define the function in the classes function definition file (.cpp) without the friend modifier
• Overloading the input output operators is a common use of friend functions

• Overloading a function means using the same function name for two or more different function definitions
• Common example is the "+" operator (which is an infix function) which can be used to add integers or floating points numbers
  Another common example is the I/O functions "<<" and ">>" which can handle a variety of data types.
• So how does the compiler tell the difference? By the number and type of the parameters to the function. As long as the number or type of the parameters are different, there is no problem.

float add(float a, float b) {
   return a + b;
}

int add(int a, int b) {
   return a + b;
}

• Overloading the c++ operators makes your objects easier to use (e.g. I/O operators)

• Common and useful way to extend the usual extraction ">>" and insertion "<<" operators so that they can work with your new objects.
• Operator function is a friend to the class

friend istream & operator >> (istream & is, objectType objectID);

// in the function definition file "Coordinate.cpp"
ostream & operator << (ostream & oStream, const Coordinate & aPoint) {
   oStream << aPoint.x << " " << aPoint.y << " " << aPoint.display;
   return oStream;
}

istream & operator >> (istream & iStream, Coordinate & aPoint) {
   iStream >> aPoint.x >> aPoint.y >> aPoint.display;
   return iStream;
}

// to use, just do the usual I/O statement (in main.cpp)
#include "Coordinate.h"
   Coordinate point1;
   cin >> point1;
   cout << point1;

• You can also do error checking on input (like SetX, etc)
• You can format the output any way you want (e.g. with descriptive text)

• Problem with previous example is that it does not guarantee consistency of x,y, display values
• This version uses the public setX, setY and setDisplay functions to take care of this
• Because it does not access the private data members, extraction need not be a friend

// in the function definition file "Coordinate.cpp"
ostream & operator << (ostream & oStream, const Coordinate & aPoint) {
   oStream << aPoint.x << " " << aPoint.y << " " << aPoint.display;
   return oStream;
}

istream & operator >> (istream & iStream, Coordinate & aPoint) {
    int x,y,display;
    iStream >> x >> y >> display;
    aPoint.setX(x);
    aPoint.setY(y);
    aPoint.setDisplay(display);
   return iStream;
}

// to use, just do the usual I/O statement (in main.cpp)
#include "Coordinate.h"
   Coordinate point1;
   cin >> point1;
   cout << point1;

• You can format the output any way you want (e.g. with descriptive text)