Inline is much more than a hint to the compiler. It changes the language rules about multiple definitions. Also, having static data isn't a cast iron reason to avoid inlining a function. The implementation is obliged to allocate a single static object for each function static whether or not the function is declared inline or not. Classes are still extensible if they have inline constructors and virtual destructors. And empty brace destructor is the one virtual function that it is sometimes a good idea to leave inline. – Dec 19 '09 at 10:49 •.

The program takes the address of the function and the call is made via the pointer to the function. // when_to_use_inline_functions.cpp class Point. The inline specifier, when used in a function's decl. (but the behavior of the program must not depend on. The program takes the address of the function and the call is made via the pointer to the function. // when_to_use_inline_functions.cpp class Point.

It's a hint in the sense the function doesn't necessarily ends up inlined (but english isn't my mother tongue). About statics in functions marked inline, the result is that the function doesn't get inlined: you pay the price for the call and also each translation unit that includes and calls the function gets its own copy of the code and static variables. The reason for not inlining constructors and destructors when developing a library is binary compatibility with future versions of your library – Dec 19 '09 at 11:06 •. It's inaccurate to call it a 'hint to the compiler'. In reality, non- inline functions can be inlined if the compiler feels like it. And inline functions won't be inlined if the compiler decides not to inline them. As Charles Bailey said, it changes the language rules.

Rather than thinking of it as an optimization hint, it is more accurate to think of it as a completely different concept. The inline keyword tells the compiler to allow multiple definitions, and nothing else. The 'inlining' optimization can be applied to almost any function, whether or not it's marked inline. – Dec 20 '09 at 2:08 •. Inline has very little to do with optimization. Inline is an instruction to the compiler not to produce an error if the function given definition occurs multiple times in the program and a promise that the definition will occur in every translation that it is used and everywhere it does appear it will have exactly the same definition.

Given the above rules, inline is suitable for short functions whose body doesn't necessitate including extra dependencies over what just a declaration would need. Every time the defintion is encountered it must be parsed and code for its body may be generated so it implies some compiler overhead over a function defined only once in a single source file. A compiler may inline (i.e. Replace a call to the function with code that performs that action of that function) any function call that it chooses. Dvr Dvs Software Client there. It used to be the case that it 'obviously' couldn't inline a function that wasn't declared in the same translation unit as the call but with the increasing use of link time optimization even this isn't true now. Equally true is the fact that functions marked inline may not be inlined. @jalf: Reading my comment in retrospect I realize it is rather vague and not that well thought out.

Defining the same function in multiple files results a linker error which can be countered by declaring the function 'static'. However, 'inline' allows you to do the same thing with subtle differences that they do not actually get internal linkage like 'static' does. I suspect that this is actually more a coincidence because language implementers/designers realized that they'll need to do something special with functions declared in header files and that carried over to 'inline'. – Dec 20 '09 at 20:09 •.

Telling the compiler to inline a function is an optimization, and the most important rule of optimization is that premature optimization is the root of all evil. Always write clear code (using efficient algorithms), then profile your program and only optimize functions that are taking too long. If you find a particular function is very short and simple, and it's getting called tens of thousands of times in a tight inner loop, it might be a good candidate. You might be surprised, though - many C++ compilers will automatically inline small functions for you - and they might ignore your request to inline, too. How does the inline keyword hinder 'clear code'? The keyword in 'premature optimization' is premature, not optimization.

Saying that you should actively *avoid optimizations is just rubbish. The point of that quote is that you should avoid the optimizations that may not be necessary, and have harmful side effects on the code (such as making it less maintainable). I fail to see how the inline keyword is going to make the code less maintainable, or how it can be harmful to add it to a function. – Dec 20 '09 at 2:11 •. Jalf, sometimes inlining a function will make your code slower, not faster. Organic Family Hymnal Zip. One example is when the function is called from several different places in your code; if the function is not inlined, then it might still be in the instruction cache when it's called from a different place, and the branch predictor might already be warmed up. There are some patterns that always improve efficiency, so it never hurts to use them.