2. Encapsulation

To encapsulate means to enclose in a capsule. It is a common perception that the term is assosiated with object-oriented programming wherein we tend to group data and related methods in a class. This need not be the case. A class can be used simply for grouping.

2.1  Constants encapsulated in a header file

Aside from any special object oriented features like classes, C++ contains a simple mechanism for encapsulation. This mechanism is a "header file".

Header files are commonly used to place related data items and functions together so that they are accessible to mutltiple programs. Encapsulation can be demonstrated using a header file as seen in the following example.
 

// The header file "MyConstants.h" is a collection of constants  // This is a form of encapsulation.  const float PI = 3.142;  const float KM_TO_MILES = 0.625;  const float MILES_TO_KM = 1.60;  const float CM_TO_INCHES = 0.393;  const float INCHES_TO_CM = 2.54;  const float LITERS_TO_GALLONS = 0.2702;  const float GALLONS_TO_LITERS = 3.70;  // This is a progrm that makes use of the above header file  #include<iostream.h>  #include "MyConstants.h"  int main(void) {     cout << "The value of PI is:" << PI << endl;    cout << "10 liters are:     " << 10*LITERS_TO_GALLONS;    cout << "gallons" << endl;     cout << "10 centimeters are:" << 10*CM_TO_INCHES;    cout << "inches"  << endl;     cout << "10 miles are:      " << 10*MILES_TO_KM;    cout << "Kilometers" << endl;     return 0;  }

2.2 Constants encapsulated in a class

Consider a case where only constants are enclosed in a class. In order to assign values to the constants, a constructor is required. This is because direct setting of constants is not permitted in a class.
 

#include<iostream.h> // The class MyConstants encapsulates public constants  class MyConstants {public:    MyConstants();    const float PI;    const float KM_TO_MILES;    const float MILES_TO_KM;    const float CM_TO_INCHES;    const float INCHES_TO_CM;    const float LITERS_TO_GALLONS;    const float GALLONS_TO_LITERS; }; // For assigning values to constants in a class we must pass the // values as parameters through the constructor.  MyConstants::MyConstants():    PI(3.142),              KM_TO_MILES(0.625),    MILES_TO_KM(1.6),       CM_TO_INCHES(0.393),    INCHES_TO_CM(2.54),     LITERS_TO_GALLONS(0.2702),    GALLONS_TO_LITERS(3.70) {} int main(void){    MyConstants C;    cout << "The value of PI =" << C.PI << endl;    cout << "10 liters = "      << 10*C.LITERS_TO_GALLONS;    cout << "gallons" << endl;    cout << "10 centimeters = " << 10*C.CM_TO_INCHES;    cout << "inches"  << endl;    cout << "10 miles = "       << 10*C.MILES_TO_KM;    cout << "Kilometers" << endl;    return 0; }

2.3   Variables encapsulated in a class

The encapsulation of variables in a class can be defined by declaring the variables either public or private. The public variables form the visible part of the package (class). This part contains all the information that another program unit is able to know about this class. The private variables, on the other hand, contain the information, which can be used only within the class.

In the following example, data is acquired from the satellite and encapsulated in the class called WeatherVars. For the sake of simplicity, a single value is returned from all calls to the functions of the class Satellite. In reality this will not be the case as the variables Temperature, Humidity, WindSpeed and WindDirection change with time. Different values are returned when these functions are called in a real time environment.
 

// The class WeatherVars encapsulates weather related parameters. class WeatherVars {public:    float Temperature[30];    float Humidity[30];    float WindSpeed[30];    int   WindDirection[30]; }; // The class Satellite acquires data from the satellite. class Satellite {public:    float GetTemperature(void)   {return 32.98;};    float GetHumidity(void)      {return 67.98;};    float GetWindSpeed(void)     {return 45.54;};    int   GetWindDirection(void) {return 120;  }; }; // The main function reads data from satellite. It takes 30 samples // per second and stores the data,in W of class WeatherVars. // The object W may be accessed later for further processing. int main(void){    int i;    WeatherVars W;    Satellite S;    for(i = 0; i <= 30; i++){       W.Temperature[i]   = S.GetTemperature();       W.Humidity[i]      = S.GetHumidity();       W.WindSpeed[i]     = S.GetWindSpeed();       W.WindDirection[i] = S.GetWindDirection();       cout << "I am reading data from the satellite." << endl;    }    return 0; }

2.4  Encapsulated functions

In addition to constants and variables, functions can also be encapsulated in a class.
 

