- Consider the + operator:
double a, b; a + b
- Every operator in C++ is
a function with 2 parameters
where:
- The name
of the function is:
operation?
where "?" is the
symbol of the operation
Example: the name of the function for "+" is:
operator+
- The type of the parameters are determined by the type of the input parameters
- The name
of the function is:
operation?
where "?" is the
symbol of the operation
- Example:
double a, b; a + b
is actually invoking the function:
double a, b; operator+(a, b)
- Suppose we
like to provide
the following
functionality
to our Matrix3x3 class (= type):
Matrix3x3 A, B; double x; B = A + x;
We can do so by defining the operator function:
Matrix3x3 operator+(Matrix3x3 &m, double x) { ... }Because:
- When C++ sees the expression:
Matrix3x3 A; double x; B = A + x;
it will search for the operator function with the following name and parameter types :
operator+(Matrix3x3 m, double x) or: operator+(Matrix3x3 &m, double x)
- Because the return type
is
Matrix3x3 ,
the function is then:
Matrix3x3 operator+(Matrix3x3 &m, double x) { ... }
- When C++ sees the expression:
- Version 1: ordinary function
class Matrix3x3 { public: double A[3][3]; }; Matrix3x3 operator+(Matrix3x3 &m, double x) { Matrix3x3 out; int i, j; for (i = 0; i < 3; i = i+1) for (j = 0; j < 3; j = j+1) out.A[i][j] = m.A[i][j] + x; return(out); } - How to use this function:
int main(int argc, char *argv[]) { Matrix3x3 B, C; C = B + 40; }
- Example Program:
(Demo above code)
- Prog file: click here
- I have to add one more fact to
operator functions
- When the C++ compiler encounters:
double a, b; a + b
it will invoke the function:
double a, b; operator+(a, b) or a.operator+(b) // This fact help us write // operator functions using member function
- Example: member function as operator function
class Matrix3x3 { public: double A[3][3]; Matrix3x3 operator+(double x) { Matrix3x3 out; int i, j; for (i = 0; i < 3; i = i+1) for (j = 0; j < 3; j = j+1) out.A[i][j] = this->A[i][j] + x; return(out); } }; - How to use this function:
int main(int argc, char *argv[]) { Matrix3x3 B, C; C = B + 40; }The expression B + 40 is unchanged , but it will NOW map to the member function
- Example Program:
(Demo above code)
- Prog file: click here
- There is
the danger
of
"too much of a good thing" by
providing too many functions
in C++
- If we define
both
mapped functions :
class Matrix3x3 { public: double A[3][3]; // -------- Ambiguous.... Matrix3x3 operator+(double x) { Matrix3x3 out; int i, j; for (i = 0; i < 3; i = i+1) for (j = 0; j < 3; j = j+1) out.A[i][j] = this->A[i][j] + x; return(out); } }; // -------- Ambiguous.... Matrix3x3 operator+(Matrix3x3 &m, double x) { Matrix3x3 out; int i, j; for (i = 0; i < 3; i = i+1) for (j = 0; j < 3; j = j+1) out.A[i][j] = m.A[i][j] + x; return(out); }
- Then C++ will
complain
that it
cannot resolve the expression B+40 :
Error: Overloading ambiguity between "operator+(Matrix3x3&, double)" and "Matrix3x3::operator+(double)".
- Example Program:
(Demo above code)
- Prog file: click here
- Suppose we want to provide the following
functionality
Matrix3x3 A, B; double x; B = x + A;
- Because the
order
of the parameters
is
changed ,
we have a
completely NEW functionality !!!
- To provide this functionality, we must define a
function
with the following
name
and
types of parameters
Matrix3x3 operator+(double x, Matrix3x3 &m) { ... }
- Example:
class Matrix3x3 { public: double A[3][3]; }; Matrix3x3 operator+(double x, Matrix3x3 &m) { Matrix3x3 out; int i, j; for (i = 0; i < 3; i = i+1) for (j = 0; j < 3; j = j+1) out.A[i][j] = m.A[i][j] + x; return(out); } - How to use this function:
int main(int argc, char *argv[]) { Matrix3x3 B, C; C = 40 + B; }
- Example Program:
(Demo above code)
- Prog file: click here
- It is not always possible
to provide
operator functions as member function
- Example:
Matrix3x3 A, B; double x; B = x + A;
- If we want to provide this
functionality
through a
member function ,
the
member function
has this form:
double x; Matrix3x3 A; x.operator+(A);
- Since
x
has the type
double ,
we
must add this function
in the
primitive type (double)
We are not allowed to add new functions to C++ primitive types
Hence, this option is NOT possible
- To
compute one element
in a
Matrix * Matrix product,
we must
add a number of products :
+- -+ +- -+ +- -+ | 1 0 0 | | 1 2 3 | | .. .. .. | | 1 1 0 | * | 4 5 6 | = | .. .. .. | | 1 2 5 | | 7 8 9 | | .. .. 1*3 + 2*6 + 5*9 | +- -+ +- -+ +- -+ A + B = C - In the example above, we see that:
c[2][2] = a[2][0]*b[0][2] + a[2][1]*b[1][2] + a[2][2]*b[2][2]
- This for loop is used to compute
the element C[2][2]
in a 3x3 matrix-matrix product:
C[2][2] = 0; for (k = 0; k < 3; k = k + 1) C[2][2] = C[2][2] + A[2][k] * B[k][2];
- In general, the following for loop is used to compute
the element C[i][j]
in a matrix-matrix product:
C[i][j] = 0.0; for (k = 0; k < N; k = k + 1) C[i][j] = C[i][j] + A[i][k] * B[k][j];
- To compute
every element C[i][j],
the above loop is executed
for
every element C[i][j]
by using a nested for-loop:
for (i = 0; i < N; i = i + 1) { for (j = 0; j < N; j = j + 1) { C[i][j] = 0.0; for (k = 0; k < N; k = k + 1) C[i][j] = C[i][j] + A[i][k] * B[k][j]; } }
- Suppose we want to write a program that
multiply two Matrix3x3 matrices:
int main(int argc, char *argv[]) { Matrix3x3 M1, M2, M3; M3 = M1 * M2; // Matrix multiplication !!! }; - C++ will search for
one of these functions:
operator*(M1, M2) // Ordinary function or M1.operator*(M2) // Member function
- Version 1: using an ordinary function
class Matrix3x3 { public: double A[3][3]; }; Matrix3x3 operator*(Matrix3x3 &m1, Matrix3x3 &m2) { Matrix3x3 out; for (i = 0; i < 3; i = i + 1) { for (j = 0; j < 3; j = j + 1) { out.A[i][j] = 0.0; for (k = 0; k < 3; k = k + 1) out.A[i][j] = out.A[i][j] + m1.A[i][k]*m2.A[k][j]; } } return(out); } - Example usage:
int main(int argc, char *argv[]) { Matrix3x3 A, B, C; C = A * B; }
- Example Program:
(Demo above code)
- Prog file: click here
- Version 2: using a member function
class Matrix3x3 { public: double A[3][3]; Matrix3x3 operator*(Matrix3x3 &m2) { Matrix3x3 out; for (i = 0; i < 3; i = i + 1) { for (j = 0; j < 3; j = j + 1) { out.A[i][j] = 0.0; for (k = 0; k < 3; k = k + 1) out.A[i][j] = out.A[i][j] + A[i][k]*m2.A[k][j]; } } return(out); } }; - Usage is unchanged:
int main(int argc, char *argv[]) { Matrix3x3 A, B, C; C = A * B; }
- Example Program:
(Demo above code)
- Prog file: click here
- The commonly used
C++ operator to
print variables
is:
cout << value;
- The type
of the variable
cout
is:
ostream
- The enable C++ to
perform the following
operation :
Matrix3x3 m; cout << m;
we must define the following operator function
operator<<( ostream & o, Matrix3x3 & x ) { ... (print Matrix3x3 x) }
- Example:
void operator<<( ostream & output, Matrix3x3 & x ) { int i, j; for (i = 0; i < 3; i = i + 1) { for (j = 0; j < 3; j = j + 1) output << x.A[i][j]; output << endl; } } - How to use it:
#include <iostream.h> int main(int argc, char *argv[]) { Matrix3x3 A; cout << A; }
- Example Program:
(Demo above code)
- Prog file: click here
- The
operator<<
function defined above
does not cascade
- Example:
this does not work
Matrix A, B; cout << "Matrix A:" << A << endl << "Matrix B: << B << endl;
- Reason: the statement is executed as follows
- cout << "Matrix A:"
invokes the operator function:
operator<<(ostream &, char &)
and prints Matrix A:
But, here is a little secret:
The operator<<(ostream &, char &) function returns its first argument !!! - Therefore: after
(cout << "Matrix A:")
finished, the returned value is
cout
and it is used in the
subsequent execution
which is:
( (cout << "Matrix A:") << A ) ^^^^^^^^^^^^^^^^^^^^^ ( cout << A ) - cout << A
invokes the operator function:
operator<<(ostream &, Matrix3x3 &)
and prints the matrix A
Now we have a problem :
The operator<<(ostream &, Matrix3x3 &) function returns NOTHING !!!
( ( ( ( (cout << "Matrix A:") << A ) << endl ) << "Matrix B: ) << B ) << endl;
- cout << "Matrix A:"
invokes the operator function:
operator<<(ostream &, char &)
and prints Matrix A:
- Making operator<< cascade:
ostream & operator<<( ostream & output, Matrix3x3 & x ) { int i, j; for (i = 0; i < 3; i = i + 1) { for (j = 0; j < 3; j = j + 1) output << x.A[i][j]; output << endl; } return(output); }
- Example Program:
(Demo above code)
- Prog file: click here
- It is possible to pass
class variable
by-value
- Example:
class Matrix3x3 { public: double A[3][3]; }; Matrix3x3 operator*(Matrix3x3 m1, Matrix3x3 m2) { Matrix3x3 out; for (i = 0; i < 3; i = i + 1) { for (j = 0; j < 3; j = j + 1) { out.A[i][j] = 0.0; for (k = 0; k < 3; k = k + 1) out.A[i][j] = out.A[i][j] + m1.A[i][k]*m2.A[k][j]; } } return(out); } - Example usage:
int main(int argc, char *argv[]) { Matrix3x3 A, B, C; C = A * B; }
- Example Program:
(Demo above code)
- Prog file: click here
- This is
NOT recommended
because of
inefficiency
(a lot of data must be
copied in )
- (I assume that you understand the
risks
of passing
variables
by
reference -
you risk changing the original variable.
But you gain a lot of speed )