Inline Functions

Programming Language & Its Applications — C++ Constructs with Objects and Classes, NEC licence examination syllabus (Nepal Engineering Council).

Inline Functions

A request to paste the body at the call site instead of jumping to it — trading code size for call overhead.

🌍 Where this lives: inlining is why C++ can be as fast as hand-written C while still letting you wrap things in tiny helper functions. Every std::vector element access v[i] is a function call in the source and zero function calls in the compiled binary — the compiler inlined it into a single memory load, which is exactly why C++ programmers can use safe abstractions without paying for them. This is also the whole reason C's #define MAX(a,b) macros exist and why they were a bad idea. Search "zero cost abstraction C++" — inlining is the mechanism that makes that phrase true rather than marketing.

What a function call actually costs

A normal call does real work beyond your code: 1. push arguments (registers or stack) 2. push the return address 3. jump to the function 4. set up a new stack frame 5. ... your actual code ... 6. put the return value in a register 7. tear down the frame 8. jump back For a function whose body is `return a + b;` the OVERHEAD is larger than the work. That is what inline removes: inline int square(int x) { return x * x; } int y = square(5); ↓ compiler substitutes the body int y = 5 * 5; ↓ and then constant-folds it int y = 25; /* zero instructions at runtime */ inline is a REQUEST, not a command. The compiler may: · inline a function you did not mark inline · refuse to inline one you did mark It decides based on body size, call count and optimisation level. -O0 typically inlines nothing; -O2 inlines a lot.

inline_basics.cpp

#include <iostream>

inline int square(int x)        { return x * x; }
inline int max2(int a, int b)   { return a > b ? a : b; }
inline double celsius(double f) { return (f - 32) * 5.0 / 9.0; }

/* NOT a good inline candidate - loops, too big */
int sum_to(int n) {
    int s = 0;
    for (int i = 1; i <= n; i++) s += i;
    return s;
}

int main() {
    std::cout << "square(7)      = " << square(7)      << "\n";
    std::cout << "max2(12, 30)   = " << max2(12, 30)   << "\n";
    std::cout << "celsius(98.6)  = " << celsius(98.6)  << "\n";
    std::cout << "sum_to(100)    = " << sum_to(100)    << "\n";
    return 0;
}
Output:
square(7)      = 49
max2(12, 30)   = 30
celsius(98.6)  = 37
sum_to(100)    = 5050

Checking the numbers: celsius(98.6) = (98.6 − 32) × 5/9 = 66.6 × 0.5556 = 37.0 ✔ (normal body temperature) sum_to(100) = 100 × 101 / 2 = 5050 ✔ (Gauss) Note that with -O2 the compiler can evaluate square(7) entirely at compile time: the binary contains the literal 49, and square() may not exist as a function at all.

Inline versus macro — why inline won

macro_vs_inline.cpp

#include <iostream>

/* THE MACRO WAY - pure text substitution, no type checking */
#define SQ_MACRO(x) ((x) * (x))
#define MAX_MACRO(a, b) ((a) > (b) ? (a) : (b))

/* THE INLINE WAY - a real function, fully type checked */
inline int sq_inline(int x)          { return x * x; }
inline int max_inline(int a, int b)  { return a > b ? a : b; }

int main() {
    int i = 5;

    /* TRAP 1: double evaluation of side effects */
    i = 5;
    std::cout << "SQ_MACRO(i++)  = " << SQ_MACRO(i++)
              << "  i is now " << i << "\n";
    /* expands to ((i++) * (i++)) - i incremented TWICE,
       and the order is unspecified: undefined behaviour */

    i = 5;
    std::cout << "sq_inline(i++) = " << sq_inline(i++)
              << "  i is now " << i << "\n";
    /* argument evaluated ONCE, then passed. Correct. */

    /* TRAP 2: no type checking */
    std::cout << "SQ_MACRO(2.5)  = " << SQ_MACRO(2.5) << "\n";
    std::cout << "sq_inline(2.5) = " << sq_inline(2.5) << "\n";
    /* the inline version TRUNCATES 2.5 to 2 - visible,
       predictable, and the compiler can warn about it */
    return 0;
}
Output (macro line is UB; a typical result):
SQ_MACRO(i++)  = 30  i is now 7      <-- 5 * 6, i bumped twice
sq_inline(i++) = 25  i is now 6      <-- correct
SQ_MACRO(2.5)  = 6.25
sq_inline(2.5) = 4

