Object-Oriented Programming (OOP) - Classes

• Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects", which contain data and code to manipulate that data

Classes

• A class is a blueprint for creating objects
• It defines the data (attributes) and functions (methods) that the objects of the class will have
• Classes encapsulate data and functions into a single unit
• Syntax: class ClassName { access_specifier: data_members; member_functions; };
• Access specifiers control the visibility of class members: public, private, and protected
• public: Members are accessible from anywhere
• private: Members are accessible only from within the class
• protected: Members are accessible from within the class and its derived classes
• Data members are variables that store the state of an object
• Member functions are functions that define the behavior of an object

Objects

• An object is an instance of a class
• Objects are created from classes
• Each object has its own unique set of data members
• Objects can interact with each other through their member functions
• Syntax: ClassName objectName;
• Accessing members of an object: objectName.memberName
• Example:

class Dog {
public:
  string name;
  int age;
  void bark() {
    cout << "Woof!" << endl;
  }
};

int main() {
  Dog myDog;
  myDog.name = "Buddy";
  myDog.age = 3;
  myDog.bark();
  return 0;
}

• In the example above, Dog is a class, and myDog is an object of the Dog class.
• name and age are data members, and bark() is a member function.

Constructors

• A constructor is a special member function that is automatically called when an object is created
• It is used to initialize the data members of the object
• A class can have multiple constructors with different parameters (constructor overloading)
• If no constructor is defined, the compiler provides a default constructor (no-argument constructor)
• Syntax: ClassName(parameters) { // initialization code }
• Example:

class Dog {
public:
  string name;
  int age;

  Dog(string dogName, int dogAge) {
    name = dogName;
    age = dogAge;
  }

  void bark() {
    cout << "Woof!" << endl;
  }
};

int main() {
  Dog myDog("Buddy", 3);
  myDog.bark();
  return 0;
}

• Copy constructor: A constructor that creates a new object as a copy of an existing object
• Syntax: ClassName(const ClassName &obj) { // copy code }

Destructors

• A destructor is a special member function that is automatically called when an object is destroyed
• It is used to release any resources that the object may have acquired
• A class can have only one destructor
• If no destructor is defined, the compiler provides a default destructor
• Syntax: ~ClassName() { // cleanup code }
• Example:

class MyClass {
public:
  MyClass() {
    // Constructor
  }
  ~MyClass() {
    // Destructor
  }
};

Inheritance

• Inheritance is a mechanism that allows a new class (derived class) to inherit the properties and methods of an existing class (base class)
• It promotes code reuse and reduces redundancy
• Types of inheritance: single, multiple, hierarchical, multilevel, and hybrid
• Single inheritance: A derived class inherits from only one base class
• Multiple inheritance: A derived class inherits from multiple base classes
• Hierarchical inheritance: Multiple derived classes inherit from a single base class
• Multilevel inheritance: A derived class inherits from a base class, which in turn inherits from another base class
• Syntax: class DerivedClass : access_specifier BaseClass { // class members };
• Access specifiers for inheritance: public, private, and protected
• public inheritance: Public members of the base class remain public in the derived class, and protected members remain protected
• private inheritance: Public and protected members of the base class become private members of the derived class
• protected inheritance: Public and protected members of the base class become protected members of the derived class

Virtual Functions and Polymorphism

• Polymorphism is the ability of an object to take on many forms
• It is achieved through virtual functions and inheritance
• A virtual function is a member function that is declared with the virtual keyword in the base class
• It can be overridden in the derived class
• When a virtual function is called through a base class pointer or reference, the version of the function that is executed is determined at runtime (dynamic binding)
• Pure virtual function: A virtual function that has no definition in the base class
• A class that contains a pure virtual function is called an abstract class
• Abstract classes cannot be instantiated
• Derived classes must provide a definition for the pure virtual function
• Example:

class Shape {
public:
  virtual double area() = 0; // pure virtual function
};

class Circle : public Shape {
private:
  double radius;
public:
  Circle(double r) : radius(r) {}
  double area() { return 3.14159 * radius * radius; }
};

class Rectangle : public Shape {
private:
  double width;
  double height;
public:
  Rectangle(double w, double h) : width(w), height(h) {}
  double area() { return width * height; }
};

int main() {
  Shape* shape1 = new Circle(5.0);
  Shape* shape2 = new Rectangle(4.0, 6.0);

  cout << "Circle area: " << shape1->area() << endl;
  cout << "Rectangle area: " << shape2->area() << endl;

  delete shape1;
  delete shape2;

  return 0;
}

• In this example, Shape is an abstract class with a pure virtual function area().
• Circle and Rectangle are derived classes that inherit from Shape and provide their own implementations of the area() function.

Encapsulation

• Encapsulation is the mechanism of hiding data and methods within a class to protect it from outside access
• It binds the data and the functions that manipulate that data, and keeps both safe from outside interference and misuse.
• Achieved through access modifiers (public, private, protected)

Abstraction

• Abstraction is the process of simplifying complex systems by modeling classes appropriate to the problem.
• It focuses on essential characteristics rather than the complete details.
• Abstract classes are used to represent abstract concepts.

Inheritance Example

#include <iostream>
#include <string>

class Animal {
public:
    std::string name;

    Animal(std::string name) : name(name) {}

    virtual void makeSound() {
        std::cout << "Generic animal sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    Dog(std::string name) : Animal(name) {}

    void makeSound() override {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    Cat(std::string name) : Animal(name) {}

    void makeSound() override {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Animal("Generic Animal");
    Dog* dog1 = new Dog("Buddy");
    Cat* cat1 = new Cat("Whiskers");

    animal1->makeSound(); // Output: Generic animal sound
    dog1->makeSound();     // Output: Woof!
    cat1->makeSound();     // Output: Meow!

    delete animal1;
    delete dog1;
    delete cat1;

    return 0;
}

• This example shows inheritance with a base class Animal and derived classes Dog and Cat. The makeSound function is overridden in the derived classes to provide specific behaviors.