इन छोरों

Question

के लिए नेस्ट सुधार करने के लिए कैसे मैं निम्नलिखित कोड है:

// vector of elements 
vector<Graphic> graphics; 

// vector of indexes of the selected graphic elements 
vector<int> selected_indexes; 

// vector according to which the graphic elements have to be "sorted" and parsed 
vector<short> order; 

for (auto o : order) 
{ 
    for (auto i : selected_indexes) 
    { 
     const auto& g = graphics[i]; 

     if (g.position() == o) 
     { 
      // parse g 
     } 
    } 
} 

मैं कस्टम तत्वों के साथ ही तत्वों को पार्स किया जा सकता चयनित किया गया है की अनुक्रमणिका का एक वेक्टर है, लेकिन में आदेश जिन्हें इन तत्वों को पार्स किया जाना है, उनके तीसरे वेक्टर के अनुसार उनके position() मान पर निर्भर करता है।

क्या इन नेस्टेड लूपों को बेहतर बनाने का कोई तरीका है, उन तत्वों पर पुनरावृत्त होने से बचने के लिए जो कि छोड़ा जाएगा क्योंकि उनकी स्थिति वर्तमान क्रम के बराबर नहीं है?

Answer 1

वहाँ एक दिया position() के साथ केवल एक Graphic वस्तु मान लिया जाये:

एक unordered_map बिल्ड: int → Graphics*, जिसे आप कॉल उदा gp, ताकि gp[i]->position() = i।

नक्शा बनाना रैखिक समय है, प्रत्येक सूचकांक के लिए इसका उपयोग निरंतर समय है, लगभग। int → vector<Graphic*>, तो

for(auto o : order) 
{ 
    for(auto const p : gp[o]) 
    { 
     auto const& g = *p; 
     // parse g 
    } 
} 

की तरह उपयोग कोड या, पिछले मामले के लिए आप के साथ उपयोग कर सकते हैं:

for(auto o : order) 
{ 
    auto const& g = *gp[o]; 
    // parse g 
} 

दी गई स्थिति के साथ एक से अधिक Graphics वस्तु नहीं हो सकता है, तो एक unordered_map निर्माण एक unordered_multimap।

Answer 2

आप पहले से ही कितने तत्वों आप कार्रवाई करने के लिए चाहते हैं पता है, तो आप एक वेक्टर है कि आपके Graphic उदाहरणों, पहले से ही तत्वों की उचित संख्या के साथ आवंटित करने के लिए संकेत रहता है का उपयोग कर सकते हैं:

vector<Graphic*> selected(selected_indexes.size(), nullptr); 

तो फिर तुम इस भर सकते हैं इसके बजाय इन आप एक अस्थायी वेक्टर बना सकते हैं और कदम से इस कदम कर सकता घोंसला बनाने की

for (auto index: selected_indexes) { 
    auto where = std::find_if(order.begin(), order.end(), [&graphics, index] (short i) { return i == graphics[index].position(); }); 
    selected[*where] = &graphics[index]; 
} 

Answer 3

: तत्वों के साथ वेक्टर, order का प्रयोग कर।

vector<Graphic> selectedGraphics; //maybe use ptr here 
selectedGraphics.reserve(selected_indexes.size()); 
for(auto i : selected_indexes) 
    selectedGraphics.push_back(graphics[i]); 

//then sort according to your order 
std::sort(selectedGraphics.begin(),selectedGraphics.end(),[order](auto left, auto right) 
{ 
    //the iterator of the position of "left" is further in front of the position of "right" 
    return order.find(left.position()) < order.find(right.position()); 
}); 

//then process 
for(auto graphic : selectedGraphics) 
    //do whatever 

तरह मान लिया गया है, कि order वेक्टर प्रविष्टियों और लोगों को जो selectedGraphics मैच कर रहे हैं। मुझे यकीन नहीं है कि क्या कोई अजीब दुष्प्रभाव होगा यदि किसी चयनित ग्राफ़िक ऑब्जेक्ट में ऐसी स्थिति है जो order वेक्टर में नहीं है।