国产 无码 综合区,色欲AV无码国产永久播放,无码天堂亚洲国产AV,国产日韩欧美女同一区二区

【Rust】所有權(quán)

這篇具有很好參考價(jià)值的文章主要介紹了【Rust】所有權(quán)。希望對(duì)大家有所幫助。如果存在錯(cuò)誤或未考慮完全的地方,請(qǐng)大家不吝賜教,您也可以點(diǎn)擊"舉報(bào)違法"按鈕提交疑問(wèn)。

所有權(quán)

所有權(quán)是Rust最獨(dú)特的特性,它讓Rust無(wú)需GC(Garbage Collection)就可保證內(nèi)存安全。Rust的核心特性就是所有權(quán),所有程序在運(yùn)行時(shí)都必須管理它們使用計(jì)算機(jī)內(nèi)存的方式。有些語(yǔ)言有垃圾回收機(jī)制,在程序運(yùn)行時(shí)會(huì)不斷地尋找不再使用的內(nèi)存。在其他語(yǔ)言中,程序員必須顯式地分配和釋放內(nèi)存。

Rust采用了第三種方式,內(nèi)存是通過(guò)一個(gè)所有權(quán)系統(tǒng)來(lái)管理的,其中包含一組編譯器在編譯時(shí)檢查的規(guī)則。當(dāng)程序運(yùn)行時(shí),所有權(quán)特性不會(huì)減慢程序的運(yùn)行速度。

stack與heap

在像Rust這樣的系統(tǒng)級(jí)編程語(yǔ)言里,一個(gè)值在stack上還是在heap上對(duì)語(yǔ)言的行為和你為什么要做某些決定是有更大的影響的。在你的代碼運(yùn)行的時(shí)候,stack和heap都是你可用的內(nèi)存,但是它們的結(jié)構(gòu)很不相同。

  • stack按值的接收順序來(lái)存儲(chǔ),按相反的順序?qū)⑺鼈円瞥ê筮M(jìn)先出,LIFO),添加數(shù)據(jù)叫壓入棧,移除數(shù)據(jù)叫做彈出棧。把值壓到stack上不叫分配。因?yàn)橹羔樖枪潭ù笮〉?,可以把指針存放在stack上。
  • 所有存儲(chǔ)在stack上的數(shù)據(jù)必須擁有已知的固定的大小。編譯時(shí)大小未知的數(shù)據(jù)或運(yùn)行時(shí)大小可能發(fā)生變化的數(shù)據(jù)必須存放在heap上。
  • Heap 內(nèi)存組織性差一些,一當(dāng)你把數(shù)據(jù)放入heap時(shí),你會(huì)請(qǐng)求一定數(shù)量的空間,操作系統(tǒng)在heap里找到一塊足夠大的空間,把它標(biāo)記為在用,并返回一個(gè)指針,也就是這個(gè)空間的地址。這個(gè)過(guò)程叫做在heap上進(jìn)行分配,有時(shí)僅僅稱為“分配”。
  • 入棧比在堆上分配內(nèi)存要快,因?yàn)椋ㄈ霔r(shí))分配器無(wú)需為存儲(chǔ)新數(shù)據(jù)去搜索內(nèi)存空間;其位置總是在棧頂。相比之下,在堆上分配內(nèi)存則需要更多的工作,這是因?yàn)榉峙淦鞅仨毷紫日业揭粔K足夠存放數(shù)據(jù)的內(nèi)存空間,并接著做一些記錄為下一次分配做準(zhǔn)備。
  • 訪問(wèn)heap 中的數(shù)據(jù)要比訪問(wèn)stack 中的數(shù)據(jù)慢,因?yàn)樾枰ㄟ^(guò)指針才能找到heap中的數(shù)據(jù)。對(duì)于現(xiàn)代的處理器來(lái)說(shuō),由于緩存的緣故,如果指令在內(nèi)存中跳轉(zhuǎn)的次數(shù)越少,那么速度就越快。
  • 如果數(shù)據(jù)存放的距離比較近,那么處理器的處理速度就會(huì)更快一些(stack 上)。如果數(shù)據(jù)之間的距離比較遠(yuǎn),那么處理速度就會(huì)慢一些(heap 上)。在heap上分配大量的空間也是需要時(shí)間的。
  • 當(dāng)你的代碼調(diào)用函數(shù)時(shí),值被傳入到函數(shù)(也包括指向 heap 的指針)。函數(shù)本地的變量被壓到stack 上。當(dāng)函數(shù)結(jié)束后,這些值會(huì)從stack 上彈出。

