When working with the object oriented paradigms, classes are the most commonly used tools. So here we are to make you understand the simple but the most important concept. This post mainly discusses the concept of encapsulation, where we shall first see what are classes and objects and then relate them to encapsulation.

Starting from the very basics, what are classes and why do we use them? Suppose that your teacher has asked you to develop a program that stores data about cars in a car showroom. Now think over the task and find objects that are required to solve the problem. In this case we only need cars as our object to complete our task.

We use classes to model real life objects; every object is defined by its properties and functions performed on it, for example in this case, car is our object; every car has some properties like color, number of wheels, manufacturer etc; some functions can be performed on the car such as repainting it, driving it etc.

The following code shows a class model of a car

class car
{
char color[8];//stores the color of car
char manufctr[10];//stores the manufacturer of car
int numOfWheels;//stores the number of a car
void drive();//function to drive the car
void repaint(char col[8]);//function to repaint the car
};

The code above shows that the class has three members color, manufctr, numOfWheels and two member-functions drive and repaint. This is how we modeled a object from a real world into our computer.

Now how do we use this class to make objects, this is where we need to learn the concept of encapsulation; allows us to combine data and functions as we just saw that in a single class we gathered all the data and functions together to form a single object. In addition to this encapsulation allows us to restrict access to some or all of the information of the object, we can set our class members as private to object or we may give them a public access where anyone can access it.

The code below shows do we restrict access to objects information

class car
{
private:
char color[8];//stores the color of car
char manufctr[10];//stores the manufacturer of car
int numOfWheels;//stores the number of a car
public:
void drive()//function to drive the car
{
cout<<"The car is being driven"<<endl;
}
void repaint(char col[8])//function to repaint the car
{
strcpy(color,col);
}
};

Private members are those which are only accessible with in the class, for example we used the color property of the car in the repaint function, whereas public members can be accessed from anywhere in the program, by default the members are declared as private. Here we have declared color, manufctr and numOfWheels as private so that no one can change them, but as we are allowed to repaint a car we can change the color of the car through a public function, repaint(the function belongs to the class so it can access color directly), which takes color as a parameter.

The following program shows how to use member functions

#include <iostream>
using namespace std;
class car
{
private:
char color[8];//stores the color of car
char manufctr[10];//stores the manufacturer of car
int numOfWheels;//stores the number of a car
public:
void drive()//function to drive the car
{
cout<<"The car is being driven"<<endl;
}
void repaint(char col[8])//function to repaint the car
{
strcpy(color,col);
}
};
int main()
{
car c1;
c1.drive();
c1.repaint("Black");
system("pause");
}

In the main function we have declared an object, c1, of type car, which now tells us that a class is a user-defined type. We can access its public members by using a dot (.) operator as shown above, notice that here we are not allowed to call or access the private members of the class.

Still the code above is incomplete, what if user wants to get the private information of the car, for example if someone wants to know who is the manufacturer?, we need to give read only access to private members of the class to the user for that we have to write some more functions. Add the following code to the public section of the class.

//returns the color of the car
char* getColor(){return color;}
//returns the manufacturer of the car
char* getManufacturer(){return manufctr;}
//returns the number of wheels
int getNumOfWheels(){return numOfWheels;}

After writing the above functions you can easily access the private information of the car in a way that the user is not able to change it. But after this code you will encounter another problem, we have not yet initialized the members of class, so when you will try to print the information using the functions listed above you will get a garbage value.

We are not allowed to change the value of members directly by assigning it to them in the private block of code. So there must be a way through which we can assign values to them. As we cannot change the values using any other function we have to make sure that values are assigned to the object at the time it is declared.

Constructors are the functions that are implicitly called whenever an instance of a class is created, more precisely; constructors are functions, which are called implicitly, having the same name as the class with no return type. This will help us in initializing our object. Following code shows how do we implement constructors and how do they help us in initializing our class members.

public:
car()
{
repaint("white");
strcpy(manufctr,"BMW");
numOfWheels=4;
}
void drive()//function to drive the car
{
cout<<"The car is being driven"<<endl;
}
void repaint(char col[8])//function to repaint the car
{
strcpy(color,col);
}

Notice that the first function after the public statement is the constructor of the class, having the same name, in the body of the constructor we have accomplished three tasks, assigned a color to the car using a repaint function we have already declared in the class, assigned a manufacturer as it is a string we used strcpy to copy the value, and assigned the number of wheels. Now try calling the get functions we wrote above you won’t get a garbage value.

Doing this is somewhat hard coding, as all the objects we declare will be of white color having four wheels, manufactured by BMW, but this is what we don’t want, to solve this issue we can parameterize our constructor.

car()//default constructor
{
repaint("white");
strcpy(manufctr,"BMW");
numOfWheels=4;
}
car(char col[8], char man[10], int num)//parametric constructor
{
strcpy(color,col);
strcpy(manufctr,man);
numOfWheels=num;
}

The code above shows the parametric constructor, this will allow us to assign different values to different instances of our class, remember that we can have multiple constructors at the same time. As in this case we have both parametric and a default constructor, this is known as polymorphism, we will study this in more detail in our next posts but just for know polymorphism means that one function can have more than one implementations.

int main()
{
car c1;
c1.drive();
c1.repaint("Black");
cout<<c1.getColor()<<endl;
cout<<c1.getManufacturer()<<endl;
cout<<c1.getNumOfWheels()<<endl;

car c2("blue","Ferrari",4);
cout<<c2.getColor()<<endl;
cout<<c2.getManufacturer()<<endl;
cout<<c2.getNumOfWheels()<<endl;
system("pause");
}

Code above shows that default constructor was called when c1 was declared, whereas c2 was instantiated by the parametric constructor by passing our desired was values in the parameters at the time when object was declared. By now our class seems to be complete and we can implement our task by creating array of objects of type car and storing information in those objects.