C++ OOPs

Other important features related to OOP in C++:

• Dynamic binding (late binding)
• Message passing (objects invoking methods on other objects)

Objects in C++ –

An object is a runtime entity that contains data (attributes) and functions (methods) that operate on that data. Objects are instances of classes.

Example –

1. Fruit object might have data: name, color, size.
2. Student object might have data: name, rollNo, age, percentage.

More points:

• Objects represent real-world entities and encapsulate state and behavior.
• Objects exist at runtime and occupy memory when created.
• Objects interact by calling each other's methods (message passing).

  
class_name obj_name; // syntax to create an object in C++
  

A class is a blueprint that defines the data members and member functions common to all objects of that type. Once a class is defined, you can create any number of objects of that class.

Example – student1, student2, student3 are objects of class student and each has its own properties like name and rollNo.

Syntax:

  
class class_name
{
private:
    // private data members and functions

public:
    // public data members and functions

protected:
    // protected data members and functions
};   
  

  
class student {
    char name[20];
    int rollNo;
  public:
    void getdetails() { /* implementation */ }
};

int main() {
    student s1; // s1 is an object
    return 0;
}
  

Note – Each OOP concept has its own detailed article; this page introduces them briefly.

Abstraction means showing only essential features to the user and hiding implementation details. This separates interface from implementation.

  
#include <iostream>
using namespace std;
int main()
{
   cout << "Data Abstraction Example" << endl;
   return 0;
}
  

For example, you use cout without knowing how it is implemented inside the iostream library — you care only about the interface.

Encapsulation bundles data and methods that operate on that data within a single unit (class) and restricts direct access to some of the object's components.

• Data hiding protects internal object state from improper access.
• Access is provided through public member functions (getters/setters).

Use case: An authentication module compares passwords internally and returns only true/false — the calling code never sees the actual password.

Inheritance allows a class (child/subclass) to acquire properties and behavior of another class (parent/superclass). This promotes code reuse.

Example – A Car class can inherit common features like wheels from a Vehicle superclass.

Polymorphism means "many forms". In C++ this commonly appears as function overloading (compile-time) and virtual functions/overriding (run-time).

Dynamic binding (late binding) links a call to the method implementation at runtime. In C++ it's achieved using virtual functions and pointers/references to base classes.

Message passing is how objects communicate: one object invokes methods on another object to request actions or exchange data.

• Improved code security and data hiding.
• Multiple instances (objects) of a class can coexist independently.
• Clean organization through modular code (classes & objects).
• Code reuse through inheritance reduces duplication.
• Scalable from small to large codebases.