精华内容
下载资源
问答
  • 38.借用与引用

    2021-03-12 11:05:42
    借用使用&关键字,引用使用ref关键字。借用的对象是必须存在的,引用的对象可以虚拟的,后期附上对象。 2.match的模式匹配上只能使用 ref,在函数声明上只能使用&来表示引用类型 3.非要给区分ref和&到底...
    /*
    1.rust中借用和引用的附带功效都一样,就是都有生命周期。借用使用&关键字,引用使用ref关键字。借用的对象是必须存在的,引用的对象可以虚拟的,后期附上对象。
    2.match的模式匹配上只能使用 ref,在函数声明上只能使用&来表示引用类型
    3.非要给区分ref和&到底哪个是引用,哪个是借用。我们可以先从词性划分,引用我归类为名词,而借用归类为动词。&A在表达式上 表示借用A,这是一个动作,那结果就是产出一个引用类型。所以let ref B表示声明了一个引用类型,它只能绑定到某次借用动作上。所以ref 更适合叫引用, &叫借用。
    
    我们在不同情况下解释&的意思:
        在表达式上,表示的是借用。
        在变量绑定上,表示解地址操作与*类似。
        在类型声明上,表示引用类型。
        在模式匹配上,无效关键字
    
    那么ref的通用解释是:
        在表达式上,无效关键字。
        在变量绑定上,表示引用类型。
        在类型声明上,无效关键字。
        在模式匹配上,表示引用类型。
    
    https://www.jianshu.com/p/ac519d8c5ec9
    https://www.cnblogs.com/chen8840/p/12699265.html
    https://www.jianshu.com/p/7ac48c978624
    */
    
    #![feature(core_intrinsics)]
    
    fn print_type_name_of<T>(_: T) {
        println!("{}", unsafe { std::intrinsics::type_name::<T>() })
    }
    
    fn test1() {
        let ref a1: i32;
        //a = 1;  expected `&i32`, found integer help: consider borrowing here: `&1`
        a1 = &1;
        print_type_name_of(a1); //&i32
    
        let ref a2 = 1;
        print_type_name_of(a2); //&i32
    
        let ref a3 = &1;
        print_type_name_of(a3); //&&i32
    
        let c = 'Q';
        // 赋值语句中左边的 `ref` 关键字等价于右边的 `&` 符号。
        let ref ref_c1 = c;
        let ref_c2 = &c;
        println!("ref_c1 equals ref_c2: {}", *ref_c1 == *ref_c2);
    
        //& 与 * 的关系, 那么&用在绑定上是怎么样的?其实&用在绑定上与*用在表达式上是一样的:
        let r1 = &1;
        print_type_name_of(r1); //&i32
        let &r2 = r1;
        print_type_name_of(r2); //i32
        let r3 = *r1;
        print_type_name_of(r3); //i32
    }
    
    fn test2() {
        fn f1(_s: &String) {
            println!("{:p}", _s);
        }
    
        fn f2(ref _s: String) {
            println!("{:p}", _s);
        }
    
        let s = String::from("hello");
        let sref1 = &s;
        let ref sref2 = s;
        println!("{:p}", sref1);
        println!("{:p}", sref2);
    
        f1(&s);
        f2(s);
    }
    
    fn test3() {
        let x = &false;
        print_type_name_of(x);
    
        let &x = &false;
        print_type_name_of(x);
    
        let ref x = false;
        print_type_name_of(x);
    
        let ref x = &false;
        print_type_name_of(x);
    }
    
    fn test4() {
        let os = Some(String::from("s"));
        match os {
            //Some(s) => {      如果这样写下面的打印信息将不可编译 : value borrowed here after partial move
            Some(ref s) => {
                print_type_name_of(s); //&alloc::string::String
            }
            _ => (),
        };
        println!("{:?}", os);
    
        let os = &Some(String::from("s"));
        match os {
            Some(s) => {
                print_type_name_of(s); //&alloc::string::String
            }
            _ => (),
        };
    }
    
    fn main() {
        test1();
        test2();
        test3();
        test4();
    }
    

     

    展开全文
  • 浅谈rust借用与引用

    千次阅读 2020-01-14 17:13:50
    浅谈rust借用与引用 先来看看rust入门上说的借用与引用: 我们将获取引用作为函数参数称为 借用(borrowing) 正如现实生活中,如果一个人拥有某 样东西,你可以从他那里借来。当你使用完毕,必须还回去。 例子...

    浅谈rust借用与引用

    先来看看rust入门上说的借用与引用:
    我们将获取引用作为函数参数称为 借用(borrowing)
    正如现实生活中,如果一个人拥有某
    样东西,你可以从他那里借来。当你使用完毕,必须还回去。
    原文链接:https://blog.csdn.net/weixin_44259356/article/details/103975850

    例子

    fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len);
    }
    fn calculate_length(s: &String) -> usize {
    s.len()
    }
    

    在这里插入图片描述
    这里首先创建了一个名字为s1的String,注意不是str,String是可变字符串,由栈里的s1保存指向堆空间的地址,长度以及容量。如上图。

    然后调用函数calculate_length,里面传入了一个s1的引用。这里s里存的是s1的引用,也就是说s是一个与s1不同的全新的变量,只是里面存的指针值指向了s1,同时没有长度和容量。这里可以理解为java的引用。

    这样做法有一个好处,函数并没有直接获得s1的所有权,当函数结束,即引用离开其作用域s被释放但是s1任然存在并不会被丢弃。所以函数结束后你任然可以继续使用s1.

    注意:rust里默认拷贝全是浅拷贝,只会拷贝栈上的引用值,并不会拷贝堆空间的值。

    深拷贝可以如下使用:

    let s1 = String::from("hello");
    let s2 = s1.clone();
    

    最后总结

    rust借用可以理解为动作,行为,类比a从b那里借东西。
    rust引用类似于java的引用,字面上的:&s1。所以我们称
    我们将获取引用作为函数参数称为 借用(borrowing)

    展开全文
  • int i = 0; i = i++; System.out.println("i = " + i);
  • js中的方法借用

    2019-11-29 11:36:38
    区别主要就是参数的接收方式不同 这两个方法都是放在obj的原型链上 例: A.call(B,参数) :A代表一个方法,B代表this的指向(相当于B借用A的方法) //方法借用 let obj={ name:'zhangsan', say:function(){ ...

    js中的方法借用: 意义非常大的2个方法:call和apply

    这两个方法的本质上作用是一样的,就是一个方法。区别主要就是参数的接收方式不同
    这两个方法都是放在obj的原型链上
    例:
    A.call(B,参数) :A代表一个方法,B代表this的指向(相当于B借用A的方法)

    //方法借用
    let obj={
        name:'zhangsan',
        say:function(){
            return `我是${this.name}`;        
        }
    }
    let obj2={
        name:"wangwu"
    }
    //借用obj的方法
    console.log(obj.say.call(obj2));//我是wangwu
    console.log(obj.say.apply(obj2));//我是wangwu
    
    //方法借用的区别
    let arr=[3,5,2,5,7];
    
    console.log(Math.max.call(this,3,5,2,5,7));//7
    console.log(Math.max.apply(this,arr));//7
    
    // Function.prototype.call(this,参数1,参数2,参数3...)
    // Function.prototype.apply(this,[参数1,参数2,参数3...])
    
    // 区别:call传的是一些参数而apply传的是一个数组
    
    展开全文
  • Rust:借用

    2018-12-26 15:48:33
    //向OS申请一个栈空间x,并将5绑定到x,OS会自动将这个空间标记为已使用 let y = x; //向OS申请一个栈空间y,将x变量绑定的值5拷贝到一个临时变量中,绑定到y,然后使得临时变量失效 println!(&amp;amp;amp...

    什么叫做借用

    变量对其管理的内存拥有所有权。这个所有权不仅可以被转移,还可以被借用。借用没有获取内存的所有权

    可以通过借用指针,也就是引用来实现所有权借用

    • &符号:只读借用
    • &mut 符号:可读写借用

    借用指针在编译之后,实际上就是一个普通的指针,它的意义只能在编译阶段的静态检查中体现。
    也就是说,借用指针和普通指针的内部数据是一模一样的,唯一的区别是语义层面上的。它的使用是告诉编译器,它对指向的这块内存区域没有所有权

    可变变量与可变引用

    fn main() {
        //可变变量
        let mut v = 0i32;
        {
            //可变引用
            let p1 = &mut v;  // p1 指针本身不能被重新绑定,我们可以通过p1改变变量var的值
            *p1 = 1;
            println!("{}", v)
        }
    
        {
            let temp = 2_i32;
            let mut p2 = &v; // 我们不能通过p2改变变量var的值,但p2指针本身指向的位置可以被改变
            p2 = &temp;
            println!("{}", *p2)
        }
        {
            let mut temp = 3_i32;
            let mut p3 = &mut v; // 我们既可以通过p3改变变量var的值,而且p3指针本身指向的位置也可以改变
            *p3 = 3;
            p3 = &mut temp;
            println!("{}", v)
        }
    }
    

    借用规则

    • 借用指针不能比它指向的变量存在的时间更长
      借用指针只能临时的拥有对这个变量读或写的权限,没有义务管理这个变量的声明周期。因此借用指针不能比它指向的变量的声明周期更长,否则就是悬空指针了
    • &mut型借用只能指向本身具有mut修饰的变量,对于只读变量,不可以有&mut型借用 【 cannot borrow i as mutable, as it is not declared as mutable】
    • 一旦遍历的值被借走了,就不能再去使用了【error[E0506]: cannot assign to x because it is borrowed】疑问:什么时候还回来呢?
    fn main(){
        let mut x = 1_i32;
    
        let p = &mut x;
    
        x = 2; //error[E0506]: cannot assign to `x` because it is borrowed
    
        println!("{}", p)
    }
    

    生命周期

    函数的生命周期

    生命周期符号使用单引号开头,后面跟一个合法的名字。

    struct T{
        member:i32,
    }
    
    fn test<'a>(arg:&'a T)->&'a i32{ //尖括号里面的'a是声明一个生命周期参数,它在后面的参数和返回值中被使用
        &arg.member
    }
    
    fn main(){
        let t = T{member:10};
        let x = test(&t);
        println!("{:?}", x)
    }
    

    生命周期之间有包含关系。如果生命周期’a比’b更长或相等,则记为’a:'b,意思是’a至少不会比’b短

    参考《深入浅出Rust》

    展开全文
  • 为什么Mutex/RwLock一般都会配合Arc使用? …… 这一类借用规则的问题,实际上都可以通过另一种思路来很好地解答,当然这也是很多大佬一定程度上认可的理解方式: Rust中的借用,分为不可变借用共享借用,和可变...
  • js 方法借用

    2018-02-26 10:34:34
    call和apply基本一致,区别在于用法上,一个是传入一个数组 ,一个是直接传入参数。 function people(){}; var animal = { name: "cc", age:16, say:function(m1,m2){ alert("他说:&...
  • 我们下面来看一篇关于JavaScript中借用方法的一个详细介绍,注意:本文假设你已经掌握使用 call()、apply()和bind()的相关知识和它们之间的区别,希望这篇文章能够让各位了解到JavaScript中的借用方法吧。
  • 使用call或apply这两个方法完成函数借调。这两个方法的功能是一样的,只有少许的区别(暂且不管)。 功能都是更改一个构造方法内部的this指向到指定的对象上。 function Father (name,age) { ...
  • rust内存安全--借用

    2021-04-05 08:35:17
    关于借用,总结一句话是“共享不可变,可变不共享” 譬如这段代码,是可以通过编译的 fn main() { let i = 1; let p1 = &i; let p2 = &i; println!("{} {} {}", i, p1, p2); } 虽然发送了共享,但没有...
  • 在JavaScript中借用方法

    2016-08-12 14:10:11
    在JavaScript中,有时可以重用其它对象的函数或方法,而不一定非得是对象本身或原型上定义的。...本文假设你已经掌握使用 call()、apply() 和 bind() 的相关知识和它们之间的区别。 原型方法
  • 二、借用构造函数实现继承: 三、借用构造函数的问题: 一、知识回顾: 在学习新知识之前我们简单回顾一下 call、apply、bind方法的使用: call和apply的共同点是能够改变函数的执行时的上下文,将一个对象的...
  • 理解Rust:所有权,借用,生命周期

    千次阅读 2018-09-23 13:23:02
    •Rust严格语法如何使用借用检查器来防止此类典型错误 •插入块的方式如何限制借用范围 •为什么函数返回引用需要生命周期指示符 •如何使用寿命指定符来表示函数及其含义 •借阅检查器的任务是什么 所有权和...
  • 这里借用《Java并发编程的艺术》提到的来说一下使用线程池的好处: 降低资源消耗。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。 当任务到达时,任务可以不需要的等到线程创建就能立即...
  • rust学习笔记基础篇4–结构体变量声明绑定,所有权,借用,引用(霜之小刀) 欢迎转载和引用,若有问题请联系 若有疑问,请联系 Email : lihn1011@163.com QQ:2279557541 关于结构体的变量声明 看...
  • 借用数据挖掘技术实现潜在客户的层次划分 西南师大计科院 2000研究生 王艳 400715 摘要本文探讨了利用数据挖掘技术结合统计学方法实现对潜在客户精确测量及准 确划分的方法步骤并对该方法传统感性方法的区别做了...
  • Aspose 借用document插入各种 到word

    千次阅读 2018-03-23 10:38:17
    使用它有点类似于使用java的StringBuilder。DOM的Node能办到的事,使用DocumentBuilder也一样能办到。而且比使用dom的方式操作document的代码要少。DocumentBuilder内部维护了一个游标Cursor,...
  • 说白了,我们前面的一段代码可以这样理解,我下面只是一个伪代码,可以这样去理解,但真正的结果还是有区别的!!!! var str= “str” ; str.toStirng(); 关于更多的理解,本文篇幅有限,有时间我会再去补充,...
  • 都是使用与方法借用以及明确this指向场景 第一个参数都是this要指向的对象 都可以利用后面参数进行传参 不同点 参数传递方式不同 call apply是立即调用 bind是动态调用 基本使用 Array.prototype.slice....
  • JavaScript学习笔记(四十) 借用方法

    千次阅读 2013-08-01 23:13:08
    借用方法(Borrowing ...你只想使用你需要的方法,而不要继承其他的你永远也不会需要的方法。 通过借用方法模式,这是可能的,得益于function的方法call()和apply()。你已经在前面见过这种模式了,在extendDeep()实
  • 我们都知道apply,call,和bind方法都是改变this指向的,但是他们之间的区别以及核心原理你真的懂了吗 //代码1 var obj={ name:"li", f: function(age,fm){ console.log(this.name+" "+age+" "+fm); } } var ...
  • •Rust严格语法如何使用借用检查器来防止此类典型错误 •插入块的方式如何限制借用范围 •为什么函数返回引用需要生命周期指示符 •如何使用寿命指定符来表示函数及其含义 •借阅检查器的任务是什么 借用和生命周期 ...
  • 借用(References&Borrowing) 如上所示,Owership让我们改变一个变量的值变得“复杂”,那能否像其他编程语言那样随意改变变量的值呢?答案是有的。 所有权系统允许我们通过“Borrowing”的方式达到这个目的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,513
精华内容 17,005
关键字:

借用与使用的区别