Question

Can anybody tell me what the difference is between an inline function and static inline function?

In which cases should I prefer static inline over inline?

I am asking this question because I have an inline function for which I am facing compilation issues during linking (relocation error:... symbol has been discarded with discarded section ...). I made it a normal function and it worked.
Now some of my seniors told me try with static inline.
Below is my function:

inline void wizSendNotifier (const char* nn_name, bpDU* arg=0, int aspect = -1)
{
   wizuiNotifier* notifier = ::wizNtrKit.getNotifier (nn_name);
   notifier->notify (arg, aspect);
}

and this not inside a class. This is inside a header file!

I guess the call to a static function should be done only in the particular TU where it is defined.

Since my function is in a header file and if i make it static, will it be the case that where ever I include that header file the static function can used used in that translation unit?

Answer 1

The non-static inline function declaration refers to the same function in every translation unit (source file) that uses it.

The One Definition Rule requires that the body of the function definition is identical in every TU that contains it, with a longish definition of “identical”. This is usually satisfied provided that the source files all use the same header, and provided that the function doesn’t use any global names with internal linkage (including static functions) or any macros that are defined differently in different TUs.

I don’t remember encountering that particular linker error before, but it’s at least possible that one of these restrictions is responsible. It’s your responsibility to satisfy the requirements: undefined behavior with no diagnostic required if you don’t.

The static inline function declaration refers to a different function in each translation unit, that just so happens to have the same name. It can use static global names or macros that are different in different TUs, in which case the function might behave differently in the different TUs, even though its definition in the header file “looks the same”.

Because of this difference, if the function contains any static local variables then it behaves differently according to whether it is static or not. If it is static then each TU has its own version of the function and hence its own copy of the static local variables. If it’s inline only, then there is only one copy of the static local variables used by all TUs.