Access modifiers: Enhancing reliability of your functions

The public access qualifier
- So far, we have use public variables and functions:
- The keyword public is an access qualifier - it determines which function has access to certain variables and functions in a class.
- It does not change the scoping or lifetime of a variable
- The public access qualifier imposes no access restriction;
  Public member variables and member functions can be accessed by any function where the class variables is visible ("in scope").
Why limit the access to variables
- More security... if you cannot access a variable, you cannot modify it.
- By disallowing certain key variables to be accessed, you can protect them from unauthorized modification which may render your program to produce erroneous results.

The private access qualifier

The restriction access qualifier is private:

class MatrixNxN { private: int N; float *A; ... }

When variables or methods are defined to be private, these variables and methods can only be accessed through MEMBER methods defined in the SAME class

Example:

class MatrixNxN { private: float *A; int N; .... }

int main(int argc, char *argv[]) { int N = 4; MatrixNxN M(N); int i, j, k; k = 1; for (i = 0; i < N; i = i + 1) for (j = 0; j < N; j = j + 1) { M.A[i*N+j] = k; // Error: inaccessible !!! k = k + 1; } }

Example Program: (Protecting private members...) ---- click here

How to manipulate member variables protected by private access qualifier

When you define some member variables (or functions) to be private, then these variables (or functions) can only be manipulated by member functions in the same class.
Hence, to manipulate member variables protected by private access qualifier, you need to define a public function (because otherwise the function is not accessible)
Furthermore, you must provide one public function for each manipulation that you allow the user to perform !!!
In other words:

For example, you can no longer initialize the matrix with statement from a function outside the class; so if you want to initialize a matrix, you need to define a member function to do so:

class MatrixNxN { private: float *A; int N; .... } int main(int argc, char *argv[]) { int N = 4; MatrixNxN M(N); int i, j, k; k = 1; for (i = 0; i < N; i = i + 1) for (j = 0; j < N; j = j + 1) { M.A[i*N+j] = k; k = k + 1; } }

class MatrixNxN { private: float *A; int N; public: void InitMatrix(float B[]) { int i; for (i = 0; i < N*N; i = i + 1) A[i] = B[i]; } .... } int main(int argc, char *argv[]) { int N = 4; MatrixNxN M(N); float B[16]; int i, j, k; k = 1; for (i = 0; i < N; i = i + 1) for (j = 0; j < N; j = j + 1) { B[i*N+j] = k; k = k + 1; } M.InitMatrix(B); }

A more elegant solution is to define a constructor that accepts an array to initialize a new MatrixNxN variable:

class MatrixNxN { private: float *A; int N; public: void InitMatrix(float B[]) { int i; for (i = 0; i < N*N; i = i + 1) A[i] = B[i]; } .... } int main(int argc, char *argv[]) { int N = 4; MatrixNxN M(N); float B[16]; int i, j, k; k = 1; for (i = 0; i < N; i = i + 1) for (j = 0; j < N; j = j + 1) { B[i*N+j] = k; k = k + 1; } M.InitMatrix(B); }

class MatrixNxN { private: float *A; int N; public: /* ----------------- Constructor(int) ----------------- */ MatrixNxN(int n) { A = new float[n*n]; N = n; } /* ------------------------- Constructor(int, float[]) ------------------------- */ MatrixNxN(int n, float B[]) { int i; A = new float[n*n]; N = n; for (i = 0; i < N*N; i = i + 1) A[i] = B[i]; } .... } int main(int argc, char *argv[]) { int N = 4; MatrixNxN M(N); // Invoke Matrix(int) float B[16]; int i, j, k; k = 1; for (i = 0; i < N; i = i + 1) for (j = 0; j < N; j = j + 1) { B[i*N+j] = k; k = k + 1; } MatrixNxN Q(N, B); // Invoke Matrix(int, float[]) }

Friend Functions....

A friend function of a class is a function defined outside that class that is given permission to access private member variables in that class
Friend functions must be declared inside the specific class using the keyword friend.

Example:

class MatrixNxN { private: float *A; int N; friend myFunction(...); // Non-member friend function friend myClass::myFunction(...); // Member friend function }

NOTE:

Example friend function

A popular friend function that programmers define is the "output" operator function operator<<
The operator function operator<< is commonly used to output C++ based type variable to the terminal:
cout << "Hello World !";
C++ looks for:
operator<<(ostream, char *); or ostream::operator<<(char *);
(cout is of the type ostream and "Hello World !" is of the type (char *))
C++ has generously provide a class ostream that included the member function ostream& ostream::operator<< (char *)
We can write "cout << M" to print a MatrixNxN variable, but we will have to provide one of the following functions:
- To allow us to write "cout << M;", we must provide one of the functions:
  - operator<<(ostream, MatrixNxN) or
  - ostream::operator<<(MatrixNxN)
The member function ostream::operator<<(MatrixNxN) is impossible to write, because we cannot modify the system defined class ostream
Fear not - we can always write the function operator<<(ostream, MatrixNxN)

Example:

Declare a friend operator function in MatrixNxN:
class MatrixNxN { private: float *A; int N; friend operator<<(ostream, MatrixNxN); }

Possibly inside another file - implement the friend function:
ostream & operator<<(ostream & cout, MatrixNxN M) { int i, j; for (i = 0; i < M.N; i = i + 1) { for (j = 0; j < M.N; j = j + 1) cout << M.A[i*M.N+j] << "\t"; cout << "\n"; } cout << "\n"; };

Now you can output a MatrixNxN variable with <<:
cout << M;

Because operator<<() returns the ostream object, you can even cascade the output operator:
cout << "Matrix M is:" << endl << M << endl;

Example Program: (Non-member friend function) ---- click here

Friend classes

Sometimes multiple classes interact with each other in a very intimate manner that it is beneficial to make every (member) function of a class a friend function

Instead of enumerating each function to be a friend, a class can be named to be a friend:

MatrixNxN M; VectorN v1, v2; v2 = M * v1;

C++ will look for the following member function:
MatrixNxN::operator*(VectorN);
Because matrix and vector frequently inter-operate, it would be beneficial to allow every function in MatrixNxN to access private variables in VectorN

You may think that you need another friend function to do the assignment to v2, but that's not neccesary, because M * v1 returns a VectorN, not a MatrixNxN
The assignment operator inside VectorN can handle the assignment !

Example: (Note: I use static Matrix3 and Vector3 classes in this example to cut down on the number of functions)

The Vector3 class:
class Vector3 { private: float x[3]; public: /* -------------------- Default constructor -------------------- */ Vector3() { int i; for (i = 0; i < 3; i=i+1) x[i] = i + 10; } friend ostream & operator<<(ostream &, Vector3 &); friend class Matrix3; // Whole class as friend ! };

Example Program: (Friend class) ---- click here

Separate compilation of the last example
- Because the last example is the first reasonably complicated program, I like to show how to break it apart into seperate program files for compilation.
- There are 2 classes: Matrix3 and Vector3.
  You need to separate each class by writing a class definition file and a class implementation file:
  - Here is the Vector3 class definition (header file): click here -------
  - Here is the Vector3 class implementation: click here
  - Here is the Matrix3 class definition (header file): click here
  - Here is the Matrix3 class implementation: click here
  - After moving the Matrix3 and Vector3 outside the main program, the main program file looks like this: click here
Soapbox talk on "black box"
- A common object oriented programming advocation is that all variables in a user-defined class should be defined as private to ensure excellent protection
- If all variables in a user-defined class are private, then users of this class must manipulate variables of this class using functions that are defined by the programmer - he cannot "abuse" the class; thus providing "perfect protection".
- The user class would in fact become a "black box" to users of that class:
- There is another advantage when all variables in a user-defined class are made private, and users are forced to use public methods to manipulate variables of that class:

Overcoming the private access qualifier protection

After telling you how "secure" your private variables are from updating by unauthorized users, I have to warn you to not feel too secure about the private access qualifier protection
Anyone with an I.Q. higher than a chimp will be able to access the private variables in a class

Here is one easy way: define an identical class and change the access to public; point to a protected variable and you will have access to all its variables - even private access variables:

class MatrixNxN { private: int N; float *A; ... } class myMatrixNxN { public: int N; float *A; ... }

int main(int argc, char *argv[]) { int N = 4; MatrixNxN M(N); myMatrixNxN *X; X = (myMatrixNxN *) &M; X->A[i] = .... you can access private variables !!!... }

Example Program: (How to hack a private variable) click here -------

Epilogue

Defining inter-dependent classes
- I wrote the following example of Matrix and Vector classes containing both a Matrix-vector and a Vector-matrix multiplication application to illustrate inter-dependent classes (based on a question from students in 2005)
  - The matrix definition: click here
  - The matrix implementation: click here
  - The vector definition: click here
  - The vector implementation: click here
  - The driver program: click here