मैं एक वेक्टर के लिए एक विशेषता वस्तु में कैसे गुजरता हूं जिसमें वेक्टर के वेक्टर में एक समान प्रकार भी होगा?

Question

यह संक्षेप में समझाने के लिए कठिन है। लेकिन मैं जो चाहता हूं वह एक ऐसी संरचना है जिसमें Vec "A" का एक क्षेत्र होता है जिसमें Vec "A" के अंदर एक और Vec "B" के साथ धागे का एक वेक्टर होता है। Vec "A" Vec "B" और थ्रेड हैंडल दोनों रखता है। वीईसी "बी" में एक समान प्रकार होता है, जिसमें विशेषता वस्तुओं की कोई आवश्यकता नहीं होती है, लेकिन वीईसी "ए" विशेषता वस्तुओं का उपयोग करके वीईसी "बी" के कई अलग-अलग प्रकार रखता है। मूल रूप से मैं Vec "B" के लिए विशेषता वस्तुओं का उपयोग नहीं करना चाहता, लेकिन Vec "A" के लिए विशेषता वस्तुओं का उपयोग करता हूं।

मैंने उपरोक्त को लागू करने की कोशिश की, लेकिन यह हमेशा सही और त्रुटियों को महसूस नहीं करता है। क्या इसका कोई वास्तविक क्रियान्वयन है या इसका कोई प्रत्यक्ष समाधान है?

मैंने इसे खोजने की कोशिश की, लेकिन मुझे ऐसा लगता है कि मैं इसे संक्षिप्त रूप से Google पर एक छोटा पैराग्राफ लिखे बिना नहीं लिख सकता।

यहाँ (छद्म-) कोड है जो मुझे लगता है कि यह होना चाहिए:

trait Tag {}

impl Tag for u32 {}
impl Tag for i64 {}


// Vec "B"
type InnerVec<T: Tag> = Vec<T>;

struct ThreadPool {
    // Vec "A"
    threads: Vec<(JoinHandle<()>, InnerVec<dyn Tag>)>,
}

Answer 1

इसलिए सबसे पहले, एक प्रकार का उपनाम नया प्रकार नहीं है। इसका एक प्रकार और लंबे प्रकार के नामों के साथ मदद करने के लिए एक प्रतिस्थापित प्रणाली की तरह है (Ex:) type Foo<T> = FooSys<T, Vec<T>, u32>;। मुझे संदेह है कि यह कभी भी आपको अतिरिक्त प्रकार की बाधाओं को जोड़ने की अनुमति देगा।

आपके मुद्दे के लिए, आपके छद्म कोड की सबसे प्रत्यक्ष कार्य व्याख्या में जीवनकाल जोड़ा जाएगा ThreadPool।

trait Tag {}

impl Tag for u32 {}
impl Tag for i64 {}


struct ThreadPool<'a> {
    threads: Vec<(JoinHandle<()>, Vec<Box<dyn Tag + 'a>>)>,
}

हालाँकि मैं आपको वास्तव में जानना चाहता हूं कि एक गतिशील Vec को गैर-गतिशील वस्तुओं से कैसे संग्रहीत किया जाए। ऐसा करने के लिए आप इसका उपयोग कर सकते हैं Anyऔर इसे अपनी इच्छानुसार टाइप कर सकते हैं। आप डॉक्स में इसके बारे में अधिक जानकारी पा सकते हैं ।

use std::any::Any;

struct ThreadPool {
    threads: Vec<(JoinHandle<()>, Box<dyn Any>)>,
}

impl ThreadPool {
    pub fn get_tags<T: 'static>(&self, index: usize) -> Option<&Vec<T>> {
        let (_, ref boxed) = self.threads[index];
        boxed.downcast_ref()
    }
}