优化C程序时，同时使用__attribute__ ((pure))和static inline是否有意义及收益？

Great question! Let's break this down clearly—these two serve distinct but complementary purposes, and using them together absolutely makes sense in the right scenarios.

First: What Each One Does #

Let's quickly recap to set the stage:

• static inline: The static keyword restricts the function's scope to the current translation unit (so you can safely define it in a header without linker errors). inline hints to the compiler that it should replace calls to this function with its actual body (eliminating function call overhead), though the compiler can ignore this hint if it thinks keeping it as a regular function is better.
• __attribute__ ((pure)): This tells the compiler your function is a pure function—its return value depends only on input parameters and global variables (if any), and it has no side effects (no modifying global state, performing I/O, or calling non-pure functions). This lets the compiler apply aggressive optimizations like caching repeated calls (if inputs don't change) or reordering calls without breaking behavior.

1. Does Using Them Together Bring Benefits? #

Absolutely—here's why:

• For small, side-effect-free utility functions (like math helpers), static inline removes call overhead, while __attribute__ ((pure)) unlocks optimizations the compiler couldn't do otherwise.
• Take this example:

  static inline int cube(int x) __attribute__ ((pure));
  
  static inline int cube(int x) {
      return x * x * x;
  }
  
  // Later in code
  int a = 5;
  int val1 = cube(a);
  int val2 = cube(a);
  

  Without __attribute__ ((pure)), the compiler might generate two separate calculations (or inline two copies of the cube logic). With pure, it knows cube(a) will return the same value every time a is 5, so it can compute it once and reuse the result—saving unnecessary cycles, especially for more complex functions.
• Even if the compiler chooses not to inline the function (e.g., to avoid code bloat from repeated calls), __attribute__ ((pure)) still helps: the compiler can cache results of repeated calls to the static function just like any other pure function.

2. Is There Practical Meaning to Using Them in the Same Declaration? #

Yes—they solve different problems, so combining them is a deliberate, useful choice:

• static inline focuses on code organization and call efficiency: it lets you define small helpers in headers without linker conflicts, and hints at cutting call overhead.
• __attribute__ ((pure)) focuses on optimization potential: it gives the compiler critical context about the function's behavior, enabling smarter performance improvements.
• This combo is especially common in performance-sensitive code (embedded systems, high-performance computing, tight loops) where every cycle counts. You get clean header-based organization, minimal call overhead, and maximum optimization opportunities all in one.

A Critical Caveat #

Never use __attribute__ ((pure)) on a function with side effects (e.g., modifying global variables, calling printf, writing to files). This will lead to undefined behavior—since the compiler will optimize based on the "pure" promise, which doesn't match the function's actual behavior.

内容的提问来源于stack exchange，提问作者Pepe