Inline Functions

Inline Function Concepts

inline int max(int a, int b) {
    return (a > b) ? a : b;
}

// Call: max(5, 3)
// Becomes: (5 > 3) ? 5 : 3

inline int add(int x, int y) {
    return x + y;
}

// Compiler decides whether
// to actually inline

🔹 Basic Inline Function

Inline functions for mathematical operations provide performance optimization by avoiding function call overhead. The inline keyword suggests to the compiler that function code should be inserted directly where called rather than using standard function call mechanics. This optimization benefits small, frequently-called functions performing simple calculations. Use inline functions carefully for small operations where performance matters, as large inline functions increase code size and may reduce overall performance.

#include <stdio.h>

inline int cube(int n) {
    return n * n * n;
}

inline float average(float a, float b) {
    return (a + b) / 2.0;
}

int main() {
    int num = 4;
    printf("Cube of %d: %d\n", num, cube(num));
    
    float avg = average(10.5, 15.3);
    printf("Average: %.2f\n", avg);
    return 0;
}

🔹 Inline vs Regular Functions

Comparing inline and regular function performance reveals trade-offs between speed and code size management. Inline functions execute faster by eliminating call overhead but increase compiled code size through duplication. Regular functions add small overhead but maintain compact code. Modern compilers intelligently decide when inlining is beneficial, often ignoring explicit inline keywords. Benchmark real programs to measure actual performance differences rather than assuming inline functions always improve speed.

🔸 Regular Function

// Regular function - has call overhead
int multiply(int a, int b) {
    return a * b;
}

int main() {
    int result = multiply(6, 7);  // Function call overhead
    printf("Result: %d\n", result);
    return 0;
}

🔸 Inline Function

// Inline function - no call overhead
inline int multiply(int a, int b) {
    return a * b;
}

int main() {
    int result = multiply(6, 7);  // May become: int result = 6 * 7;
    printf("Result: %d\n", result);
    return 0;
}

🔹 When to Use Inline Functions

Best practices guide appropriate inline function usage for maximum benefit without compromising code quality. Use inline functions for small, frequently-called functions where performance bottlenecks exist, simple mathematical operations or comparisons, and functions used in performance-critical code sections. Avoid inline functions that are large, complex, recursive, or used rarely. Remember that explicit inline declarations are suggestions that modern compilers may ignore based on optimization analysis.

// Good inline candidates
inline int isEven(int n) {
    return n % 2 == 0;
}

inline float celsiusToFahrenheit(float c) {
    return (c * 9.0 / 5.0) + 32.0;
}

// Poor inline candidate - too complex
int calculateFactorial(int n) {  // Don't inline this
    if (n <= 1) return 1;
    int result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

🔹 Practical Inline Examples

Real-world inline function examples demonstrate practical applications in common programming scenarios. Minimum and maximum functions comparing two values, absolute value calculations for mathematical operations, and boolean checks determining positive numbers all benefit from inlining. These small, frequently-used utility functions improve program performance while maintaining code clarity. Building a library of well-designed inline utility functions accelerates development and improves overall program efficiency.

#include <stdio.h>

inline int min(int a, int b) {
    return (a < b) ? a : b;
}

inline int max(int a, int b) {
    return (a > b) ? a : b;
}

inline int abs(int x) {
    return (x < 0) ? -x : x;
}

inline int isPositive(int n) {
    return n > 0;
}

int main() {
    int x = -15, y = 25;
    
    printf("Min(%d, %d) = %d\n", x, y, min(x, y));
    printf("Max(%d, %d) = %d\n", x, y, max(x, y));
    printf("Absolute value of %d = %d\n", x, abs(x));
    printf("Is %d positive? %s\n", x, isPositive(x) ? "Yes" : "No");
    
    return 0;
}