C++ Functions

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

int main() {
    cout << square(6) << endl;   // 36
}

• The first word is the return type, int here.
• Then the name and, in brackets, the parameters with their types.
• return sends a value back and ends the function.
• A function must be declared above the code that calls it, or the compiler won't know it exists yet.

Use void as the return type for functions that don't return anything.

If you'd rather put main first, declare a prototype at the top: the function's first line followed by a semicolon. The full definition can then come later in the file:

double area(double w, double h);   // prototype

int main() {
    cout << area(3, 4);
}

double area(double w, double h) {
    return w * h;
}

In bigger projects, prototypes live in header files (.h) so that many .cpp files can use the same functions.

By default, C++ passes a copy of each argument. Changing the parameter inside the function doesn't affect the caller's variable.

Add & after the type to pass by reference. The parameter then becomes another name for the caller's variable, so changes are visible outside:

void addBonus(int& points) {
    points += 10;
}

References are also used to avoid copying large values. const string& name means "use the caller's string without copying it, and don't change it".

Give a parameter a default value and callers can leave it out:

void greet(string name, string greeting = "Hello") { ... }
greet("Ivy");            // Hello, Ivy
greet("Ivy", "Welcome"); // Welcome, Ivy

Overloading means writing several functions with the same name but different parameter types or counts. The compiler picks the version that matches the arguments you pass.

A variable declared inside a function is a local variable. It's created when that line runs and destroyed when the function ends, so every call starts afresh. Parameters work the same way. Two functions can each have a variable called total without any clash, because each one only exists inside its own braces.

Sometimes a function needs to remember something between calls. Adding static to a local variable makes it live for the whole program, while staying visible only inside that function:

int nextTicket() {
    static int number = 0;   // set to 0 once, the first time only
    number++;
    return number;
}

Calling nextTicket() three times returns 1, 2 and then 3. Without static, number would be recreated as 0 on every call, and the function would always return 1.

Variables declared outside every function are global: any function in the file can read and change them. That sounds handy, but when something goes wrong, every function is a suspect. Prefer passing values in as parameters and returning results, and keep globals for true constants such as const double PI = 3.14159;.