Lesson 1

This module introduces you to the basic concept of encapsulation in C++. The following will be discussed:

1. Why encapsulation is central to object-oriented programming
2. What classes and objects are
3. How to write member functions as part of an abstract data type
4. How to limit access to an ADT's member data and functions
5. How a class differs from a struct. At the end of the module, you'll be given the opportunity to take a quiz covering these topics.

Encapsulation is a fundamental principle of object-oriented programming (OOP), and it plays a crucial role in C++. This principle involves bundling related data (attributes) and behaviors (methods) into a single unit called an object. Furthermore, it restricts direct access to an object’s data and methods, providing a way to shield the internal state of an object and prevent unauthorized modifications. In C++, encapsulation is achieved using classes and access modifiers. A class is a blueprint for creating objects. It groups together related data members (variables) and member functions (methods) that operate on these data. Here's an example:

class Car {
private: 
    int speed;

public:
    void setSpeed(int s) {
        if (s >= 0)
            speed = s;
        else
            std::cout << "Invalid speed value!" << std::endl;
    }

    int getSpeed() {
        return speed;
    }
};

In the example above, Car is a class encapsulating the data member speed and the member functions setSpeed and getSpeed. The speed data member is marked as private, meaning it can only be accessed or modified by the member functions of the Car class. It cannot be directly accessed from outside the class. This is an example of data hiding. The setSpeed and getSpeed functions are public member functions. They provide an interface through which code outside the Car class can interact with the speed data member. These methods are known as getters and setters or accessors and mutators, respectively.
The setSpeed method includes a check to ensure that the speed is not set to a negative value. This demonstrates another key benefit of encapsulation: it enables validation of data prior to modifying the object's state, ensuring that the object remains in a valid state. In conclusion, encapsulation in C++ is used to bundle related data and behaviors into a single entity, a class, and to hide the internal state of the object. This promotes data integrity by preventing direct access to the object's data and providing controlled access through public methods. By using encapsulation, C++ allows programmers to create more secure and maintainable code, enhancing the robustness and flexibility of the software.

• Data Access through public interface: All data access must occur through the public interface. Thus, the data fields of an object are effectively hidden from the programmer. The act of hiding data is called encapsulation. While it is theoretically possible in C++ to leave data fields unencapsulated (by placing them into the public section), this is very uncommon in practice.
  Classes in C++ provide static encapsulation of objects by generating code which contains specific knowledge about the internals of encapsulated objects. Static encapsulation occurs at compile time and therefore cannot directly support the evolution of objects since recompilation of source code is required if the internal layout changes. This also prohibits the use of distributed or persistent objects without first ensuring that the internal representations of the objects match the ones in the compiled code.

Encapsulation is about bundling data (attributes) and methods (operations) that operate on the data into a single unit or object, and controlling access to these components. Here's a step-by-step example:

1. Define a class with private data members and public methods to access or modify them.
2. Use access specifiers (`private`, `public`, `protected`) to control access.
3. Implement getter and setter methods** for controlled access to private members.

Here's a simple example using a `BankAccount` class:

#include <iostream>
#include <string>

class BankAccount {
private:
   // Private attributes, not accessible from outside the class
   std::string accountHolder;
   double balance;

public:
   // Constructor
   BankAccount(std::string name, double initialBalance = 0.0) 
       : accountHolder(name), balance(initialBalance) {}

   // Getter for account holder
   std::string getAccountHolder() const {
       return accountHolder;
   }

   // Getter for balance
   double getBalance() const {
       return balance;
   }

   // Setter for balance (withdraw or deposit)
   void setBalance(double amount) {
       if (amount >= 0) {
           balance = amount;
       } else {
           std::cout << "Cannot set negative balance." << std::endl;
       }
   }

   // Method to deposit money
   void deposit(double amount) {
       if (amount > 0) {
           balance += amount;
       } else {
           std::cout << "Invalid deposit amount." << std::endl;
       }
   }

   // Method to withdraw money
   bool withdraw(double amount) {
       if (amount > 0 && amount <= balance) {
           balance -= amount;
           return true;
       } else {
           std::cout << "Withdrawal failed. Insufficient funds or invalid amount." << std::endl;
           return false;
       }
   }
};

int main() {
   BankAccount account("Alice", 1000.0);

   std::cout << "Account holder: " << account.getAccountHolder() << std::endl;
   std::cout << "Current balance: $" << account.getBalance() << std::endl;

   account.deposit(500.0);
   std::cout << "After deposit, balance: $" << account.getBalance() << std::endl;

   account.withdraw(200.0);
   std::cout << "After withdrawal, balance: $" << account.getBalance() << std::endl;

   // This will not compile because balance is private
   // account.balance = -1000; 

   return 0;
}

Explanation:

• Private Members: `accountHolder` and `balance` are private, meaning they can only be accessed within the `BankAccount` class.
• Public Methods: Methods like `getAccountHolder()`, `getBalance()`, `deposit()`, and `withdraw()` provide controlled access to the private data. This is encapsulation.
• Data Integrity: By using methods to change `balance`, we ensure it can't be set to a negative value directly from outside the class.
• Encapsulation Benefits:
  • Data Hiding: The internal representation of the object is protected from direct modification.
  • Control: You can add logic to modify data (like checking for negative deposits).
  • Flexibility: If you need to change how `balance` is stored or calculated, you can do so internally without changing the interface.

This example demonstrates how encapsulation helps in maintaining the integrity of an object's state and provides an interface for interacting with the object in a controlled manner.

• Hiding Information in Python: This process of hiding the implementation, or functional details, of an object is suitably called information hiding. It is also sometimes referred to as encapsulation, but encapsulation is actually a more all-encompassing term. Encapsulated data is not necessarily hidden. Encapsulation is, literally, creating a capsule and so think of creating a time capsule. If you put a bunch of information into a time capsule, lock and bury it, it is both encapsulated and the information is hidden. On the other hand, if the time capsule has not been buried and is unlocked or made of clear plastic, the items inside it are still encapsulated, but there is no information hiding. The distinction between encapsulation and information hiding is largely irrelevant, especially at the design level. Many practical references use these terms interchangeably. As Python programmers, we do not actually have or need true information hiding, so the more encompassing definition for encapsulation is suitable.