- Design principles
- Determine the
functionality:
-
this will become the set of
functions
that you must provide in the class
- Determine
what information is needed
to
implement
the
functions:
-
this will become the set of
class variables
that you must provide in the class
- Determine the
functionality:
- We will use 3x3 matrices
to learn how to design
functionalities
for a class
- Example 3x3 matrix:
+- -+ | 1 2 3 | | 4 5 6 | | 7 8 9 | +- -+
- Why only 3x3, why not NxN:
I want to focus on programming issues NOT algorithmic issues Once you have mastered the programming techniques, you can easily write the same functions for NxN matrices
- Class name:
class Matrix3x3 { ..... }; // <--- Note: class definition must end in ;
- The Final Functionality will include:
- scalar * Matrix3x3
Matrix3x3 A, B; B = 67 * A;
- Matrix3x3 * Matrix3x3
Matrix3x3 A, B, C; C = A * B;
- Matrix3x3 * Vector3
Matrix3x3 A; Vector3 v, u; v = A * u;
- Vector3 * Matrix3x3
Matrix3x3 A; Vector3 v, u; v = u * A;
- And so on...
- scalar * Matrix3x3
- But it will be a long way before we will get to that point.
- Problem:
What information is necessary to represent a 3x3 matrix ?
- Solution:
class Matrix3x3 { public: double A[3][3]; }; // <--- Note: class definition must end in ;
- When we define a new class :
class Matrix3x3 { public: double A[3][3]; };there are NO functions existing that accept a parameter of that class.
Then obviously you CANNOT invoke any function using a parameter of the new class
We must write some first....
I compare writing functions that uses the new class
Teach the compiler what to do with the new class
- Consider the following
naive
Matrix + Scalar
function:
+- -+ +- -+ | 1 2 3 | | 8 9 10 | | 4 5 6 | + 7 = | 11 12 13 | | 7 8 9 | | 14 15 16 | +- -+ +- -+
- Input parameters:
- a Matrix3x3 parameter
- a double parameter
- Output parameters:
- a Matrix3x3 parameter
- Version 1: ordinary function
class Matrix3x3 { public: double A[3][3]; }; Matrix3x3 addScalar(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 = addScalar(&B, 40); }
- Example Program:
(Demo above code)
- Prog file: click here
- Version 2: member function
- Remember
that
every class function
has an
implicit parameter (this)
that has the
same type as the class
- Notice:
Matrix3x3 addScalar(Matrix3x3 *m, double x) { ... }the parameter m has the same type as the class Matrix3x3
(It should not come as a surprise, because the addScalar() function performs operation with Matrix3x3 matrix !)
- We can (and will) make
addScalar()
into a
member function in the Matrix3x3 class
by
passing
m
as a
implicit parameter
The function call will become:
m.addScalar(x)
- Remember
that
every class function
has an
implicit parameter (this)
that has the
same type as the class
- Solution:
class Matrix3x3 { public: double A[3][3]; Matrix3x3 addScalar(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); } };NOTE:
- The input parameter m
is now the
implicit parameter this
- To access the variable
A[i][j]
in the
implicit parameter ,
we must use:
this->A[i][j]
- Because there is no
local or parameter variable
defined that has the
name A ,
we can also use:
A[i][j]
( this is not necessary)
- The input parameter m
is now the
implicit parameter this
- How to use this function:
int main(int argc, char *argv[]) { Matrix3x3 B, C; C = B.addScalar(40); }
- Example Program:
(Demo above code)
- Prog file: click here
- Consider the following
more
useful
Matrix + Matrix
(matrix addition)
function:
+- -+ +- -+ +- -+ | 1 0 0 | | 1 2 3 | | 2 2 3 | | 1 1 0 | + | 4 5 6 | = | 5 6 6 | | 1 1 1 | | 7 8 9 | | 8 9 10 | +- -+ +- -+ +- -+
- Input parameters:
- a Matrix3x3 parameter
- a second Matrix3x3 parameter
- Output parameters:
- a Matrix3x3 parameter
- Version 1: ordinary function
class Matrix3x3 { public: double A[3][3]; }; Matrix3x3 addMatrix(Matrix3x3 *m1, Matrix3x3 *m2) { 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] = m1->A[i][j] + m2->A[i][j]; return(out); } - How to use this function:
int main(int argc, char *argv[]) { Matrix3x3 A, B, C; C = addMatrix(&A, &B); }
- Example Program:
(Demo above code)
- Prog file: click here
- Version 2: member function
- We can make
addMatrix()
into a
member function in the Matrix3x3 class
by
passing
m1
as a
implicit parameter
The function call will become:
m1.addMatrix(m2)
- We can make
addMatrix()
into a
member function in the Matrix3x3 class
by
passing
m1
as a
implicit parameter
- Solution:
class Matrix3x3 { public: double A[3][3]; Matrix3x3 addMatrix(Matrix3x3 *m2) { 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] + m2->A[i][j]; return(out); } };NOTE:
- Again, to access the variable
A[i][j]
in the
implicit parameter ,
we must use:
this->A[i][j]
- Because there is no
local or parameter variable
defined that has the
name A ,
we can also use:
A[i][j]
( this is not necessary)
- Again, to access the variable
A[i][j]
in the
implicit parameter ,
we must use:
- How to use this function:
int main(int argc, char *argv[]) { Matrix3x3 A, B, C; C = B.addMatrix(&A); }
- Example Program:
(Demo above code)
- Prog file: click here