所有權(quán)存在的原因

所有權(quán)解決的問(wèn)題:跟蹤代碼的哪些部分正在使用heap 的哪些數(shù)據(jù);最小化 heap 上的重復(fù)數(shù)據(jù)量;清理heap上未使用的數(shù)據(jù)以避免空間不足。一旦懂了所有權(quán),就不需要經(jīng)常去想stack或heap了,但是知道管理heap數(shù)據(jù)是所有權(quán)存在的原因,這有助于解釋它為什么會(huì)這樣工作。

所有權(quán)規(guī)則

  • 每個(gè)值都有一個(gè)變量,這個(gè)變量是該值的所有者。
  • 每個(gè)值同時(shí)只能有一個(gè)所有者。
  • 當(dāng)所有者超出作用域(scope)時(shí),該值將被刪除。

變量作用域

Scope就是程序中一個(gè)項(xiàng)目的有效范圍。

fn main() {
    //s 不可用
    let s = "hello";//s 可用
                    //可以對(duì) s 進(jìn)行相關(guān)操作
}//s 作用域到此結(jié)束,s 不再可用

String類型

String比那些基礎(chǔ)標(biāo)量數(shù)據(jù)類型更加復(fù)雜。字符串字面值:程序里手寫的那些字符串值,它們是不可變的。Rust還有第二種字符串類型:String。在heap上分配,能夠存儲(chǔ)在編譯時(shí)未知數(shù)量的文本。

fn main() {
    let mut s = String::from("Hello");
    s.push_str(",World");
    println!("{}",s);
}

為什么String類型的值可以修改,而字符串字面值卻不能修改,因?yàn)樗鼈兲幚韮?nèi)存的方式不同。

內(nèi)存和分配

字符串字面值,在編譯時(shí)就知道它的內(nèi)容了,其文本內(nèi)容直接被硬編碼到最終的可執(zhí)行文件里,速度快、高效。是因?yàn)槠洳豢勺冃浴?/p>

String類型為了支持可變性,需要在heap上分配內(nèi)存來(lái)保存編譯時(shí)未知的文本內(nèi)容:操作系統(tǒng)必須在運(yùn)行時(shí)來(lái)請(qǐng)求內(nèi)存,這步通過(guò)調(diào)用String::from來(lái)實(shí)現(xiàn)。當(dāng)用完 String之后,需要使用某種方式將內(nèi)存返回給操作系統(tǒng)。這步,在擁有GC的語(yǔ)言中,GC會(huì)跟蹤并清理不再使用的內(nèi)存。沒有GC,就需要我們?nèi)プR(shí)別內(nèi)存何時(shí)不再使用,并調(diào)用代碼將它返回。―如果忘了,那就浪費(fèi)內(nèi)存;如果提前做了,變量就會(huì)非法;如果做了兩次,也是 Bug。必須一次分配對(duì)應(yīng)一次釋放。

Rust采用了不同的方式:對(duì)于某個(gè)值來(lái)說(shuō),當(dāng)擁有它的變量走出作用范圍時(shí),內(nèi)存會(huì)立即自動(dòng)的交還給操作系統(tǒng)。Rust會(huì)在變量超出作用域時(shí)調(diào)用一個(gè)特殊的函數(shù)drop釋放其內(nèi)存。

變量與數(shù)據(jù)交互的方式

1.Move

多個(gè)變量可以與同一個(gè)數(shù)據(jù)使用一種獨(dú)特的方式來(lái)交互。

