std :: कतार पुनरावृत्ति

Question

मुझे std::queue से अधिक पुनरावृत्त करने की आवश्यकता है। www.cplusplus.com का कहना है:

डिफ़ॉल्ट रूप से, यदि कोई कंटेनर वर्ग एक विशेष कतार वर्ग के लिए निर्दिष्ट किया जाता है, मानक कंटेनर वर्ग टेम्पलेट Deque प्रयोग किया जाता है।

तो क्या मैं किसी भी तरह से कतार के अंतर्निहित डेक पर जा सकता हूं और इसे फिर से कर सकता हूं?

Answer 1

यदि आपको queue पर फिर से शुरू करने की आवश्यकता है तो आपको कतार से कुछ और चाहिए। मानक कंटेनर एडाप्टर का बिंदु न्यूनतम इंटरफ़ेस प्रदान करना है। यदि आपको पुनरावृत्ति करने की भी आवश्यकता है, तो क्यों न केवल डेक (या सूची) का उपयोग करें?

Answer 2

संक्षेप में: नहीं

वहाँ एक हैक, underlaid कंटेनर के रूप में वेक्टर उपयोग करते हैं, तो queue::front वैध संदर्भ वापस आ जाएगी, यह परिवर्तित जब तक < = queue::back

Answer 3

एक पुनरावृति सूचक को आप पुनरावृति करने की आवश्यकता है है एक कतार ... कतार आपको आवश्यक कंटेनर नहीं है।
आपने कतार क्यों ली?
आप एक कंटेनर क्यों नहीं लेते जिसे आप फिर से कर सकते हैं?

---

1. यदि आप एक कतार तो लेने आप कहते हैं कि आप एक 'कतार' इंटरफेस में एक कंटेनर रैप करने के लिए करना चाहते हैं: - सामने - वापस - धक्का - पॉप - ...

यदि आप पुन: प्रयास करना चाहते हैं, तो कतार में एक गलत इंटरफ़ेस है। एक कतार एक एडाप्टर है कि मूल कंटेनर की एक सीमित सबसेट प्रदान करता है

2. एक कतार की परिभाषा एक फीफो और परिभाषा के द्वारा एक फीफो iterable

Answer 4

जब मैं अन्य लोगों के साथ सहमत नहीं है कि एक के प्रत्यक्ष उपयोग इटेरेबल कंटेनर एक पसंदीदा समाधान है, मैं यह इंगित करना चाहता हूं कि सी ++ मानक किसी भी कारण से आप इसे चाहे किसी भी तरह के समाधान के लिए पर्याप्त समर्थन की गारंटी देता है।

अर्थात्, आप std::queue से विरासत और अंतर्निहित कंटेनर के शुरू() और अंत तक पहुँचने के लिए() अपने संरक्षित सदस्य Container c; उपयोग कर सकते हैं (बशर्ते कि इस तरह के तरीकों वहाँ मौजूद हैं)। यहाँ एक उदाहरण है कि VS 2010 और tested with ideone में काम करता है:

#include <queue> 
#include <deque> 
#include <iostream> 

template<typename T, typename Container=std::deque<T> > 
class iterable_queue : public std::queue<T,Container> 
{ 
public: 
    typedef typename Container::iterator iterator; 
    typedef typename Container::const_iterator const_iterator; 

    iterator begin() { return this->c.begin(); } 
    iterator end() { return this->c.end(); } 
    const_iterator begin() const { return this->c.begin(); } 
    const_iterator end() const { return this->c.end(); } 
}; 

int main() { 
    iterable_queue<int> int_queue; 
    for(int i=0; i<10; ++i) 
     int_queue.push(i); 
    for(auto it=int_queue.begin(); it!=int_queue.end();++it) 
     std::cout << *it << "\n"; 
    return 0; 
} 

Answer 5

std::queue एक कंटेनर एडाप्टर है, और आप कंटेनर इस्तेमाल किया (यह चूक एक deque उपयोग करने के लिए) निर्दिष्ट कर सकते हैं। यदि आपको एडाप्टर में उससे परे कार्यक्षमता की आवश्यकता है तो बस deque या किसी अन्य कंटेनर का उपयोग करें।

Answer 6

क्यों न केवल उस कतार की एक प्रति बनाएं जिसे आप फिर से चालू करना चाहते हैं, और एक समय में आइटम को हटाएं, उन्हें प्रिंट करते समय प्रिंट करें? यदि आप तत्वों के साथ जितना अधिक करना चाहते हैं, तो एक कतार गलत डेटा संरचना है।

Answer 7

https://stackoverflow.com/a/471461/383779 पर छवि देखें और फिर यह तय करें कि कौन सी कंटेनर आपकी आवश्यकताओं के अनुरूप सर्वोत्तम है।

Answer 8

आप मूल कतार को अस्थायी कतार में सहेज सकते हैं।तो फिर तुम बस अपने सामान्य पॉप अस्थायी कतार पर, मूल एक के माध्यम से जाने के लिए उदाहरण के लिए कार्य करें: अंत में

queue tmp_q = original_q; //copy the original queue to the temporary queue 

while (!tmp_q.empty()) 
{ 
    q_element = tmp_q.top(); 
    std::cout << q_element <<"\n"; 
    tmp_q.pop(); 
} 

, tmp_q खाली हो जाएगा लेकिन मूल कतार अछूता है।