Templates and Exception Handling: Function/Class Templates, try-throw-catch and Common Exceptions Questions

Q: Explain class template with one use case.

A **class template** defines a generic class, e.g., `Box `. It can be instantiated as `Box ` or `Box `. Use case: implementing reusable data structures like stacks/queues.

Question 1

Define template.

Accepted Answer

A **template** lets us write code once and use it for multiple data types (**generic programming**).

Question 2

What is a function template?

Accepted Answer

A **function template** is a generic function that works for different data types.

Question 3

What is a class template?

Accepted Answer

A **class template** is a generic class that can be instantiated for different types.

Question 4

What is an exception?

Accepted Answer

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

Question 5

Name the keywords used in exception handling.

Accepted Answer

**try**, **throw**, **catch**.

Question 6

What does catch-all look like?

Accepted Answer

Catch-all is written as **`catch(...)`**.

Question 7

Explain templates and state any three advantages.

Accepted Answer

Templates support **generic programming** by allowing the same function/class to work for different data types. Advantages (any three):
- reduces code duplication
- improves reusability
- type-safe generic code (better than macros)
- easier maintenance

Hence templates are widely used in C++ libraries.

Question 8

Explain function template with a simple example idea.

Accepted Answer

A **function template** is written using `template<class T>` and uses **T** as a placeholder type. When called with `int`/`double`, compiler generates the specific function (**instantiation**). Example idea: generic `max(a,b)`.

Question 9

Explain class template with one use case.

Accepted Answer

A **class template** defines a generic class, e.g., `Box`. It can be instantiated as `Box` or `Box`. Use case: implementing reusable data structures like stacks/queues.

Question 10

Explain try, throw and catch (brief).

Accepted Answer

**try** contains risky code, **throw** signals an exception, and **catch** handles the exception. If an exception is thrown in try, control transfers to the matching catch block.

Question 11

Explain multiple catch blocks and catch-all.

Accepted Answer

Multiple `catch` blocks can handle different exception types. We should place **specific** catches first and `catch(...)` (catch-all) at the end to handle any remaining exceptions.

Question 12

Explain stack unwinding in exception handling.

Accepted Answer

**Stack unwinding** occurs when an exception propagates out of functions; destructors for local objects are called automatically while the runtime searches for a matching catch block.

Question 13

Explain function templates with syntax, working and a small table.

Accepted Answer

### **Explain function templates with syntax and advantage** A **function template** is a generic function definition that works for different data types. **Syntax**: - `template ` (or `template `) - `T func(T a, T b) { ... }` **Working**: - `T` acts as a **type parameter**. - When the function is called with a type (like int/double), compiler creates a specific version (**instantiation**). | Concept | Meaning | |---|---| | **Type parameter** | placeholder type (T) | | **Instantiation** | compiler generates code for a type | **Advantage**: reduces duplication and supports **generic programming**.

Question 14

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 15

Explain exception handling in C++ using try-throw-catch with flowchart and table.

Accepted Answer

### **Explain exception handling in C++ with flow (try-throw-catch)**

**Exception handling** is a mechanism to handle runtime errors gracefully.

**Keywords**:
- **try**: code that may throw
- **throw**: signal an exception
- **catch**: handle the exception

**Flow**:

```text
Normal code → try block
   ↓ if exception occurs
throw → search matching catch → handle → continue/terminate
```

**Multiple catch**:
- write specific catches first
- `catch(...)` at last for any exception

| Block | Role |
|---|---|
| try | risky code |
| throw | raise exception |
| catch | handle exception |

Thus exception handling separates normal logic from error handling and improves program reliability.

Templates and Exception Handling: Function/Class Templates, try-throw-catch and Common Exceptions

8 more questions to unlock