मेरे पास एक Particle संरचना है जिस पर मैं गणना करता हूं:

struct Particle {
   Vector3 Pos;

   void UpdatePosition();
};

मेरे पास एक स्ट्रक्चर ParticleGroup भी है जिसमें दो Particle ऑब्जेक्ट हैं। UpdatePositions() को कॉल करते समय, दोनों कणों की स्थिति अपडेट की जाती है।

struct ParticleGroup {
    Particle *p1 = NULL;
    Particle *p2 = NULL;

    ParticleGroup(Particle &p1, Particle &p2);
    void UpdatePositions();
};

अब अगर मैं एक कण और एक कण समूह वस्तुओं को इस तरह बना देता हूं:

Particle p1;
Particle p2;
ParticleGroup pGroup(p1, p2);

और फिर Particle::UpdatePosition() विधि का उपयोग करके p1 की स्थिति को अपडेट करें, इसकी नई स्थिति pGroup में दिखाई देने वाली है। और इसके विपरीत अगर मैं Particle::UpdatePositions() विधि कहता हूं।

हालांकि अगर मैं Particle ऑब्जेक्ट्स की एक सरणी और ParticleGroup ऑब्जेक्ट्स की एक सरणी std::vector का उपयोग करके बना देता हूं:

vector<Particle>particles;
vector<ParticleGroup>pGroups;

अब प्रत्येक वेक्टर को Particle ऑब्जेक्ट की अपनी कॉपी मिलती है और एक वेक्टर में स्थिति को अपडेट करने से दूसरे में प्रतिबिंबित नहीं होगा।

क्या इन structs के सरणी बनाने का कोई तरीका है और अभी भी कण स्थिति में परिवर्तन परिलक्षित होता है?

c++
0
Lenny White 28 नवम्बर 2019, 17:16
1
मैं इसे इस तरह से करूंगा: प्रत्येक कण समूह में कण वेक्टर में startIdx और endIdx (uint) होता है। कण वेक्टर और समूहों को सिंक में रखने के लिए आपको कुछ अतिरिक्त काम करना होगा, लेकिन अद्यतन समय पर आप समूह कणों पर बहुत कुशलता से पुनरावृति कर सकते हैं।
 – 
One Man Monkey Squad
28 नवम्बर 2019, 17:30
यह स्पष्ट नहीं है कि आप ऐसा क्यों सोचेंगे कि वेक्टर में कणों में परिवर्तन उन कण समूहों में परिलक्षित नहीं होगा जो उन्हें इंगित करते हैं।
 – 
eerorika
28 नवम्बर 2019, 17:32
सूचकांक के साथ समाधान मेरे लिए बहुत अच्छा काम कर सकता है, धन्यवाद!
 – 
Lenny White
28 नवम्बर 2019, 17:39

3 जवाब

सबसे बढ़िया उत्तर

वेक्टर तत्वों के भंडारण को बढ़ने के साथ स्थानांतरित कर सकता है। इसलिए आप उनके लिए एक पॉइंटर स्टोर नहीं कर सकते क्योंकि वे अमान्य हो सकते हैं। यदि यह एक निश्चित आकार है, तो इसे पूर्व-आवंटित करके काम किया जा सकता है।

Shared_ptr के अलावा (जैसा कि पहले ही उल्लेख किया गया है, जो काम करता है लेकिन एक भारी समाधान है), कण के सूचकांक को संग्रहीत करने पर विचार करें - एक सूचक के लिए एक बढ़िया विकल्प, लेकिन हल करने के लिए वेक्टर तक पहुंच की आवश्यकता होती है। कुछ इस तरह:

struct ParticleGroup {
    int pIdx1 = -1;
    int pIdx2 = -1;

    ParticleGroup(int p1, int p2);
    void UpdatePositions(std::vector<Particle> const& particles) {
        if (pIdx1 != -1) {
            particles[pIdx1].updatePosition();
        }
        ...
    }
};

यह विचार देने के लिए पर्याप्त है, भले ही वास्तविक वेक्टर को बेहतर तरीके से अलग किया जा सकता है, सदस्य के रूप में संग्रहीत किया जा सकता है, आदि।

1
Chris Uzdavinis 28 नवम्बर 2019, 17:35

ज़रूर, आपके पास कुछ विकल्प हैं।

  1. यदि आपको इस बात का अग्रिम ज्ञान है कि आपको कितने कुल कणों की आवश्यकता होगी, तो आप वेक्टर के तार्किक आकार को बदले बिना उन कणों के लिए भंडारण को पूर्व-आवंटित करने के लिए vector::reserve का उपयोग कर सकते हैं। तब आपको कभी भी इस बारे में चिंता करने की आवश्यकता नहीं होगी कि जैसे-जैसे नए कण जुड़ते जाते हैं, Particle ऑब्जेक्ट मेमोरी में इधर-उधर हो जाते हैं।

  2. वैकल्पिक रूप से, अपने वेक्टर में सीधे Particle ऑब्जेक्ट स्टोर न करें। इसके बजाय, एक vector<shared_ptr<Particle>> या उस प्रभाव के लिए कुछ बनाएं, वेक्टर स्टोरिंग पॉइंटर्स के साथ Particles। अब, जब भी वेक्टर आकार बदलता है, मौजूदा Particle की स्मृति में स्थान नहीं बदलेगा।

उम्मीद है ये मदद करेगा!

2
templatetypedef 28 नवम्बर 2019, 17:23

वैक्टर में पॉइंट वाले ऑब्जेक्ट कहीं और पॉइंटर्स वाली ऑब्जेक्ट्स से अलग नहीं होते हैं। आपको यह तय करने की आवश्यकता है कि जब आप किसी ऑब्जेक्ट को पॉइंटर्स के साथ कॉपी करते हैं तो क्या होता है, और आपको यह तय करने की आवश्यकता होती है कि जब आप पॉइंट-टू-ऑब्जेक्ट्स की प्रतिलिपि बनाते हैं तो क्या होता है। और आप यह तय करना चाह सकते हैं कि किस प्रकार का सूचक या सूचक जैसी वस्तु सबसे अच्छा काम करती है (नियमित संकेत सबसे अच्छे प्रकार नहीं हो सकते हैं)।

आपके मामले में आप शायद कभी भी पॉइंट-टू ऑब्जेक्ट्स (कणों) की प्रतिलिपि नहीं बनाना चाहते हैं। आपके आवेदन के संदर्भ में इस तरह की नकल का कोई मतलब नहीं है। तो आप इसके बजाय कुछ प्रॉक्सी ऑब्जेक्ट्स को स्टोर और पास करना चाहते हैं। ऐसे प्रॉक्सी ऑब्जेक्ट कई रूप ले सकते हैं।

  1. स्मार्ट पॉइंटर्स (std::shared_ptr या समान)।
  2. नियमित संकेतक।
  3. कुछ वैश्विक सरणी में सूचकांक।
  4. कुछ वैश्विक कंटेनर में इटरेटर।

मैं कहूंगा कि ज्यादातर मामलों में पहला विकल्प सबसे अच्छा है इसलिए यह आपकी डिफ़ॉल्ट पसंद होनी चाहिए।

0
n. 'pronouns' m. 28 नवम्बर 2019, 17:41