Parameter passing mechanisms in Compiler Design - Step-by-Step Execution

Concept Flow - Parameter passing mechanisms

Start Function Call

↓

Evaluate Arguments

↓

Pass Parameters to Function

↓

Pass by Value

↓

Copy of Value

↓

Function Uses Copy

↓

Pass by Reference

↓

Address Passed

↓

Function Uses Original

↓

Pass by Value-Result

↓

Copy Passed In

↓

Copy Returned Out

↓

Pass by Name

↓

Expression Substitution

↓

Evaluate in Caller Context

↓

Function Ends

↓

Return to Caller

This flow shows how arguments are evaluated and passed to functions using different mechanisms, affecting whether the function works on copies or original data.

Execution Sample

Compiler Design

function increment(x) {
  x = x + 1;
}

let a = 5;
increment(a);

This code calls a function that tries to increase a variable by 1 using pass by value.

Analysis Table

Step	Parameter Passing	Parameter Value Inside Function	Effect on Original Variable	Notes
1	Pass by Value	x = 5 (copy of a)	a = 5 (unchanged)	Function works on copy, original not changed
2	Pass by Reference	x points to a (5)	a = 6 (changed)	Function modifies original variable
3	Pass by Value-Result	x = 5 (copy)	a = 6 (copy returned after function)	Copy used inside, then copied back
4	Pass by Name	x behaves like 'a' expression	a = 6 (changed)	Expression substituted, original updated
5	End	-	-	Function call ends, control returns to caller

💡 Function call completes after parameter passing and execution

State Tracker

Variable	Start	After Pass by Value	After Pass by Reference	After Pass by Value-Result	After Pass by Name	Final
a	5	5	6	6	6	6
x (inside function)	-	5 (copy)	reference to a	5 (copy)	expression 'a'	-

Key Insights - 3 Insights

Why doesn't the original variable 'a' change when using pass by value?

Because the function receives a copy of 'a', changes to 'x' affect only the copy, not the original 'a' (see execution_table row 1).

How does pass by reference allow the function to modify the original variable?

The function parameter points directly to the original variable's memory, so changes to 'x' affect 'a' (see execution_table row 2).

What is the difference between pass by value-result and pass by value?

Pass by value-result copies the value in and then copies it back out after the function finishes, so changes are reflected in the original (see execution_table row 3), unlike pass by value.

Visual Quiz - 3 Questions

Look at the execution_table at step 2. What is the value of 'a' after the function call using pass by reference?

A 5

B 6

C Undefined

D 0

💡 Hint

Check the 'Effect on Original Variable' column for step 2 in the execution_table.

At which step does the function work on a copy but still updates the original variable after finishing?

A Step 3

B Step 1

C Step 4

D Step 5

💡 Hint

Look for 'copy returned after function' in the Notes column of the execution_table.

If the function uses pass by value, what happens to the original variable 'a' after the function call?

A It changes to 6

B It becomes undefined

C It remains 5

D It doubles

💡 Hint

Refer to the 'Effect on Original Variable' for pass by value in the execution_table.

Concept Snapshot

Parameter passing mechanisms determine how arguments are given to functions:
- Pass by Value: function gets a copy, original unchanged
- Pass by Reference: function gets address, original can change
- Pass by Value-Result: copy in and copy back after
- Pass by Name: expression substituted and evaluated in caller's context
Each affects whether the function can modify the caller's variables.

Full Transcript

Parameter passing mechanisms control how data is sent to functions. Pass by value sends a copy, so changes inside do not affect the original. Pass by reference sends the address, so changes affect the original variable. Pass by value-result sends a copy but copies it back after the function ends, updating the original. Pass by name substitutes the expression itself, so the function works directly with the caller's data. Understanding these helps predict how functions affect variables.

Practice

1. Which parameter passing mechanism sends a copy of the argument to the function, so changes inside the function do not affect the original variable?

easy

A. Pass by name

B. Pass by reference

C. Pass by value

D. Pass by result

Solution