let x = 5;
let y = x;

整數(shù)是已知固定大小的簡(jiǎn)單的值,這兩個(gè)5被壓到了stack中。

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

一個(gè)String由3部分組成:一個(gè)指向存放字符串內(nèi)容的指針,一個(gè)長(zhǎng)度,一個(gè)容量。這些存放在stack中,存放字符串內(nèi)容的部分在heap上,長(zhǎng)度len,就是存放字符串內(nèi)容所需的字節(jié)數(shù)。容量capacity是指String從操作系統(tǒng)歐冠總共獲得內(nèi)存的字節(jié)數(shù)。

【Rust】所有權(quán)

當(dāng)把s1賦給s2,String的數(shù)據(jù)被賦值了一份,在stack上復(fù)制了一份指針、長(zhǎng)度、容量,并沒有復(fù)制指針?biāo)赶虻膆eap上的數(shù)據(jù)。當(dāng)變量離開作用域時(shí),Rust會(huì)自動(dòng)調(diào)用drop 函數(shù),并將變量使用的heap內(nèi)存釋放。當(dāng)s1、s2離開作用域時(shí),它們都會(huì)嘗試釋放相同的內(nèi)存,這就是二次釋放(double free)bug。

為了保證內(nèi)存安全,Rust并沒有嘗試復(fù)制被分配的內(nèi)存,而是選擇讓s1失效,當(dāng)s1離開作用域的時(shí)候,Rust不需要釋放任何東西。

【Rust】所有權(quán)

如果你在其他語(yǔ)言中聽說(shuō)過(guò)術(shù)語(yǔ)淺拷貝(shallow copy)和深拷貝(deep copy),那么拷貝指針、長(zhǎng)度和容量而不拷貝數(shù)據(jù)可能聽起來(lái)像淺拷貝。不過(guò)因?yàn)镽ust同時(shí)使第一個(gè)變量無(wú)效了,這個(gè)操作被稱為移動(dòng)(move),而不是叫做淺拷貝。隱含的設(shè)計(jì)原則:Rust不會(huì)自動(dòng)創(chuàng)建數(shù)據(jù)的深拷貝,就運(yùn)行時(shí)性能而言,任何自動(dòng)賦值的操作都是廉價(jià)的。

2.Clone

如果真想對(duì)heap上面的String數(shù)據(jù)進(jìn)行深度拷貝,而不僅僅是stack上的數(shù)據(jù),可以使用clone方法。

let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);

【Rust】所有權(quán)

3.Copy

let x = 5;
let y = x;

這段代碼似乎與我們剛剛學(xué)到的內(nèi)容相矛盾:沒有調(diào)用 clone,不過(guò) x 依然有效且沒有被移動(dòng)到 y 中。

原因是像整型這樣的在編譯時(shí)已知大小的類型被整個(gè)存儲(chǔ)在棧上,所以拷貝其實(shí)際的值是快速的。這意味著沒有理由在創(chuàng)建變量y后使x無(wú)效。換句話說(shuō),這里沒有深淺拷貝的區(qū)別,所以這里調(diào)用 clone 并不會(huì)與通常的淺拷貝有什么不同。

Rust提供了Copy trait,可以用于像整數(shù)這樣完全存放在stack上面的類型。如果一個(gè)類型實(shí)現(xiàn)了Copy這個(gè)trait,那么舊的變量在賦值后仍然可用;如果一個(gè)類型或者該類型的一部分實(shí)現(xiàn)了Drop trait,那么,Rust不允許讓它再去實(shí)現(xiàn)Copy trait了。

一些擁有Copy trait的類型:任何簡(jiǎn)單標(biāo)量的組合類型都可以是Copy的,任何需要分配內(nèi)存或某種資源的都不是Copy的。

  • 所有的整數(shù)類型,例如u32
  • bool
  • char
  • 所有的浮點(diǎn)類型,例如f64
  • Tuple(元組),如果其所有的字段都是Copy的

所有權(quán)與函數(shù)

