Organizing Code with Functions

Functions must be declared before they are called. The compiler needs to know a function's signature — its name, return type, and parameter types — before it can validate calls to it.

A prototype is a declaration without a body, placed above the caller (typically at the top of the file or in a header):

// Prototype (declaration only)
double Area(double radius);

int main() {
    Area(5.0);  // valid — compiler already knows Area's signature
}

// Full definition can come after
double Area(double radius) {
    return 3.14159 * radius * radius;
}

extern specifies that a symbol has external linkage — it can be accessed from a different translation unit. Can be applied to: Global Variables, Functions, Template Declarations.

Internal Linkage with static

The counterpart to extern is using the static keyword at file scope. It gives a symbol internal linkage — the opposite of extern — meaning it's only visible within its own translation unit and can't be accessed from other files.

// fileA.cpp
static int counter = 0; // only accessible within fileA.cpp

// fileB.cpp
extern int counter;    // linker error — counter has internal linkage

Non-const Global Variables

A non-const global variable is extern by default. All other declarations of it across files must use extern to tell the linker which definition is the real one:

// fileA.cpp
int i = 42; // declaration AND definition

// fileB.cpp
extern int i; // declaration only — same as i in fileA

// fileD.cpp — ERROR
int i = 43; // LNK2005: 'i' already has a definition
extern int i = 43; // same error (extern ignored on definitions)

Const Global Variables

const is internal by default. To make a global const accessible externally, add extern to both the initial definition and all declarations.

Parameters can have default values, making them optional at the call site. Defaults must be placed at the end of the parameter list — you cannot have a required parameter after a defaulted one.

double Area(double radius, double pi = 3.14159);

Area(5.0);           // uses default pi
Area(5.0, 3.14159265); // overrides default pi

Passing an Array

Arrays decay to a pointer when passed to a function. Both syntaxes below are equivalent — the function receives a pointer, not a copy:

void Print(int numbers[]);   // array syntax
void Print(int* numbers);    // pointer syntax — identical

Passing by Reference

A reference parameter binds directly to the caller's variable — no copy is made and changes affect the original:

void Double(int& x) {
    x *= 2;
}

int val = 5;
Double(val);  // val is now 10

When a function is called, the CPU uses a call stack to track where to return to. The sequence is:

1. The compiler converts the function call to a CALL instruction containing the callee's address
2. When CALL executes, the address of the next line (the return address) is saved on the stack
3. Execution jumps to the function's position in memory
4. The RET instruction pops the return address off the stack and jumps back to it

The inline keyword is a request to the compiler to paste the function's code directly at the call site instead of generating a CALL instruction. This eliminates the function-call overhead.

inline int Square(int x) {
    return x * x;
}

Functions with the same name but different parameter lists are called overloaded functions. The compiler picks the right version based on the arguments at the call site.

double Area(double radius);              // circle
double Area(double width, double height); // rectangle

Area(5.0);         // calls circle version
Area(4.0, 3.0);    // calls rectangle version

Overloads must differ in their parameter list. The following are not valid bases for overloading:

To support overloading at the linker level, the compiler encodes the parameter types into each function's symbol name — a process called name mangling. This creates unique symbols even when source names are identical.

void func(int x);     // mangled as something like: _Z4funci
void func(double x);  // mangled as something like: _Z4funcd
void func(std::string x); // mangled with the full type encoding

When you call an overloaded function, the compiler follows these steps to pick the right one:

1. Gather all functions in scope with the same name
2. Remove any whose number of parameters doesn't match
3. If more than one remains, select the best match
4. If there is no clear winner, report an ambiguity error

What is "Best Match"?

Candidates are ranked from best to worst. The compiler selects the highest-ranked match for each argument: