Neden bir yapıda referanslar için aynı yaşamları kullandınız?

Question

Bu soru When is it useful to define multiple lifetimes in a struct?'a benzer, ancak umarım yeterince farklıdır. Bu sorunun cevabı faydalıdır, ancak bir yaklaşımın avantajlarına odaklanır (yapısal referanslar için ayrı yaşam sürelerini kullanarak), ancak dezavantajları (varsa). Bu soru, bunun gibi, yapıları oluştururken hayatların nasıl seçileceğine dair rehberlik arıyor. birbirine bağlı bu

Çağrı versiyonu x ve y aynı ömrü olması gerekmektedir, çünkü:

struct Foo<'a> { 
    x: &'a i32, 
    y: &'a i32, 
} 

ve gevşek yaşam süreleri farklı olabileceği için, versiyonu çağırır:

struct Foo<'a, 'b> { 
    x: &'a i32, 
    y: &'b i32, 
} 

Başvurulan soruya verilen yanıt net bir durum verir. istemci kodu gevşek sürümü verilirken çalıştırılabilir/çalıştırılabilir, ancak sürümüne bağlı olarak başarısız olur. sürümü için birlikte çalışan herhangi bir istemci kodunun gevşek sürümü için de çalışacağı ve numaralı güvenliğin (yani güvenli) olduğu gibi garanti edileceği durum böyle değil mi? Ön yüzde doğru değildir. gevşek sürümü, bir yapı tasarımcısı perspektifinden açıkça daha esnektir. İyi/kabul edilmiş bir cevap olduğu düşünüldüğünde, rehberlik, bir numaralı yapıdaki referansları kullanırken, her zaman'u onlara farklı yaşam süreleri verebilir.

Bu tavsiyenin sakıncası, ekstra yazmayı göz ardı ederek nelerdir? Örneğin, bir yapıda referansları gerektiren için bir fayda var mı?

Answer 1

hiç bir yapı içinde başvuruları gerektiren orada yarar aynı ömrünü

Evet var ve bu bir yapı olan ötesine geçer. yaşam süreleri birbirinden hep farklı olsaydı, o zaman bu fonksiyonu yazamadı:

struct EvenOrOdd<'a, 'b> { 
    even: &'a str, 
    odd: &'b str, 
} 

impl<'a, 'b> EvenOrOdd<'a, 'b> { 
    fn do_it(&self, i: u8) -> &str { 
     if i % 2 == 0 { 
      self.even 
     } else { 
      self.odd 
     } 
    } 
} 

Not Bu derler ederken:

fn foo<'a, 'b>(a: &'a str, b: &'b str) -> &str { // What lifetime to return? 
    if (global_random_number() == 42) { a } else { b } 
} 

yapı için uygulama, böyle bir şey olabilir , yapının kendisinin dışına çıkabilen bir dizgi döndürmez; bu, amaçlananın kendisi değil.

fn foo<'a, 'b>(a: &'a str, b: &'b str) { 
    let result = { 
     EvenOrOdd { even: a, odd: b }.do_it(42) 
    }; 

    println!("{}", result); 
} 

Bu birleşik ömürleri ile çalışacaktır:

:

struct EvenOrOdd<'a> { 
    even: &'a str, 
    odd: &'a str, 
} 

impl<'a> EvenOrOdd<'a> { 
    fn do_it(&self, i: u8) -> &'a str { 
     if i % 2 == 0 { self.even } else { self.odd } 
    } 
} 

Bu yorumu var bağlantılı cevabın karşısında olan bu kod çalışması gerekir rağmen başarısız

Eğer toplu bir değer alır ve onu

kullandıktan sonra bunun bir bölümünü atmak bölmek mümkün istiyorum

Bu durumda, bir toplam değer ve birleştirme bunları almak istiyoruz. Bu yararlı olsa da gerektiğinde, ben ağlama ve eğer patlak diş gıcırdatacaksınız düşünemiyorum

struct EvenOrOdd<'a, 'b: 'a> { 
    even: &'a str, 
    odd: &'b str, 
} 

impl<'a, 'b> EvenOrOdd<'a, 'b> { 
    fn do_it(&self, i: u8) -> &'a str { 
     if i % 2 == 0 { self.even } else { self.odd } 
    } 
} 

:

nadir durumlarda, sen ayrı ve birleşik yaşamlar arasında iğneye iplik gerekebilir her seferinde bu şekilde yazmak zorundaydık.

---

görmezden ekstra Etmezdim

yazarak.

foo<'a>(Bar<'a>) 

olması kesinlikle

foo<'a, 'b', 'c, 'd>(Bar<'a, 'b', 'c, 'd>) 

daha iyi

ekstra jenerik parametrelerden faydalanarak değildir.