Değeri taşıdığım bir kutuyu nasıl yeniden kullanabilirim?

Question

Ben olmayan bazı copyable türünü ve tüketir ve (belki) onu üreten bir işlevi vardır:

struct NotBox<T> { 
    contents: T 
} 

Biz yapabilirsiniz:

type Foo = Vec<u8>; 

fn quux(_: Foo) -> Option<Foo> { 
    Some(Vec::new()) 
} 

Şimdi kavramsal bir şekilde Box çok benzer bir türünü göz önünde geçici NotBox içeriğini dışarı hareket eder ve onu dönmeden önce geri bir şey koyar bir fonksiyon yazabiliriz:

fn bar(mut notbox: NotBox<Foo>) -> Option<NotBox<Foo>> { 
    let foo = notbox.contents; // now `notbox` is "empty" 
    match quux(foo) { 
     Some(new_foo) => { 
      notbox.contents = new_foo; // we put something back in 
      Some(notbox) 
     } 
     None => None 
    } 
} 

Ben Box es ile çalışır benzer bir işlevi yazmak istiyorum ama derleyici bunu sevmez:

fn baz(mut abox: Box<Foo>) -> Option<Box<Foo>> { 
    let foo = *abox; // now `abox` is "empty" 
    match quux(foo) { 
     Some(new_foo) => { 
      *abox = new_foo; // error: use of moved value: `abox` 
      Some(abox) 
     } 
     None => None 
    } 
} 

yerine Some(Box::new(new_foo)) geri dönebilirler ama bu gereksiz tahsisini gerçekleştiren - Zaten benim emrinde bazı bellek var! Bunu önlemek mümkün mü?

Ben de match tabloların kurtulmak istiyorum ama yine derleyici (hatta NotBox versiyonu için) memnun değil:

fn bar(mut notbox: NotBox<Foo>) -> Option<NotBox<Foo>> { 
    let foo = notbox.contents; 
    quux(foo).map(|new_foo| { 
     notbox.contents = new_foo; // error: capture of partially moved value: `notbox` 
     notbox 
    }) 
} 

o geçici bir çözüm mümkün mü?

Answer 1

Yani, Box'dan çıkmak özel bir durum ... şimdi ne olacak?

std::mem modülü, Rust'un bellek güvenliğini deliğe sokmadan (!), Değerleri hareket ettirmek için bir dizi güvenli işlev sunar.ilgi burada swap ve replace şunlardır:

pub fn replace<T>(dest: &mut T, src: T) -> T 

böylece gibi kullanabilirsiniz Hangi:

fn baz(mut abox: Box<Foo>) -> Option<Box<Foo>> { 
    let foo = std::mem::replace(&mut *abox, Foo::default()); 

    match quux(foo) { 
     Some(new_foo) => { 
      *abox = new_foo; 
      Some(abox) 
     } 
     None => None 
    } 
} 

o Box ödünç vermez, çünkü o da, map durumunda yardımcı olur:

fn baz(mut abox: Box<Foo>) -> Option<Box<Foo>> { 
    let foo = std::mem::replace(&mut *abox, Foo::default()); 

    quux(foo).map(|new_foo| { *abox = new_foo; abox }) 
} 

Answer 2

Kutuların dışına taşınması, derleyicide özel kasalıdır. Onlardan bir şeyleri hareket ettirebilirsiniz, ama bir şeyi geri taşıyamazsınız, çünkü hareket etme hareketi de ayrılır. std::ptr::write, std::ptr::read ve std::ptr::replace ile aptalca bir şey yapabilirsiniz, ancak doğru olması zor, çünkü bir şey geçerli olduğunda Box içinde bırakılmalıdır. Sadece tahsisi kabul etmenizi veya bunun yerine Box<Option<Foo>>'a geçmenizi tavsiye ederim.

Answer 3

geçici olarak NotBox içeriğini dışarı taşır ve ona kısmen değeriyle almak yapı dışarı taşıyabilirsiniz çünkü var

dönmeden önce geri bir şey koyar bir işlev yazabilirsiniz. Tüm alanlar ayrı değişkenlermiş gibi davranır. Yapı Drop'u uygularsa, bu mümkün değildir, çünkü drop tüm yapının geçerli olmasını gerektirir, her zaman (panik durumunda). Özellikle, neden baz bağımsız değişken olarak Box atması gereken ve neden quux olamaz - geçici çözümü sağlayan gelince

, yeterince bilgi girmediniz? Hangi işlevler sizinki ve hangi değişkenin bir parçası değilsiniz? Gerçek tip Foo nedir? Büyük mü?

En iyi çözüm, Box'u kullanmamaktır.