Functions: declare, define, call and return

Why functions?

As programs grow, writing everything inside main becomes a mess. A function packs one job, such as "work out GST", under a name. You write it once, test it once and call it from many places. If the GST rule changes, you fix one function.

Writing a function

#include <iostream>

double withGst(double price, double rate) {
    return price + price * rate / 100;
}

int main() {
    double bill = withGst(1000, 18);
    std::cout << bill << '\n';                 // 1180
    std::cout << withGst(250, 5) << '\n';      // 262.5
}

• Return type: the type of the value the function gives back (double here). void means it gives back nothing.
• Parameters: the named inputs, each with its type, in the brackets.
• Arguments: the actual values passed when calling, like 1000 and 18.
• return: ends the function and hands the value back.

Pass by value

By default C++ copies each argument into the parameter. This is pass by value: changing the parameter inside the function does not change the caller's variable. In the next module you will learn references, which let a function change the caller's variable or avoid copying big objects.

void addBonus(int marks) {
    marks += 5;          // changes only the local copy
}

int main() {
    int m = 80;
    addBonus(m);
    std::cout << m;      // still 80
}

Declaration versus definition

The compiler reads a file from top to bottom. If main calls a function that is written below main, the compiler has not seen it yet and reports an error. A declaration, also called a prototype, is just the first line followed by a semicolon. It promises "this function exists; its body comes later".

#include <iostream>

int square(int n);          // declaration (prototype)

int main() {
    std::cout << square(9) << '\n';   // 81
}

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

Splitting code into files

// gst.h  (header: declarations only)
#pragma once
double withGst(double price, double rate);

// gst.cpp  (source: definitions)
#include "gst.h"
double withGst(double price, double rate) {
    return price + price * rate / 100;
}

// main.cpp
#include <iostream>
#include "gst.h"
int main() { std::cout << withGst(100, 18) << '\n'; }

Use angle brackets <iostream> for standard and system headers, and double quotes "gst.h" for your own files. If you forget to add gst.cpp to the compile command, the linker reports "undefined reference to withGst".

Common mistakes

• Forgetting return in a non-void function. The compiler warns ("control reaches end of non-void function"); using the result is undefined behaviour.
• Calling a function before it is declared: "was not declared in this scope". Add a prototype or move the function above main.
• Expecting a pass-by-value parameter change to affect the caller.
• Putting function definitions (bodies) in a header that many .cpp files include. That causes "multiple definition" linker errors unless the function is marked inline.