
OOPS - OBJECT ORIENTED PROGRAMMING

FUNDAMENDAL IDEA :-
--------------------

  TO COMBINE INTO A SMALLER UNIT BOTH DATA AND THE FUNCTIONS THAT
OPERATE ON THE DATA, SUCH A UNIT IS CALLED THE OBJECT.

  AN OBJECT FUNCTION PROVIDES THE ONLY WAY TO ACCESS THE DATA.THUS THE 
DATA IS HIDDEN AND IS SAFE FROM ACCIDENTAL ALTERATION, DATA AND FUNCTIONS 
ARE ENCAPSULATED INTO A SINGLE ENTITY ,DATA ENCAPSULATION AND DATA HIDING 
ARE THE KEY TERMS USED FOR DESCRIBING AN OBJECT ORIENTED LANGUAGE.

  THE FUNCTIONS OF AN OBJECT ARE CALLED THE MEMBER FUNCTIONS IN C++, 
THESE MEMBER FUNCTIONS ARE CALLED METHODS IN OTHER OBJECT ORIENTED LANGUAGE 
LIKE SMALL TALK

OBJECTS
MEMBER DATA
MEMBER FUNCTONS

CHARACTERISTICS OF AN  LANGUAGE
-------------------------------
THE IMPORTANT ELEMENTS OF AN OBJECT ORIENTED LANGUAGE ARE :-
CLASS

AN OBJECT IN C++ IS AN INSTANCE OF A CLASS, FOR EG. 
INT A,B,C;
A,B,C ARE THREE VAIABLES OF TYPE INT, YOU CAN DEFINE MANY OBJECTS OF 
THE SAME CLASS.

AN ANOLOGY
----------
FORD,OPELAND LANCER SHARE CERTAIN SIMILAR FEATURES AND HENCE CAN BE 
GROUPED TO FORM THE OBJECTS OF THE CLASS CARS.

INHERITANCE
-----------
  INHERITANCE IS THE PROCESS OF CREATING A NEW CLASS, CALLED THE DERIVED 
CLASS,FROM THE EXISTING CLASS CALLED THE BASE CLASS.

AN ANOLOGY
----------
 MOTORCYCLES, CARS AND TRUCKS HAVE CERTAIN COMMON PROPERTIES - ALL HAVE 
WHEELS, ENGINES, HORNS, ETC. THUS THEY CAN BE GROUPED UNDER A CLASS CALLED 
AUTOMOBLES. APART FROM SHARING THESE COMMON FEATURES, EACH SUBCLASS HAS ITS 
OWN PARTICULAR CHARACTERISTICS - CAR USE PETROL WHILE TRUCKS USE DIESEL.

REUSABILITY
-----------
 IN OOP, THE CONCEPT OF INHERITANCE PROVIDES THE IDEA OF REUSABILITY. 
THIS MEANS THAT WE CAN ADD ADDITIONAL FEATURES TO AN EXISTING CLASS WITHOUT 
MODIFYING IT. THIS IS POSSIBLE BY DERIVING A NEW CLASS FROM AN EXISTING 
ONE .THE NEW CLASS WILL HAVE THE COMBINED FEATURES OF BOTH THE CLASSES.

POLYMORPHISM
------------
 THE WORD POLYMORPHISM IS DERIVED FROM TWO LATIN WORDS POLY(MANY) AND 
MORPHOS (FORMS). THE CONCEPT OF USING OPERATORS OR FUNCTIONS IN DIFFERENT 
WAYS, DEPENDING ON WHAT THEY ARE OPERATING ON, IS POLYMORPHISM.
FOR EXAMPLE AN OPERATION MAY EXHIBIT DIFFERENT BEHAVIOR IN DIFFERENT INSTANCES.
THE BEHAVIOR DEPENDS UPON THE TYPES OF DATA USED IN THE OPERATION.
FOR EXAMPLE CONSIDER THE OPERATION OF ADDITION. FOR TWO NUMBERS 
THE OPERATION WILL GENERATE A SUM. IF THE OPERANTS ARE STRINGS, THEN THE 
OPERATION  WOULD PRODUCE A THIRD STRING BY CONCATENATION.

CLASS & OBJECTS 
---------------
CLASS SPECIFIER 
---------------
 THE SPECIFIER FOR A CLASS WITH THE KEYWORD CLASS FOLLOWED BY THE CLASS 
NAME. 
EG:  CLASS ADD

DEFINING THE OBJECT
-------------------
 ADD A1;

   THE ABOVE STATEMENT DEFINES AN OBJECT A1, WHICH IS AN INSTANCE OF A 
CLASS CALLED ADD. IT IS THIS DEFINITION THAT ACTUALLY CREATES OBJECTS AND 
ALLOCATES MEMORY FOR THEM.

ACCESS SPECIFIERS 
-----------------
* PRIVATE  -> CANNOT BE ACCESSED OUTSIDE THE CLASS
* PUBLIC   -> CAN BE ACCESSED OUTSIDE THE CLASS.

MEMBER FUNCTIONS 
----------------
 FUNCTIONS WHICH ARE DECLARED INSIDE THE CLASS

EG.

VOID SUM(VOID)
{
}

