C++ Functions

A named piece of work

You already use functions: main is one, and swapInts in the references chapter was another. A function packages a block of statements behind a name. You write the steps once. You call the name whenever you need those steps.

Every function has a return type (what it hands back, or void if it hands back nothing), a name, parentheses, and a brace body. Execution of a program still starts at main. Other functions run only when something calls them.

Return a value

Put helpers above main so the compiler has already seen the full definition whenmain calls them. The return type on the left must match what return sends back.

#include <iostream>
using namespace std;

double square(double x) {
  return x * x;
}

int main() {
  cout << square(3.0) << endl;
  double area = square(5.0);
  cout << area << endl;
  return 0;
}

square(3.0) is a call. The argument 3.0 becomes the parameter x inside the function. When return runs, the call is replaced by the value 9.0. You can print that value or store it.

void means no value back

A void function does work — usually printing or updating something through a reference — and then stops. There is no return value to assign. You can write a bare return; to leave early. You cannot write int n = greet();.

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

void greet(string name) {
  cout << "hello, " << name << endl;
}

int main() {
  greet("Mina");
  greet("Omar");
  return 0;
}

Two calls, one definition. Change the message in greet and every call site updates. That is the whole reason to extract a function: one place to fix, not six pasted copies.

Declaration versus definition

A definition is the function with a body. A declaration (a prototype) is the return type, the name, and the parameter list, ending with a semicolon and no braces. The compiler only needs a declaration before the first call. The definition can sit later in the file.

#include <iostream>
using namespace std;

int maxOf(int a, int b);

int main() {
  cout << maxOf(4, 9) << endl;
  cout << maxOf(12, 3) << endl;
  return 0;
}

int maxOf(int a, int b) {
  if (a > b) {
    return a;
  }
  return b;
}

The prototype above main promises that maxOf exists. The definition belowmain keeps the file readable when helpers grow. The parameter names in the prototype are optional; the types are not. They must match the definition.

Call order and one main

C++ reads the file top to bottom. If you call a function the compiler has never seen, you get an error. Two legal layouts:

• Define helpers first, then main.
• Declare prototypes first, then main, then define the helpers.

A program you run has exactly one main. Helpers return to whoever called them. mainreturns to the operating system. Keep using return 0; at the end of main.

What belongs in a function

Give a function one job and a name that says that job: square, greet,maxOf. If you cannot name it without the word “and”, it is probably two functions. Do not put all of main into one giant helper. Leave program setup in main and factor the repeated pieces.

#include <iostream>
using namespace std;

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

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

int main() {
  for (int i = 1; i <= 4; i++) {
    cout << i << " squared " << square(i)
         << ", cubed " << cube(i) << endl;
  }
  return 0;
}

Next: how arguments get into the function — copy, share, and default values.