Functions & Parameter Passing

Function Call — add(3, 7) — Watch how arguments are copied into parameters, the function body executes, and the return value is sent back to the caller.

#include <iostream>
using namespace std;

// Function definition: takes two ints, returns their sum
int add(int x, int y) {
    int result = x + y;  // Computation happens with local copies
    return result;       // Send result back to caller
}

int main() {
    int a = 3, b = 7;
    
    // Function call: a and b are copied into x and y
    int sum = add(a, b);
    
    cout << "Sum: " << sum << endl;  // Output: Sum: 10
    cout << "a: " << a << ", b: " << b << endl;  // Output: a: 3, b: 7 (unchanged)
    
    return 0;
}

def add(x: int, y: int) -> int:
    """Takes two integers and returns their sum."""
    result = x + y  # Computation with local copies
    return result    # Send result back to caller

a = 3
b = 7

# Function call: a and b are passed by value (for immutable types)
total = add(a, b)

print(f"Sum: {total}")        # Output: Sum: 10
print(f"a: {a}, b: {b}")      # Output: a: 3, b: 7 (unchanged)

public class FunctionBasics {
    // Function definition: takes two ints, returns their sum
    static int add(int x, int y) {
        int result = x + y;  // Computation with local copies
        return result;       // Send result back to caller
    }
    
    public static void main(String[] args) {
        int a = 3, b = 7;
        
        // Function call: a and b are copied into x and y
        int sum = add(a, b);
        
        System.out.println("Sum: " + sum);          // Output: Sum: 10
        System.out.println("a: " + a + ", b: " + b); // Output: a: 3, b: 7 (unchanged)
    }
}

Failed Swap — Pass by Value — Watch how pass by value creates independent copies. The swap succeeds inside the function but the caller's variables remain unchanged.

#include <iostream>
using namespace std;

// Swap using pass by value — DOES NOT WORK!
void swapByValue(int a, int b) {
    int temp = a;   // Save copy of a
    a = b;          // Only local copy changes
    b = temp;       // Only local copy changes
    cout << "Inside function: a=" << a << ", b=" << b << endl;
    // Prints: a=10, b=5 (swapped locally)
}

int main() {
    int x = 5, y = 10;
    
    cout << "Before swap: x=" << x << ", y=" << y << endl;
    // Prints: x=5, y=10
    
    swapByValue(x, y);  // Passes COPIES of x and y
    
    cout << "After swap: x=" << x << ", y=" << y << endl;
    // Prints: x=5, y=10 (UNCHANGED!)
    
    return 0;
}

def swap_by_value(a: int, b: int) -> None:
    """Attempt to swap using pass by value — DOES NOT WORK!"""
    temp = a    # Save copy of a
    a = b       # Only local name rebinding
    b = temp    # Only local name rebinding
    print(f"Inside function: a={a}, b={b}")
    # Prints: a=10, b=5 (swapped locally)

x = 5
y = 10

print(f"Before swap: x={x}, y={y}")
# Prints: x=5, y=10

swap_by_value(x, y)  # Integers are immutable — behaves like pass by value

print(f"After swap: x={x}, y={y}")
# Prints: x=5, y=10 (UNCHANGED!)

# In Python, the idiomatic way to swap is: x, y = y, x

public class SwapByValue {
    // Swap using pass by value — DOES NOT WORK!
    static void swapByValue(int a, int b) {
        int temp = a;   // Save copy of a
        a = b;          // Only local copy changes
        b = temp;       // Only local copy changes
        System.out.println("Inside function: a=" + a + ", b=" + b);
        // Prints: a=10, b=5 (swapped locally)
    }
    
    public static void main(String[] args) {
        int x = 5, y = 10;
        
        System.out.println("Before swap: x=" + x + ", y=" + y);
        // Prints: x=5, y=10
        
        swapByValue(x, y);  // Passes COPIES of x and y
        
        System.out.println("After swap: x=" + x + ", y=" + y);
        // Prints: x=5, y=10 (UNCHANGED! Java primitives are always pass by value)
    }
}

Successful Swap — Pass by Reference — Watch how pass by reference gives the function direct access to the caller's variables. The swap modifies the originals, not copies.

#include <iostream>
using namespace std;

// Method 1: Pass by reference using C++ references (cleaner syntax)
void swapByRef(int &a, int &b) {
    int temp = a;  // a IS x (not a copy)
    a = b;         // Directly modifies x
    b = temp;      // Directly modifies y
}

// Method 2: Pass by reference using pointers (C-style)
void swapByPtr(int *a, int *b) {
    int temp = *a;  // Read value at address a
    *a = *b;        // Write value at address b into address a
    *b = temp;      // Write saved value into address b
}

int main() {
    int x = 5, y = 10;
    
    // Using C++ references
    swapByRef(x, y);  // x and y are passed by reference
    cout << "After swapByRef: x=" << x << ", y=" << y << endl;
    // Output: x=10, y=5 (swapped!)
    
    // Reset
    x = 5; y = 10;
    
    // Using pointers
    swapByPtr(&x, &y);  // Pass addresses of x and y
    cout << "After swapByPtr: x=" << x << ", y=" << y << endl;
    // Output: x=10, y=5 (swapped!)
    
    return 0;
}

# Python does not have true pass by reference for immutable types (int, str, etc.)
# However, we can achieve similar effects with MUTABLE types (lists, dicts)

# Approach 1: Use a list to hold values (simulates pass by reference)
def swap_using_list(arr: list, i: int, j: int) -> None:
    """Swaps elements at indices i and j in the list.
    Lists are mutable, so changes persist in the caller."""
    arr[i], arr[j] = arr[j], arr[i]

