1

Iam programing in C. I want some description about static and inline functions. I know that if we make a function static then it is an indication to compiler that it is under internal linkage for only one translation unit. I have following doubts regarding static and inline :

  1. If we make a function as static , can we use it in other translation units ...i.e in other .c files? If yes ..how?
  2. If we make the function as static inline what is the difference then ? How it will be treated by the compiler ?
  3. Does making a function as static gives the same effect as a macro?
  4. Treating a function to be inline is dependent on the compiler depending on the size . So is there any way that we can forcefully make it to be treated like inline?
  5. How we can use inline and static functions for optimization ?

Please shed some light on the above things inline. Platform is Linux, gcc compiler , C language.

john
  • 1,323
  • 2
  • 19
  • 31
  • 1
    A function that is declared static in a translation unit will not be visible in other translation units. It is possible to re-define it in multiple translation units though. – Vaughn Cato Apr 30 '12 at 04:26

3 Answers3

4

  1. A static function can't be used in other translation units. That's their raison d'être.

  2. inline hints to the compiler that the function should be inlined instead of called.

  3. Making a function static is different than using a macro. A macro essentially overrules the compiler. Whether it thinks it wise to inline or not, a macro will be inlined; macros are textual substitution. You can also pass a static function to something requiring a function pointer. Can't do that with a macro.

  4. Macros will forcefully inline anything. Even specifying inline can be overruled.

  5. Make functions you don't want to export static. If a function is really small, and you really think it should be inlined, you can tell the compiler that with inline. Macros are really only for metaprogramming. The compiler knows better than you.

Dave
  • 10,964
  • 3
  • 32
  • 54
  • 7
    However, you can always pass the address of a `static` function somewhere else as a function pointer. – Greg Hewgill Apr 30 '12 at 04:30
  • Ok, for your point 5, but this use of `static` should really be restricted to functions that are not declared in a header file, otherwise you may have copies of them all over. – Jens Gustedt Apr 30 '12 at 08:47
  • Funnily, "inline hints the compiler that a function should be inlined" is technically not at all correct, though that's probably what I'd have said too. The standard really says _"[...] suggests that calls to the function be as fast as possible"_. A kind of silly wording, admittedly (though indeed not inlining _can_ be faster due to L1 pressure). – Damon Apr 30 '12 at 09:15
  • @Damon I assume it was worded that way to make it more obvious that compilers can - and indeed often enough will - ignore the keyword. – Voo Apr 30 '12 at 10:28
3

static and inline serve two very different purposes.

As you say correctly static means that the symbol of the function is not exported from the compilation unit where it is defined. Therefore different compilation units can have such symbols with the same name without conflict. Whether or not this corresponds to the same function declaration and definition is up to you. But such functions as all statically allocated objects can well be used in a different compilation unit by statically or dynamically exporting a pointer to it.

inline is different. Its intent is to make it possible for the compiler to inline your function, thus the name, but its major direct effect is that the function symbol is usually not emitted at all. This is designed for the purpose that you may put the definition of the function in a header file and include that file in several compilation units without creating multiple symbols in each of them. For the defined function it also has the effect that you are not allowed to declare static variables inside an inline function, since it would not be clear at all in which compilation unit that object would have to be realized.

So to summarize, static generates plenty of copies of your function, inline generates none; static has its major use in ".c" files and inline in ".h"

The first has the effect that you may at certain places not detect that two function pointers point to the "same" function, the second may have the effect that if you need a function pointer to the function there is no function object to which it would refer. Such a function can be forced to be emitted (in just one compilation unit!) by placing a sort of "instantiation" in the .c file:

// .h definition
inline void toto(void) { }

// .c instantiation
void toto(void);
Jens Gustedt
  • 76,821
  • 6
  • 102
  • 177
1

These days compilers will determine whether an inline function will actually be inlined or not, as not all functions are good candidates for it. If so, then function body is simply injected/inlined where the respective function is referenced.

Such functions should be reserved for frequent function calls where the function body is usually quite short, though i suppose this doesnt have to be the case.

AlvinfromDiaspar
  • 6,611
  • 13
  • 75
  • 140