Polymorphism: Function Overloading, Operator Overloading and Virtual Functions (Basics) Questions

Question 1

What is early binding?

Accepted Answer

**Early binding** is compile-time resolution of function call (non-virtual functions).

Question 2

Write syntax of pure virtual function.

Accepted Answer

`virtual void f() = 0;`

Question 3

Explain compile-time polymorphism with examples.

Accepted Answer

**Compile-time polymorphism** (static binding) is decided during compilation. Examples:
- **Function overloading** (same name, different parameters)
- **Operator overloading** (operators for class objects)

Compiler selects correct function/operator based on signature.

Question 4

Define polymorphism.

Accepted Answer

**Polymorphism** means **many forms**—same name can have different behaviour.

Question 5

What is function overloading?

Accepted Answer

**Function overloading** is using the same function name with different parameter lists.

Question 6

What is operator overloading?

Accepted Answer

**Operator overloading** gives user-defined meaning to operators for class objects.

Question 7

What is a virtual function?

Accepted Answer

A **virtual function** enables dynamic binding so derived version is called through base pointer/reference.

Question 8

Explain run-time polymorphism with example.

Accepted Answer

**Run-time polymorphism** (dynamic binding) is decided during execution using **virtual functions**.
Example: `Base *p = new Derived; p->show();` calls `Derived::show()` if `show()` is virtual and overridden.

This ensures correct method is executed for derived objects.

Question 9

State rules for function overloading (any three).

Accepted Answer

Rules (any three):
- same function name
- different **number** of parameters, or
- different **types** of parameters, or
- different **order** of parameter types
- cannot overload by changing **return type only**

Overloading is resolved by compiler.

Question 10

Differentiate between overloading and overriding (brief).

Accepted Answer

**Overloading**: same name, different parameter list, no inheritance needed, compile-time.
**Overriding**: same signature in derived class, inheritance required, run-time with virtual.

They solve different problems: different inputs vs different behaviours.

Question 11

Explain operator overloading and mention one limitation.

Accepted Answer

**Operator overloading** allows operators to work with class objects (e.g., `+` for complex).
Limitation: precedence/associativity cannot be changed and some operators like **`::`**, **`.`**, **`?:`**, **`sizeof`** cannot be overloaded.

Question 12

Explain early binding vs late binding.

Accepted Answer

**Early binding** is compile-time function selection (non-virtual). **Late binding** is run-time selection (virtual).
Late binding chooses function based on actual object type through base pointer/reference.

Question 13

Explain polymorphism in C++ and its types with a table.

Accepted Answer

### **Explain polymorphism in C++ and its types (with table)**

**Polymorphism** means **many forms**—the same name can perform different actions depending on context.

**Types**:
- **Compile-time (static) polymorphism**: decided at compile time.
  - **function overloading**, **operator overloading**
- **Run-time (dynamic) polymorphism**: decided at run time.
  - **overriding** using **virtual functions**

| Type | Also called | Examples |
|---|---|---|
| Compile-time | static binding | overloading |
| Run-time | dynamic binding | virtual functions |

Thus polymorphism improves flexibility and supports reusable, extensible designs.

Question 14

Explain function overloading and differentiate it from overriding with a table.

Accepted Answer

### **Explain function overloading and differentiate it from overriding**

**Function overloading** uses the same function name with **different parameter list** (number/type/order). It is **compile-time polymorphism**.

**Overriding** happens in inheritance: derived class defines a function with the **same signature** as base class to change behaviour. With **virtual**, it becomes run-time polymorphism.

| Basis | **Overloading** | **Overriding** |
|---|---|---|
| Parameters/signature | different | same |
| Inheritance | not required | required |
| Binding | compile-time | run-time (virtual) |

So, overloading is about different inputs, overriding is about different behaviour in derived classes.

Question 15

Explain virtual functions and dynamic binding with a flow/diagram and table.

Accepted Answer

### **Explain virtual functions and dynamic binding with a flow/diagram**

A **virtual function** is a base class function declared with `virtual` that can be overridden in derived classes.

If we call it using a base class pointer/reference, C++ uses **dynamic binding** and calls the correct derived version.

```text
Base *p = new Derived;
p->show();
If show() is virtual → runtime checks actual object type → Derived::show() executes
```

| Binding | When decided | Used with |
|---|---|---|
| Early (static) | compile time | non-virtual |
| Late (dynamic) | run time | virtual |

Thus virtual functions enable run-time polymorphism and correct behaviour through base pointers.

Polymorphism: Function Overloading, Operator Overloading and Virtual Functions (Basics)

8 more questions to unlock