What 's the difference between " static " and "static inline" function?

In C, the primary difference between static and static inline functions lies in their linkage properties and how the compiler handles them.

static functions

The static keyword, when used in function definition, restricts the function's scope to the source file where it is declared. This means it can only be called within the same source file. This approach helps avoid conflicts with functions of the same name in other source files and provides a certain level of encapsulation.

Example:

c
// File: module.c
static int helper_function(int x) {
    return x * x;
}

int public_function(int x) {
    return helper_function(x) + x;
}

In this example, helper_function is declared with static, so it can only be called within module.c, while public_function can be used in other files.

static inline functions

static inline functions combine the characteristics of both static and inline keywords. The scope is similarly limited to the file where it is defined, but it also has the property of inline, which suggests the compiler to expand the function body at the call site as much as possible, rather than performing a regular function call. This is commonly used for small functions to reduce the overhead of function calls.

Example:

c
// File: module.c
static inline int fast_add(int a, int b) {
    return a + b;
}

int compute_sum(int x, int y) {
    return fast_add(x, y);
}

In this example, fast_add is declared with static inline, so it is limited to use within module.c, and it suggests the compiler to expand the code of fast_add directly within compute_sum, rather than performing a regular function call.

Summary

Overall, static functions are used to restrict the visibility of the function to the file where it is defined, whereas static inline functions, in addition to restricting visibility, suggest the compiler to perform optimizations by expanding function calls to improve execution efficiency. Using static inline can avoid unnecessary overhead of function calls, especially for small functions that are called frequently.