Understanding the Basics of Encapsulation in C++

Encapsulation is a fundamental concept in Object Oriented Programming (OOP) that involves bundling data (attributes) and methods (functions) into a single unit known as a class. This encapsulated unit acts as a self-contained module which enhances code organization and promotes a more intuitive and manageable structure for programmers. In simpler terms, encapsulation allows you to group related data and functions together and provides a clear and effective way to work with objects in C++.

Encapsulation is the process of forming objects. An encapsulated object is often called an abstract data type and it is what object oriented programming is all about. Without encapsulation, which involves the use of one or more classes in C++, there is no object oriented programming.

What is Encapsulation?

Encapsulation is a crucial concept in C++ that involves bundling together data (attributes) and methods (functions) into a cohesive unit, commonly known as a class. This encapsulation process is akin to placing all relevant components within a single container, creating a self-contained module with a specific purpose.

When we properly encapsulate some C++ code, we actually build an impenetrable wall to protect the contained code from accidental corruption due to the little errors. We also tend to isolate errors to small sections of code to make them easier to find and fix.

Data or Attributes

Encapsulation allows you to define and store data within a class, forming the attributes or properties of an object. These attributes represent the characteristics or state of the object and are encapsulated within the class to control access and visibility.

Methods or Functions

In addition to data, encapsulation includes the methods or functions in C++ that operate on the encapsulated data. These functions define the behavior of the object and encapsulate the logic required to manipulate the internal state. By bundling both data and methods together, encapsulation ensures that the functionality closely relates to the object it serves.

The Class – Single Unit

The encapsulated unit, or a class in C++, acts as a blueprint for creating objects. It encapsulates the data and methods related to a particular entity that provides a clear and organized structure for programming. Objects instantiated from this class inherit its attributes and behaviors to form instances with their own encapsulated state and functionality.

Benefits of Encapsulation

Encapsulation is a powerful concept that fosters cleaner code design, enhances reusability and facilitates effective management of complex software systems in C++. Here are some of the benefits of Encapsulation.

Data or Information Hiding

In the following C++ program we’ll explore a basic example of information hiding. Let’s break down the program step by step to understand the concepts at play. Keep in mind that this is a simple program, and the precautions taken here may seem unnecessary for its size. However, they serve as a demonstration of techniques applicable to larger and more complex programs.

#include <iostream>

// Class definition
class one_datum {
private:
    int data_store;

public:
    // Function to set the value of data_store
    void set(int value) {
        data_store = value;
    }

    // Function to get the value of data_store
    int get_value() {
        return data_store;
    }
};

int main() {
    // Creating an instance of the class
    one_datum my_instance;

    // Setting the value using the set() function
    my_instance.set(42);

    // Getting the value using the get_value() function
    int retrieved_value = my_instance.get_value();

    // Displaying the result
    std::cout << "The stored value is: " << retrieved_value << std::endl;

    return 0;
}

#include <iostream>

// Class definition

class one_datum {

private:

int data_store;

public:

// Function to set the value of data_store

void set(int value) {

data_store = value;

}

// Function to get the value of data_store

int get_value() {

return data_store;

}

};

int main() {

// Creating an instance of the class

one_datum my_instance;

// Setting the value using the set() function

my_instance.set(42);

// Getting the value using the get_value() function

int retrieved_value = my_instance.get_value();

// Displaying the result

std::cout << "The stored value is: " << retrieved_value << std::endl;

return 0;

}

Introduction of a Class: The first you notice is the introduction of a class, starting from line 4. In C++, a class is similar to a structure but begins with a private section. The keyword ‘class’ is used to declare a class, distinguishing it from a structure.

Class Definition – one_datum: The class named one_datum consists of a single variable called data_store and two functions: set() and get_value(). In a broader sense, a class is a collection of variables and one or more functions that can operate on that data.

Private Section in a Class

The private section of a class is like a restricted area where data is kept hidden and cannot be accessed from outside the C++ class. It acts as a protective barrier, preventing accidental interference with the variables by external code. This restriction is like building a “brick wall” around the variables to safeguard them.

Public Section in a Class

The public keyword, introduced in line 6, signifies that anything following it can be accessed from outside the class. In our example, the two functions (set and get_value) are declared in the public section, making them accessible to the calling function or any other function within its scope. However, the private variable remains inaccessible directly.

While the private variable is hidden, the member functions are termed as “member functions” because they are part of the class and provide the only sanctioned means to interact with the encapsulated data.

In C++, variables have three scopes: local, file, and class. Class scope means a variable is available anywhere within the class’s scope and nowhere else. Although this might seem confusing, the rules have practical reasons, and understanding them will become clearer as we delve deeper into examples and applications.

Modularity

