Introduction to OOP

Object-Oriented Programming focuses on organizing code around objects and data rather than functions and logic. The main goals of OOP are to improve code reusability, scalability, and maintainability.

Key Concepts of OOP

1. Classes and Objects: Classes define the blueprint for objects, and objects are instances of classes.
2. Encapsulation: Bundling data and methods that operate on the data within a single unit or class.
3. Inheritance: Mechanism for creating a new class from an existing class, inheriting attributes and behaviors.
4. Polymorphism: Ability to treat objects of different classes through a common interface.
5. Abstraction: Hiding complex implementation details and exposing only necessary parts.

Defining and Using Classes

A class in C++ is a user-defined data type that groups related variables (attributes) and functions (methods) into a single unit. Classes define the properties and behaviors of objects.

Basic Syntax of a Class

class ClassName {
public:
    // Data members
    Type variableName;

    // Member functions
    void functionName() {
        // Function body
    }
};

Example: Defining a Simple Class

class Car {
public:
    // Data members
    std::string make;
    std::string model;
    int year;

    // Member functions
    void displayInfo() {
        std::cout << "Make: " << make << ", Model: " << model << ", Year: " << year << std::endl;
    }
};

Creating and Using Objects

Once a class is defined, you can create objects (instances) of that class and use its methods and attributes.

Example:

int main() {
    // Creating an object of Car
    Car myCar;

    // Setting data members
    myCar.make = "Toyota";
    myCar.model = "Camry";
    myCar.year = 2020;

    // Calling member function
    myCar.displayInfo();

    return 0;
}

Constructors and Destructors

Constructors and destructors are special member functions used to initialize and clean up objects, respectively.

Constructors

Constructors are called when an object is created. They initialize the object’s data members and can be overloaded to provide multiple ways of initializing an object.

Syntax:

ClassName() {
    // Initialization code
}

Example:

class Car {
public:
    std::string make;
    std::string model;
    int year;

    // Default constructor
    Car() : make("Unknown"), model("Unknown"), year(0) {}

    // Parameterized constructor
    Car(std::string mk, std::string mdl, int yr) : make(mk), model(mdl), year(yr) {}

    void displayInfo() {
        std::cout << "Make: " << make << ", Model: " << model << ", Year: " << year << std::endl;
    }
};

Destructors

Destructors are called when an object goes out of scope or is explicitly deleted. They are used to release resources allocated by the object.

Syntax:

~ClassName() {
    // Cleanup code
}

Example:

class Car {
public:
    // Destructor
    ~Car() {
        std::cout << "Car object destroyed" << std::endl;
    }
};

Inheritance and Polymorphism

Inheritance and polymorphism are two fundamental concepts in OOP that enhance code reusability and flexibility.

Inheritance

Inheritance allows a class to inherit attributes and methods from another class, promoting code reuse and establishing a relationship between classes.

Syntax:

class BaseClass {
    // Base class members
};

class DerivedClass : public BaseClass {
    // Derived class members
};

Example:

class Vehicle {
public:
    std::string type;

    void displayType() {
        std::cout << "Type: " << type << std::endl;
    }
};

class Car : public Vehicle {
public:
    int numberOfDoors;

    void displayInfo() {
        displayType();
        std::cout << "Number of Doors: " << numberOfDoors << std::endl;
    }
};

Using Inheritance:

int main() {
    Car myCar;
    myCar.type = "Sedan";
    myCar.numberOfDoors = 4;
    myCar.displayInfo();

    return 0;
}

Polymorphism

Polymorphism allows objects of different classes to be treated through a common interface. There are two types of polymorphism in C++: compile-time (method overloading) and runtime (method overriding).

Method Overloading (Compile-Time Polymorphism)

Example:

class Print {
public:
    void show(int i) {
        std::cout << "Integer: " << i << std::endl;
    }

    void show(double d) {
        std::cout << "Double: " << d << std::endl;
    }
};

Method Overriding (Runtime Polymorphism)

Method overriding occurs when a derived class provides a specific implementation of a function that is already defined in its base class.

Example:

class Animal {
public:
    virtual void makeSound() {
        std::cout << "Animal makes a sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Dog barks" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "Cat meows" << std::endl;
    }
};

Using Polymorphism:

int main() {
    Animal* animal;

    Dog dog;
    Cat cat;

    animal = &dog;
    animal->makeSound();  // Outputs: Dog barks

    animal = &cat;
    animal->makeSound();  // Outputs: Cat meows

    return 0;
}

Practical Examples and Use Cases

Example 1: Banking System

A simple banking system using classes to represent accounts and transactions.

class BankAccount {
private:
    std::string accountNumber;
    double balance;

public:
    BankAccount(std::string accNum, double initialBalance) : accountNumber(accNum), balance(initialBalance) {}

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

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

    void displayBalance() {
        std::cout << "Account Number: " << accountNumber << ", Balance: $" << balance << std::endl;
    }
};

Using the Banking System:

int main() {
    BankAccount account("123456", 1000.00);

    account.deposit(500.00);
    account.withdraw(200.00);
    account.displayBalance();

    return 0;
}

Example 2: Shape Hierarchy

A class hierarchy for different shapes using inheritance and polymorphism.

class Shape {
public:
    virtual void draw() = 0;  // Pure virtual function
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Rectangle" << std::endl;
    }
};

Using the Shape Hierarchy:

int main() {
    Shape* shape;

    Circle circle;
    Rectangle rectangle;

    shape = &circle;
    shape->draw();  // Outputs: Drawing Circle

    shape = &rectangle;
    shape->draw();  // Outputs: Drawing Rectangle

    return 0;
}

Example 3: Employee Management System

A system to manage employees using classes and inheritance.

class Employee {
protected:
    std::string name;
    double salary;

public:
    Employee(std::string empName, double empSalary) : name(empName), salary(empSalary) {}

    virtual void displayInfo() {
        std::cout << "Name: " << name << ", Salary: $" << salary << std::endl;
    }
};

class Manager : public Employee {
private:
    int teamSize;

public:
    Manager(std::string empName, double empSalary, int team) : Employee(empName, empSalary), teamSize(team) {}

    void displayInfo() override {
        Employee::displayInfo();
        std::cout << "Team Size: " << teamSize << std::endl;
    }
};

class Developer : public Employee {
private:
    std::string programmingLanguage;

public:
    Developer(std::string empName, double empSalary, std::string lang) : Employee(empName, empSalary), programmingLanguage(lang) {}

    void displayInfo() override {
        Employee::displayInfo();
        std::cout << "Programming Language: " << programmingLanguage << std::endl;
    }
};

Using the Employee Management System:

int main() {
    Manager manager("Alice", 90000, 5);
    Developer developer("Bob", 80000, "C++");

    manager.displayInfo();
    developer.displayInfo();

    return 0;
}

Conclusion

Object-Oriented Programming in C++ provides a powerful way to design and organize code through classes and objects. By understanding and applying the principles of encapsulation, inheritance, and polymorphism, you can write more modular, reusable, and maintainable code. The practical examples provided illustrate how these concepts can be applied to real-world scenarios, helping you build robust and scalable applications in C++. Continue exploring these concepts and practicing with more examples to deepen your understanding of C++ OOP.