Objects

An object is like a real-world thing created from a class blueprint. It holds actual values and can do things using the functions defined in the class.

Example of Object from real world object — A real-world car object made from the 'Car' class

There are two main ways to create objects in languages like C++:

1. Stack Object Creation:
This is when you create the object directly in memory. It gets destroyed automatically when it goes out of scope.

// C++ example
class Car {
public:
    void drive() { /* ... */ }
};

int main() {
    Car myCar; // Stack object
    myCar.drive();
    // myCar is destroyed automatically
}

2. Dynamic Object Creation:
This method gives you more control. You create the object using new and must manually delete it to avoid memory leaks.
```
// C++ example
Car* myCarPtr = new Car(); // Dynamic object
myCarPtr->drive();
delete myCarPtr; // You must delete it manually
```

🔁 In short: stack objects are easy to manage, while dynamic objects give you more control but require extra care.

Class Components

A class contains multiple components:

Attributes (or Properties): These are the data or characteristics of the class, like a car's color or model. They define what the object can hold.

// Attribute example
class Car {
  public:
    string color;
    int model;
};

Methods (or Functions): These are the actions or behaviors the class can perform, like starting the engine or honking the horn. They define what the object can do.

// Method example
class Car {
  public:
    void honk() {
      cout << "Beep!";
    }
};

Constructors: These are special methods that run when you create an object. They set up the initial state of the object, like setting the car's color or model when you create a new car object.

// Constructor example
class Car {
  public:
    string color;
    Car(string c) {
      color = c;
    }
};

Destructors: These are special methods that run when an object is destroyed. They clean up resources or perform any necessary final actions, like releasing memory or closing files.

// Destructor example
class Car {
  public:
    ~Car() {
      // cleanup code
    }
};

Access Modifiers: These control how the class's attributes and methods can be accessed. They can be public (accessible from anywhere), private (accessible only within the class), or protected (accessible within the class and its subclasses).

Access Modifier — Access Modifer and Who can Access Them

// Access Modifiers example
class Car {
  private:
    int speed;
  public:
    void setSpeed(int s) { speed = s; }
};

Static Members and Functions: These belong to the class itself, not to any specific object. A static attribute is shared by all objects of the class, and a static method can be called without creating an object. For example, you might use a static variable to count how many objects have been created.

// Static Member/Function example
class Car {
  public:
    static int count;
    Car() { count++; }
    static void showCount() {
      cout << count;
    }
};
int Car::count = 0;

Friend Classes and Functions: These are special functions or classes that are allowed to access the private and protected members of another class. They are useful when two or more classes need to work closely together and share internal details, but you still want to keep those details hidden from the rest of the code.

// Friend Function example
class Box {
  private:
    int width;
  public:
    friend void setWidth(Box &b, int w);
};
void setWidth(Box &b, int w) {
  b.width = w;
}

Inheritance

Inheritance is like passing down traits from parents to children, but in code! It lets you create a new class (called a derived or child class) based on an existing class (the base or parent class). The child class automatically gets all the attributes and methods of the parent, and you can add more or change them as needed.

This helps you avoid repeating code and makes it easier to organize related classes. For example, you can have Mother and Father classes, and then create a Child class that inherits from them.

Inheritance Example with Family — A Child inheriting traits from Mother and Father

Types of Inheritance

Single Inheritance: A class inherits from one base class.
Example: Child inherits only from Mother.

// Single Inheritance
class Mother {
  public:
    void hair_color() { /* ... */ }
};
class Child : public Mother {
  // Child gets hair_color() from Mother
};

Multiple Inheritance: A class inherits from more than one base class.
Example: Child inherits from both Mother and Father.

// Multiple Inheritance
class Mother {
  public:
    void cook() { /* ... */ }
};
class Father {
  public:
    void drive() { /* ... */ }
};
class Child : public Mother, public Father {
  // Child gets cook() from Mother and drive() from Father
};

Multilevel Inheritance: A class is derived from another derived class (like a chain).
Example: Grandmother → Mother → Child.

// Multilevel Inheritance
class Grandmother {
  public:
    void cook() { /* ... */ }
};
class Mother : public Grandmother {
  // inherits cook()
};
class Child : public Mother {
  // inherits cook() from Grandmother through Mother
};

Hierarchical Inheritance: Multiple classes inherit from the same base class.
Example: Both Son and Daughter inherit from Mother.

// Hierarchical Inheritance
class Mother {
  public:
    void hair_type() { /* ... */ }
};
class Son : public Mother { /* ... */ };
class Daughter : public Mother { /* ... */ };
// Both Son and Daughter get thick hair()

Hybrid Inheritance: A combination of two or more types of inheritance.
Example: A ColoredRectangle class inherits from both Rectangle (which inherits from Shape) and Color.

// Hybrid Inheritance Example
class Shape { /* ... */ };
class Rectangle : public Shape { /* ... */ };
class Color { /* ... */ };
class ColoredRectangle : public Rectangle, public Color { /* ... */ };
// ColoredRectangle inherits from both Rectangle (which inherits Shape) and Color

The Diamond Problem

Sometimes, multiple inheritance can cause confusion. Imagine both Mother and Father inherit from Grandmother, and then Child inherits from both Mother and Father. Now, Child has two copies of Grandmother! This is called the diamond problem.

Diamond Problem with Family — The Diamond Problem: Child gets two Grandmothers!

// Diamond Problem Example
class Grandmother { public: void cook() { /* ... */ } };
class Mother : public Grandmother { };
class Father : public Grandmother { };
class Child : public Mother, public Father { };
// Child has two copies of Grandmother::cook()

Solving the Diamond Problem

To fix this, C++ lets you use virtual base classes. By declaring the inheritance as virtual, you make sure only one copy of the base class is shared, no matter how many times it appears in the hierarchy.

// Solution with Virtual Base Class
class Grandmother { public: void cook() { /* ... */ } };
class Mother : virtual public Grandmother { };
class Father : virtual public Grandmother { };
class Child : public Mother, public Father { };
// Only one copy of Grandmother in Child

If you ever need to specify which parent's method to use (in case of ambiguity), you can use the scope resolution operator (::):

// Using scope resolution
child.Mother::cook(); // Calls cook() from Mother's Grandmother
child.Father::cook(); // Calls cook() from Father's Grandmother

In summary: inheritance helps you reuse code, but be careful with multiple inheritance! Virtual base classes and the scope resolution operator help you avoid confusion and keep things tidy—even in a big family tree.