Getting started with C++Templates Metaprogramming Iterators Returning several values from a function std::string Namespaces File I/O Classes/Structures Smart Pointers Function Overloading std::vector Operator Overloading Lambdas Loops std::map Threading Value Categories Preprocessor SFINAE (Substitution Failure Is Not An Error)The Rule of Three, Five, And Zero RAII: Resource Acquisition Is Initialization Exceptions Implementation-defined behavior Special Member Functions Random number generation References Sorting Regular expressions Polymorphism Perfect Forwarding Virtual Member Functions Undefined Behavior Value and Reference Semantics Overload resolution Move Semantics Pointers to members Pimpl Idiom std::function: To wrap any element that is callable const keyword auto std::optional Copy Elision Bit Operators Fold Expressions Unions Unnamed types mutable keyword Bit fields std::array Singleton Design Pattern The ISO C++ Standard User-Defined Literals Enumeration Type Erasure Memory management Bit Manipulation Arrays Pointers Explicit type conversions RTTI: Run-Time Type Information Standard Library Algorithms Friend keyword Expression templates Scopes Atomic Types static_assert operator precedence constexpr Date and time using <chrono> header Trailing return type Function Template Overloading Common compile/linker errors (GCC)Design pattern implementation in C++Optimization in C++Compiling and Building Type Traits std::pair Keywords One Definition Rule (ODR)Unspecified behavior Floating Point Arithmetic Argument Dependent Name Lookup std::variant Attributes Internationalization in C++Profiling Return Type Covariance Non-Static Member Functions Recursion in C++Callable Objects std::iomanip Constant class member functions Side by Side Comparisons of classic C++ examples solved via C++ vs C++11 vs C++14 vs C++17 The This Pointer Inline functions Copying vs Assignment Client server examples Header Files Const Correctness std::atomics Data Structures in C++Refactoring Techniques C++ Streams Parameter packs Literals Flow Control Type Keywords Basic Type Keywords Variable Declaration Keywords Iteration type deduction std::any C++11 Memory Model Build Systems Concurrency With OpenMP Type Inference std::integer_sequence Resource Management std::set and std::multiset Storage class specifiers Alignment Inline variables Linkage specifications Curiously Recurring Template Pattern (CRTP)Using declaration Typedef and type aliases Layout of object types C incompatibilities std::forward_list Optimization Semaphore Thread synchronization structures C++ Debugging and Debug-prevention Tools & Techniques Futures and Promises More undefined behaviors in C++Mutexes Unit Testing in C++Recursive Mutex decltype Using std::unordered_map Digit separators C++ function "call by value" vs. "call by reference"Basic input/output in c++Stream manipulators C++ Containers Arithmitic Metaprogramming

Inline functions

Remarks:

Usually if code generated for a function is sufficiently small then it's a good candidate to be inlined. Why so? If a function is large and is inlined in a loop, for all the calls made, the large function's code would be duplicated leading to the generated binary size bloat. But, how small is sufficient?

While inline functions seem to be great way to avoid function calling overhead, it's to be noted that not all functions that are marked inline are inlined. In other words, when you say inline, it is only a hint to the compiler, not an order: the compiler isn't obliged to inline the function, it's free to ignore it - most of them do. Modern compilers are better at making such optimisations that this keyword is now a vestige of the past, when this suggestion of function inlining by the programmer was taken seriously by the compilers. Even functions not marked inline are inlined by the compiler when it sees benefit in doing so.

Inline as a linkage directive

The more practical use of inline in modern C++ comes from using it as a linkage directive. When defining, not declaring, a function in a header which is going to be included in multiple sources, then each translation unit will have its own copy of this function leading to a ODR (One Definition Rule) violation; this rule roughly says that there can be only one definition of a function, variable, etc. To circumvent this violation, marking the function definition inline implicitly makes the function linkage internal.

FAQs

When should I write the keyword 'inline' for a function/method in C++?

Only when you want the function to be defined in a header. More exactly only when the function's definition can show up in multiple compilation units. It's a good idea to define small (as in one liner) functions in the header file as it gives the compiler more information to work with while optimizing your code. It also increases compilation time.

When should I not write the keyword 'inline' for a function/method in C++?

Don't add inline when you think your code will run faster if the compiler inlines it.

When will the the compiler not know when to make a function/method inline?

Generally, the compiler will be able to do this better than you. However, the compiler doesn't have the option to inline code if it doesn't have the function definition. In maximally optimized code usually all private methods are inlined whether you ask for it or not.

Non-member inline function declaration

inline int add(int x, int y);

Non-member inline function definition

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

Member inline functions

// header (.hpp)    
struct A
{
    void i_am_inlined()
    {
    }
};

struct B
{
    void i_am_NOT_inlined();
};

// source (.cpp)    
void B::i_am_NOT_inlined()
{
}

What is function inlining?

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

int main()
{
    int a = 1, b = 2;
    int c = add(a, b);
}

In the above code, when add is inlined, the resulting code would become something like this

int main()
{
    int a = 1, b = 2;
    int c = a + b;
}

The inline function is nowhere to be seen, its body gets inlined into the caller's body. Had add not been inlined, a function would be called. The overhead of calling a function -- such as creating a new stack frame, copying arguments, making local variables, jump (losing locality of reference and there by cache misses), etc. -- has to be incurred.