6. Calling and Returning with Functions

Lesson: Calling Functions & Parameter Lists (C++)

Calling a function correctly means constructing the parameter list so it exactly matches the function’s required types. In C++, a function’s identity is not just its name: the parameter types are part of its signature. If the call’s parameter list doesn’t match, compilation fails (or calls a different overload).

1) Function Calls & Exact Type Matching

Declaration, then call:

int f1(int x) {
    int y = 5;
    return y;      // demo only: ignores x
}

int main() {
    int z = f1(2); // OK: argument type int matches parameter type int
}

The compiler enforces type/size compatibility so that the value you pass fits in the memory reserved for the parameter. This protects memory layout and prevents corruption; any logic safety you gain is a happy by-product.

2) Substitution & Nested Calls

The value for each parameter must be computed before the call can proceed. Parenthesised, nested calls are evaluated “inside-out” for each nested expression:

int f1(int x) { return 5; }

int main() {
    int z = f1( f1(2) ); // inner f1(2) is evaluated to produce the argument of the outer call
}

This enables concise code, but readability suffers when nesting is overused:

int f1(int){ return 5; }
int f2(int){ return 7; }

int z = f1( f2( f1(1) ) ); // hard to read
// Clearer:
int a = f1(1);
int b = f2(a);
int z2 = f1(b);

3) Order of Evaluation Pitfalls (Multiple Arguments)

When a function has multiple arguments, do not rely on the order in which those arguments are evaluated — the standard allows the compiler to choose. Side effects in separate arguments can therefore behave unexpectedly.

int i = 0;
int g(){ return i++; }
int h(){ return i++; }

// Unspecified relative evaluation order of arguments:
// either g() or h() may run first; 'i' is incremented twice, order unknown.
int r = std::max(g(), h());

// Safer:
int a = g();
int b = h();
int r2 = std::max(a, b);

4) Overloads, Conversions & Ambiguity

C++ allows function overloading — same name, different parameter types. The compiler selects the best match by exact match, promotions, then conversions. Ambiguities cause compile errors.

void print(int);
void print(double);
// void print(std::string_view); // uncomment to support strings

print(42);     // calls print(int)
print(3.14);   // calls print(double)
print('A');    // character promotes; likely print(int)
print("hi");   // ❌ ambiguous/missing unless string overload exists

Prefer explicit overloads (or templates) over relying on implicit conversions that can surprise callers.

5) Forward Declarations & Circular Calls

Mutually calling functions need at least one forward declaration so the compiler knows the second function’s signature when compiling the first. Beware unbounded mutual recursion (infinite back-and-forth).

int f2(int);          // forward declaration

int f1(int x) {       // calls f2
    int y = 5;
    return f2(y);
}

int f2(int x) {       // calls f1
    int y = 7;
    return f1(y);     // ❌ without a base case, this can recurse forever
}

Add termination conditions (base cases) or redesign to break the cycle.

6) Choosing Parameter Passing Style

Pick parameter types that express intent and cost:

• By value: int f(int x) — cheap scalars; copies are fine.
• By const reference: int f(const std::string& s) — avoid copying large objects; no modification.
• By non-const reference: void f(std::vector<int>& v) — call intends to modify v.
• By rvalue reference: void f(std::string&& s) — take ownership / move.

int sum(const std::vector<int>& v);     // read-only, no copy
void append(std::vector<int>& v, int x); // modifies caller's vector
void set_name(std::string&& s);          // consumes a temporary by move

7) Worked Example — Fix the Calls

Identify problems and refactor for clarity and safety:

int f1(int){ return 5; }
int f2(int){ return 7; }

int i = 0;
int g(){ return i++; }
int h(){ return i++; }

int main() {
    int z = f1( f2( f1(1) ) );  // hard to read
    int r = std::max(g(), h()); // side-effect order risk

    // Better:
    int a = f1(1);
    int b = f2(a);
    int z2 = f1(b);

    int ga = g();
    int hb = h();
    int r2 = std::max(ga, hb);
}

8) Quick Checklist — Safe, Readable Calls

• Match parameter types exactly (or add explicit, safe overloads).
• Avoid deep nesting; introduce named intermediates.
• Do not rely on argument evaluation order; separate side effects.
• Use forward declarations for mutual calls, but ensure base cases if recursive.
• Choose parameter passing style to reflect intent and cost.

Mini Exercise — Call Sites, Signatures & Safe Parameter Lists

Goal: practise matching exact parameter types, de-nesting for clarity, avoiding argument order pitfalls, designing unambiguous overloads, breaking circular calls safely, and choosing the right passing style.

