Operators in C++: nothing more than functions with a weird name...

What is an operator
- Consider the following two expressions:
  - In C++, these expressions are the same !
- Every operator in C++ is a function with 2 parameters

A Matrix multiplication operator

Traditional operators (such as "+", "-", "*", "&&", "||", etc) do not work with user-defined classes
The reason is very simple: the computer does not know how to manipulate informations in a user-defined classes
In order to allow operators to work with user-defined classes, we must instruct (teach) C++ how to manipulate the information in the user-defined classes (after all, you have defined this class yourself, so you should know what to do with the information - if not, you are in deep trouble...).
Consider the following 3x3 matrix class (structure variable):
Suppose we want to write a program that multiply two matrices:
- The C++ programming language will complain because it does not know how to multiply Matrix3 variables
- You can satisfy C++'s complain by teaching C++ how to multiply two Matrix3 variables
As discussed above, these two expression are the same in C++:

Therefore, we can satisfy C++'s demand by defining the following function:

Matrix3 operator*(Matrix3 M1, Matrix3 M2) { Matrix3 r; int i, j, k; for (i = 0; i < 3; i=i+1) for (j = 0; j < 3; j=j+1) r.A[i][j] = 0; for (i = 0; i < 3; i=i+1) for (j = 0; j < 3; j=j+1) for (k = 0; k < 3; k=k+1) r.A[i][j] = r.A[i][j] + M1.A[i][k]*M2.A[k][j]; return r; }

Clearly, the parameter type of the input must be Matrix3
Since the output is assigned to a Matrix3 variable, the output type must also be Matrix3

Example Program: (Matrix multiply operator) ---- click here

Safety versus Efficiency

Consider the matrix multiplication operator function from above:

How are the input parameters M1 and M2 passed in ?
By value... in other words: by making a copy of the entire variable (in this case, copying 9 float variables)
This can be a big problem is you have a 1000x1000 matrix... the computer will spend too much time doing useless copying....
But that is the safest thing to do, since this way, you prevent the original matrix to be altered.
But in every case, you have weight the benefit and the cost of safety through passing by value.
In this case, to cost is too much to pay.

A faster (but less safe) implementation is:

Matrix3 operator*(Matrix3 & M1, Matrix3 & M2) { Matrix3 r; int i, j, k; for (i = 0; i < 3; i=i+1) for (j = 0; j < 3; j=j+1) r.A[i][j] = 0; for (i = 0; i < 3; i=i+1) for (j = 0; j < 3; j=j+1) for (k = 0; k < 3; k=k+1) r.A[i][j] = r.A[i][j] + M1.A[i][k]*M2.A[k][j]; return r; }

The input parameters are passed by reference: only the address (of the first memory location of the matrix) is copied.

Example Program: (Compare performance of by value and by ref) ----
- This program execute a by value function many times: click here
- This program execute the same program by reference many times: click here
- Compile the programs using:
- Run the programs using:

Matrix-vector multiplication

Using the same technique, we can define a Matrix-vector multiplication operation...

We define a Matrix3 class as before:

class Matrix3 { public: float A[3][3]; };

We define a Vector3 class as before:

class Vector3 { public: float x[3]; };

We want the capability to write the following expression:

Matrix3 M; Vector3 v1, v2; v2 = M * v1; // Matrix3 * Vector3

Considering the input parameter types and the output type, we come to the conclusion that we must define the following operator function:

Vector3 operator*(Matrix3 & M, Vector3 & v) { Vector3 z; int i, j; for (i = 0; i < 3; i=i+1) z.x[i] = 0; for (i = 0; i < 3; i=i+1) for (j = 0; j < 3; j=j+1) z.x[i] = z.x[i] + M.A[i][j]*v.x[j]; return z; }

Example Program: (Matrix-Vector multiply operator) ---- click here