The full comparison: MACRO inline FUNCTION handled by preprocessor compiler type checking NONE full argument evaluated every time it exactly once appears debugger visibility invisible normal function scope rules ignores them obeys them can be a class no yes (member fn) member needs () armour yes, obsessively no The classic macro bug: #define SQUARE(x) x * x SQUARE(2 + 3) -> 2 + 3 * 2 + 3 = 11, not 25 Armouring with parentheses fixes that one: #define SQUARE(x) ((x) * (x)) but nothing fixes double evaluation. Rule for modern C++: use inline functions, constexpr, or templates. Reserve macros for conditional compilation (#ifdef) and things that genuinely need textual tricks (#__FILE__, #__LINE__ in assert).

Read the macro trap carefully — SQ_MACRO(i++) is not merely wrong, it is undefined behaviour. Modifying i twice with no sequencing between them means the standard makes no promise at all, so different compilers legitimately print 25, 30 or 36. A bug that changes answer when you change compiler is far worse than one that is simply wrong.

Worked example — when inlining hurts

Inlining trades CODE SIZE for CALL OVERHEAD. Both matter. Suppose a 50-byte function is called from 200 places: not inlined: 50 bytes of code + 200 × ~5 bytes of call = 50 + 1000 = 1,050 bytes inlined : 200 × 50 bytes = 10,000 bytes That is roughly 10× the machine code for this function. Why bigger can be SLOWER — the instruction cache: A typical L1 instruction cache is 32 KB. Code that fits runs from cache; code that does not must be fetched from L2 or main memory, which is 10-100× slower. So bloating a hot loop's code out of L1 can make an "optimised" build measurably slower. This is called CODE BLOAT and it is a real, measured effect — which is why gcc has -Os (optimise for size) and why compilers ignore your inline hint on large functions. Good inline candidates: · 1-3 lines, no loops · getters and setters · small operators, comparisons, accessors Bad candidates: · anything with a loop · recursive functions (cannot fully inline anyway) · large bodies called from many places · virtual functions called through a base pointer (the target is unknown at compile time)

member_inline.cpp

#include <iostream>

class Rectangle {
    double w, h;
public:
    Rectangle(double w, double h) : w(w), h(h) {}

    /* defined INSIDE the class body -> implicitly inline */
    double width()  const { return w; }
    double height() const { return h; }
    double area()   const { return w * h; }

    /* declared here, defined outside */
    double perimeter() const;
    void   describe() const;
};

/* explicit inline when defining outside the class */
inline double Rectangle::perimeter() const {
    return 2 * (w + h);
}

/* not inline - has I/O, too big to be worth it */
void Rectangle::describe() const {
    std::cout << w << " x " << h
              << "  area=" << area()
              << "  perim=" << perimeter() << "\n";
}

int main() {
    Rectangle r(4.5, 8.0);
    r.describe();
    std::cout << "width via getter = " << r.width() << "\n";
    return 0;
}
Output:
4.5 x 8  area=36  perim=25
width via getter = 4.5

Every member function defined inside the class body is implicitly inline — you do not write the keyword. That is why getters and setters written in the header cost nothing: they compile to the same single memory access as touching the field directly, while still letting you change the implementation later.

Why inline functions belong in headers

To paste a function's body at a call site, the compiler must SEE that body while compiling that translation unit. math.h: inline int square(int x); /* declaration only */ main.cpp: #include "math.h" int y = square(5); ← compiler cannot inline; body is elsewhere So inline function DEFINITIONS go in the header: math.h: inline int square(int x) { return x * x; } This normally violates the One Definition Rule — the same function defined in 10 .cpp files. The inline keyword grants an exception: multiple identical definitions are allowed, and the linker keeps one. That is inline's SECOND meaning, and in modern C++ it is the more important one: meaning 1: "consider substituting the body" (a hint) meaning 2: "multiple definitions are OK" (binding rule) C++17 extended this to variables: inline int counter = 0; /* one shared counter, safe to put in a header */

🌍 Go further: inline is now the weakest tool in this space. constexpr asks the compiler to run the function at compile time entirely, so constexpr int f = factorial(10); puts 3628800 in the binary with no runtime code at all. And link-time optimisation (g++ -flto) lets the compiler inline across .cpp file boundaries, which plain inline never could. Try compiling something with and without -O2 -flto and compare size a.out — seeing the numbers move makes this concrete. Search "constexpr vs inline vs LTO".

💡 Exam angle: define inline as a request to substitute the body at the call site, and list what the compiler may refuse to inline (loops, recursion, large bodies, virtual calls). The inline versus macro comparison is asked almost every year — type checking, single argument evaluation, debuggability, and scope obedience are the four points. Know that member functions defined inside the class body are implicitly inline, and mention code bloat as the cost.

Syllabus points

Inline function concept

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.