在語(yǔ)義上,將值傳遞給函數(shù)和把值賦給變量是類似的,將值傳遞給函數(shù)將發(fā)生移動(dòng)或復(fù)制。

fn main() {
    let mut s = String::from("Hello,World");

    take_ownership(s);//s 被移動(dòng) 不再有效

    let x = 5;

    makes_copy(x);//復(fù)制

    println!("x:{}",x);
}

fn take_ownership(some_string: String){
    println!("{}",some_string);
}

fn makes_copy(some_number: i32){
    println!("{}",some_number);
}

返回值與作用域

函數(shù)在返回值的過(guò)程中同樣也會(huì)發(fā)生所有權(quán)的轉(zhuǎn)移。

fn main() {
    let s1 = gives_ownship();gives_ownership 將返回值轉(zhuǎn)移給s1

    let s2 = String::from("hello");

    let s3 = takes_and_give_back(s2);//s2 被移動(dòng)到takes_and_gives_back 中,它也將返回值移給 s3
}

fn gives_ownship()->String{
    let some_string = String::from("hello");
    some_string
}

fn takes_and_give_back(a_string:String)->String{
    a_string
}

一個(gè)變量的所有權(quán)總是遵循同樣的模式:把一個(gè)值賦給其它變量時(shí)就會(huì)發(fā)生移動(dòng)。當(dāng)一個(gè)包含heap數(shù)據(jù)的變量離開作用域時(shí),它的值就會(huì)被drop函數(shù)清理,除非數(shù)據(jù)的所有權(quán)移動(dòng)到另一個(gè)變量上了。

如何讓函數(shù)使用某個(gè)值,但不獲得其所有權(quán)?

fn main() {
    let s1 = String::from("hello");

    let (s2, len) = calculate_length(s1);

    println!("The length of '{}' is {}.", s2, len);
}

fn calculate_length(s: String) -> (String, usize) {
    let length = s.len(); 

    (s, length)
}

但是這傳進(jìn)來(lái)傳出去很麻煩,Rust有一個(gè)特性,叫做引用(references)。

引用

參數(shù)的類型是&String而不是String,&符號(hào)就表示引用:允許你引用某些值而不取的其所有權(quán)。

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()
}

【Rust】所有權(quán)

借用

我們把引用作為函數(shù)參數(shù)這個(gè)行為叫做借用。不可以修改借用的變量。和變量一樣,引用默認(rèn)也是不可變的。

可變引用

fn main() {
    let mut s1 = String::from("Hello");

    let len = calculate_length(&mut s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &mut String) -> usize {
    s.push_str(",World");
    s.len()
} 

可變引用有一個(gè)重要的限制:在特定作用域內(nèi),對(duì)某一塊數(shù)據(jù),只能有一個(gè)可變的引用。這樣的好處是可在編譯時(shí)防止數(shù)據(jù)競(jìng)爭(zhēng)。以下三種行為會(huì)發(fā)生數(shù)據(jù)競(jìng)爭(zhēng),兩個(gè)或多個(gè)指針同時(shí)訪問(wèn)一個(gè)數(shù)據(jù),至少有一個(gè)指針用于寫入數(shù)據(jù),沒有使用任何機(jī)制來(lái)同步對(duì)數(shù)據(jù)的訪問(wèn)。我們可以創(chuàng)建新的作用域,來(lái)允許非同時(shí)的創(chuàng)建多個(gè)可變引用。

    let mut s = String::from("hello");
    {
        let r1 = &mut s;
    }
    let r2 = &mut s;

另一個(gè)限制是不可以同時(shí)擁有一個(gè)可變引用和一個(gè)不變的引用。多個(gè)不可變的引用是可以的。

懸空引用Dangling References

懸空指針(Dangling Pointer):一個(gè)指針引用了內(nèi)存中的某個(gè)地址,而這塊內(nèi)存可能己經(jīng)釋放并分配給其它人使用了。

在Rust里,編譯器可保證引用永遠(yuǎn)都不是懸空引用:
如果你引用了某些數(shù)據(jù),編譯器將保證在引用離開作用域之前數(shù)據(jù)不會(huì)離開作用域。

引用的規(guī)則

在任何給定的時(shí)刻,只能滿足下列條件之一:

  • 一個(gè)可變的引用
  • 任意數(shù)量不可變的引用引用必須一直有效

引用必須一直有效。

切片

Rust的另外一種不持有所有權(quán)的數(shù)據(jù)類型:切片(slice)。

編寫一個(gè)函數(shù),該函數(shù)接收一個(gè)用空格分隔單詞的字符串,并返回在該字符串中找到的第一個(gè)單詞。如果函數(shù)在該字符串中并未找到空格,則整個(gè)字符串就是一個(gè)單詞,所以應(yīng)該返回整個(gè)字符串。

fn main() {
    let mut s = String::from("Hello world");
    let wordIndex = first_word(&s);

    s.clear();
    println!("{}", wordIndex);
}

fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }
    s.len()
}

