Code in header files will always be inlined?

Question

I just had a discussion with a coworker concerning code in header files:

He says that code defined in header files will always be inlined by the compiler (like the code from the function GetNumber() in my example header). I say it will be inlined sometimes, whenever the compiler decides to do so. So which one of us has to bring a cake to work for telling filthy lies? Or maybe we are both wrong...?

MyClass.hpp

   class MyClass
    {
    public:
    MyClass();
    ~MyClass();

    int GetNumber() const 
    {
     //...; 
     return m_number;
    };

    private:
    int m_number;
    };

Answer 1

That's not true, only code in member functions will be inlined (should the compiler decide to do so) if specified within the class declaration. It must allow the members to be defined though, so they might be declared as the equivalent of C's static (which will allow it to be used within the compilation unit, but cannot be linked to other object files), which will put one version in each object file. Try it yourself, you'll notice that unless you specify the inline keyword for anything outside the class declaration, you'll get duplicates.

Answer 2

The compiler decides. Even using _inline only tells the compiler you prefer inline code, but the compiler's cost/benefit analyser can decide otherwise.

You can use _forceinline if you're using Microsoft C++ to make the code inline, but that could result in larger binaries.

Answer 3

This depends on what you mean by "inlining". If something is defined in a header file, it will be compiled separately into each compilation unit that includes it. Whether any calls to the function will be inlined will be up to the compiler.

Answer 4

Your pal is wrong, you're right.

Inlining do not depends on where the code is (header or not). After preprocessing there is no headers or non-headers. Whole unit is a single file, it contains all included stuff.

Try running gcc preprocessor then you will see:

gcc -E some_source_file_with_includes

Answer 5

Actually both are correct. The way you guys meant is bit different. (I guess)

From the C++ standard doc for inline function,

1. A function declaration (8.3.5, 9.3, 11.4) with an inline specifier declares an inline function.

2. A function defined within a class definition is an inline function.

So as your colleague said, it is indeed inline function .

But the code substitution for the inline function instead of the normal function call is dependent on the compiler. (I hope this is what YOU mean) Even if the compiler doesn't substitute it is still an inline function.

Hope it clears your concern..

Answer 6

Any function defined within the class (like your GetNumber example) rather than just declared is implicitly inline. What that means is that it's equivilent to using the inline keyword, so multiple inclusions of the header will not cause link errors due to multiple definitions of those functions.

Most modern compiler treat inline as a linkage command and nothing more. Some compilers provide stronger keywords such as CL's __forceinline which mean 'inline this if it's possible to do so'.

So you're both right and both wrong to a degree.