OOPS Important Concepts

Syntax Cheat Sheet

Access Specifiers (private, protected, public)

class MyClass {

// private
private:      // Only class members & friends can access (Default in Class)
    int a;

// protected
protected:    // Class + derived classes + friends can access (Default in Struct)
    int b;

// public
public:       // Accessible from anywhere
    int c;
};

Modes of Inheritance

// public inheritance
class Derived : public Base { };

// protected inheritance
class Derived : protected Base { };

// private inheritance
class Derived : private Base { };

Friend Keyword

class MyClass {
private:
    int secret;
public:
  // friend function
    friend void reveal(MyClass obj); // Function can access private data
};

Static Keyword

class Test {
    // static variable (shared by all objects)
    static int count; // Declaration inside class

    // static function (can access only static members because No 'this' pointer)
    static void func(){...};
};

// Definition of static variable outside the class
int Test::count = 0;

Const Keyword

// const function (does not modify member variables)
void display() const {...};  // 'const' variable written after function ⭐

// const variable (value cannot change after initialization)
const int x = 10;

// const object (can only call const member functions)
const MyClass obj;

Constructor & Destructor

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

Virtual and Overridden Function

class Base {
public:
  // Virtual Function
    virtual void show() { cout << "Base"; }
};


class Derived : public Base {
public:
  // Overrides Base::show() (Func in base must be virtual)
    void show() override { cout << "Derived"; }  // 'override' variable  return after func name ⭐
};

Pure Virtual Function (Abstract Class)

class Shape {
public:
    virtual void draw() = 0; // Must be overridden
};

---

Const vs Static

Here’s a short Static vs Const comparison for C++:

Feature	static	const
Meaning	Variable/function belongs to the class, not an object	Value cannot be changed after initialization
Scope	Shared by all objects of the class	Each object gets its own copy (unless combined with static)
Initialization	For class members, must be defined outside class (unless constexpr in C++17+)	Must be initialized at declaration (for variables)
Default Value	Zero-initialized if not set	Must have an explicit value at compile time (for const data members)
Function Effect	static function → no this pointer, can only access static members	const function → cannot modify member variables
Lifetime	Exists for the entire program run	Exists as long as its scope/object exists
Usage	Class-level data, counters, utility functions	Read-only variables, protecting data from modification

class Demo {
    static int count;   // static var (shared)
    const int id;       // const var (unique to each object)
public:
    Demo(int x) : id(x) { count++; }
    static void showCount();   // static func
    void display() const;      // const func
};

---

Function Signature

Function Signature - In C++, the function signature is the part of the function declaration that the compiler uses to uniquely identify a function.
It includes:

1. Function name
2. Number of parameters
3. Types of parameters (including their order)

It does not include:

• Return type
• Parameter names
• const qualifier on the function itself (though it can affect overloading in member functions)

Example:

void show(int, double);   // signature: show(int, double)
void show(double, int);   // different signature

Significance in Polymorphism

1. Compile-time Polymorphism (Function Overloading)

   • Overloading is possible only if function signatures differ.
   • Changing only the return type does not change the signature, so it won’t overload.

   int fun(int);    // OK
   void fun(int);   // ❌ Error: same signature as above

2. Runtime Polymorphism (Virtual Functions)

   • For overriding in inheritance, the signature must match exactly (including const-ness)
   • If the signature is different, it becomes function hiding, not overriding.

   class Base {
       virtual void show(int);
   };
   class Derived : public Base {
       void show(int) override; // ✅ Same signature → overriding
   };

In short:

• Overloading → Different signatures.
• Overriding → Same signatures.