Encapsulation in C++: A Guide to Data Privacy

Introduction

Welcome! Today's subject is Encapsulation, a cornerstone of Object-Oriented Programming (OOP) in C++ . Encapsulation is the process of bundling data and the operations that modify them into one unit — commonly an object — thereby protecting the data from unwanted alterations. This level of data protection ensures the creation of robust and maintainable software. Prepare yourself for an exciting journey as we delve into how encapsulation functions in C++ and explore the critical role it plays in safeguarding data privacy.

Unraveling Encapsulation

Starting with the basics, encapsulation involves wrapping data and the methods that modify this data into a single compartment known as a class . It protects the internal state of an object from undesired external interference. To illustrate, consider a C++ class representing a bank account. Without encapsulation, the account balance could be directly altered. With encapsulation, however, the balance can only change through specified methods such as deposit or withdraw . C++ class BankAccount {public: void deposit(double amount); void withdraw(double amount); double checkBalance() const; private: int accountNumber; double balance;};

Encapsulation: Guardian of Data Privacy

Encapsulation restricts direct access to an object's data and prevents unwanted data alteration. This principle is comparable to window blinds, allowing you to look out while preventing others from peeping in. In C++, encapsulation is achieved through access specifiers like private and public . By default, class members are private, restricting direct access. Data intended to be hidden from outside manipulation is placed under the private access specifier, while public members are accessible. Consider a class Person with a private attribute name . C++ class Person {public: Person(std::string name) : name(name) {} std::string getName() const; private: std::string name; // Private attribute}; std::string Person::getName() const {return name;} In this example, name is private, and getName() enables us to access it safely.

Getter and Setter Methods in Encapsulation

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Practical Application and Summary

Let's apply the principle of encapsulation to our BankAccount class, which includes private attributes like account number and balance, along with public methods for withdrawals, deposits, and balance checks.

C++

#include <iostream>

class BankAccount {
public:
    BankAccount(int account_no, double initial_balance)
        : account_no(account_no), balance(initial_balance) {}

    void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            std::cout << "Insufficient funds." << std::endl;
        }
    }

    void deposit(double amount) {
        balance += amount;
    }

    double checkBalance() const {
        return balance;
    }

private:
    int account_no;
    double balance;
};

int main() {
    BankAccount account(1, 500.0);
    account.withdraw(100.0);  // Withdraws 100.0 from the balance
    account.deposit(50.0);    // Deposits 50.0 to the balance
    std::cout << "Current balance: " << account.checkBalance() << std::endl;
    // Output: Current balance: 450
    return 0;
}

#include <iostream>

class BankAccount {
public:
    BankAccount(int account_no, double initial_balance)
        : account_no(account_no), balance(initial_balance) {}

    void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            std::cout << "Insufficient funds." << std::endl;
        }
    }

    void deposit(double amount) {
        balance += amount;
    }

    double checkBalance() const {
        return balance;
    }

private:
    int account_no;
    double balance;
};

int main() {
    BankAccount account(1, 500.0);
    account.withdraw(100.0);  // Withdraws 100.0 from the balance
    account.deposit(50.0);    // Deposits 50.0 to the balance
    std::cout << "Current balance: " << account.checkBalance() << std::endl;
    // Output: Current balance: 450
    return 0;
}

In the above code, the BankAccount class encapsulates account details, while the public methods manage the balance in a controlled manner.

Separate Class Declaration and Implementation

In larger projects, it's common practice in C++ to separate class declarations and implementations into different files: a header file (.hpp) and a source file (.cpp). This separation improves code organization and maintainability.

Let's revisit the BankAccount class using this approach:

BankAccount.hpp

C++

class BankAccount {
public:
    BankAccount(int account_no, double initial_balance);
    void withdraw(double amount);
    void deposit(double amount);
    double checkBalance() const;

private:
    int account_no;
    double balance;
};

class BankAccount {
public:
    BankAccount(int account_no, double initial_balance);
    void withdraw(double amount);
    void deposit(double amount);
    double checkBalance() const;

private:
    int account_no;
    double balance;
};

BankAccount.cpp

C++

#include "BankAccount.hpp"
#include <iostream>

BankAccount::BankAccount(int account_no, double initial_balance)
    : account_no(account_no), balance(initial_balance) {}

void BankAccount::withdraw(double amount) {
    if (balance >= amount) {
        balance -= amount;
    } else {
        std::cout << "Insufficient funds." << std::endl;
    }
}

void BankAccount::deposit(double amount) {
    balance += amount;
}

double BankAccount::checkBalance() const {
    return balance;
}

// Example usage in a main function
int main() {
    BankAccount account(1, 500.0);
    account.withdraw(100.0);  // Withdraws 100.0 from the balance
    account.deposit(50.0);    // Deposits 50.0 to the balance
    std::cout << "Current balance: " << account.checkBalance() << std::endl;
    // Output: Current balance: 450
    return 0;
}

#include "BankAccount.hpp"
#include <iostream>

BankAccount::BankAccount(int account_no, double initial_balance)
    : account_no(account_no), balance(initial_balance) {}

void BankAccount::withdraw(double amount) {
    if (balance >= amount) {
        balance -= amount;
    } else {
        std::cout << "Insufficient funds." << std::endl;
    }
}

void BankAccount::deposit(double amount) {
    balance += amount;
}

double BankAccount::checkBalance() const {
    return balance;
}

// Example usage in a main function
int main() {
    BankAccount account(1, 500.0);
    account.withdraw(100.0);  // Withdraws 100.0 from the balance
    account.deposit(50.0);    // Deposits 50.0 to the balance
    std::cout << "Current balance: " << account.checkBalance() << std::endl;
    // Output: Current balance: 450
    return 0;
}

By using separate files, you define your class interface in the header file and implement its functionality in the corresponding source file. This method helps manage complex projects by making your code more modular and easier to navigate.