1. Step 1: Understand pass by value

   Pass by value means the function receives a copy of the argument, so any changes inside the function do not affect the original variable.

2. Step 2: Compare with other mechanisms

   Pass by reference sends the original variable, so changes affect it. Pass by name and result behave differently and are less common.

3. Final Answer:

   Pass by value -> Option C

4. Quick Check:

   Copy sent, original unchanged = Pass by value [OK]

Hint: Copy means pass by value, original means pass by reference [OK]

Common Mistakes:

• Confusing pass by value with pass by reference
• Thinking pass by name sends a copy
• Assuming pass by result is the same as pass by value

2. Which of the following is the correct syntax to declare a function parameter passed by reference in C++?

easy

A. void func(int &x);

B. void func(int x);

C. void func(ref int x);

D. void func(*int x);

Solution

1. Step 1: Recall C++ reference syntax

   In C++, passing by reference uses the ampersand (&) symbol after the type in the parameter list.

2. Step 2: Analyze options

   void func(int &x); uses int &x which is correct. void func(int x); passes by value, C is invalid syntax, and D is pointer syntax, not reference.

3. Final Answer:

   void func(int &x); -> Option A

4. Quick Check:

   C++ reference uses & in parameter [OK]

Hint: Look for & symbol in parameter for C++ reference [OK]

Common Mistakes:

• Confusing pointer (*) with reference (&)
• Using invalid 'ref' keyword in C++
• Assuming no symbol means pass by reference

3. Consider the following pseudocode using pass by reference:

function increment(x) {
  x = x + 1
}

var a = 5
increment(a)
print(a)

What will be the output?

medium

A. 5

B. Undefined

C. Error

D. 6

Solution

1. Step 1: Understand pass by reference effect

   Since x is passed by reference, the function changes the original variable a by adding 1.

2. Step 2: Trace the code execution

   a starts at 5, increment adds 1 making it 6, then print outputs 6.

3. Final Answer:

   6 -> Option D

4. Quick Check:

   Pass by reference changes original = 6 [OK]

Hint: Pass by reference changes original variable [OK]

Common Mistakes:

• Assuming pass by reference behaves like pass by value
• Thinking the original variable remains unchanged
• Ignoring the effect of increment inside the function

4. Identify the error in this code snippet using pass by value:

function swap(x, y) {
  temp = x
  x = y
  y = temp
}

var a = 3
var b = 4
swap(a, b)
print(a, b)

medium

A. Print statement is incorrect

B. swap function does not swap original variables

C. Variables a and b are not declared

D. Syntax error in function definition

Solution

1. Step 1: Understand pass by value behavior in swap

   Since parameters are passed by value, swap changes only local copies x and y, not original a and b.

2. Step 2: Check the output effect

   After swap call, a and b remain 3 and 4, so swap does not work as intended.

3. Final Answer:

   swap function does not swap original variables -> Option B

4. Quick Check:

   Pass by value means original unchanged [OK]

Hint: Pass by value swaps local copies only [OK]

Common Mistakes:

• Assuming swap changes original variables with pass by value
• Looking for syntax errors where none exist
• Ignoring parameter passing mechanism effect

5. You want to write a function that modifies a list of numbers by doubling each element. Which parameter passing mechanism is best to use to ensure the original list is changed efficiently?

hard

A. Pass by reference

B. Pass by value

C. Pass by name

D. Pass by result

Solution

1. Step 1: Consider efficiency and effect on original list

   Pass by value copies the entire list, which is inefficient and changes won't affect original.

2. Step 2: Choose mechanism that modifies original efficiently

   Pass by reference sends the original list, allowing direct modification without copying.

3. Final Answer:

   Pass by reference -> Option A

4. Quick Check:

   Modify original efficiently = Pass by reference [OK]

Hint: Modify original data efficiently with pass by reference [OK]

Common Mistakes:

• Choosing pass by value and expecting original change
• Confusing pass by name with pass by reference
• Ignoring efficiency of copying large data