1. Match the signature (no accidental conversions)
   Fix the call sites so they match the intended parameter types without surprising promotions/narrowing.

   int  scale_int(int x, int factor);
   double scale_double(double x, double factor);
   
   int main() {
       long long big = 10000000000LL;
       double d = 2.5;
   
       auto a = scale_int(42, 2.0);     // ❌ mixed types
       auto b = scale_double(3, d);     // ❌ relies on implicit int→double
       auto c = scale_int(big, 3);      // ❌ potential narrowing
   
       // TODO: Write correct calls OR adjust function signatures responsibly.
   }
   

   • Show both approaches: (1) fix the calls with explicit casts; (2) refactor signatures to accept the real use-cases (e.g., templates or wider types). State which you chose and why.
2. De-nest for clarity (substitution still preserved)
   Rewrite the nested calls with named intermediates, then extract a tiny “pipeline” function that documents the order.

   int f1(int x){ return x + 1; }
   int f2(int x){ return x * 2; }
   int f3(int x){ return x - 3; }
   
   int main() {
       int z = f1( f2( f3( f1(5) ) ) ); // ❌ hard to read
       // TODO: z2 using intermediates; then a function int pipeline(int) { ... }
   }
   

3. Argument evaluation order: separate side effects
   Make the result deterministic by removing side effects from argument expressions.

   #include <algorithm>
   int i = 0;
   int g(){ return i++; }
   int h(){ return i += 10; } // different side effect
   
   int main() {
       int r = std::max(g(), h()); // ❌ relative evaluation order unspecified
       // TODO: refactor to two statements (no side effects in the call).
   }
   

   • Explain (one sentence) why the standard allows either argument to be evaluated first.
4. Overloads & ambiguity: make intent obvious
   Remove ambiguity without “mystery” conversions; prefer explicit overloads.

   #include <string>
   #include <string_view>
   
   void print(int);
   void print(double);
   // void print(std::string_view); // maybe needed?
   
   int main() {
       print(42);        // ok
       print(3.14);      // ok
       print('A');       // likely calls print(int) via promotion
       print("hi");      // ❌ ambiguous/missing
       // TODO: Add the right overload(s) and show unambiguous calls, including u8/u16 string literals if you wish.
   }
   

5. Forward declarations & termination
   Provide the minimum forward declaration and add a base case to ensure the mutual recursion stops.

   int f2(int);                 // forward declaration
   
   int f1(int x) {              // calls f2
       if (x <= 0) return 0;    // TODO: sensible base case
       return f2(x - 1);
   }
   
   int f2(int x) {              // calls f1
       // TODO: matching base case / measure that decreases
       return f1(x - 1);
   }
   

   • Explain what “measure strictly decreases” means for proving termination here.
6. Choose parameter passing style to express intent
   Refactor signatures to avoid copies when reading, and to make mutation/consumption explicit.

   #include <vector>
   #include <string>
   
   // ❌ unclear intent / unnecessary copies
   int    sum(std::vector<int> v);
   void   append(std::vector<int> v, int x);
   void   set_name(std::string s);
   
   // TODO: Rewrite as:
   // int    sum(const std::vector<int>& v);            // read-only
   // void   append(std::vector<int>& v, int x);        // modifies caller
   // void   set_name(std::string&& s);                 // consumes temporary
   

   • Give a one-line rationale for each choice (value / const& / & / &&).
7. Worked clean-up: fix the calls
   Apply all the above: remove nesting, separate side effects, and make passing style explicit.

   #include <algorithm>
   int f1(int){ return 5; }
   int f2(int){ return 7; }
   int i = 0;
   int g(){ return i++; }
   int h(){ return i++; }
   
   int main() {
       int z  = f1( f2( f1(1) ) );      // ❌
       int r  = std::max(g(), h());     // ❌
   
       // TODO:
       // int a = f1(1);
       // int b = f2(a);
       // int z2 = f1(b);
       // int ga = g();
       // int hb = h();
       // int r2 = std::max(ga, hb);
   }
   

#include <iostream>

int add(int left, int right) {
    return left + right;
}

int twice(int value) {
    return value * 2;
}

int main() {
    const int subtotal{add(12, 8)};
    const int total{twice(subtotal)};
    std::cout << total << '\n';
}

// Avoid making the result depend on which argument is evaluated first.
consume(read_next(), read_next());

// Make the required order explicit.
const auto first = read_next();
const auto second = read_next();
consume(first, second);

const auto first = read_next();
const auto second = read_next();
consume(first, second);