inline in C++ and compiler

Question

!! Specific on frequently used methods like getter & setter. !!

I have no idea when the keyword inline should be used. Ofc I know what it does, but I still have no idea.

According to an interview with Bjarne Stroustrup he said:

My own rule of thumb is to use inlining (explicitly or implicitly) only for simple one- or two-line functions that I know to be frequently used and unlikely to change much over the years. Things like the size() function for a vector. The best uses of inlining is for function where the body is less code than the function call and return mechanism, so that the inlined function is not only faster than a non-inlined version, but also more compact in the object core: smaller and faster.

But I often read that the compiler automatically inline short functions like getter, setter methods (in this case getting the size() of a vector).

Can anyone help?

Edit:

Coming back to this after years and more experience the high performance C+++ programming, inline can indeed help. Working in the games industry even forceinline sometimes makes a difference, since not all compilers work the same. Some might inline automatically some don't. My advice is if you work on frameworks, libraries or any heavily used code consider the use of inline, but this is just general advice anyway since you want such code to be fully optimized for any compiler. Always using inline might not be the best, because you'll also need the class definition for this part of the code. Sometimes this can increase compilation times if you can't use forward declarations anymore.

another hint: you can use C++14 auto return type deduction even with seperating the function definition:

MyClass.h

class MyClass
{
    int myint;
public:
    auto GetInt() const;
}  

inline auto MyClass::GetInt() const { return myint; }

all in one .h file.

Answer 1

Actually, inline keyword is not for the compiler anymore, but for the linker.

That is, while inline in function declaration still serves for most compilers as a hint, on high optimization setting they will inline things without inline and won't inline things with inline, if they deem it better for the resulting code.

Where it is still necessary is to mark function symbols as weak and thus circumvent One Definition Rule, which says that in given set of object files you want to make into a binary, each symbol (such as function) shall be present only once.

Answer 2

Bjarne's quote is old. Modern compilers are pretty smart at it.

That said, if you don't use Link Time Code Generation, the compiler must see the code to inline it. For functions used in multiple .cpp files, that means you need to define them in a header. And to circumvent the One Definition Rule in that case, you must define those functions as inline.

Class members defined inside the class are inline by default, though.

Answer 3

The below speaks specifically to C++:

The inline keyword has nothing to do with inlining.

The inline keyword allows the same function to be defined multiple times in the same program:

Every program shall contain exactly one definition of every non-inline function or variable that is odr-used in that program; no diagnostic required.

§3.2 [basic.def.odr]

Attaching meaning beyond this to the inline keyword is erroneous. The compiler is free to inline (or not) anything according to the "as-if rule":

A conforming implementation executing a well-formed program shall produce the same observable behavior as one of the possible executions of the corresponding instance of the abstract machine with the same program and the same input.

§1.9 [intro.execution]

Answer 4

Considering what compiler optimizations can do, the only use of inline I have today is for non-template function whose body is defined inside headers files outside class bodies.

Everything is defined (note: defined != declared) inside class bodies is inline by default, just as templates are.

The meaning of inline in fact is: "Defined in header, potentially imported in multiple sources, just keep just one copy of it" told to the linker.

May be in c++35 someone will finally decide to replace that keyword with another one more meaningful.

Answer 5

C++ standard Section 7.1.2 Point 2:

(...) The inline specifier indicates to the implementation that inline substitution of the function body at the point of call is to be preferred to the usual function call mechanism. An implementation is not required to perform this inline substitution at the point of call (...)

In other words instead of havin a single code for your function, that is called several times, the compiler may just duplicate your code in the various places the function is called. This avoids the little overhead related to the function call, at the cost of bigger executables.

Be aware that inline keyword may be used also with namespaces, but with a very different meaning. Members of an inline namespace can be used in most respects as though they were members of the enclosing namespace. (see Standard, section 7.3.1 point 8).

Edit: The google style guide recommends to inline only when a function is ten lines or less.

Answer 6

I'm answering the question my self!: Solution: After a few performance tests, the rule of thumb from Stroustrup is right! inlining Short functions like the .size() from vector can improve the performance (.size() calls are used frequently). But the impact is only noticeable for FREQUENTLY used functions. If a getter/setter method is used a lot, inlining it might increase the performance.

Stroustrup:

Don’t make statements about “efficiency” of code without first doing time measurements. Guesses about performance are most unreliable.