An inline function is one for which the compiler copies the code from the function definition directly into the code of the calling function rather than creating a separate set of instructions in memory. Instead of transferring control to and from the function code segment, a modified copy of the function body may be substituted directly for the function call. In this way, the performance overhead of a function call is avoided. Using the inline specifier is only a suggestion to the compiler that an inline expansion can be performed; the compiler is free to ignore the suggestion.
Any function, with the exception of main,
can be declared or defined as inline with the inline function
specifier. Static local variables are not allowed to be defined within
the body of an inline function.
C++ functions
implemented inside of a class declaration are automatically defined
inline. Regular C++ functions and member functions declared outside
of a class declaration, with the exception of main,
can be declared or defined as inline with the inline function
specifier. Static locals and string literals defined within the body
of an inline function are treated as the same object across translation
units; see Linkage of inline functions for details.
inline int add(int i, int j) { return i + j; }The most efficient way to code an inline function is to place the inline function definition in a header file, and then include the header in any file containing a call to the function which you would like to inline.
- The inline keyword is recognized
under compilation with xlc
or c99,
or with the -qlanglvl=stdc99 or -qlanglvl=extc99 options
or -qkeyword=inline.
The __inline__ (or __inline)
keyword is recognized at all language levels; however, see Linkage of inline functions below for the semantics of
this keyword.
- The inline, __inline, and __inline__ keywords
are recognized at all language levels.
Linkage of inline functions
In C, inline functions are treated
by default as having static linkage; that is, they are only
visible within a single translation unit. Therefore,
in the following example, even though function foo is
defined in exactly the same way, foo in file a.c and foo in
file b.c are treated as separate functions: two function
bodies are generated, and assigned two different addresses in memory: // a.c
#include <stdio.h>
inline int foo(){
return 3;
}
void g() {
printf("foo called from g: return value = %d, address = %p\n", foo(), &foo);
}
// b.c
#include <stdio.h>
inline int foo(){
return 3;
}
void g();
int main() {
printf("foo called from main: return value = %d, address = %p\n", foo(), &foo);
g();
}foo called from main: return value = 3, address = 0x10000580
foo called from g: return value = 3, address = 0x10000500// a.c
#include <stdio.h>
inline int foo(){
return 6;
}
void g() {
printf("foo called from g: return value = %d\n", foo());
}
// b.c
#include <stdio.h>
int foo(){
return 3;
}
void g();
int main() {
printf("foo called from main: return value = %d\n", foo());
g();
}
If you specify
the __inline__ keyword, with the trailing underscores,
the compiler uses the GNU C semantics for inline functions. In contrast
to the C99 semantics, a function defined as __inline__ provides
an external definition only; a function defined as static
__inline__ provides an inline definition with internal linkage
(as in C99); and a function defined as extern __inline__,
when compiled with optimization enabled, allows the co-existence of
an inline and external definition of the same function. For more information
on the GNU C implementation of inline functions, see the GCC information,
available at http://gcc.gnu.org/onlinedocs/.
You must define an inline function in exactly the same way
in each translation unit in which the function is used or called.
Furthermore, if a function is defined as inline,
but never used or called within the same translation unit, it is discarded
by the compiler (unless you compile with the -qkeepinlines option).
foo called from main: return value = 3, address = 0x10000580
foo called from g: return value = 3, address = 0x10000580// a.C
#include <stdio.h>
inline int foo(){
return 6;
}
void g() {
printf("foo called from g: return value = %d, address = %p\n", foo(), &foo);
}
// b.C
#include <stdio.h>
inline int foo(){
return 3;
}
void g();
int main() {
printf("foo called from main: return value = %d, address = %p\n", foo(), &foo);
g();
}foo called from main: return value = 6, address = 0x10001640
foo called from g: return value = 6, address = 0x10001640// a.C
#include <stdio.h>
inline int foo(){
static int x = 23;
printf("address of x = %p\n", &x);
x++;
return x;
}
void g() {
printf("foo called from g: return value = %d\n", foo());
}
// b.C
#include <stdio.h>
inline int foo()
{
static int x=23;
printf("address of x = %p\n", &x);
x++;
return x;
}
void g();
int main() {
printf("foo called from main: return value = %d\n", foo());
g();
}address of x = 0x10011d5c
foo called from main: return value = 24
address of x = 0x10011d5c
foo called from g: return value = 25If you want to ensure that each instance of function
defined as inline is treated as a separate function, you can use the static specifier
in the function definition in each translation unit, or compile with
the -qstaticinline option.
Note, however, that static inline functions are removed from name
lookup during template instantiation, and are not found. 