這個(gè)程序編譯時(shí)沒有任何錯(cuò)誤,但是wordIndex與s狀態(tài)完全沒有聯(lián)系。s被清空后wordIndex仍返回s傳給函數(shù)時(shí)狀態(tài)的值。Rust為這種情況提供了解決方案。字符串切片。

字符串切片

字符串切片是指向字符串中一部分內(nèi)容的引用。形式:

[開始索引..結(jié)束索引]

開始索引是切片起始位置的索引值,結(jié)束索引是切片終止位置的所有值。

let s = String::from("Hello World");

let hello = &s[0..5];
let world = &s[6..11];

let hello2 = &s[..5];
let world2 = &s[6..];

【Rust】所有權(quán)

字符串切片的范圍索引必須發(fā)生在有效的UTF-8字符邊界內(nèi)。如果嘗試從一個(gè)多字節(jié)的字符中創(chuàng)建字符串切片,程序會(huì)報(bào)錯(cuò)并退出。

重寫firstworld:


fn main() {
    let mut s = String::from("Hello World");

    let word = first_word(&s);

    //s.clear(); // 錯(cuò)誤!
    println!("the first word is: {}", word);
}

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

字符串字面值是切片,字符串字面值被直接存儲(chǔ)在二進(jìn)制程序中。

將字符串切片作為參數(shù)傳遞

有經(jīng)驗(yàn)的Rust開發(fā)者會(huì)采用&str作為參數(shù)類型,因?yàn)檫@樣就可以同時(shí)接收String和&str類型的參數(shù)了:

fn first_word(s: &str) -> &str {

使用字符串切片直接調(diào)用該函數(shù),使用String可以創(chuàng)建一個(gè)完整的String切片來(lái)調(diào)用該函數(shù)。

定義函數(shù)時(shí)使用字符串切片來(lái)代替字符串引用會(huì)使我們的API更加通用,且不會(huì)損失任何功能。

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    let mut s2 = "hello world";

    let word2 = first_word(s2);
    //s.clear(); // 錯(cuò)誤!
    println!("the first word of s is: {}", word);
    println!("the first word of s2 is: {}", word2);
}

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

其他類型的切片

let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];

它跟字符串 slice 的工作方式一樣,通過(guò)存儲(chǔ)第一個(gè)集合元素的引用和一個(gè)集合總長(zhǎng)度。文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-509026.html

到了這里,關(guān)于【Rust】所有權(quán)的文章就介紹完了。如果您還想了解更多內(nèi)容,請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章,希望大家以后多多支持TOY模板網(wǎng)!

本文來(lái)自互聯(lián)網(wǎng)用戶投稿,該文觀點(diǎn)僅代表作者本人,不代表本站立場(chǎng)。本站僅提供信息存儲(chǔ)空間服務(wù),不擁有所有權(quán),不承擔(dān)相關(guān)法律責(zé)任。如若轉(zhuǎn)載,請(qǐng)注明出處: 如若內(nèi)容造成侵權(quán)/違法違規(guī)/事實(shí)不符,請(qǐng)點(diǎn)擊違法舉報(bào)進(jìn)行投訴反饋,一經(jīng)查實(shí),立即刪除!

