Inline Functions in C++ Explained — How, Why, and When to Use Them

#include <iostream>

// A tiny utility — perfect candidate for inlining.
// Without inline, every call would generate a full function-call sequence.
inline double celsiusToFahrenheit(double celsius) {
    // Formula: multiply by 9/5, then add 32
    return (celsius * 9.0 / 5.0) + 32.0;
}

// A heavier function — compiler will likely ignore inline here
// because the body is too large to benefit from expansion.
inline void printWeatherReport(double celsius) {
    double fahrenheit = celsiusToFahrenheit(celsius); // inner call may also get inlined
    std::cout << "Temperature: " << celsius << "°C / "
              << fahrenheit << "°F\n";
    if (celsius < 0)   std::cout << "  Status: Freezing\n";
    else if (celsius < 15) std::cout << "  Status: Cold\n";
    else if (celsius < 25) std::cout << "  Status: Comfortable\n";
    else               std::cout << "  Status: Hot\n";
}

int main() {
    // The compiler expands celsiusToFahrenheit() in-place here —
    // as if we had written: (0.0 * 9.0 / 5.0) + 32.0
    double freezingPoint = celsiusToFahrenheit(0.0);
    double bodyTemp      = celsiusToFahrenheit(37.0);
    double boilingPoint  = celsiusToFahrenheit(100.0);

    std::cout << "Freezing point : " << freezingPoint << "°F\n";
    std::cout << "Body temp      : " << bodyTemp      << "°F\n";
    std::cout << "Boiling point  : " << boilingPoint  << "°F\n";
    std::cout << "\n";

    printWeatherReport(-5.0);
    printWeatherReport(22.0);
    printWeatherReport(38.0);

    return 0;
}

// ─── MathUtils.h (imagine this is a separate header file) ───────────────────
// Without 'inline' here, including this header in multiple .cpp files
// would cause a linker error: 'multiple definition of clampValue'

// inline tells the linker: "multiple identical copies are fine — merge them"
inline int clampValue(int value, int minVal, int maxVal) {
    if (value < minVal) return minVal;
    if (value > maxVal) return maxVal;
    return value;
}

// Member functions defined inside a class body are IMPLICITLY inline.
// You don't need the keyword — the compiler adds it automatically.
class Rectangle {
public:
    Rectangle(double width, double height)
        : width_(width), height_(height) {}

    // Implicitly inline — defined right here in the class body
    double area() const {
        return width_ * height_;
    }

    // Also implicitly inline
    double perimeter() const {
        return 2.0 * (width_ + height_);
    }

    // A larger method — still inline by language rules,
    // but the compiler may choose NOT to expand it in-place
    void describe() const {
        std::cout << "Rectangle(" << width_ << " x " << height_ << ")\n";
        std::cout << "  Area      : " << area()      << "\n";
        std::cout << "  Perimeter : " << perimeter() << "\n";
    }

private:
    double width_;
    double height_;
};

// ─── main.cpp ────────────────────────────────────────────────────────────────
#include <iostream>
// In a real project: #include "MathUtils.h"

int main() {
    // Testing clampValue — a real use case: keeping a sensor reading in range
    int rawSensorReading = 1450;   // sensor sometimes spikes beyond valid range
    int validReading = clampValue(rawSensorReading, 0, 1023);
    std::cout << "Raw reading   : " << rawSensorReading << "\n";
    std::cout << "Clamped value : " << validReading     << "\n\n";

    int anotherReading = clampValue(-20, 0, 1023);  // below minimum
    std::cout << "Below-min clamped: " << anotherReading << "\n\n";

    // Testing implicitly-inline class methods
    Rectangle livingRoom(5.5, 4.2);
    livingRoom.describe();

    Rectangle garage(6.0, 3.0);
    garage.describe();

    return 0;
}

#include <iostream>
#include <chrono>
#include <numeric>   // std::accumulate
#include <vector>

// CANDIDATE 1: Tiny — ideal for inlining
// One arithmetic operation, called millions of times in simulation code
inline double squareMetersToSquareFeet(double squareMeters) {
    return squareMeters * 10.7639;
}

// CANDIDATE 2: Non-inline version of the same function
// (In real code you wouldn't have both — this is for illustration)
double squareMetersToSquareFeetRegular(double squareMeters) {
    return squareMeters * 10.7639;
}

// CANDIDATE 3: Too complex for inlining to help
// Recursive functions cannot be inlined — the compiler will silently ignore inline here
inline long long fibonacci(int n) {          // compiler will NOT inline this
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2); // recursion blocks inlining
}

