Data Encapsulation and Abstraction

Data Encapsulation and Abstraction
All C++ programs are composed of the following two fundamental elements:
? Program statements code: This is the part of a program that performs actions and
they are called methods.
? Program data: The data is the information of the program which affected by the
program methods.
Encapsulation is an Object Oriented Programming concept that binds together the
data and methods that manipulate the data, and that keeps both safe from outside
interference and misuse. Data encapsulation led to the important OOP concept of data
hiding.
Data encapsulation is a mechanism of bundling the data, and the methods that use
them and data abstraction is a mechanism of exposing only the interfaces and hiding
the implementation details from the user.
C++ supports the properties of encapsulation and data hiding through the creation of
user-defined types, called classes. We already have studied that a class can contain
private and public members. By default, all items defined in a class are private. For
example:

The variables length, breadth, and height are private. This means that they can be
accessed only by other members of the Box class, and not by any other part of your
program. This is one way encapsulation is achieved.
Any C++ program where you implement a class with public and private members is an
example of data encapsulation and data abstraction. Consider the following example:

Above class adds numbers together, and returns the sum. The public members
addNum and getTotal are the interfaces to the outside world and a user needs to
know them to use the class. The private member total is something that is hidden
from the outside world, but is needed for the class to operate properly.
Abstract Class (Interfaces)
An interface describes the behavior or capabilities of a C++ class without committing
to a particular implementation of that class.
The C++ interfaces are implemented using abstract classes and these abstract classes
should not be confused with data abstraction which is a concept of keeping
implementation details separate from associated data.