değiştir enum varyantı ise herhangi klonlama olmadan yenisine eski varyantın bir alan taşırken bir enum varyantı güncellemek istiyorum

Question

yeni bir çeşidi ile alan taşıyarak:

enum X { 
    X1(String), 
    X2(String), 
} 

fn increment_x(x: &mut X) { 
    match x { 
     &mut X::X1(s) => { 
      *x = X::X2(s); 
     } 
     &mut X::X2(s) => { 
      *x = X::X1(s); 
     } 
    } 
} 

Bunun nedeni çalışmıyor s'u &mut X'dan kaldıramazız. Bir enum X { X1, X2 } uygulanması ve bu basitleştirilmiş bir örnektir vb struct S { variant: X, str: String } kullanmak gibi

önermek etmeyin şeyler varyantları diğer alanlara çok sahip ve başka bir varyantı olan bir alan taşımak isteyen düşünün.

Answer 1

&mut X'dan s'u taşıyamadığımız için bu işe yaramıyor.

Sonra yeni bir ... bunu değere göre yapı alıp dönmek yoktur: Eğer dışarı dize hareket edebilir çünkü eğer

enum X { 
    X1(String), 
    X2(String), 
} 

fn increment_x(x: X) -> X { 
    match x { 
     X::X1(s) => X::X2(s), 
     X::X2(s) => X::X1(s), 
    } 
} 

Sonuçta, derleyici sizi koruyor sayımın, daha sonra yarım inşa edilmiş bir durumda olurdu. Fonksiyonun o anda panik yapması durumunda ipi serbest bırakmaktan kim sorumlu olurdu? Enumdaki dizgiyi veya yerel değişkendeki dizgiyi serbest bırakmalıdır. İki katına çıkılamazsa, bellek güvenliği sorunudur.

bir değişken referans üzerinde uygulamak zorunda olduğu sen, orada geçici bir kukla değeri saklamak olsaydı: Boş String (sadece birkaç işaretçiler var çok fena değil oluşturma

use std::mem; 

fn increment_x_inline(x: &mut X) { 
    let old = mem::replace(x, X::X1(String::new())); 
    *x = increment_x(old); 
} 

, hiçbir yığın tahsis), ancak her zaman mümkün değildir. Bu durumda, Option kullanabilirsiniz: Eğer bir sıfır maliyetli bir şekilde değer dışına taşımadan bunu yapmak istiyorsanız

fn increment_x_inline(x: &mut Option<X>) { 
    let old = x.take(); 
    *x = old.map(increment_x); 
} 

Answer 2

, siz (AFAIK) güvensiz kod biraz başvurmak zorunda:

#[derive(Debug)] 
enum X { 
    X1(String), 
    X2(String), 
} 

fn increment_x(x: &mut X) { 
    let interim = unsafe { mem::uninitialized() }; 
    let prev = mem::replace(x, interim); 
    let next = match prev { 
     X::X1(s) => X::X2(s), 
     X::X2(s) => X::X1(s), 
    }; 
    let interim = mem::replace(x, next); 
    mem::forget(interim); // Important! interim was never initialized 
} 

Düzenleme: Teşekkür