Since templates are defined within headers and compiler is able to determine if inlining a function is advantageous, does it make any sense? I've heard that modern compilers know better when to inline a function and are ignoring inline
hint.
edit: I would like to accept both answers, but this is not possible. To close the issue I am accepting phresnel's answer, because it received most votes and he is formally right, but as I mentioned in comments I consider Puppy's and Component 10's answers as correct ones too, from different point of view.
The problem is in C++ semantics, which is not strict in case of inline
keyword and inlining. phresnel says "write inline if you mean it", but what is actually meant by inline
is not clear as it evolved from its original meaning to a directive that "stops compilers bitching about ODR violations" as Puppy says.
It is not irrelevant. And no, not every function template is inline
by default. The standard is even explicit about it in Explicit specialization ([temp.expl.spec])
Have the following:
a.cc
#include "tpl.h"
b.cc
#include "tpl.h"
tpl.h (taken from Explicit Specialization):
#ifndef TPL_H
#define TPL_H
template<class T> void f(T) {}
template<class T> inline T g(T) {}
template<> inline void f<>(int) {} // OK: inline
template<> int g<>(int) {} // error: not inline
#endif
Compile this, et voila:
g++ a.cc b.cc
/tmp/ccfWLeDX.o: In function `int g<int>(int)':
inlinexx2.cc:(.text+0x0): multiple definition of `int g<int>(int)'
/tmp/ccUa4K20.o:inlinexx.cc:(.text+0x0): first defined here
collect2: ld returned 1 exit status
Not stating inline
when doing explicit instantiation may also lead to issues.
So in summary: For non fully specialized function templates, i.e. ones that carry at least one unknown type, you can omit inline
, and not receive errors, but still they are not inline
. For full specializations, i.e. ones that use only known types, you cannot omit it.
Proposed rule of thumb: Write inline
if you mean it and just be consistent. It makes you think less about whether to or not to just because you can. (This rule of thumb is conforming to Vandevoorde's/Josuttis's C++ Template: The Complete Guide).