Functions and Modular Programming: Scope, Storage Classes, Inline Functions, Recursion and Parameter Passing Questions

Question 1

Define function.

Accepted Answer

A **function** is a named block of code that performs a specific task and can be called whenever needed.

Question 2

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 3

What is modular programming?

Accepted Answer

**Modular programming** is dividing a program into small independent modules (functions) for easier development and reuse.

Question 4

What is recursion?

Accepted Answer

**Recursion** is when a function calls itself to solve a problem using smaller subproblems.

Question 5

What is a static local variable?

Accepted Answer

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

Question 6

State one advantage of inline function.

Accepted Answer

It can reduce **function call overhead** for small frequently used functions.

Question 7

Explain the need/advantages of functions in programming.

Accepted Answer

Functions support **modular programming**. Advantages:
- improves **readability** by dividing program into parts
- enables **reusability** (same code used multiple times)
- easier **testing and debugging**
- reduces duplication and improves maintenance

Hence functions make large programs manageable.

Question 8

Differentiate between parameters and arguments.

Accepted Answer

**Parameters** are variables written in the function definition/prototype. **Arguments** are actual values passed in the function call.

Example: `int add(int x, int y)` → `x,y` are parameters; `add(10,20)` → `10,20` are arguments.

Question 9

Explain call by value and call by reference (brief).

Accepted Answer

In **call by value**, a **copy** is passed, so original variable does not change. In **call by reference**, a **reference/address** is passed, so changes inside function affect the original variable.

Reference parameters in C++ use `&` like `int &x`.

Question 10

Explain scope of variables (local, global, block).

Accepted Answer

**Scope** is where a variable can be accessed.
- **Local**: declared in a function; usable only there.
- **Block**: declared inside `{}` like loops/if; usable only inside that block.
- **Global**: declared outside all functions; accessible throughout program (use carefully to avoid bugs).

Question 11

Explain inline functions with advantages and limitation.

Accepted Answer

An **inline function** suggests compiler to expand function code at call site.
**Advantage**: reduces call overhead for small functions.
**Limitation**: not suitable for large functions; compiler may ignore inline request and code size may increase.

Question 12

Explain recursion and the importance of base case.

Accepted Answer

**Recursion** means a function calls itself. It must have a **base case** to stop recursion; otherwise it becomes infinite and may cause stack overflow.
A recursive step reduces input until base case is reached.

Question 13

Differentiate between call by value and call by reference with a table/flowchart.

Accepted Answer

### **Differentiate between call by value and call by reference**

**Call by value** passes a **copy** of the argument to the function, so changes inside the function do **not** affect the original variable. **Call by reference** passes a **reference/address**, so changes inside the function **reflect back** in the caller.

| Basis | **Call by value** | **Call by reference** |
|---|---|---|
| What is passed | Copy of value | Reference/address |
| Effect on original | No change | Changes reflect |
| Memory | New local copy | Works on same variable |
| Use case | Safe read-only operations | Modify actual variable (swap, update) |

```text
Value: a → copy → function
Reference: a → same a → function
```

**Conclusion**: Use **call by reference** when the function must modify the caller’s variables, otherwise call by value is safer.

Question 14

Explain storage classes in C++ with a table.

Accepted Answer

### **Explain storage classes in C++ (basics) with examples**
Storage class specifies a variable’s **scope**, **lifetime**, and sometimes **storage location**.

**1) auto**:
- Default for local variables.
- Lifetime: within the block/function.

**2) register**:
- Requests variable to be stored in CPU register for faster access (compiler may ignore).

**3) static**:
- **Static local** variable retains value between calls.
- Useful for counters.

**4) extern**:
- Refers to a global variable defined in another file.

| Storage class | Scope (basic) | Lifetime | Typical use |
|---|---|---|---|
| auto | local | block | normal local variable |
| register | local | block | fast loop counters |
| static | local/global | whole program | preserve value, file scope |
| extern | global | whole program | share global across files |

Thus storage classes control how and how long variables exist in memory.

Question 15

Explain recursion with base case and show a flowchart/example.

Accepted Answer

### **Explain recursion with base case and working (example) + flow**

**Recursion** is a technique where a function calls itself to solve a problem by reducing it into smaller subproblems.

**Two important parts**:
- **Base case**: stops recursion.
- **Recursive step**: calls itself with a smaller input.

Example idea: factorial
- **factorial(n) = n × factorial(n−1)**
- Base case: factorial(0) = 1

```text
fact(4)
→ 4*fact(3)
→ 4*3*fact(2)
→ 4*3*2*fact(1)
→ 4*3*2*1*fact(0)
→ 4*3*2*1*1
```

Flow:

```text
Start → Check base case? → Yes: return value
                 ↓ No
            Do recursive call → return result
```

**Note**: Recursion uses the **call stack**, so very deep recursion can cause stack overflow.

Functions and Modular Programming: Scope, Storage Classes, Inline Functions, Recursion and Parameter Passing

8 more questions to unlock