return: Getting a Value Back

A void function does a job. A function with a return type answers a question.

int addUp(int a, int b) {
  return a + b;
}

int total = addUp(3, 4);   // total is 7

The void has been replaced by int, which is a promise: this function hands back a whole number. return is where it keeps that promise.

That one change is what let the last lesson's rollDice() stop reaching out and modifying a global. A function that takes what it needs and hands back an answer depends on nothing outside itself — so it can be tested on its own, and dropped into another sketch tomorrow unchanged.

return also ends the function immediately. Anything after it never runs. That is useful in its own right: check for the bad case first, return early, and the rest of the function can assume everything is fine.

Even a void function can use return; on its own to leave early.

No wiring. Read everything in the Serial Monitor at 9600 baud.

A function that answers

int square(int n) {
  return n * n;
}

void setup() {
  Serial.begin(9600);
  Serial.println(square(7));    // 49

  int a = square(3);
  int b = square(a);            // 81 — the answer of one feeds the next
  Serial.println(b);
}

void loop() {
}

The type before the name says what comes back. int square(...) returns an int.

The value can be printed, stored, or passed straight into something else. That is what makes these functions build on each other.

Any type

float average(int total, int count) {
  return (float)total / count;
}

bool isHot(int temperature) {
  return temperature > 30;
}

char grade(int mark) {
  if (mark >= 80) return 'A';
  if (mark >= 60) return 'B';
  return 'F';
}

isHot() is worth a second look. It returns the result of the comparison — a bool — with no if at all. Then:

Statistics as functions.

Take the array from ARD-PG-13:

int readings[10] = {23, 45, 12, 67, 34, 89, 21, 56, 78, 43};

Write four functions, each taking the array and its length:

• int total(int arr[], int len)
• float average(int arr[], int len)
• int biggest(int arr[], int len)
• int countAbove(int arr[], int len, int threshold)

Note the parameter shape int arr[] — that is how an array is passed.

Then setup() should be four printed lines, calling them.

Watch out: sizeof(arr) inside those functions will not give you 10. That is why len is a parameter.

Think about it: average() needs the total. Should it call total() rather than adding the values again? Try it both ways. Which would you rather change if the definition of the total ever altered?