Rust 中的 #[inline] 属性是什么意思？

在 Rust 中，内联（Inline） 是一种编译器优化技术，核心思想是将函数或方法的代码直接嵌入到调用它的位置，从而避免传统函数调用的开销（如压栈、跳转、返回等）。下面通过具体例子和对比，帮助你直观理解这一概念：

1. 什么是“代码嵌入调用位置”？

假设我们有一个简单函数 add，用于计算两个数的和：

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let result = add(1, 2);
}

未内联时的执行过程：

1. 调用 add(1, 2) 时，程序会跳转到 add 函数的地址。
2. 将参数 1 和 2 压入栈中。
3. 执行 a + b，得到结果 3。
4. 返回到 main 函数，将结果存入 result。

内联后的执行过程（添加 #[inline] 属性）：

#[inline]
fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    // 内联后等效于直接写入 a + b
    let result = 1 + 2;  // 编译器将函数体直接替换到此处
}

此时，add 函数的代码 1 + 2 被直接嵌入到 main 函数的调用位置，省去了跳转和参数传递的步骤。

2. 为什么需要内联？
优化场景：

• 高频调用的小函数（如数学运算、Getter/Setter）。
• 性能关键路径（如循环内的计算）。

示例对比：

假设有一个循环调用 square 函数计算平方：

fn square(x: i32) -> i32 {
    x * x
}

fn main() {
    let mut sum = 0;
    for i in 1..=1000 {
        sum += square(i);  // 每次循环都需执行函数调用
    }
}

未内联时：循环中每次调用 square(i) 都会产生函数调用开销。
内联优化后（添加 #[inline]）：

#[inline]
fn square(x: i32) -> i32 {
    x * x
}

fn main() {
    let mut sum = 0;
    for i in 1..=1000 {
        sum += i * i;  // 直接替换为乘法操作
    }
}

内联后，循环内直接执行 i * i，避免了 1000 次函数调用开销，性能显著提升。

3. 内联的代价与注意事项

优点：

• 减少函数调用开销，提升执行速度。
• 可能触发更多编译器优化（如常量传播、死代码消除）。

缺点：

• 代码膨胀：多次内联会导致编译后的二进制文件变大（如大函数被内联多次）。
• 调试困难：内联后的代码堆栈信息可能不直观。

适用场景建议：

• 小函数（如 add、getter）适合内联。
• 大函数或低频调用函数（如复杂算法）应避免内联。

4. 内联属性的分类

Rust 提供不同内联属性，控制优化力度：

1. #[inline]：建议编译器内联，但最终由编译器决定。

   rust 复制代码

   #[inline]
   fn calculate(a: i32) -> i32 { a * 2 }

2. #[inline(always)]：强制内联（除非不可行）。

   rust 复制代码

   #[inline(always)]
   fn critical_code(x: f64) -> f64 { x.sqrt() }

3. #[inline(never)]：禁止内联。

   rust 复制代码

   #[inline(never)]
   fn large_function(data: &[u8]) { /* 复杂处理 */ }