Modularity is a software design principle that emphasizes to break down a system into smaller, independent, and manageable modules. Each module should encapsulate a specific functionality to make it easier to understand, modify, and maintain the code. Encapsulation, as a fundamental aspect of object-oriented programming, plays a key role in achieving modularity.

By bundling related data and methods within a class (encapsulation), you create a self-contained and coherent module. This module hides the internal details and complexity and exposes only essential functionalities through well-defined interfaces (public methods). This not only simplifies the understanding of the code but also allows for easier modifications and maintenance because changes within a module don’t affect the rest of the program.

C++ Example of Modularity

Let’s consider a simple example involving a class representing a geometric shape, specifically a rectangle. The class encapsulates the width and height as private attributes and provides public methods to set the dimensions, calculate the area, and display information.

#include <iostream>

class Rectangle {
private:
    double width;
    double height;

public:
    // Set the dimensions of the rectangle
    void setDimensions(double w, double h) {
        width = w;
        height = h;
    }

    // Calculate and return the area of the rectangle
    double calculateArea() const {
        return width * height;
    }

    // Display information about the rectangle
    void displayInfo() const {
        std::cout << "Rectangle - Width: " << width << ", Height: " << height << std::endl;
        std::cout << "Area: " << calculateArea() << std::endl;
    }
};

int main() {
    // Create an instance of the Rectangle class
    Rectangle myRectangle;

    // Set dimensions using the public method
    myRectangle.setDimensions(5.0, 3.0);

    // Display information using the public method
    myRectangle.displayInfo();

    return 0;
}

#include <iostream>

class Rectangle {

private:

double width;

double height;

public:

// Set the dimensions of the rectangle

void setDimensions(double w, double h) {

width = w;

height = h;

}

// Calculate and return the area of the rectangle

double calculateArea() const {

return width * height;

}

// Display information about the rectangle

void displayInfo() const {

std::cout << "Rectangle - Width: " << width << ", Height: " << height << std::endl;

std::cout << "Area: " << calculateArea() << std::endl;

}

};

int main() {

// Create an instance of the Rectangle class

Rectangle myRectangle;

// Set dimensions using the public method

myRectangle.setDimensions(5.0, 3.0);

// Display information using the public method

myRectangle.displayInfo();

return 0;

}

In this program, the Rectangle class encapsulates the width and height as private attributes. The public methods (setDimensions, calculateArea, and displayInfo) provide controlled access to manipulate and retrieve information about the rectangle.

Code Organization

Code organization refers to how a program’s components, such as classes, functions, and variables, are structured and arranged. Encapsulation contributes significantly to better code organization by grouping related data and methods together within a class. This bundling of functionality enhances the overall structure of the code, making it more intuitive and manageable.

When using encapsulation, each class becomes a self-contained unit and represents a specific concept or entity in the system. This organization provides clear boundaries and separation of concerns and allows programmers to focus on individual components without being overwhelmed by the entire codebase. It promotes a modular and hierarchical structure which makes it easier to navigate, understand, and maintain.

C++ Example of Code Organization

Let’s consider a scenario where we have a simple application that manages information about different shapes – circles and rectangles. Encapsulation allows us to organize the code by creating separate classes for each shape, making the overall structure more organized.

#include <iostream>
#include <cmath>

// Shape base class
class Shape {
public:
    virtual double calculateArea() const = 0;
    virtual void displayInfo() const = 0;
};

// Circle class
class Circle : public Shape {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    // Implementation of pure virtual function
    double calculateArea() const override {
        return 3.14 * radius * radius;
    }

    // Implementation of pure virtual function
    void displayInfo() const override {
        std::cout << "Circle - Radius: " << radius << std::endl;
        std::cout << "Area: " << calculateArea() << std::endl;
    }
};

// Rectangle class
class Rectangle : public Shape {
private:
    double width;
    double height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}

    // Implementation of pure virtual function
    double calculateArea() const override {
        return width * height;
    }

    // Implementation of pure virtual function
    void displayInfo() const override {
        std::cout << "Rectangle - Width: " << width << ", Height: " << height << std::endl;
        std::cout << "Area: " << calculateArea() << std::endl;
    }
};

int main() {
    // Creating instances of Circle and Rectangle
    Circle myCircle(5.0);
    Rectangle myRectangle(4.0, 6.0);

    // Displaying information using the common Shape interface
    myCircle.displayInfo();
    std::cout << "---------------------" << std::endl;
    myRectangle.displayInfo();

    return 0;
}

#include <iostream>

#include <cmath>

// Shape base class

class Shape {

public:

virtual double calculateArea() const = 0;

virtual void displayInfo() const = 0;

};

// Circle class

