Question 1

The statement used to signal an exception is:

Accepted Answer

`throw` raises an exception.

Question 2

Recursion must have:

Accepted Answer

Without a **base case**, recursion may become infinite.

Question 3

Order of destructor calls when destroying a derived object is:

Accepted Answer

Derived destructor runs first, then base destructor.

Question 4

Which is true about operator overloading?

Accepted Answer

Overloading changes behavior, not precedence/associativity rules.

Question 5

Function overloading is an example of:

Accepted Answer

Overloading is resolved at compile time (static binding).

Question 6

Call by reference in C++ is commonly implemented using:

Accepted Answer

Reference parameters like `int &x` allow modifying the original argument.

Question 7

Dynamic memory allocation in C++ uses:

Accepted Answer

C++ uses **new/delete** for dynamic allocation.

Question 8

Friendship in C++ is:

Accepted Answer

Friendship is not inherited (and not transitive by default).

Question 9

Which header is used for standard input/output in C++?

Accepted Answer

`cin` and `cout` are defined in **<iostream>**.

Question 10

A constructor has:

Accepted Answer

Constructors do not have any return type.

Question 11

Which header file is used for file handling in C++?

Accepted Answer

File stream classes are provided by **<fstream>**.

Question 12

Which operator has higher precedence in the expression 2 + 3 * 4?

Accepted Answer

Multiplication has higher precedence than addition.

Question 13

The operator used to access the value at the address stored in a pointer is:

Accepted Answer

`*p` **dereferences** pointer `p`.

Question 14

Which inheritance type involves one base class and multiple derived classes?

Accepted Answer

Hierarchical: one base with multiple derived classes.

Question 15

Which operator cannot be overloaded?

Accepted Answer

`::` (scope resolution) cannot be overloaded.

Question 16

Which concept wraps data and functions into a single unit?

Accepted Answer

Encapsulation bundles data members and member functions.

Question 17

Which is used to read a complete line including spaces?

Accepted Answer

`getline()` reads an entire line.

Question 18

Which is NOT allowed to be overloaded?

Accepted Answer

`::` cannot be overloaded.

Question 19

Inline function is mainly beneficial when:

Accepted Answer

Inlining can reduce call overhead for small frequently-called functions.

Question 20

Which is a class template usage?

Accepted Answer

Class templates are used like `Box<int>`.

Question 21

Define structure.

Accepted Answer

A **structure** is a user-defined type that groups variables of different data types under one name.

Question 22

What is a static local variable?

Accepted Answer

A **static local** variable retains its value between function calls (initialized once).

Question 23

What is a base class?

Accepted Answer

A **base class** is the existing class from which another class is derived.

Question 24

What is a virtual function?

Accepted Answer

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

Question 25

State the order of constructor calls in inheritance.

Accepted Answer

Constructor order is **Base → Derived**.

Question 26

What is C++?

Accepted Answer

**C++** is a general-purpose, compiled language that supports **procedural** and **object-oriented programming (OOP)**.

Question 27

What is an exception?

Accepted Answer

An **exception** is an abnormal runtime event that disrupts normal program flow.

Question 28

What is a variable?

Accepted Answer

A **variable** is a named memory location whose value can change during program execution.

Question 29

What is a function prototype?

Accepted Answer

A **function prototype** declares a function’s **return type** and **parameter list** to the compiler before its use.

Question 30

Which header is used for file streams?

Accepted Answer

**<fstream>**.

Question 31

Differentiate between struct and class (any three points).

Accepted Answer

In C++, `struct` and `class` are similar, but:
- Default access: **struct → public**, **class → private**
- Typical use: struct for simple data grouping; class for encapsulation
- Both support member functions and constructors

So the main difference is default access control.

Question 32

Write short note on memory leak and how to avoid it.

Accepted Answer

A **memory leak** occurs when allocated memory is not freed (missing `delete/delete[]`). Over time, program consumes more memory.
Avoid by always releasing dynamic memory and setting pointers to **nullptr** after delete.

