When should I write the keyword 'inline' for a function/method in C++?
Questions added by seeing some answers...
When should I not write the keyword 'inline' for a function/method in C++?
When will the the compiler not know when to make a function/method 'inline'?
Does it matter if an application is multithreaded when one writes 'inline' for a function/method?
1) Nowadays, pretty much never. If it's a good idea to inline a function, the compiler will do it without your help.
2) Always. See #1.
(Edited to reflect that you broke your question into two questions...)
The inline function would have to be very short and simple and you would need to be very certain that making it an inline function would be of some performance benefit. I would never use the word inline until I had real data that showed that there would be a benefit to making it inline. I would test it both before and after to verify that the "inline" optimization was of benefit.
Modern C++ Compilers are very very good at optimization. Usually they can figure out what to do without hints like "inline".
On more careful consideration if you need to define a function in a header file, or a function in more than one header file - if you make the function "inline" it will not cause link errors. If the function is not inline then you will have copies of the function in multiple files and get link errors.
In reality, pretty much never. All you're doing is suggesting that the compiler make a given function inline (e.g., replace all calls to this function /w its body). There are no guarantees, of course: the compiler may ignore the directive.
The compiler will generally do a good job of detecting + optimizing things like this.
When it is a [typically short] function which is going to be called in "tight" (read performance sensitive) loops.
This said, several compilers will decide when it is good to inline and will just do this for you... Some of the compiler's command line options may "help" it be more or less aggressive with the amount of inline that is done.
when the method is small and you want to avoid the overhead cost of a function call.
See item #30 in Effective C++
You want to put it in the very beginning, before return type. But most Compilers ignore it. If it's defined, and it has a smaller block of code, most compilers consider it inline anyway.
When developing and debugging code, leave inline out. It complicates debugging.
The major reason for adding them is to help optimize the generated code. Typically this trades increased code space for speed, but sometimes inline saves both code space and execution time.
Expending this kind of thought about performance optimization before algorithm completion is premature optimization.
You still need to explicitly inline your function when doing template specialization (if specialization is in .h file)
The primary you want to use the inline keyword is with templates. With most compilers templates have to be in a header so they're visible in all files that use them. If you instantiate your template with the same parameter in more than one translation unit, and use the same function in both, you've just defined the same function twice -- violating the one definition rule.
Making the function inline cures that problem. You can do this either by defining the function inside the class template definition, or by placing it outside the class definition, but explicitly marking it inline. I generally define the function inside the class definition if it's really short (especially one-liners) but move it out of the class definition if it's very long at all.
Edit: It is true that the standard makes some concessions to allow multiple definitions of template instantiations (for one example), but you have to be extremely careful: it takes almost an entire page to describe the conditions that must be met for such a multiple definition to be allowed. One of those requirements is that:
If D is a template, and is defined in more than one translation unit, then the last four requirements from the list above shall apply to names from the template’s enclosing scope used in the template definition (14.6.3), and also to dependent names at the point of instantiation (14.6.2).
When you're writing template code, you generally know next to nothing about the dependent names at the point of instantiation. Worse, you generally don't want to know such things. In most cases, the whole point of a template is that a user should be able to instantiate it over any type that meets a few specific requirements (that, in an ideal world, you'd have expressed in concepts, R.I.P.)
Since your template code can't depend on those requirements being met, the reasonable alternative is to assure that they don't have to be met -- and making all the functions inline is a big start toward that.
When one should inline :
1.When one want to avoid overhead of things happening when funtion is called like parameter passing , control transfer, control return etc..
2.The funtion should be small,frequently called and making inline is really advantageous since as per 80-20 rule,try to make those funtion inline which has major impact on program performance.
As we know that inline is just a request to compiler similar to register and it will cost you at Object code size.
Oh man, one of my pet peeves.
inline is more like static or extern than a directive telling the compiler to inline your functions. extern, static, inline are linkage directives, used almost exclusively by the linker, not the compiler.
It is said that inline hints to the compiler that you think the function should be inlined. That may have been true in 1998, but a decade later the compiler needs no such hints. Not to mention humans are usually wrong when it comes to optimizing code, so most compilers flat out ignore the 'hint'.
static the variable/function name cannot be used in other compilation units. Linker needs to make sure it doesn't accidentally use a statically defined variable/function from another compilation unit.
extern use this variable/function name in this compilation unit but don't complain if it isn't defined. The linker will sort it out and make sure all the code that tried to use some extern symbol has its address.
inline this function will be defined in multiple compilation units, don't worry about it. The linker needs to make sure all compilation units use a single instance of the variable/function.
Note: Declaring templates inline is worthless. They have the linkage semantics of inline already.
So specific answers to your questions:
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.
Don't add inline when you think your code will run faster if the compiler inlines it.
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.
As an aside to prevent inlining in GCC use __attribute__(( noinline )) and in visual studio use __declspec(noinline).
Multithreading doesn't affect inlining in anyway.
the one said that inlining functions has to do only with linker is fundamentally wrong. When the compiler inserts inlined function into the main function body it does a pretty decent job of reorganizing data flow thru general use registers and stack. If it just inserted the function body as it is with pushing registers to stack and getting them back - that wouldn't make any sense, cause this idea is opposite to the inlining.