// Class MathOperations encapsulates various mathematical functions. // They are all declared as public and can be accessed by users. class MathOperations {public:    int   AddTwoNums(int a, int b);    int   SubTwoNums(int a, int b);    float DivTwoNums(float a, float b);    int   MulTwoNums(int a, int b);    int   GetCube(int a);    int   GetSqr (int a);    float GetSqrt(int a); }; int MathOperations::AddTwoNums(int a, int b){ return (a + b);} int MathOperations::SubTwoNums(int a, int b){ return (a - b);} float MathOperations::DivTwoNums(float a, float b){    if (b != 0)       return (a / b);    else{       cout <<" A number cannot be divided by zero." << endl;       return 0;    } } int MathOperations::MulTwoNums(int a, int b) {return (a*b);} int MathOperations::GetCube(int a)           {return (a*a*a);} int MathOperations::GetSqr(int a)            {return (a*a);} float MathOperations::GetSqrt(int a){    if (a < 0){       cout << "Square root of a negative number does not exist." << endl;       return 0;    }else       return (sqrt(a)); } int main(void){    MathOperations X;    cout << " 2 + 3 = " << X.AddTwoNums(2,3) << endl;    cout << " 2 - 3 = " << X.SubTwoNums(2,3) << endl;    cout << " 2 / 3 = " << X.DivTwoNums(2,3) << endl;    cout << " 2 * 3 = " << X.MulTwoNums(2,3) << endl;    cout << "Cube of 2 = "        << X.GetCube(2)  << endl;    cout << "Square of 2 = "      << X.GetSqr(2)   << endl;    cout << "Square root of 4 = " << X.GetSqrt(4)  << endl;    return 0; }

The output of this program is

 2 + 3 = 5
 2 - 3 = -1
 2 / 3 = 0.666667
 2 * 3 = 6
 cube of 2 = 8
 square of 2 = 4
 square root of 4 = 2.0

The object-oriented meaning of encapsulation is to enclose related data, routines and definitions in a class capsule. This does not necessarily mean data hiding. This is evident from the above examples. The classes MyConstants, MyVariables, and MathOperations are defined to contain only public members. They do not hide any data. They merely enclose related data.

It is generally not required to know the implementation details of methods. This results in separating the contents of class into a public interface (only method declarations are present in the class header) and the implementation details. The interface is the visible surface of the capsule, while the implementation is hidden in the capsule.

2.5  Class Earth

Data hiding is evident in the class Earth below. Both data and functions can be encapsulated in a class.
 

// Class Earth defines properties of planet Earth. class Earth{ public:    int NumOfOceans;    int NumOfContinents;    Earth();    double GetVolume();    double GetEscapeVel(); private:    double Mass;    double Density;    double EquatorialRadius;    double GravConstant; }; // This constructor assigns values to the inherent properties of the class earth. Earth::Earth(){    NumOfOceans     = 8;    NumOfContinents = 7;    Mass            = 5.98e+24;    Density         = 5536.00;    EquatorialRadius= 6.378e+6;    GravConstant    = 6.67e-11; } double Earth::GetVolume() {return Mass/Density;} double Earth::GetEscapeVel(){    double temp1;    temp1 = 2*Mass*GravConstant/EquatorialRadius;    return (sqrt(temp1)); } int main(void){    Earth E;    cout << "There are " << E.NumOfOceans;         << " oceans on the planet Earth" << endl;    cout << " The volume of earth is " << E.GetVolume();         << " cubic meters" << endl ;    cout << " The earth's escape velocity is ";         << E.GetEscapeVel() << "m/s" << endl;    return 0; }

The above class really defines a class of earth  "objects" as discussed in Chapter 3. Note that logically there is only one instance for the class Earth. This is so because there is no logic in defining two earth objects, as the properties of the earth are unique.

2.6 Class to format text

The next example applies the concept to a more informal entity, a format. Formatting is primarily the organization of text to suit a user's needs. Multiple instances of the format class below do not make sense as each instance would be performing the same operations.
 

// This class defines report properties.  class Format{ public :    format()              {PageNum = 1;};    char  Tab()           {return "\t";};    char  Newline()       {return "\n";};    char* PageTitle()     {return " Class Report ";};    char* Header()        {return "EECS 6500, 1999";};    int   Footer()        {return PageNum; };    void  IncrementPage() {PageNum++;}; private:    int   PageNum; }; // This program simply demonstrates the use of the format class. int main(void){    format Document;    cout << " The Page Title for this Document is ";    cout << Document.PageTitle() << Document.Newline();    for(int i = 0 ; i < 3 ; i++){       cout << Document.Tab();            << "The header for this Document is ";            << Document.Header() << Document.Newline();       cout << Document.Tab();            << "The current page number is ";            << Document.Footer() << Document.Newline();       Document.IncrementPage();    }    return 0; }

In short, encapsulation is grouping conceptually related information and operations together.

References:

1. STC Ada Language Reference Manual. Western Digital Corporation, 1983.
2. Henry F. Ledgard. The Little Book of Object-Oriented Programming. Prentice-Hall, 1996.
3. Bjarne Stroustrup. What Is Object-Oriented Programming. IEEE Software, May 1988.