Basic Definition

An inline function is defined similarly to regular functions, with the addition of the inline keyword before the function signature.

inline void logMessage(const char* msg) {
    std::cout << msg;
}

Why Use Inline Functions

• Original Purpose: To replace certain #define macro definitions
• Performance Goal: To improve program execution efficiency

Differences Between Regular and Inline Functions

1. Regular Functions: When called, the compiler generates jump instructions. Execution transfers to the function's code segment and returns afterward.

2. Inline Functions: The compiler copies the function's compiled binary instructions directly to the call site, eliminating the jump.

Advantages of Inline Functions

The primary benefit is improved execution speed (no jump or return overhead). However, this comes at the cost of increased executable file size (code bloat)—essentially trading space for time.

Explicit vs. Implicit Inline

Explicit Inline: Adding the inline keyword before the function definition (supported in C since C99). When defined outside the class declaration, this is called explicit inline.

class Renderer {
    int buffer;
public:
    void draw();
};

inline void Renderer::draw() {
    std::cout << "Buffer: " << buffer << std::endl;
}

Implicit Inline: Member functions defined directly inside a class or struct body are automatically treated as inline functions by the compiler.

class Renderer {
    int buffer;
public:
    void draw() {
        std::cout << "Buffer: " << buffer << std::endl;
    }
};

Macros vs. Inline Functions

Macro functions substitute the function body directly at the call site during preprocessing, similar to inline functions in that they trade space for time. However, critical differences exist:

1. Macros are not real functions. They are text substitutions without parameter stack operations, return values, or type checking. While this makes them type-agnostic, it introduces security vulnerabilities.

2. Inline functions are real functions. They perform parameter passing, stack operations, can return values, and enforce strict type checking. This type safety means they aren't generic—function overloading or templates are needed for different types.

Inline and Static

You may often see static combined with inline. Here's why:

Conceptual Separation: static implies internal linkage. Each translation unit (source file including the header) receives its own independent copy of the inline function. When multiple source files include the header, this prevents redefinition errors (at the cost of increased binary size).

Important Distinction: If you simply want to define a function in a header, prefer inline over static. They differ significantly in linkage:

• static functions have internal linkage. Different translation units can contain identically named static functions, but each is visible only within its unit. If the same static function definition appears in multiple units, each receives a separate copy.

• inline functions have external linkage. When called from different translation units, each references the same single definition.

Critical Implication for Static Variables:

• Inside inline functions, static variables are shared across all translation units (enabling patterns like Meyer's Singleton).
• Inside static funcsions, static variables are unique to each translation unit.

Note: static inline functions behave identically to static functions alone, making the combination redundant and potentially confusing.

When to Use Inline

Since inlining increases executable size and memory overhead, only frequently-called simple functions are suitable candidates.

Complex functions called infrequently won't benefit enough from inlining to justify the space cost. Additionally, functions with recursion or dynamic binding (virtual funtcions) cannot be inlined, so the compiler ignores the inline keyword for these.

Additional constraints:

1. Avoid complex control structures: Inline functions should not contain loops or switch statements. If present, the compiler treats the function as a regular function. Recursive functions cannot be inline. Inline is suitable only for small functions (1–5 lines). For large functions, call overhead is negligible compared to execution time.

2. Definition before use: The inline function definition must appear before its first call in the translation unit.

3. Class scope: Functions defined inside class bodies are implicitly inline.

Defining Member Functions Outside the Class

While you can define member functions inside the class body, you can also declare them inside and define them outside.

class Employee {
public:
    void display();
private:
    int id;
    std::string name;
    char level;
};

void Employee::display() {
    std::cout << "ID: " << id << std::endl;
    std::cout << "Name: " << name << std::endl;
    std::cout << "Level: " << level << std::endl;
}

Scope Resolution: When defining inside the class body, you don't prefix the function with the class name. When defining outside, you must qualify it with the class name and the scope resolution operator ::.

If :: appears without a class name prefix (e.g., ::display() or just display()), it indicates a global function, not a member function.

Member functions must be declared in the class before external definition—the class definition must precede the function definition.

Best Practice: Declaring inside and defining outside supports encapsulation. Functions with 2–3 lines may be defined inside the class; longer functions should be declared inside and defined outside.

Inline Functions in Class Definitions

Member functions defined inside class bodies are typically small, yet function call overhead is relatively large compared to executing a few statements. To reduce this overhead, C++ automatically treats member functions defined inside the class (without complex control structures) as inline.

class Point {
public:
    void show() {
        std::cout << "X: " << x << std::endl;
        std::cout << "Y: " << y << std::endl;
    }
private:
    int x;
    int y;
};

The show() function above is implicitly inline. You could explicitly write inline void show(), but this is redundant for in-class definitions.

Important: Member functions defined outside the class are not automatically inline. To make them inline, you must use explicit declaration:

class Point {
public:
    inline void show();
private:
    int x, y;
};

inline void Point::show() {
    std::cout << "X: " << x << std::endl;
    std::cout << "Y: " << y << std::endl;
}

If defining inline functions outside the class, both the class definition and member function definition must reside in the same header file, otherwise the compiler cannot perform the substitution. However, this breaks the separation of interface and implementation. While it improves execution speed, it compromises information hiding. Only specify as inline those small, frequently-called member functions defined outside the class.

Summary

Inline functions resemble C macros in that they expand at the call site, embedding the function body directly. This eliminates call overhead but increases code size through duplication at each call site.

Key Concept: Substitution at the call site
Purpose: To solve function call efficiency problems by eliminating the overhead of parameter passing, stack frame creation, and return jumps.