Question 33

Explain enum with example and use.

Accepted Answer

An **enum** defines named integer constants. Example: `enum Day{Mon,Tue,Wed};`
Use: improves readability and restricts values to a fixed set (avoid magic numbers).

Question 34

Explain destructor and its importance.

Accepted Answer

A **destructor** runs when an object is destroyed. It has name `~ClassName()` and no return type.
Importance: used to release resources like dynamic memory/files, preventing leaks and ensuring proper cleanup.

Question 35

Explain multiple inheritance and mention one issue.

Accepted Answer

**Multiple inheritance** occurs when a derived class inherits from more than one base class.
Issue: **ambiguity** can occur if both bases contain same member name. It can be resolved using **scope resolution (`Base1::member`)**.

Question 36

Explain types of inheritance with diagrams.

Accepted Answer

### **Explain types of inheritance with diagrams**

**Types of inheritance**:

1) **Single**: one base → one derived
2) **Multilevel**: base → derived1 → derived2
3) **Multiple**: one derived inherits from multiple bases
4) **Hierarchical**: one base → multiple derived
5) **Hybrid**: combination (e.g., multiple + multilevel)

```text
Single:      B → D
Multilevel:  B → D1 → D2
Multiple:    B1   B2
               ↘ ↙
                D
Hierarchical:      B
                 ↙   ↘
                D1   D2
Hybrid: (combination)
```

So each type describes a different relationship pattern between classes.

Question 37

Explain this pointer and type conversion in C++ with a flow/overview.

Accepted Answer

### **Explain this pointer and type conversion (overview with flow)**

**this pointer**:
- `this` points to the **current object** inside a non-static member function.
- Common use: resolve name conflict: **`this->x = x;`**
- Used for chaining: `return *this;`

**Type conversion**:
- **Implicit**: automatic by compiler
- **Explicit**: forced casting
- For classes: conversion constructor (basic → class) and conversion operator (class → basic)

```text
Object calls method → inside method 'this' points to that object → this->member accesses that object’s data

Type conversion:
Implicit/Explicit → (basic types)
Conversion constructor / conversion operator → (user-defined types)
```

Thus `this` clarifies object context and type conversion helps different types work together.

Question 38

Explain class templates with example and flow.

Accepted Answer

### **Explain class templates with example and use** A **class template** is a generic class that can work with different data types. Example idea: - `template class Box { T data; ... }` - `Box b1;` stores int - `Box b2;` stores float **Why useful**: - helps build reusable data structures (stack, queue) - type-safe and avoids writing separate classes for each type ```text Template class → instantiate with type → Box, Box... ``` So class templates enable reusable and flexible class designs.

Question 39

Explain constructor and destructor order in inheritance with a table/flow.

Accepted Answer

### **Explain constructor/destructor order in inheritance (with flow + example idea)**

When a **derived object** is created:
- **Base class constructor** runs first
- then **Derived class constructor**

When it is destroyed:
- **Derived destructor** runs first
- then **Base destructor**

| Event | Order |
|---|---|
| Object creation | **Base → Derived** |
| Object destruction | **Derived → Base** |

```text
Create D:
Base() → Derived()

Destroy D:
~Derived() → ~Base()
```

Reason: base part must be initialized before derived extends it, and cleanup happens in reverse order.

Question 40

Explain inheritance in C++ and its benefits with a diagram.

Accepted Answer

### **Explain inheritance in C++ and its benefits (with diagram)**

**Inheritance** is the process of creating a **derived class** from a **base class** so that the derived class can reuse base class members.

**Benefits**:
- **Code reusability** (avoid rewriting)
- easier maintenance (base changes reflect in derived)
- supports hierarchy and extension

```text
Base class (B) → Derived class (D)
D reuses B’s members + adds new features
```

Thus inheritance reduces duplication and helps build larger programs efficiently.

Programming in C++ — Question Paper

20 more questions to unlock