INVOKING MEMBER FUNCTIONS 
-------------------------
A1.SUM();
 MEMBER FUNCTION
OBJECT
 
 THE DOT OPERATOR ALSO CALLED THE CLASS MEMBER ACCESS OPERATOR, IS USED 
TO ASSOCIATE THE OBJECT NAME WITH THE MEMBER FUNCTION.

SCOPE RESOLUTION OPERATOR (::)
------------------------------
   THE MEMBER FUNCTIONS ARE DEFINED WITHIN THE CLASS. THESE FUNCTIONS CAN 
BE DEFINED OUTSIDE THE BOUNDARIES OF THE CLASS USING THE SCOPE RESOLUTION 
OPERATOR.


VOID ADD::INPUT(INT A,INT B);
|     |    |
|     |    FUNCTION NAME
|     CLASS NAME 
RETURN TYPE OF THE FUNCTION INPUT()

NOTE : THE DECLARATION VOID INPUT(INT,INT); INFORMS THE COMPILER THAT THIS 
IS A MEMBER OF A CLASS BUT WILL BE DEFINED OUTSIDE THE CLASS.

CONSTRUCTORS
------------

 EVERY OBJECT WOULD HAVE A COPY OF MEMBER DATA WHICH REQUIRES 
INITIALINSATION BEFORE IT CAN BE USED ,THERE IS NO POSSIBILITY OF 
MEMBER DATA GETTING INITIALISED AUTOMATICALLY WHENEVER AN OBJECT IS CREATED.
SINCE THIS REQUIREMENT IS SO COMMON, C++ ALLOWS OBJECTS TO INITIALISE 
THEMSELVES AS AND WHEN THEY ARE CREATED . THIS AUTOMATIC INITIALISATION  IS 
PERFORMED THROUGH THE USE OF CONSTRUCTOR FUNCTIONS

DECLARATION OF CONSTRUCTORS
---------------------------
CLASS ADD
{
PRIVATE:
 INT A,B,C;

PUBLIC:
 ADD();   // CONSTRUCTOR
 VOID INPUT(INT,INT);
 VOID SUM(VOID);
 VOID DISP(VOID);
};

ADD::ADD()
{
A=B=C=0;
COUT << "CONSTRUCTOR INVOKED" << ENDL;
}
NOTE : IF NO CONSTRUCTORS ARE DECLARED FOR A CLASS, THE COMPILER INVOKES 
ITS OWN CONSTRUCTOR.

OVERLOADING CONSTRUCTORS CAN BE ALSO PERFORMED

DESTRUCTORS 
-----------
	 
   DESTRUCTORS ARE FUNCTIONS THAT ARE COMPLIMENTARY TO CONSTRUCTORS. THEY 
DE-INITIALIZE OBJECTS WHEN THEY ARE DESTROYED. A DESTRUCTOR IS INVOKED WHEN 
AN OBJECT OF THE CLASS GOES OUT OF SCOPE, OR WHEN THE MEMORY OCCUPIED BY 
ITS DEALLOCATED USING THE DELETE OPERATOR.

DECLARATION OF DESTRUCTORS
--------------------------
   A DESTRUCTOR IS A FUNCTION THAT HAS THE SAME NAME AS THAT OF THE CLASS BUT 
IS PREFIXED WITH A ~(TILDE),OVERLOADING A DESTRUCTOR IS NOT POSSIBLE.

 A CLASS HAVE ONLY ONE DESTRUCTOR. A DESTRUCTOR WILL NOT RETURN A VALUE 
OR ARGUMENTS CANNOT BE PASSED.

ADVANTAGES OF OOPS
------------------
* THROUGH INHERITANCE, WE CAN ELIMINATE REDUNDANT CODE AND EXTEND THE USE 
  OF EXISTING CLASSES.

* WE CAN BUILD PROGRAMS FROM THE STANDARD WORKING MODULES THAT COMMUNICATE 
  WITH ONE RATHER THAN HAVING TO START WRITING THE CODE FROM SCRATCH.THIS 
  LEADS TO SAVING OF DEVELOPMENT TIME AND HIGHER PRODUCTIVITY.

* THE PRINCIPAL OF DATA HIDING HELPS THE PROGRAMMER TO BUILT SECURE PROGRAMS 
  THAT CANNOT BE INVADED BY CODE IN OTHER PARTS OF THE PROGRAM.

* IT IS POSSIBLE TO HAVE MULTIPLE INSTANCES OF AN OBJECT TO CO-EXIST WITHOUT 
  ANY INTERFERENCE

* IT IS EASY TO PARTITION THAT WORK IN A PROJECT ENABLES US TO CAPTURE MORE 
  DETAILS OF A MODEL IN IMPLEMENTABLE FORM.

* OBJECT ORIENTED SYSTEMS CAN BE EASILY UPGRADED FROM SMALL TO LARGE SYSTEMS.

* MESSAGE PASSING TECHNIQUES FOR COMMUNICATION BETWEEN OBJECTS MAKES THE 
  INTERFACE DESCRIPTIONS WITH EXTERNAL SYSTEMS MUCH SIMPLER

* SOFTWARE COMPLEXITY CAN BE EASILY MANAGED.
