Function call flow in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What happens when a function is called in Rust?

The program pauses at the call, jumps to the function's code, runs it, then returns to continue after the call.

intermediate

What is a stack frame in the context of function calls?

A stack frame stores information like function parameters, local variables, and return address for each function call.

beginner

How does Rust handle returning values from functions?

Rust returns values by passing them back to the caller after the function finishes running, often using the return keyword or the last expression.

beginner

Why is the order of function calls important in Rust?

Because each function must finish and return before the caller continues, the order controls the program's flow and output.

intermediate

What is recursion in function call flow?

Recursion is when a function calls itself, creating multiple stack frames until a base case stops the calls.

What does the program do immediately after a function call in Rust?

A Jumps to the function's code and runs it

B Skips the function and continues

C Ends the program

D Waits for user input

When a function is called, Rust jumps to that function's code to execute it before continuing.

What information is NOT stored in a stack frame during a function call?

A Local variables

B Global constants

C Return address

D Function parameters

Global constants are stored separately, not in the stack frame for each function call.

How does Rust return a value from a function?

A Using the return keyword or last expression

B By printing it directly

C By storing it in a global variable

D Rust functions cannot return values

Rust functions return values using the return keyword or by the last expression evaluated.

What happens if a function calls itself without a base case?

A Rust prevents the call automatically

B The function returns immediately

C The program runs forever until it crashes

D The function skips the recursive call

Without a base case, recursion causes infinite calls leading to a crash (stack overflow).

Why must a function finish before the caller continues?

A To avoid user input

B Because Rust does not support multiple functions

C To save memory

D To keep the program flow predictable

Finishing functions before continuing keeps the program flow clear and predictable.

Explain the flow of a function call in Rust from start to finish.

Think about what happens step-by-step when you call a function.

Describe what a stack frame is and why it is important in function call flow.

Imagine each function call as a box holding important info.

Practice

1. What happens when a function is called in Rust?

easy

A. The program runs the function's code and then returns to the call point.

B. The program skips the function's code and continues after the call.

C. The function code runs only if called twice.

D. The program stops running after the function call.

Solution

1. Step 1: Understand function call behavior

   When a function is called, the program jumps to the function's code and executes it.

2. Step 2: Return to the call point

   After the function finishes, the program returns to the line after the call and continues running.

3. Final Answer:

   The program runs the function's code and then returns to the call point. -> Option A

4. Quick Check:

   Function call flow = run code then return [OK]

Hint: Function calls run code then return to caller [OK]

Common Mistakes:

• Thinking function code is skipped
• Believing program stops after call
• Assuming function runs only if called twice

2. Which of these is the correct way to call a function named greet in Rust?

easy

A. call greet;

B. greet();

C. greet[];

D. function greet();

Solution

1. Step 1: Recall Rust function call syntax

   Functions are called by writing their name followed by parentheses, even if no arguments are passed.

2. Step 2: Match the correct syntax

   Only greet(); matches this pattern correctly.

3. Final Answer:

   greet(); -> Option B

4. Quick Check:

   Function call syntax = name + () [OK]

Hint: Use functionName() to call functions in Rust [OK]

Common Mistakes:

• Omitting parentheses when calling functions
• Using brackets [] instead of parentheses
• Using keywords like 'call' or 'function' incorrectly

3. What will be the output of this Rust code?

fn add_one(x: i32) -> i32 {
    x + 1
}

fn main() {
    let result = add_one(5);
    println!("{}", result);
}

medium

A. 5

B. Error: missing semicolon

C. 6

D. 0

Solution

1. Step 1: Understand the function behavior

   The function add_one takes an integer and returns that integer plus one.

2. Step 2: Trace the function call and output

   Calling add_one(5) returns 6, which is printed by println!.

3. Final Answer:

   6 -> Option C

4. Quick Check:

   5 + 1 = 6 [OK]

Hint: Follow function return values to find output [OK]

Common Mistakes:

• Confusing input and output values
• Thinking semicolon causes error here
• Assuming function prints instead of returns

4. Identify the error in this Rust code snippet:

fn multiply(x: i32, y: i32) -> i32 {
    x * y
}

fn main() {
    let result = multiply(4);
    println!("{}", result);
}

medium

A. Function multiply is missing a return statement.

B. Variable result is not declared.

C. println! macro is used incorrectly.

D. multiply is called with wrong number of arguments.

Solution

1. Step 1: Check function definition parameters

   The function multiply requires two arguments: x and y.

2. Step 2: Check function call arguments

   The call multiply(4) provides only one argument, causing an error.

3. Final Answer:

   multiply is called with wrong number of arguments. -> Option D

4. Quick Check:

   Function call args must match definition [OK]

Hint: Match function call arguments to definition [OK]

Common Mistakes:

• Ignoring argument count mismatch
• Thinking missing return causes error here
• Assuming println! usage is wrong

5. Given these functions:

fn first() {
    println!("Start");
    second();
    println!("End");
}

fn second() {
    println!("Middle");
}

fn main() {
    first();
}

What is the order of printed lines when main runs?

hard

A. Start\nMiddle\nEnd

B. Middle\nStart\nEnd

C. Start\nEnd\nMiddle

D. End\nMiddle\nStart

Solution

1. Step 1: Trace the call flow from main

   Main calls first(), which prints "Start" then calls second().

2. Step 2: Follow nested function calls

   second() prints "Middle" and returns. Then first() prints "End".

3. Final Answer:

   Start\nMiddle\nEnd -> Option A

4. Quick Check:

   Call flow order = Start, Middle, End [OK]

Hint: Follow calls step-by-step to find print order [OK]

Common Mistakes:

• Ignoring nested function call order
• Assuming prints happen after all calls
• Mixing up print sequence