領(lǐng)支付寶紅包贊助服務(wù)器費(fèi)用

相關(guān)文章

  • Rust-所有權(quán)(ownership)

    Rust入門學(xué)習(xí)系列-Rust 的核心功能(之一)是 所有權(quán)(ownership)。引入這個(gè)概念是為了更好的管理計(jì)算機(jī)的內(nèi)存。下面篇幅讓我們來(lái)研究下這個(gè)功能有什么神奇之處。 常見的編程語(yǔ)言中計(jì)算機(jī)內(nèi)存管理方式: Java:Java使用Java虛擬機(jī)(JVM)來(lái)管理計(jì)算機(jī)內(nèi)存。JVM有一個(gè)垃圾回收

    2024年02月19日
    瀏覽(31)
  • rust學(xué)習(xí)——棧、堆、所有權(quán)

    rust學(xué)習(xí)——棧、堆、所有權(quán)

    棧和堆是編程語(yǔ)言最核心的數(shù)據(jù)結(jié)構(gòu),但是在很多語(yǔ)言中,你并不需要深入了解棧與堆。 但對(duì)于 Rust 這樣的系統(tǒng)編程語(yǔ)言,值是位于棧上還是堆上非常重要, 因?yàn)檫@會(huì)影響程序的行為和性能。 棧和堆的核心目標(biāo)就是為程序在運(yùn)行時(shí)提供可供使用的內(nèi)存空間。 棧 棧按照順序存

    2024年02月07日
    瀏覽(31)
  • Rust核心功能之一(所有權(quán))

    Rust核心功能之一(所有權(quán))

    目錄 1、什么是所有權(quán)? 1.1?所有權(quán)規(guī)則 ?1.2 變量作用域 1.3 String 類型 1.4 內(nèi)存與分配 變量與數(shù)據(jù)交互的方式(一):移動(dòng) 變量與數(shù)據(jù)交互的方式(二):克隆 只在棧上的數(shù)據(jù):拷貝 1.5 所有權(quán)與函數(shù) 1.6 返回值與作用域 所有權(quán)(系統(tǒng))是 Rust 最為與眾不同的特性,對(duì)語(yǔ)言的

    2024年02月04日
    瀏覽(36)
  • Rust-所有權(quán)和移動(dòng)語(yǔ)義

    Rust-所有權(quán)和移動(dòng)語(yǔ)義

    拿C語(yǔ)言的代碼來(lái)打個(gè)比方。我們可能會(huì)在堆上創(chuàng)建一個(gè)對(duì)象,然后使用一個(gè)指針來(lái)管理這個(gè)對(duì)象: 接下來(lái),我們可能需要使用這個(gè)對(duì)象: 然而,這段代碼之后,誰(shuí)能猜得到,指針p指向的對(duì)象究竟發(fā)生了什么?它是否被修改過(guò)了?它還存在嗎,是否已經(jīng)被釋放?是否有另外一個(gè)指

    2024年01月18日
    瀏覽(25)
  • 【Rust】Rust學(xué)習(xí) 第四章認(rèn)識(shí)所有權(quán)

    【Rust】Rust學(xué)習(xí) 第四章認(rèn)識(shí)所有權(quán)

    所有權(quán)(系統(tǒng))是 Rust 最為與眾不同的特性,它讓 Rust 無(wú)需垃圾回收(garbage collector)即可保障內(nèi)存安全。因此,理解 Rust 中所有權(quán)如何工作是十分重要的。 4.1?所有權(quán) 所有運(yùn)行的程序都必須管理其使用計(jì)算機(jī)內(nèi)存的方式。一些語(yǔ)言中具有垃圾回收機(jī)制,在程序運(yùn)行時(shí)不斷地

    2024年02月13日
    瀏覽(21)
  • Rust語(yǔ)法:所有權(quán)&引用&生命周期

    Rust語(yǔ)法:所有權(quán)&引用&生命周期

    垃圾回收管理內(nèi)存 Python,Java這類語(yǔ)言在管理內(nèi)存時(shí)引用了一種叫做垃圾回收的技術(shù),這種技術(shù)會(huì)為每個(gè)變量設(shè)置一個(gè)引用計(jì)數(shù)器(reference counter),來(lái)統(tǒng)計(jì)每個(gè)對(duì)象的引用次數(shù)。 一旦某個(gè)對(duì)象的引用數(shù)為0,垃圾回收器就會(huì)擇取一個(gè)時(shí)機(jī)將其所占用的空間回收。 以Python為例子

    2024年02月12日
    瀏覽(24)
  • 30天拿下Rust之所有權(quán)

    概述 ????????在編程語(yǔ)言的世界中,Rust憑借其獨(dú)特的所有權(quán)機(jī)制脫穎而出,為開發(fā)者提供了一種新穎而強(qiáng)大的工具來(lái)防止內(nèi)存錯(cuò)誤。這一特性不僅確保了代碼的安全性,還極大地提升了程序的性能。在Rust中,所有權(quán)是一種編譯時(shí)檢查機(jī)制,用于追蹤哪些內(nèi)存或資源何時(shí)可

    2024年03月08日
    瀏覽(24)
  • Rust語(yǔ)言從入門到入坑——(5)Rust 所有權(quán)

    Rust語(yǔ)言從入門到入坑——(5)Rust 所有權(quán)

    主要介紹Rust所有權(quán)的知識(shí),涉及到變量的作用域,內(nèi)存釋放機(jī)制,移動(dòng),克隆,引用等知識(shí),很多知識(shí)是Rust語(yǔ)言特有機(jī)制。 所有權(quán)有以下三條規(guī)則: - Rust 中的每個(gè)值都有一個(gè)變量,稱為其所有者。 - 一次只能有一個(gè)所有者。 - 當(dāng)所有者不在程序運(yùn)行范圍時(shí),該值將被刪除

    2024年02月10日
    瀏覽(19)
  • Rust 基礎(chǔ)入門 —— 2.3.所有權(quán)和借用

    Rust 的最主要光芒: 內(nèi)存安全 。 實(shí)現(xiàn)方式: 所有權(quán)系統(tǒng) 。 因?yàn)槲覀冞@里實(shí)際講述的內(nèi)容是關(guān)于 內(nèi)存安全的,所以我們最好先復(fù)習(xí)一下內(nèi)存的知識(shí)。 然后我們,需要理解的就只有所有權(quán)概念,以及為了開發(fā)便利,進(jìn)一步引出的引用借用概念。 內(nèi)存作為存儲(chǔ)程序運(yùn)行時(shí)數(shù)據(jù)

    2024年02月12日
    瀏覽(28)
  • 【跟小嘉學(xué) Rust 編程】四、理解 Rust 的所有權(quán)概念

    【跟小嘉學(xué) Rust 編程】四、理解 Rust 的所有權(quán)概念

    【跟小嘉學(xué) Rust 編程】一、Rust 編程基礎(chǔ) 【跟小嘉學(xué) Rust 編程】二、Rust 包管理工具使用 【跟小嘉學(xué) Rust 編程】三、Rust 的基本程序概念 【跟小嘉學(xué) Rust 編程】四、理解 Rust 的所有權(quán)概念 本章節(jié)將講解 Rust 獨(dú)有的概念(所有權(quán))。所有權(quán)是 Rust 最獨(dú)特的特性,它使得 Rust 能夠

    2024年02月10日
    瀏覽(31)

覺得文章有用就打賞一下文章作者

支付寶掃一掃打賞

博客贊助

微信掃一掃打賞

請(qǐng)作者喝杯咖啡吧~博客贊助

支付寶掃一掃領(lǐng)取紅包,優(yōu)惠每天領(lǐng)

二維碼1

領(lǐng)取紅包

二維碼2

領(lǐng)紅包