class Circle : public Shape {

private:

double radius;

public:

Circle(double r) : radius(r) {}

// Implementation of pure virtual function

double calculateArea() const override {

return 3.14 * radius * radius;

}

// Implementation of pure virtual function

void displayInfo() const override {

std::cout << "Circle - Radius: " << radius << std::endl;

std::cout << "Area: " << calculateArea() << std::endl;

}

};

// Rectangle class

class Rectangle : public Shape {

private:

double width;

double height;

public:

Rectangle(double w, double h) : width(w), height(h) {}

// Implementation of pure virtual function

double calculateArea() const override {

return width * height;

}

// Implementation of pure virtual function

void displayInfo() const override {

std::cout << "Rectangle - Width: " << width << ", Height: " << height << std::endl;

std::cout << "Area: " << calculateArea() << std::endl;

}

};

int main() {

// Creating instances of Circle and Rectangle

Circle myCircle(5.0);

Rectangle myRectangle(4.0, 6.0);

// Displaying information using the common Shape interface

myCircle.displayInfo();

std::cout << "---------------------" << std::endl;

myRectangle.displayInfo();

return 0;

}

In this program, the Shape base class provides a common interface for different shapes. The Circle and Rectangle classes encapsulate the details of their respective shapes. This separation of concerns enhances code organization by isolating the functionality related to each shape within its own class.

The code is organized in a way that aligns with the real-world concept of shapes. Each class has a clear purpose and provides an intuitive interface (calculateArea and displayInfo). Programmers can easily understand, modify, and extend the code by focusing on specific classes and their interactions.

Access Modifiers in C++

Access modifiers in C++, namely public, private, and protected, play a crucial role in encapsulation. They control the visibility and accessibility of class members which includes attributes and methods, from outside the class. Understanding these modifiers is essential for designing classes with proper encapsulation, ensuring that data is accessed and manipulated in a controlled manner.

Public

Members declared as public are accessible from anywhere, both inside and outside the class. These members can be accessed by objects of the class, as well as by other functions and classes. Public members are part of the class’s public interface.

Private

Members declared as private are only accessible within the class they are defined. They cannot be accessed directly from outside the class, promoting information hiding. Private members are not visible to functions or classes that use objects of the class.

Protected

Members declared as protected are similar to private members but have additional visibility in derived classes. They are accessible within the class and its derived classes. Protected members are often used in inheritance to allow derived classes to access certain functionalities while still restricting access from external code.

C++ Example of Access Modifiers

#include <iostream>

class ExampleClass {
public:
    // Public member accessible from anywhere
    int publicVar;

    // Public method accessible from anywhere
    void publicMethod() {
        std::cout << "Public method called." << std::endl;
    }

private:
    // Private member accessible only within this class
    int privateVar;

    // Private method accessible only within this class
    void privateMethod() {
        std::cout << "Private method called." << std::endl;
    }

protected:
    // Protected member accessible within this class and derived classes
    int protectedVar;

    // Protected method accessible within this class and derived classes
    void protectedMethod() {
        std::cout << "Protected method called." << std::endl;
    }
};

int main() {
    ExampleClass obj;

    // Accessing public members
    obj.publicVar = 42;
    obj.publicMethod();

    // Private members cannot be accessed from outside the class
    // obj.privateVar;  // This would result in a compilation error
    // obj.privateMethod();  // This would result in a compilation error

    // Protected members cannot be accessed from outside the class or its derived classes
    // obj.protectedVar;  // This would result in a compilation error
    // obj.protectedMethod();  // This would result in a compilation error

    return 0;
}

#include <iostream>

class ExampleClass {

public:

// Public member accessible from anywhere

int publicVar;

// Public method accessible from anywhere

void publicMethod() {

std::cout << "Public method called." << std::endl;

}

private:

// Private member accessible only within this class

int privateVar;

// Private method accessible only within this class

void privateMethod() {

std::cout << "Private method called." << std::endl;

}

protected:

// Protected member accessible within this class and derived classes

int protectedVar;

// Protected method accessible within this class and derived classes

void protectedMethod() {

std::cout << "Protected method called." << std::endl;

}

};

int main() {

ExampleClass obj;

// Accessing public members

obj.publicVar = 42;

obj.publicMethod();

// Private members cannot be accessed from outside the class

// obj.privateVar; // This would result in a compilation error

// obj.privateMethod(); // This would result in a compilation error

// Protected members cannot be accessed from outside the class or its derived classes

// obj.protectedVar; // This would result in a compilation error

// obj.protectedMethod(); // This would result in a compilation error

return 0;

}

In this example:

publicVar and publicMethod are accessible from outside the class.
privateVar and privateMethod are only accessible within the class.
protectedVar and protectedMethod are accessible within the class and its derived classes.

Common Mistakes and Best Practices in Encapsulation

Exposing Public Data Members

Common Mistake: Declaring data members as public which allows direct access and modification from outside the class.
Best Practice: Avoid exposing data members directly. Instead, use private members and provide controlled access through methods.

