• Unlike other programming language paradigms the object-oriented paradigm is both a programming style as well as a methodology.
• The methodology is concerned with:
  1. Flexibility and adaptability
  2. Software reuse
  3. Consistent notation and integration of the design phases.
• Broadly we can state that the OOP methodology partitions a problem into subgroups of related parts, these groups are then presented in a hierarchy and each group is referred to as an object.

EXAMPLE OBJECT ORIENTED LANGUAGES

The key feature of Object Oriented Programming (OOP) is, as the name suggests, the object. An object can be thought of as some real world entity which a programmer wishes to "model".

Classes describe categories of object. They define the data (attributes or features) that can be associated with an object, and the functions (operations or methods) that can be applied to them. Consequently we say that a particular object is an instance of a class.

In C++ a class is considered to be a compound data type (this is not the case in all OOP languages, e.g. Smalltalk'80). Thus, in C++, a class definition can be viewed as a template which enables the programmer to declare instances of a particular class (type).

Components of a class can be either data members or function members (member functions) Further, in C++, three categories of membership are identified:

1. PUBLIC. Members which can be accessed from any where in a program.
2. PRIVATE. Members for internal use (i.e. within the object) which can only be accessed from outside the object through the use of public member functions.
3. PROTECTED. Private members which are inherited by classes derived from the current class.

Thus a C++ class can comprise, at most, three sections corresponding to the above three access categories. Note that, since one of the principals of OOP is data hiding, data is normally declared in the private section of a class.

Most OOP languages provide a set of preprogrammed ("built-in") classes and objects to support common operations such as Input and Output (I/O). For this purpose C++ provides the built in classes ostream and istream, and a number of objects which are instances of the classes ostream and istream. The most commonly used ostream and istream objects are:

1. cout, an output object, which is an instance of the class ostream, and is designed to output data to the screen.
2. cin, an input object, which is an instance of the class istream, and is designed to input data to a program.

BUILT IN CLASSES FUNCTION (MEMBERS)

Naturally, built in classes also have built in member functions associated with them which may be used by the programmer directly. To associate a member function with an object we use a member operator (`.') in a similar manner to that used to access "members" of C structures. For example the istream class has a built in function getline. This can be be associated with the cin input object as follows:

cin.getline(name,N);

The getline function is used to read a specified number of characters (specified by N) into an array specified by the argument name.

C++ example program using cout and cin

#include < iostream.h >

int main(void)
{
const int Size = 20;
char name[Size];

cin.getline(name,Size);

cout << name << "\n";
}

With respect to the above code the following points should be noted:

1. The << operator is referred to as the input operator and is used to pass messages to cout objects.
2. The >> operator is referred to as the output operator and is used to return responses from cin objects.
3. Both cout and cin are smart objects capable of automatically converting information from one form to another according to program context (i.e. we do not have to define the input or output type as we do in C).
4. Not only is cout an ostream object but so is (say) cout << "Yum!"; this feature allows us to write sequences of << operators.

Only a limited amount of programming can be achieved using the built in classes and their members. For most real applications programmers must define their own classes and members.

A C++ example of a user defined class definition

// circle.h

class Circle {
        public:
                float Radius;
                float Area;
                float Circumference;
        };

Here we have created a class Circle which has three data members: Radius, Area and Circumference. Further points to note concerning the above code:

• The class contains only public data members (members that can be accessed from anywhere in a program).
• It is common practice to:
  1. Declare all class definitions in a separate header (.h) file, and
  2. To commence class data member names (and class function member names) with an upper case letter.

CREATING INSTANCES OF PROGRAMMER DEFINED CLASSES

#include "circle.h"
#include <math.h>
#include <iostream.h>

main()
{
Circle disc;
const float pi = 22.0/7.0;

cin >> disc.Radius = 7.0;
disc.Area = pi*disc.Radius*disc.Radius;
disc.Circumference = pi*disc.Radius*2;

cout << "Radius:   "  << disc.Radius << "\n" ;
cout << "Area:     "  << disc.Area << "\n" ;
cout << "Circumference: " << disc.Circumference << "\n" ;
}

Points to note:

• The header file circle.h has been included using a #include statement.
• When an object is created we say that it has been initialised.
• When an object that exists has values allocated to it we refer to this as assignment.
• In appearance, a C++ member function is identical to a standard C function and can be used in a similar manner.
• To compile the above use the "spell" CC -Aa -o FILENAME FILENAME.C this will create an executable file called FILENAME from a source file called FILENAME.C.

In line with the principal of data hiding, in the above example, we would prefer the data to be hidden (i.e. private):

// circle.h

class Circle {
        private:
                float Radius;
                float Area;
                float Circumference;
        };

However, to support this, we now require a public function to create instances of the class. C++ provides a special class member function, called a constructor, to do this. A constructor function has the same name as its class name. For each programmer defined class C++ automatically creates a default constructor. We can thus write a short program to create an instance of the above class, using a constructor function, as follows:

#include "circle.h"

void main(void)
{
Circle disc = Circle();
}