Control Structure

Lesson 27 - Using return Statement

Learn how return exits a function immediately, with or without a value.

Progress indicator

Lesson 27 of 28

Learning Objectives

Understand what return does in a function.
Write correct return syntax for value and void functions.
Use early return to simplify control flow.
Compare return and break behavior clearly.
Trace caller-callee flow when return executes.
Avoid common return-related mistakes.

Concept Explanation

What is return

return immediately exits the current function.

It can optionally send a value back to the caller if the function has a return type.

return Syntax

return value;   // for non-void functions
return;         // for void functions

How return Works

Function starts executing statements.
When return is reached, function stops immediately.
Control goes back to the caller function.
If value is returned, caller receives it.

Function	return type	Behavior
`normalizeLevel()`	`int`	Returns numeric value (0..255)
`blinkIfValid()`	`void`	Can exit early with `return;`

return with Value

In non-void functions like int, return must provide a value.

return in void Function

In void functions, return; exits early without value.

It is useful for guard checks like "if input is invalid, stop here".

Early Return Pattern

Early return handles invalid cases first, then keeps main logic clean and readable.

void process(int value) {
  if (value < 0) {
    return; // guard
  }
  // main logic stays cleaner
}

return vs break (Comparison)

return exits the whole function.
break exits only loop or switch block.
Use return for function-level exit, break for block-level exit.

When to Use return

Return computed values from helper functions
Exit early on invalid input
Stop function after completing required action

Example Code

This example uses return with value and return in a void function.

const int ledPin = 2;

int normalizeLevel(int value) {
  if (value < 0) {
    return 0;
  }
  if (value > 255) {
    return 255;
  }
  return value;
}

void blinkIfValid(int level) {
  if (level == 0) {
    Serial.println("Skip blink: level is 0");
    return;
  }

  digitalWrite(ledPin, HIGH);
  delay(level);
  digitalWrite(ledPin, LOW);
}

void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  int rawLevel = 300;
  int safeLevel = normalizeLevel(rawLevel);
  blinkIfValid(safeLevel);
  delay(1000);
}

Example Code Explanation

normalizeLevel() returns a safe range between 0 and 255.
return 0 and return 255 are early returns for out-of-range values.
blinkIfValid() is void and uses return; to skip blinking at level 0.
After return runs, remaining statements in that function are skipped.
Caller function continues from next line after function call.

Real-life example

In safety checks, you can return early from a function when sensor value is invalid, preventing risky output updates.

Execution Trace (One Loop Cycle)

Step	Code Path	Result
1	`rawLevel = 300`	Input value starts above valid LED range.
2	`safeLevel = normalizeLevel(rawLevel)`	Function call begins.
3	`if (value > 255) return 255;`	Early return triggers, function exits immediately.
4	Back in `loop()`	`safeLevel` receives returned value `255`.
5	`blinkIfValid(safeLevel)`	LED blinks because value is not 0, then loop continues.

What Happens Inside

Function call enters its own execution context.
return immediately ends that context.
Program jumps back to the caller line after the function call.
For typed functions, returned value is assigned to a variable or expression.
For void functions, return only controls flow.

Internal flow rule

call function -> execute until return -> jump back to caller -> continue next line

What the CPU does conceptually

Store the caller position (where execution should return).
Run function statements in order.
On return, stop function and restore caller position.
Continue caller from the next statement after the function call.

Real-world embedded use cases

Battery check: return early if voltage is too low.
Sensor read: return default value if sensor data is invalid.
Motor control: return immediately if safety pin indicates fault.
Network send: return false if connection is not ready.

Common Mistakes with return

Missing return value in non-void function.
Adding unreachable code after return inside same block.
Confusing return with break in loops.
Overusing early returns without clear conditions.

Best Practices for return

Return early for invalid inputs to reduce nesting.
Ensure all control paths in non-void functions return a value.
Use descriptive function names to make return intent clear.
Keep return logic simple and consistent.
Avoid too many scattered return points if they reduce readability.

Practice Task

Add one more guard return in normalizeLevel() for value == 0.
Modify blinkIfValid() to return early if level is below 50.
Create a new bool isValidLevel(int) helper that returns true/false.
Log caller flow before and after function calls to observe return behavior.

Try it now

Open simulator workspace and practice function-level exits with return.

Run in Simulator