// Common Mistake
class Rectangle {
public:
    double width;
    double height;
};

// Best Practice
class Rectangle {
private:
    double width;
    double height;

public:
    // Getter method
    double getWidth() const {
        return width;
    }

    // Setter method
    void setWidth(double w) {
        if (w > 0) {
            width = w;
        }
    }
};

// Common Mistake

class Rectangle {

public:

double width;

double height;

};

// Best Practice

class Rectangle {

private:

double width;

double height;

public:

// Getter method

double getWidth() const {

return width;

}

// Setter method

void setWidth(double w) {

if (w > 0) {

width = w;

}

};

Lack of Data Validation – Data Integrity

Common Mistake: Failing to validate input data when using public setter methods.
Best Practice: Implement data validation within setter methods to ensure data integrity.

// Common Mistake
class Circle {
public:
    void setRadius(double r) {
        radius = r;
    }
};

// Best Practice
class Circle {
private:
    double radius;

public:
    // Improved Setter method with validation
    void setRadius(double r) {
        if (r > 0) {
            radius = r;
        }
    }
};

// Common Mistake

class Circle {

public:

void setRadius(double r) {

radius = r;

}

};

// Best Practice

class Circle {

private:

double radius;

public:

// Improved Setter method with validation

void setRadius(double r) {

if (r > 0) {

radius = r;

}

};

Overuse of Getter and Setter Methods

Common Mistake: Creating unnecessary getter and setter methods for every private member.
Best Practice: Only provide getter and setter methods for attributes that require external access. Some internal attributes may not need public accessors.

Violating Single Responsibility Principle

Common Mistake: Including unrelated functionalities within a single class.
Best Practice: Follow the Single Responsibility Principle. Each class should have a single responsibility, making the code more modular and easier to understand.

// Common Mistake
class FileIO {
public:
    void readFile(const std::string& filename) {
        // Read file logic
    }

    void processUserData() {
        // Process user data logic
    }
};

// Best Practice
class FileReader {
public:
    void readFile(const std::string& filename) {
        // Read file logic
    }
};

class UserDataProcessor {
public:
    void processUserData() {
        // Process user data logic
    }
};

// Common Mistake

class FileIO {

public:

void readFile(const std::string& filename) {

// Read file logic

}

void processUserData() {

// Process user data logic

}

};

// Best Practice

class FileReader {

public:

void readFile(const std::string& filename) {

// Read file logic

}

};

class UserDataProcessor {

public:

void processUserData() {

// Process user data logic

}

};

Neglecting Inheritance Properly

Common Mistake: Incorrectly using access modifiers in inheritance, leading to unintended exposure or restriction of members.
Best Practice: Clearly define the access levels for inherited members and consider using protected access for shared functionality.

Conclusion

Encapsulation is a foundational principle in C++ that plays a pivotal role in building robust and maintainable code. Through the bundling of related data and methods into classes, encapsulation provides a structured and organized approach to designing software.

Understanding and applying encapsulation principles are critical for building robust, flexible, and scalable C++ code. As developers embrace encapsulation, they lay the foundation for building software that is not only efficient and reliable but also adaptable to future changes and enhancements.

Understanding the Basics of Encapsulation in C++

Table of Contents

What is Encapsulation?

Data or Attributes

Methods or Functions

The Class – Single Unit

Benefits of Encapsulation

Data or Information Hiding

Private Section in a Class

Public Section in a Class

Modularity

C++ Example of Modularity

Code Organization

C++ Example of Code Organization

Access Modifiers in C++

Public

Private

Protected

C++ Example of Access Modifiers

Common Mistakes and Best Practices in Encapsulation

Exposing Public Data Members

Lack of Data Validation – Data Integrity

Overuse of Getter and Setter Methods

Violating Single Responsibility Principle

Neglecting Inheritance Properly

Conclusion

About The Author

M. Saqib

Understanding the Basics of Encapsulation in C++

Table of Contents

What is Encapsulation?

Data or Attributes

Methods or Functions

The Class – Single Unit

Benefits of Encapsulation

Data or Information Hiding

Private Section in a Class

Public Section in a Class

Modularity

C++ Example of Modularity

Code Organization

C++ Example of Code Organization

Access Modifiers in C++

Public

Private

Protected

C++ Example of Access Modifiers

Common Mistakes and Best Practices in Encapsulation

Exposing Public Data Members

Lack of Data Validation – Data Integrity

Overuse of Getter and Setter Methods

Violating Single Responsibility Principle

Neglecting Inheritance Properly

Conclusion

About The Author

M. Saqib

Related Posts

C++ Vector – std::vector – A Complete Guide with Examples and Programs

Destructors in C++

The C++ Modulus Operator [mod or % operator]

Inheritance in C++