Some Name's questions

考虑以下简单示例：

use std::cell::RefCell;

// Compiles fine
fn good(t: RefCell<String>) -> bool {
    t.borrow().len() == 12
}

// error[E0597]: `t` does not live long enough
fn bad(t: RefCell<String>) -> bool {
    let t = t;
    t.borrow().len() == 12
}

操场

该bad函数无法编译并出现以下错误：

error[E0597]: `t` does not live long enough
  --> src/lib.rs:9:5
   |
8  |     let t = t;
   |         - binding `t` declared here
9  |     t.borrow().len() == 12
   |     ^---------
   |     |
   |     borrowed value does not live long enough
   |     a temporary with access to the borrow is created here ...
10 | }
   | -
   | |
   | `t` dropped here while still borrowed
   | ... and the borrow might be used here, when that temporary is dropped and runs the destructor for type `Ref<'_, String>`
   |
   = note: the temporary is part of an expression at the end of a block;
           consider forcing this temporary to be dropped sooner, before the block's local variables are dropped
help: for example, you could save the expression's value in a new local variable `x` and then make `x` be the expression at the end of the block
   |
9  |     let x = t.borrow().len() == 12; x
   |     +++++++                       +++

这对我来说看起来非常奇怪。仅将函数参数重新分配给局部变量会导致编译失败。你能解释一下为什么吗？

例子：

use std::ops::Index;

fn test(v: &Vec<Vec<i32>>) {  
    let t = v.index(0); //ok
    let t = v[0]; //error, Vec<i32> does not implement Copy trait
}

操场

为什么会发生这种情况？如文档中所述：

fn index(&self, index: I) -> &<Vec<T, A> as Index<I>>::Output

执行索引 ( container[index]) 操作

所以应该是一样的。

这是示例：

fn bar<T>(v: &mut Vec<T>) {
    bar(v); //reborrows
    bar(v); //reborrows
}

编译得很好。但考虑稍微修改的版本：

fn foo<T>(v: &mut Vec<T>) {
    let mut f = ||{
        foo(v);
    };
    let mut g = ||{
        foo(v);
    };
    f();
    g();
}

我们这里遇到的是编译错误：

error[E0524]: two closures require unique access to `*v` at the same time
 --> src/lib.rs:5:17
  |
2 |     let mut f = ||{
  |                 -- first closure is constructed here
3 |         foo(v);
  |             - first borrow occurs due to use of `*v` in closure
4 |     };
5 |     let mut g = ||{
  |                 ^^ second closure is constructed here
6 |         foo(v);
  |             - second borrow occurs due to use of `*v` in closure
7 |     };
8 |     f();
  |     - first borrow later used here

操场

我猜错误消息与同时拥有多个可变引用有关。但在第一个示例中也同时有多个引用。这很令人困惑。

考虑以下代码：

fn main() {
    let foo = 1;
    let bar: i32 = -&foo; //ok, -1
    let baz: i32 = &foo;  //error, expected `i32`, found `&{integer}`
    let bad: i32 = !&foo; //ok, -2
}

操场

通读Rust Reference我发现

可能的强制站点有：

• 给出显式类型的 let 语句。

[...]

• 函数调用的参数

所以let baz: i32 = &foo;也应该有效，因为它是一个给定显式类型的 let 语句。

为什么它拒绝编译？

考虑 的定义compare_and_exchange_strong_explicit：

_Bool atomic_compare_exchange_strong_explicit( volatile A* obj,
                                               C* expected, C desired,
                                               memory_order succ,
                                               memory_order fail );

我对 的用例感到困惑memory_order fail。考虑到 x86，很明显可能lock cmpxchg会失败，但也明确定义了（强调我的）

读取或写入不能用 I/O 指令、锁定 指令或序列化指令重新排序

这使得这种memory_order fail无关紧要，因为lock在任何情况下都能保证顺序一致性。

例子：

#include <stdatomic.h>

