Private Access modifiers: Enhancing reliability of your functions

What is special about member functions ?
- We see that each functionality can be implemented using:
- An "ordinary" (non-member) functon does not belong to any class
- An member functon is part of some class
- A class contains:
- We can define special access modes for variables (and functions) in a class
  We will discuss this next....
Access qualifiers
- There are 3 access qualifiers for members (variables or functions) of a class
- Each 3 access qualifiers defines a certain access permission to a member
  An access qualifier determines which functions can read/write a variable or can invoke a function
- NOTE: the protected mode is similar to the private mode except in derived classes (discussed later)

The public access qualifier

We have seen public member variables and functions:

class Matrix3x3 { public: float A[3][3]; ... }

A variable defined as public does not have any access restriction

Example:

class myClass { public: int x; // Public variables void f1(int a) { x = a; // Access public member variable // (It's actually: this->x = a; } }; class yourClass { public: void f1(myClass & p, int a) { p.x = a; // Access public member variable } }; int main(int argc, char ** argv) { myClass jam; yourClass butter; jam.x = 1234; butter.f1(jam, 4444); jam.f1(7777); }

The public variable x can be accessed from an "ordinary" function (main)
The public variable x can be accessed from a member function in another class
The public variable x can be accessed from a member function in your own class

The private access qualifier

A variable defined as private is restricted to functions defined in the (same) class

A private member variable can be only be accessed (read/write) by a function in the same class
A private member function can be only be invoked by a function in the same class

Example:

class myClass { private: int x; // Private variable void f1(int a) // Private function { x = a; // ALLOW access to private variable // (It's actually: this->x = a; } }; class yourClass { public: void f1(myClass & p, int a) { p.x = a; // ERROR: NO access to private variable } }; int main(int argc, char ** argv) { myClass jam; jam.x = 1234; // ERROR: NO access to private variable butter.f1(jam, 4444); jam.f1(7777); }

Example Program: (Demo above code)
- Prog file: click here

When you compile the program, you will get these errors:

void f1(myClass & p, int a) { p.x = a; // ERROR: NO access to private variable } Error: x is not accessible from yourClass::f1(myClass&, int).
jam.x = 1234; Error: x is not accessible from main(int, char**).
jam.f1(7777); Error: myClass::f1(int) is not accessible from main(int, char**). (The function f1 in myClass is also private !!!)

Why limit the access to variables
- You have more control over which function can update the variables.
- By localizing the updates to only functions in the same class, finding errors in large programs is simplified

Example: symmetric 3x3 matrices

Suppose we write a program that will only work when a matrix is symmetric
We can use the private access qualifier to make sure that the matrix is symmetric

Example:

class Matrix3x3 { private: double A[3][3]; public: int init(double m[3][3]) // Check for symmetry { if ( ! isSymmetric(m) ) { cout << "Input matrix is NOT symmetric" << endl; // Initialize matrix to a "dummy" matrix for (i = 0; i < 3; i = i + 1) for (j = 0; j < 3; j = j + 1) A[i][j] = 0; return(0); // Error indication } // Initialize matrix with input for ( i = 0; i < 3; i = i + 1 ) for ( j = 0; j < 3; j = j + 1 ) A[i][j] = m[i][j]; return(1); // OK } ... }

Because the variable A[3][3] is private, the user cannot initialize this variable from main():

int main(int argc, char *argv[]) { Matrix3x3 A, B, C; A.A[0][0] = 1.0; A.A[0][1] = 0.0; A.A[0][2] = 0.0; // NOT allowed !!! A.A[1][0] = 1.0; A.A[1][1] = 1.0; A.A[1][2] = 1.0; // NOT allowed !!! A.A[2][0] = 1.0; A.A[2][1] = 0.0; A.A[2][2] = 0.0; // NOT allowed !!! ... }

Instead, the user is forced to use the public method init to initial the variables:

int main(int argc, char *argv[]) { Matrix3x3 A, B, C; double p[3][3]; p[0][0] = 1.0; p[0][1] = 0.0; p[0][2] = 1.0; p[1][0] = 0.0; p[1][1] = 1.0; p[1][2] = 1.0; p[2][0] = 1.0; p[2][1] = 1.0; p[2][2] = 0.0; if ( A.init(p) == 0 ) { cout << "Input error, exiting..." << endl; exit(1); } ... }

Example Program: (Demo above code)
- This program tries to use a asymmetric matrix: click here
- This program uses symmetric matrices: click here
Moral of the story:

The protection comes with some inconvenience

The example above showed:

You can no longer initialize the matrix with statement from a function outside the class (such as main);
So you need to define one member function for every task that you want to do to the variables.... that can be a lot of member functions...

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
A good hacker will be able to access the private variables in a class

Here is one (easy) way:

define a class with identical variables
Make sure the access qualifier is public
Cast a "protected class" to this unprotected class.
Now you will have access to all its variables - even private variables...

Example:

class myMatrix3x3 { public: double A[3][3]; } class Matrix3x3 { private: double A[3][3]; ... } int main(int argc, char *argv[]) { Matrix3x3 A, B, C; myMatrix3x3 *m; m = &A; m->A[0][0] = 1.0; m->A[0][1] = 0.0; m->A[0][2] = 1.0; m->A[1][0] = 0.0; m->A[1][1] = 1.0; m->A[1][2] = 1.0; m->A[2][0] = 1.0; m->A[2][1] = 1.0; m->A[2][2] = 0.0; }

Example Program: (Demo above code)
- Prog file: click here