Master C++ Default Arguments and Inline Functions: When and How to Use Them

In C++, default arguments and inline functions are two important function features that can improve code readability and execution efficiency.

1. Default Arguments

1.1 What are default arguments?

Default arguments allow specifying a default value for a parameter in the function declaration. If the argument is omitted at the call site, the compiler uses the default value.

1.2 Syntax example

#include <iostream>
using namespace std;

// Function declaration with default argument
void printMessage(string message = "Hello, C++!");

int main() {
    printMessage();          // uses default argument
    printMessage("Hi there!"); // overrides default argument
    return 0;
}

// Function definition
void printMessage(string message) {
    cout << message << endl;
}

Output:

Hello, C++!
Hi there!

1.3 Rules for default arguments

They must be placed at the rightmost positions in the parameter list; otherwise compilation fails.

When the declaration and definition are separated, default arguments can only appear in the declaration.

Default arguments can be constants, global variables, or function calls, but not local variables.

2. Inline Functions

2.1 What is an inline function?

An inline function is an optimization technique where the compiler expands the function body at each call site instead of performing a regular function call, reducing call overhead and improving performance.

2.2 Syntax example

#include <iostream>
using namespace std;

// Inline function declaration
inline int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(5, 3); // may be replaced by "5 + 3"
    cout << "Result: " << result << endl;
    return 0;
}

Output:

Result: 8

2.3 Suitable scenarios

Small functions that are called frequently, such as simple arithmetic operations.

Replacing macros, because inline functions are safer and support type checking.

2.4 Precautions

The inline keyword is only a suggestion; the compiler may ignore it.

Complex functions (e.g., recursive or with many loops) are not suitable, as they can cause code bloat.

The definition must be placed in a header file if used across multiple translation units, otherwise linking errors may occur.

3. Default Arguments vs. Inline Functions

Feature

Default Arguments: Provide default values for parameters, simplifying calls; applicable to functions with optional parameters; compiler substitutes default values.

Inline Functions: Reduce function call overhead, optimizing performance; suitable for short, frequently called functions; compiler may expand the function body.

Limitations: Default arguments must be placed from right to left; inline functions may not be applied to complex functions.

Conclusion

Default arguments make function calls more flexible and reduce the need for overloads.

Inline functions improve performance for short, high‑frequency calls.

The two can be combined, e.g.:

inline void log(string msg = "Debug info") {
    cout << msg << endl;
}