void fail_seqcst(volatile int *p, int *expected, int *desirable){
    atomic_compare_exchange_strong_explicit(p, expected, desirable, memory_order_release, memory_order_seq_cst);
}

void fail_relaxed(volatile int *p, int *expected, int *desirable){
    atomic_compare_exchange_strong_explicit(p, expected, desirable, memory_order_release, memory_order_relaxed);
}

编译为：

fail_relaxed:
        mov       ecx, edx                                      
        mov       eax, DWORD PTR [rsi]                          
        lock      
        cmpxchg   DWORD PTR [rdi], ecx                          
        mov       DWORD PTR [rsi], eax                          
        sete      al                                            
        movzx     eax, al                                       
        ret 

fail_seqcst:
        mov       ecx, edx                                      
        mov       eax, DWORD PTR [rsi]                          
        lock      
        cmpxchg   DWORD PTR [rdi], ecx                          
        mov       DWORD PTR [rsi], eax                          
        sete      al                                            
        movzx     eax, al                                       
        ret                                                     

神箭

memory_order_relaxed编译器是否可以进行任何优化来区分和memory_order_seq_cst在这种情况下的代码x86？或者也许有一种架构可以使这种差异变得显着？

考虑以下代码：

class SomeClass {

    companion object {
        val str = "My String"
        object AnotherObject {
             fun foo(str: String) {
                  return str + //companion object's str
             }
        }
    }
}

如何SomeClass::companion object::str参考AnotherObject::foo？

考虑使用以下编译的示例-O3 -march=native：

struct str{
    volatile uint64_t a1;
    volatile uint64_t a2;
    volatile uint64_t a3;
    volatile uint64_t a4;
};

int main(void){
    struct str str1;
    struct str str2;
    str1.a1 = str2.a2;
    str1.a2 = str2.a2;
    str1.a3 = str2.a3;
    str1.a4 = str2.a4;
}

它产生以下汇编代码：

main:
        push    rbp
        vpxor   xmm0, xmm0, xmm0
        vmovdqu8        YMMWORD PTR [rsp-32], ymm0
        mov     rbp, rsp
        mov     rax, QWORD PTR [rsp-24]
        mov     QWORD PTR [rsp-64], rax
        mov     rax, QWORD PTR [rsp-24]
        mov     QWORD PTR [rsp-56], rax
        mov     rax, QWORD PTR [rsp-16]
        mov     QWORD PTR [rsp-48], rax
        mov     rax, QWORD PTR [rsp-8]
        mov     QWORD PTR [rsp-40], rax
        xor     eax, eax
        vzeroupper
        pop     rbp
        ret

Godbolt 实例

在我的机器上KbL i7-8550U它产生几乎相同的机器代码：

(gdb) disas main
Dump of assembler code for function main:
   pxor   xmm0,xmm0
   movaps XMMWORD PTR [rsp-0x28],xmm0
   mov    rax,QWORD PTR [rsp-0x20]
   movaps XMMWORD PTR [rsp-0x18],xmm0
   mov    QWORD PTR [rsp-0x48],rax
   mov    rax,QWORD PTR [rsp-0x20]
   mov    QWORD PTR [rsp-0x40],rax
   mov    rax,QWORD PTR [rsp-0x18]
   mov    QWORD PTR [rsp-0x38],rax
   mov    rax,QWORD PTR [rsp-0x10]
   mov    QWORD PTR [rsp-0x30],rax
   xor    eax,eax
   ret    

在我的机器上支持avx2，但不SIMD用于复制。

如何提示gcc使用256 bitbased SIMD（因为该结构的大小为 256 字节）？

我尝试编写以下代码：

val s: Function<String, String> = { s -> s + s }

它编译时出现以下错误：

Type mismatch: inferred type is (???) -> [Error type: Return type for function cannot be resolved] but Function<String, String> was expected

Cannot infer a type for this parameter. Please specify it explicitly.

Kotlin将lambda分配给函数的正确方法是什么Java？