小编mer*_*ian的帖子

这是我觉得有趣的事情：

pub fn sum_of_squares(n: i32) -> i32 {
    let mut sum = 0;
    for i in 1..n+1 {
        sum += i*i;
    }
    sum
}

这是 Rust 中平方和的简单实现。rustc 1.65.0这是带有with的汇编代码-O3

        lea     ecx, [rdi + 1]
        xor     eax, eax
        cmp     ecx, 2
        jl      .LBB0_2
        lea     eax, [rdi - 1]
        lea     ecx, [rdi - 2]
        imul    rcx, rax
        lea     eax, [rdi - 3]
        imul    rax, rcx
        shr     rax
        imul    eax, eax, 1431655766
        shr     rcx
        lea     ecx, [rcx + 4*rcx]
        add     ecx, …

C++ 不定义某些行为（例如更好的错误检查）的原因是什么？为什么不抛出一些错误并停止呢？

一些伪代码例如：

if (p == NULL && op == deref){
    return "Invalid operation"
 }

对于整数溢出：

if(size > capacity){
    return "Overflow"
}

我知道这些都是非常简单的例子。但我很确定大多数 UB 都能被编译器捕获。那么为什么不实施它们呢？因为它确实很耗时并且不进行错误检查更快？一些 UB 可以通过单个 if 语句捕获。那么也许速度并不是唯一的问题？

我是 Rust 新手。我在 Rust 的编译器中找到了这段代码。

#[must_use]
pub struct IeeeFloat<S> {
    /// Absolute significand value (including the integer bit).
    sig: [Limb; 1],

    /// The signed unbiased exponent of the value.
    exp: ExpInt,

    /// What kind of floating point number this is.
    category: Category,

    /// Sign bit of the number.
    sign: bool,

    marker: PhantomData<S>,
}

然后他们做了

impl<S> Copy for IeeeFloat<S> {}
impl<S> Clone for IeeeFloat<S> {
    fn clone(&self) -> Self {
        *self
    }
}

我的问题是，这和 #[derive(Copy, Clone)] 不一样吗？为什么他们明确地为 IEEE 编写 impl …

在 Rust 中，函数的顺序并不重要，不像 C 或 C++，主函数应该在最后。但对于闭包来说就不一样了，我想知道为什么

例如，此代码编译：

fn main(){
    println!("{}", add_up(1));
}
fn add_up(x: i32) -> i32{
    x + y
}
const y:i32 = 1;

并且此代码无法编译：

fn main(){
    let add_up = |x:i32| x + y;
    let y = 1;
    println!("{}", add_up(1));
}

我知道第一个 y 是一个全局变量，这不是一个公平的比较，但这是我目前能想到的例子。要点是，通常顺序在 rust 中并不重要（main 位于哪里或 add_up 位于哪里），但对于闭包则不一样。为什么？