Introduction to Objects and Object Oriented Programming

What are "Objects"
- Programs often consist of different parts with a very specific purpose/functionality
- A certain functionality is achieved/provided by one or more function operating on some common information
- Example:
  - A numerical analysis library can consist of a set of functions
  - These functions operate on some common information (e.g., input matrix, initial condition, etc)
- Presently, the information that the functions operate on, and the functions themselves, can be stored in different physical location (places)
- A logical step in the development of programming languages is to bring data and functions together and make it a coherent unit:
  - The common data that are shared by a specific set of function that manipulate them are identified
  - Functions that are inside the "privilage set" have unlimited access to the data
  - But functions that are outside the "privilage set" are given provisional access on a function-by-function basis (or no access at all).
Separation of data and instructions
- Consider a 3x3 matrix structure:
  Recall how to define reference variables and use it to access components in a class:
  This will be very important in the next discussion....
- Consider the following function that adds a matrix and a number:
- You should know how to invoke this function AddNum with the address of an 3x3 array (matrix) and a number x:
- Example Program: (Complete program with AddNum) ---- click here
- You can clearly see that there is no "bond" between the type Matrix3x3 and the function AddNum that operates on the Matrix3x3 data type.
- Besides of no obvious bonding, C++ provides mechanisms to let you "fool" the compiler...
  You probably do not want to do the following, but you can easily fool the compiler with underhanded programming tricks, and the AddNum will add anything (which are not necessarily Matrix3x3 variables...
- Example Program: (Fooling the C++ compiler...) ---- click here
  Just compile the program, no errors !!!

Associating data and functions: objects

The million dollar question is now:

Suppose if we like to designate this function for exclusive use: this function will only add 3x3 array (matrix) that are defined using Matrix3x3 ???

I put the original programs here for easy comparison:

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

void AddNum(Matrix3x3 *p, float x) { int i, j; for (i = 0; i < 3; i = i + 1) for (j = 0; j < 3; j = j + 1) p->A[i][j] = p->A[i][j] + x; };

C++ allows you to include function inside class definitions as follows:

class Matrix3x3 { public: float A[3][3]; void AddNum(float x) { int i, j; for (i = 1; i < 3; i = i + 1) for (j = 1; j < 3; j = j + 1) this->A[i][j] = this->A[i][j] + x; }; };

The inclusion of the function AddNum puts this function into the "exclusive set"

Notice that the FIRST parameter (p) is missing from the parameter list.

The reason is that every in this "exclusive set" MUST operate on one variable of the enclosing type (which is Matrix3x3).

This assumed parameter variable is accessed through the special pointer PARAMETER variable this.

(And you do NOT need to define this special parameter variable this - every "special function" has one "automatically")

In other words:

Every function in the "exclusive set" of function has an assumed (hidden) parameter variable this.

The type of the variable this is (className *) - where "className" is the name of the enclosing class

The functions defined inside a class (which always have an assumed parameter this) are known as member functions

Using classes with member functions: how to invoke member functions
- A member function must always be invoked using one (reference) variable of the designated type
- Syntax:
  - The parameters in the AddNum() call are:
    - M
    - 4
  - Notice that the first parameter is written outside the "traditional brace notation".
  - Notice that although the variable "M" is used, the address of the variable "M" is passed by value to the member function
    This value (= the address of the variable "M") is copied into the assumed parameter variable this!!!
- Example Program: (Using a member function) ---- click here

Shorthand: dropping this->

Since member functions always operate on a class variable that is accessed through the pointer variable this, it can be pretty tedious to write "this->" before every element accessed...
Hence, C++ allows the programmer to "shorthand" the access of member elements this->MemberVariable into: MemberVariable

The class definition can be shortened to:

class Matrix3x3 { public: float A[3][3]; void AddNum(float x) { int i, j; for (i = 1; i < 3; i = i + 1) for (j = 1; j < 3; j = j + 1) A[i][j] = A[i][j] + x; }; };

Example Program: (Demo the shorthand notation) ---- click here

Member operator functions

Operator functions can also be defined as member functions (member operator).
You know ofcourse that the following 2 expressions are equivalent:
- When C++ encounters the expression a + b, the C++ compiler would find the function operator+(type(a), type(b)).
However, if operator+ were a member function, the way to invoke this function would look like:
C++ needs to amend its rules in order to accomodate member operator functions:
- When C++ encounters the expression a + b, the C++ compiler find a function operator+(type(a), type(b)) or a member function type(a).operator+(type(b)).

Example:

class Matrix3x3 { public: float A[3][3]; void operator+(float x) { int i, j; for (i = 0; i < 3; i = i + 1) for (j = 0; j < 3; j = j + 1) A[i][j] = A[i][j] + x; } };

int main(int argc, char *argv[]) { Matrix3x3 M; ... M + 4; }

Example Program: (Member operator function) ---- click here

Difference between member functions and member operators
- The C++ compiler can tell the difference between
  - f(a, b) is a non-member function that takes two parameters of type(a) and type(b).
  - a.f(b) is a member function from the class type(a) that takes one parameters of type(b)
- However..., consider the following 2 expression:
  - When the C++ compiler encounters the expression a + b, the C++ compiler will decide on one of the two above functions.
  - Because the C++ compiler must decide on one of two possible operation functions, if you present both options to the C++ compiler, then the C++ compiler CANNOT make the decision (too many choices are not good :-))
- Example:
  - Here is a program where we define an ordinary member and a non-member function with the same name and types of variables: click here ----
    This program will compile and run
  - Here is a program where we define a member and a non-member operaror function with the same name and types of variables: click here ----
    This program will not compile due to ambiguity...