- The
private
mechanism helps us
limit accessibility of variables
to functions in one single class
- This mechanism will
cause problems
if the desired functionality
is implemented using
multiple classes
- Consider the
consequences
of the
use of private variables
in the
matrix-vector multiplication
programs:
class Vector3 { private: double d[3]; ... }; class Matrix3x3 { private: double A[3][3]; ... };
- Example:
This Matrix * Vector operator function is not allowed to access the private variables:
class Vector3 { private: double d[3]; ... }; class Matrix3x3 { private: double A[3][3]; ... }; Vector3 operator* ( Matrix3x3 m, Vector3 & v) { Vector3 out; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; // Not allowed !!! for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + m.A[i][k] * v.d[k]; // Not allowed !!! } }Because:
- The variable d[]
(in out.d[] and v.d[])
of the Vector3 class variable
is
private
and thus
cannot
be accessed by operator*
which is
function outside
the
Vector3 class
- The same argument goes for the variable A[i][k]
- The variable d[]
(in out.d[] and v.d[])
of the Vector3 class variable
is
private
and thus
cannot
be accessed by operator*
which is
function outside
the
Vector3 class
- Example Program:
(Demo above code)
- Prog file: click here
Compile with:
CC -c Friend-1.C
Compilation will result in these errors:
out.d[i] = 0.0; Error: d is not accessible from operator*(Matrix3x3&, Vector3&) out.d[i] = out.d[i] + A[i][k] * v.d[k]; Error: d is not accessible from operator*(Matrix3x3&, Vector3&) Error: A is not accessible from printM(Matrix3x3*)
NOTE:
-
Notice the variable out is a local variable, so the variable
out.d[i]
is in the function's scope.
Eventhough the variable is the scope, the access is denied based on access qualification (not enough "right of access")
- Using a
member function
does NOT solve the problem
Example:
The Matrix * Vector member operator function is not allowed to access the private variable d[] in Vector3:
class Vector3 { private: double d[3]; ... }; class Matrix3x3 { private: double A[3][3]; Vector3 operator* ( Vector3 & v) { Vector3 out; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; // Not allowed... for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + A[i][k] * v.d[k]; // Not allowed... } } };Because:
- The variable d[] (in out.d[] and v.d[]) of the Vector3 class variable is private and cannot be accessed by a member function in the Matrix3x3 class
- Example Program:
(Demo above code)
- Prog file: click here
Compile with:
CC -c Friend-2.CCompilation will result in these errors:
out.d[i] = 0.0; Error: d is not accessible from Matrix3x3::operator*(Vector3&) out.d[i] = out.d[i] + A[i][k] * v.d[k]; Error: d is not accessible from Matrix3x3::operator*(Vector3&)
- When the implementation of a
functionality
requires the use of
more than one class ,
you can
permit
all functions
or some specific function(s) in another class
to access
private variables
- This mechanism is called a friend class or friend function
-
A friend function
is allowed to access the
private variable
of a class
- Friend functions must be
declared
inside the specific class
using the keyword
friend.
- Example friend function:
class Vector3 { private: double d[3]; ... friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); // Allows operator*() to access "d[]" }; class Matrix3x3 { private: double A[3][3]; ... friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); // Allows operator*() to access "A[][]" };
Vector3 operator* ( Matrix3x3 &m, Vector3 & v) { Vector3 out; int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + m.A[i][k] * v.d[k]; } return(out); }
- Example Program:
(Demo above code)
- Prog file: click here
- Compile with:
CC -c Friend-3.C(because there is no main function)
There is one little problem with the program:
friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); line 9: Error: Matrix3x3 is not defined.
The compiler complains about this problem:
class Vector3 { private: double d[3]; ... friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); ^^^^^^^^^^^^ undefined !!! // Allows operator*() to access "d[]" }; class Matrix3x3 // <----- Matrix3x3 definition { private: double A[3][3]; ... friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); ^^^^^^^^^^^^ it is now defined... // Allows operator*() to access "A[][]" };
Vector3 operator* ( Matrix3x3 &m, Vector3 & v) { Vector3 out; int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + m.A[i][k] * v.d[k]; } return(out); } - This problem
will NOT go away
is we
change the order of definition:
class Matrix3x3 { private: double A[3][3]; ... friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); ^^^^^^^^^^^^ undefined !!! // Allows operator*() to access "A[][]" }; class Vector3 { private: double d[3]; ... friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); ^^^^^^^^^^^^ it is now defined... // Allows operator*() to access "d[]" };
Vector3 operator* ( Matrix3x3 &m, Vector3 & v) { Vector3 out; int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + m.A[i][k] * v.d[k]; } return(out); } - This problem can be solved using a class declaration
- A class
is
declared
using the construct:
class classname ;
A declaration informs the compiler of the type of a variable
A declaration does NOT convey information about its structure
A class declaration is an incomplete class definition - lacking information about its structure
- So what good is it ? :-)
- You can
declare
variables of a class
after:
- A class declaration
- (And also after a class definition - obviously)
Example:
class myClass; // Class declaration
extern myClass x; // Declaration of a myClass variable // This will NOT reserve memory space, // so compiler do NOT need to know // the structure of myClass
class yourClass { ... friend myClass f1( myClass x ); // An address is passed to f1 // Compiler does not need to // know the structure // Declaration is sufficient information };
- A class declaration
- Example Program:
(Demo above code)
- Prog file: click here
Compile with:
CC -c Declare.C(because there is no main function)
- NOTE:
obviously, you
cannot define a class variable
after only
declaring a class
Example:
class myClass; // Class declaration // "Incomplete definition"
myClass x; // Definition of a myClass variable // This RESERVES memory space, // so compiler NEEDS to know // the structure of myClassYou will get a compilation error...
- Solving the compilation error:
class Matrix3x3; // <--- Declare class Matrix3x3 class Vector3 { private: double d[3]; ... friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); ^^^^^^^ NO compilation errors !!! }; class Matrix3x3 { private: double A[3][3]; ... friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); // Allows operator*() to access "A[][]" };
Vector3 operator* ( Matrix3x3 &m, Vector3 & v) { Vector3 out; int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + m.A[i][k] * v.d[k]; } return(out); }
- Example Program:
(Demo above code)
- Prog file: click here
- Compile with:
CC -c Friend-3a.C(because there is no main function)
NO compile errors...
- The following is a working
(but very ugly )
example of using
friend functions
to access
private variables
Example:
class Matrix3x3; class Vector3 { private: double d[3]; friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); friend ostream & operator<< (ostream & output, Vector3 & v); friend int main(int argc, char *argv[]); }; class Matrix3x3 { private: double A[3][3]; friend Vector3 operator* ( Matrix3x3 &m, Vector3 & v); friend ostream & operator<< (ostream & output, Matrix3x3 & m); friend int main(int argc, char *argv[]); };
Vector3 operator* ( Matrix3x3 &m, Vector3 & v) { Vector3 out; int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + m.A[i][k] * v.d[k]; } return(out); }
ostream & operator<< (ostream & output, Vector3 & v) { int i, j; for (i = 0; i < 3; i = i+1) { output << v.d[i]; } output << endl; return(output); }
[ostream & operator<< (ostream & output, Matrix3x3 & m) is omitted]
int main(int argc, char *argv[]) { Matrix3x3 A; Vector3 v, u; A.A[0][0] = 1.0; A.A[0][1] = 0.0; A.A[0][2] = 0.0; A.A[1][0] = 1.0; A.A[1][1] = 1.0; A.A[1][2] = 0.0; A.A[2][0] = 1.0; A.A[2][1] = 1.0; A.A[2][2] = 1.0; cout << "Initial matrix A:" << endl << endl; printM(&A); v.d[0] = 1.0; v.d[1] = 2.0; v.d[2] = 3.0; cout << "Initial vector v:" << endl << endl; printV(&v); u = A * v; cout << endl << "After u = A * v, vector u:" << endl << endl; printV(&u); }
- Example Program:
(Demo above code)
- Prog file: click here
- NOTES:
- Access to private variables
in a class through
friend function is
completely under the control of the author of the class
...
Usually, the same author would also be writing the friend function !
- We have to
make
main()
a
friend function
because it
initializes the variables
A[][]
and
d[]
The main() function is NOT a good function to be made a friend
We will see later how to better handle initialization when we discuss constructor functions
- Access to private variables
in a class through
friend function is
completely under the control of the author of the class
...
- The Matrix-Vector multiplication can also
be implemented using a
member function
as
friend
We need to jump through another kind of hoop to avoid type check errors !!!
- Example: the Naive Implementation...
class Matrix3x3 { private: double A[3][3]; // We don't need: // // friend Vector3 operator* ( Vector3 & v ); // // because member functions can access // private variables in its own class public: Vector3 operator* ( Vector3 & v ) { Vector3 out; int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + A[i][k] * v.d[k]; } return(out); } };NOTE:
We do NOT need to make operator* () into a friend function of the class Matrix3x3 because all member functions of the class Matrix3x3 have access to the private variable A[][]
- We
DO need
to make
operator* () into a
friend function
of the class
Vector3
- The notation of a
member function funcname()
in the class
myClass
is:
myClass::funcname()
- Therefore, the following
construct
defines that
the operator*() function in the
Matrix3x3
class is a
friend function :
class Vector3 { private: double d[3]; friend Vector3 Matrix3x3::operator* ( Vector3 & v ); };
- First attempt to make a member friend function:
class Matrix3x3; class Vector3 { private: double d[3]; friend Vector3 Matrix3x3::operator* ( Vector3 & v ); };
class Matrix3x3 { private: double A[3][3]; public: Vector3 operator* ( Vector3 & v ) { Vector3 out; int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + A[i][k] * v.d[k]; } return(out); } };
- Example Program:
(Demo above code)
- Prog file: click here
Compile with:
CC -c Friend-5.C
- This solution has the following error:
Error: In this declaration "*" is of an incomplete type "Matrix3x3"
Because:
class Matrix3x3; class Vector3 { private: double d[3]; friend Vector3 Matrix3x3::operator* ( Vector3 & v ); ^^^^^^^^^^^^^^^^^^^^^ };
class Matrix3x3 { private: double A[3][3]; public: Vector3 operator* ( Vector3 & v ) { Vector3 out; int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + A[i][k] * v.d[k]; } return(out); } };The compiler complaints because we reference a member (function) inside Matrix3x3
To resolve this reference, the compiler needs to know structure of Matrix3x3 OK, let's put Matrix3x3 before Vector3
- Second attempt to make a member friend function:
(change order)
class Vector; class Matrix3x3 { private: double A[3][3]; public: Vector3 operator* ( Vector3 & v ) { Vector3 out; int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + A[i][k] * v.d[k]; } return(out); } };
class Vector3 { private: double d[3]; friend Vector3 Matrix3x3::operator* ( Vector3 & v ); };
- Example Program:
(Demo above code)
- Prog file: click here
Compile with:
CC -c Friend-5a.C
- This solution has the following error:
Error: In this declaration "out" is of an incomplete type "Vector3"
Because:
class Vector3; class Matrix3x3 { private: double A[3][3]; public: Vector3 operator* ( Vector3 & v ) { Vector3 out; // <----- Variable definition // Vector3 is only declared.... int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + A[i][k] * v.d[k]; } return(out); } };
class Vector3 { private: double d[3]; friend Vector3 Matrix3x3::operator* ( Vector3 & v ); };The compiler complaints because we defined a variable using an incompletely defined class Vector3
To avoid this definition, we use separating class definition and class implementation
- Final attempt to make a member friend function:
(separating class definition and implementation)
class Vector; class Matrix3x3 { private: double A[3][3]; public: Vector3 operator* ( Vector3 & v ); // Function implementation is found elsewhere !! };
class Vector3 { private: double d[3]; friend Vector3 Matrix3x3::operator* ( Vector3 & v ); };
// Implementation Vector3 Matrix3x3::operator* ( Vector3 & v ) { Vector3 out; int i, k; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + A[i][k] * v.d[k]; } return(out); }
- Example Program:
(Demo above code)
- Prog file: click here
Compile with:
CC -c Friend-6.C
No errors !
- If you feel this is too painful,
don't worry...
There is a simpler way to make private variables accessible to member functions of another class:
friend class
- If
multiple classes
interact closely with each other
that it is easier to make
the close interacting class
into a
friend class - Friend classes must be
declared
inside the specific class
using the keyword
friend class
- Example: Our first solution
(See: click here)
class Vector3 { private: double d[3]; ... }; class Matrix3x3 { private: double A[3][3]; Vector3 operator* ( Vector3 & v ) { Vector3 out; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + A[i][k] * v.d[k]; } } };Can be resolved by making Matrix3x3 into a friend class of Vector3
class Vector3 { private: double d[3]; ... friend class Matrix3x3; }; class Matrix3x3 { private: double A[3][3]; Vector3 operator* ( Vector3 & v) { Vector3 out; for (i = 0; i < 3; i = i + 1) { out.d[i] = 0.0; for (k = 0; k < 3; k = k + 1) out.d[i] = out.d[i] + A[i][k] * v.d[k]; } } };
- Example Program:
(Demo above code)
- Prog file: click here
Compile with:
CC -c Friend-7.C
- Example Program:
(A runnable program based on above code)
- Prog file: click here