values = [5, 10]
print(f"Before swap: {values}")   # [5, 10]
swap_using_list(values, 0, 1)
print(f"After swap: {values}")    # [10, 5] — swapped!

# Approach 2: The Pythonic way — tuple unpacking (no function needed)
x, y = 5, 10
print(f"Before: x={x}, y={y}")    # x=5, y=10
x, y = y, x                       # Pythonic swap
print(f"After: x={x}, y={y}")     # x=10, y=5

# Approach 3: Return swapped values (functional style)
def swap_functional(a: int, b: int) -> tuple:
    return b, a

x, y = 5, 10
x, y = swap_functional(x, y)
print(f"After functional swap: x={x}, y={y}")  # x=10, y=5

public class SwapByReference {
    // Java does NOT support pass by reference for primitives.
    // To modify caller's data, we use wrapper objects or arrays.
    
    // Approach 1: Use an array (elements are mutable via the reference)
    static void swapArray(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    // Approach 2: Use a wrapper class
    static class IntWrapper {
        int value;
        IntWrapper(int value) { this.value = value; }
    }
    
    static void swapWrappers(IntWrapper a, IntWrapper b) {
        int temp = a.value;
        a.value = b.value;
        b.value = temp;
    }
    
    public static void main(String[] args) {
        // Array approach
        int[] values = {5, 10};
        System.out.println("Before: " + values[0] + ", " + values[1]);
        swapArray(values, 0, 1);
        System.out.println("After: " + values[0] + ", " + values[1]);
        // Output: After: 10, 5
        
        // Wrapper approach
        IntWrapper x = new IntWrapper(5);
        IntWrapper y = new IntWrapper(10);
        swapWrappers(x, y);
        System.out.println("After wrapper swap: " + x.value + ", " + y.value);
        // Output: After wrapper swap: 10, 5
    }
}

#include <iostream>
#include <vector>
using namespace std;

// Pass by value — safe, no side effects
int square(int x) {
    return x * x;  // x is a copy, original is safe
}

// Pass by const reference — efficient, read-only access
int sumArray(const vector<int> &arr) {
    int total = 0;
    for (int val : arr) {
        total += val;
    }
    return total;  // No copy of the vector was made!
}

// Pass by reference — modification needed
void doubleEach(vector<int> &arr) {
    for (int &val : arr) {
        val *= 2;  // Modifies original array elements
    }
}

// Multiple return values via reference parameters
void getMinMax(const vector<int> &arr, int &minVal, int &maxVal) {
    minVal = arr[0];
    maxVal = arr[0];
    for (int val : arr) {
        if (val < minVal) minVal = val;
        if (val > maxVal) maxVal = val;
    }
}

int main() {
    // Pass by value
    int n = 5;
    cout << "Square of " << n << " = " << square(n) << endl;
    cout << "n is still " << n << endl;  // n unchanged
    
    // Pass by const reference (efficient read)
    vector<int> nums = {3, 1, 4, 1, 5};
    cout << "Sum: " << sumArray(nums) << endl;
    
    // Pass by reference (modification)
    doubleEach(nums);
    cout << "Doubled: ";
    for (int v : nums) cout << v << " ";  // 6 2 8 2 10
    cout << endl;
    
    // Multiple returns via reference
    int lo, hi;
    getMinMax(nums, lo, hi);
    cout << "Min: " << lo << ", Max: " << hi << endl;
    
    return 0;
}

from typing import List, Tuple

# Pass by value behavior (immutable types like int)
def square(x: int) -> int:
    return x * x  # x is a local name, original is safe

# Pass by reference behavior (mutable types like list)
def double_each(arr: List[int]) -> None:
    """Modifies the original list in place."""
    for i in range(len(arr)):
        arr[i] *= 2  # Mutates the original list!

# Multiple return values using tuple (Pythonic approach)
def get_min_max(arr: List[int]) -> Tuple[int, int]:
    return min(arr), max(arr)

# Pass by value behavior
n = 5
print(f"Square of {n} = {square(n)}")  # 25
print(f"n is still {n}")               # 5 (unchanged)

# Pass by reference behavior (list is mutable)
nums = [3, 1, 4, 1, 5]
double_each(nums)
print(f"Doubled: {nums}")  # [6, 2, 8, 2, 10] — original is modified!

# Multiple return values
lo, hi = get_min_max(nums)
print(f"Min: {lo}, Max: {hi}")

import java.util.Arrays;

public class ParameterPassingSummary {
    // Pass by value — safe, no side effects
    static int square(int x) {
        return x * x;  // x is a copy
    }
    
    // Pass by sharing — array reference is copied, but array itself is shared
    static int sumArray(int[] arr) {
        int total = 0;
        for (int val : arr) {
            total += val;
        }
        return total;  // Does not modify arr
    }
    
    // Modification through shared reference
    static void doubleEach(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] *= 2;  // Modifies original array elements
        }
    }
    
    // Multiple return values using array (Java workaround)
    static int[] getMinMax(int[] arr) {
        int min = arr[0], max = arr[0];
        for (int val : arr) {
            if (val < min) min = val;
            if (val > max) max = val;
        }
        return new int[]{min, max};
    }
    
    public static void main(String[] args) {
        // Pass by value
        int n = 5;
        System.out.println("Square of " + n + " = " + square(n));
        System.out.println("n is still " + n);  // unchanged
        
        // Pass by sharing (array)
        int[] nums = {3, 1, 4, 1, 5};
        System.out.println("Sum: " + sumArray(nums));
        
        // Modification through shared reference
        doubleEach(nums);
        System.out.println("Doubled: " + Arrays.toString(nums));
        // [6, 2, 8, 2, 10]
        
        // Multiple returns
        int[] result = getMinMax(nums);
        System.out.println("Min: " + result[0] + ", Max: " + result[1]);
    }
}