Inline Functions in C++

In this lesson: What inline functions are in C++, when the compiler inlines, advantages and limits — with example. In Hindi & English.

What is an inline function?

A normal function call has a small cost: the program jumps to the function, passes arguments, and jumps back. For a one-line function such as "return the larger of two numbers", that overhead can be bigger than the work itself. An inline function asks the compiler to paste the function's body directly at each place it is called, removing the jump.

This lesson covers the beginner view — syntax, examples, advantages and limits. For the deeper rules about headers and the One Definition Rule, see C++ inline functions: ODR, headers and performance.

Syntax

inline return_type function_name(parameters) {
    // small body
}

The keyword goes before the return type in the function definition.

Example: square and maximum

#include <iostream>

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

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

int main() {
    std::cout << "Square of 7 : " << square(7) << "\n";
    std::cout << "Max(45, 62) : " << maxOf(45, 62) << "\n";

    int marks[] = {78, 91, 66, 84};
    int best = marks[0];
    for (int m : marks) best = maxOf(best, m);
    std::cout << "Highest mark: " << best << "\n";
    return 0;
}

If the compiler inlines square(7), the generated code is as if you had written 7 * 7 directly — no call at all.

Inline member functions

A member function defined inside the class body is automatically inline:

class Circle {
    double r;
public:
    Circle(double radius) : r(radius) {}
    double area() const { return 3.14159 * r * r; }   // implicitly inline
    double perimeter() const;                          // declared only
};

inline double Circle::perimeter() const {              // defined outside: add inline
    return 2 * 3.14159 * r;
}

Getters and setters are the classic example of small functions that benefit from this.

Inline function vs macro

In C, programmers used macros for speed. The same idea as a macro has hidden traps:

#define SQUARE_M(x) ((x) * (x))
inline int squareF(int x) { return x * x; }

int i = 3;
int a = SQUARE_M(i++);   // i incremented twice — undefined/buggy
int j = 3;
int b = squareF(j++);    // j incremented once, b = 9

When will the compiler not inline?

The compiler usually refuses (or it gives no benefit) when the function:

• is large or contains loops, switch or goto,
• is recursive,
• contains static variables,
• is called through a function pointer or its address is taken,
• is virtual and called through a base pointer (resolved at run time).

Modern compilers with optimisation (-O2) also inline small functions you did not mark inline. So use inline for tiny functions defined in headers, not as a speed trick for big ones.

Advantages and disadvantages

Common mistakes

• Marking large or recursive functions inline and expecting speed.
• Declaring a function inline in a header but defining it in a .cpp file — other files then get "undefined reference" errors. Inline functions must be defined where they are used, usually in the header.
• Thinking inline guarantees inlining.
• Using a macro when an inline (or constexpr) function would be safer.

Summary

• inline asks the compiler to replace calls with the function body.
• Best for very small, frequently called functions.
• Member functions defined inside a class are inline automatically.
• Inline functions are type-safe and evaluate arguments once — unlike macros.
• The compiler may ignore inline; don't use it on big or recursive functions.

Related: functions, preprocessor directives, inline functions in depth.