精华内容
下载资源
问答
  • 借用与使用的区别
    2021-03-12 11:05:42
    /*
    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();
    }
    

     

    更多相关内容
  • 在解决原型中包含引用类型值所带来问题的过程中,开发人员开始使用一种叫做借用构造函数(constructor stealing)的技术(有时候也叫做伪造对象或经典继承)。这种技术的基本思想相当简单,即在子类型构造函数的内部...
  • 浅谈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)

    展开全文
  • rust的共享引用可变引用编译示例,与其C++的区别

    引用

    1. &符号表示共享引用:允许你在引用某些值而不取得其所有权。
    fn main() 
    {
        let s1 = "rust".to_string();
        let len = str_len(&s1);//传入的是s1的引用
    
        print!("{}  {}", s1.len(),len);
    
    }
    
    fn str_len(str : & String) -> usize
    {
        str.len()
    }
    
    1. 如果要在共享引用的状态要改变数据的值,则会引起恐慌。通俗的理解是,你借用了别人的东西,正常情况下,你是不可以对你借用的东西做任何改动。把引用做为参数的行为,在rust里面也称为借用。
    fn str_len(str : & String) -> usize
    {
        str.pop();//想要改变引用的数据的值
        str.len()
    }
    

    这里编译时不通过的,会报以下错误:
    在这里插入图片描述
    3. 如果想在引用的时候能改变数据里面的值,则需要在数据前面加上mut指明传入的数据是可变的。

    fn main() 
    {
        let mut s1 = "rust".to_string();
        let len = str_len(&mut s1);
    
        print!("{}  {}", s1.len(),len);
    
    }
    
    fn str_len(str : &mut String) -> usize
    {
        str.push_str(",hello");
        str.len()
    }
    

    4.Rust的设计原则是,同⼀作⽤域内,对于某⼀个对象的引⽤,只允许存在两种情况:要么只有⼀个可变引⽤,要么同时存在多个共享引⽤,共享引⽤不允许修改内容,可变引⽤才有修改权限。

     let mut s1 = "rust".to_string();
     let s2 = &mut s1;
     let s3 = &mut s1;
    
     print!("{} {}",s2,s3);
    

    会报以下错误:

    error[E0499]: cannot borrow `s1` as mutable more than once at a time
     --> src/main.rs:7:14
      |
    6 |     let s2 = &mut s1;
      |              ------- first mutable borrow occurs here
    7 |     let s3 = &mut s1;
      |              ^^^^^^^ second mutable borrow occurs here
    8 | 
    9 |     print!("{} {}",s2,s3);
      |                    -- first borrow later used here
    

    这样做的原因是为防止数据竞争,数据竞争在编译时很难被发现,只有在运行时才出现,rust的单个可变引用在根本上解决了这种问题,可能会发生数据竞争的几种情况:

    • 两个或多个指针同时访问同一个数据时;
    • 到少有一个指针用于写入数据;
    • 没有使用任何机制来同步对数据的访问;

    5.但可以通过创建新的作用域,非同时创建多个可变引用。

    let mut s1 = "rust".to_string();
    
     {
          let s2 = &mut s1;
     }
    
    let s3 = &mut s1;
    

    6.不可以同时拥有一个可变的引用和一个不可变的引用。

    let mut s1 = "rust".to_string();
    
    let s2 = &s1;
    
    let s3 = &mut s1;
    
    print!("{}  {}", s2.len(),s3.len());
    

    报错:

    error[E0502]: cannot borrow `s1` as mutable because it is also borrowed as immutable
      --> src/main.rs:9:14
       |
    7  |     let s2 = &s1;
       |              --- immutable borrow occurs here
    8  | 
    9  |     let s3 = &mut s1;
       |              ^^^^^^^ mutable borrow occurs here
    ...
    16 |     print!("{}  {}", s2.len(),s3.len());
       |                      -------- immutable borrow later used here
    
    1. 在Rust中,编译器可以保证引用永远都不是悬空引用。
      悬空引用是指一个指针引用了内存中的某个地址,而这块内存可能已经释放并分配给其它数据使用,在rust里,如果引用了某些数据,编译器将保证在引用离开作用域之前数据不会离开作用域。
    fn main() 
    {
        let s = dangle_ref();
    }
    
    fn dangle_ref() -> &String
    {
        let str = "rust".to_string();
        &str
    }
    

    报错:

    error[E0106]: missing lifetime specifier
     --> src/main.rs:8:20
      |
    8 | fn dangle_ref() -> &String
      |                    ^ expected named lifetime parameter
      |
      = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
    help: consider using the `'static` lifetime
      |
    8 | fn dangle_ref() -> &'static String
      |                    ~~~~~~~~
    

    这里的str的生命周期出了函数作用域后就不起作用了。

    8.rust 与C++的区别在于,C++中有一种引用,并且是可变的,但rust中的类型,如果没有实现Copy trait,那么在此类型的变量赋值、函数入参、函数返回值都是move语义。C++ 11 之后也有move语法。

    展开全文
  • CATIA许可借用

    2022-01-25 17:48:18
    CATIA软件是可以将许可借用到本地,借用成功之后,即可离线使用,可用于出差员工。许可借用为的是方便不同场景下对设计工程师合理使用软件工具的友好性。然而,在CATIA许可借用的情况,常常会因为管理不善导致许可...

           你知道CATIA许可在企业中可以借用吗?如何借用以及如何控制借用呢?

           CATIA软件是可以将许可借用到本地,借用成功之后,即可离线使用,可用于出差员工。许可借用为的是方便不同场景下对设计工程师合理使用软件工具的友好性。然而,在CATIA许可借用的情况,常常会因为管理不善导致许可借用不归还,或不清楚谁借用了,从而导致整体CATIA许可资源紧张。那么,如何管理和控制CATIA许可借用情况呢?

           首先我们需要梳理企业中软件许可资源情况、使用软件的部门人员信息、日常使用软件许可的频率/场景/并发量等信息,基于这些基本信息来决策许可如何对员工进行授权、如何合理分配、如何控制借用等。

     

    1. CATIA许可授信控制:将可以使用许可的员工或机器加入授信名单中,只有名单内的成员才可以使用软件许可;
    2. CATIA许可预留管理将急需许可的员工划分到一个组内,针对该组指定时间预留许可,只要有许可放置出来,优先提供给组内员工;
    3. CATIA许可分配管理:针对不常用该软件的部门进行分配少量许可,那么这些人员只能使用分配的许可数量。
    4. CATIA许可借用控制对软件许可进行借用控制,控制哪些员工可以借用许可并设置借用期限,到期自动归还。

          我们只有充分了解企业中的CATIA许可资源和CAITA用户信息的情况下,才能更好的合理安排CATIA许可的整体使用,做到让真正有需求的用户随时都能使用软件,非相关需求的用户不允许滥用和随意借用CATIA许可以造成资源浪费。

           关于CATIA许可借用的控制,格发许可优化管理系统为您提供全套成熟的解决方案,解决您软件许可合理及有效的管理等问题。除此之外格发管理系统还能进行资产管理、资产台账管理等解决企业IT部门的所有管理烦恼。

    展开全文
  • 理解Rust的引用与借用

    2021-03-07 02:50:03
    困惑接触Rust也一段时间了,但对References(引用) 、borrowing(借用) 、 &关键字、ref关键字、* ...(因为人在学习中总现有的知识对比,所以有了这一条)网上有很多对Rust中引用和借用部分进行翻译和解释。...
  • 借用构造函数实现继承,案例及分析
  • 我们下面来看一篇关于JavaScript中借用方法的一个详细介绍,注意:本文假设你已经掌握使用 call()、apply()和bind()的相关知识和它们之间的区别,希望这篇文章能够让各位了解到JavaScript中的借用方法吧。
  • 二、借用构造函数实现继承: 三、借用构造函数的问题: 一、知识回顾: 在学习新知识之前我们简单回顾一下 call、apply、bind方法的使用: call和apply的共同点是能够改变函数的执行时的上下文,将一个对象的...
  • 我们都知道apply,call,和bind方法都是改变this指向的,但是他们之间的区别以及核心原理你真的懂了吗 //代码1 var obj={ name:"li", f: function(age,fm){ console.log(this.name+" "+age+" "+fm); } } var ...
  • js中的方法借用

    2019-11-29 11:36:38
    区别主要就是参数的接收方式不同 这两个方法都是放在obj的原型链上 例: A.call(B,参数) :A代表一个方法,B代表this的指向(相当于B借用A的方法) //方法借用 let obj={ name:'zhangsan', say:function(){ ...
  • 借用数据挖掘技术实现潜在客户的层次划分 西南师大计科院 2000研究生 王艳 400715 摘要本文探讨了利用数据挖掘技术结合统计学方法实现对潜在客户精确测量及准 确划分的方法步骤并对该方法传统感性方法的区别做了...
  • 前言linux中有两个角色管理员用户只有root是管理员,其他添加的用户都是普通用户,就算把它加到sudoer文件中,还是普通用户,只不过变为可以借用管理员权限的普通用户罢了。步骤首先,只有root管理员或是可以借用...
  • int i = 0; i = i++; System.out.println("i = " + i);
  • Rust:借用

    2018-12-26 15:48:33
    //向OS申请一个栈空间x,并将5绑定到x,OS会自动将这个空间标记为已使用 let y = x; //向OS申请一个栈空间y,将x变量绑定的值5拷贝到一个临时变量中,绑定到y,然后使得临时变量失效 println!(&amp;amp;amp...
  • 为什么Mutex/RwLock一般都会配合Arc使用? …… 这一类借用规则的问题,实际上都可以通过另一种思路来很好地解答,当然这也是很多大佬一定程度上认可的理解方式: Rust中的借用,分为不可变借用共享借用,和可变...
  • 动态INCLUDE 用法:”included.jsp” flush=”true”> 说明:它总是会检查所含文件中的变化,适合...而页面设置也可以借用主文件的. 静态INCLUDE 用法:<%@ include file=”included.htm” %> 说明:用include
  • js 方法借用

    2018-02-26 10:34:34
    call和apply基本一致,区别在于用法上,一个是传入一个数组 ,一个是直接传入参数。 function people(){}; var animal = { name: "cc", age:16, say:function(m1,m2){ alert("他说:&...
  • ES5继承和ES6继承的区别: es5继承首先是在子类中创建自己的this指向,最后将方法添加到this中 Child.prototype=new Parent() || Parent.apply(this) || Parent.call(this) es6继承是使用关键字先创建父类的实例...
  • 主要介绍了JavaScript继承基础讲解,原型链、借用构造函数、混合模式、原型式继承、寄生式继承、寄生组合式继承,需要的朋友可以参考下
  • MySQLOracle的主要区别

    千次阅读 2021-05-08 20:37:18
    MysqlOracle区别1. Oracle是大型数据库而Mysql是中小型数据库,Oracle市场占有率达40%,Mysql只有20%左右,同时Mysql是开源的而Oracle价格非常高。2. Oracle支持大并发,大访问量,是OLTP最好的工具。3. 安装所用...
  • 这里借用《Java并发编程的艺术》提到的来说一下使用线程池的好处: 降低资源消耗。 通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。 当任务到达时,任务可以不需要的等到线程创建就能立即...
  • rust学习笔记基础篇4–结构体变量声明绑定,所有权,借用,引用(霜之小刀) 欢迎转载和引用,若有问题请联系 若有疑问,请联系 Email : lihn1011@163.com QQ:2279557541 关于结构体的变量声明 看...
  • rust内存安全--借用

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,566
精华内容 19,026
热门标签
关键字:

借用与使用的区别

友情链接: Modbus_T2_AT89S52.zip