int main() {
    const int ITERATIONS = 10'000'000;  // ten million conversions — realistic for a geometry engine

    // --- Benchmark inline version ---
    auto startInline = std::chrono::high_resolution_clock::now();
    double inlineSum = 0.0;
    for (int i = 0; i < ITERATIONS; ++i) {
        inlineSum += squareMetersToSquareFeet(static_cast<double>(i));
    }
    auto endInline = std::chrono::high_resolution_clock::now();
    auto inlineMs  = std::chrono::duration_cast<std::chrono::milliseconds>(endInline - startInline).count();

    // --- Benchmark regular version ---
    auto startRegular = std::chrono::high_resolution_clock::now();
    double regularSum = 0.0;
    for (int i = 0; i < ITERATIONS; ++i) {
        regularSum += squareMetersToSquareFeetRegular(static_cast<double>(i));
    }
    auto endRegular = std::chrono::high_resolution_clock::now();
    auto regularMs  = std::chrono::duration_cast<std::chrono::milliseconds>(endRegular - startRegular).count();

    std::cout << "Inline function  : " << inlineMs  << " ms  (sum=" << inlineSum  << ")\n";
    std::cout << "Regular function : " << regularMs << " ms  (sum=" << regularSum << ")\n";
    std::cout << "\n";

    // Demonstrating that inline on recursive functions has no effect
    std::cout << "fibonacci(10) = " << fibonacci(10) << "  (inline keyword ignored here)\n";
    std::cout << "fibonacci(15) = " << fibonacci(15) << "\n";

    return 0;
}

#include <iostream>
#include <cmath>    // std::sqrt

// A 2D vector type — used in game engines, physics simulations, GUIs.
// Every method here is a prime candidate for inlining.
struct Vector2D {
    double x;
    double y;

    // Constructor — implicitly inline (defined in class body)
    Vector2D(double x, double y) : x(x), y(y) {}

    // Getter-style method — implicitly inline, single expression body
    double magnitudeSquared() const {
        return (x * x) + (y * y);   // avoids expensive sqrt when just comparing lengths
    }

    // Slightly heavier but still reasonable for inlining
    double magnitude() const {
        return std::sqrt(magnitudeSquared());
    }

    // Returns a unit vector — normalised direction
    Vector2D normalised() const {
        double mag = magnitude();
        if (mag < 1e-9) return Vector2D(0.0, 0.0);  // guard against divide-by-zero
        return Vector2D(x / mag, y / mag);
    }

    // Operator overloads — all implicitly inline.
    // Inlining these is a genuine win: inner loops in physics engines
    // call operator+ thousands of times per frame.
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(x + other.x, y + other.y);
    }

    Vector2D operator-(const Vector2D& other) const {
        return Vector2D(x - other.x, y - other.y);
    }

    Vector2D operator*(double scalar) const {
        return Vector2D(x * scalar, y * scalar);
    }

    // Dot product — used for angle calculations and projection
    double dot(const Vector2D& other) const {
        return (x * other.x) + (y * other.y);
    }

    void print(const std::string& label) const {
        std::cout << label << ": (" << x << ", " << y << ")\n";
    }
};

// Free function defined OUTSIDE the class — needs explicit inline
// if it were in a header. Here it's in one .cpp file, so it's fine either way,
// but we add inline to show the pattern.
inline double distanceBetween(const Vector2D& pointA, const Vector2D& pointB) {
    Vector2D delta = pointA - pointB;   // operator- gets inlined here
    return delta.magnitude();
}

int main() {
    Vector2D playerPosition(3.0, 4.0);
    Vector2D enemyPosition(7.0, 1.0);
    Vector2D playerVelocity(1.5, -0.5);

    playerPosition.print("Player position");
    enemyPosition.print("Enemy position");

    // Chain of operator calls — each gets expanded inline in a tight physics loop
    Vector2D nextPosition = playerPosition + (playerVelocity * 0.016); // 60fps delta time
    nextPosition.print("Player next frame");

    double dist = distanceBetween(playerPosition, enemyPosition);
    std::cout << "Distance to enemy : " << dist << "\n";

    // Normalised direction from player toward enemy
    Vector2D toEnemy = (enemyPosition - playerPosition).normalised();
    toEnemy.print("Direction to enemy (unit vector)");

    // Dot product tells us if enemy is roughly 'in front of' the player's movement direction
    Vector2D movementDir = playerVelocity.normalised();
    double alignment = movementDir.dot(toEnemy);
    std::cout << "Movement alignment with enemy: " << alignment
              << (alignment > 0 ? "  (moving toward enemy)" : "  (moving away)") << "\n";

    return 0;
}