संकेत

Question

मेरे प्राथमिकता कतार घोषित रूप के साथ एक C++ priority_queue के लिए विधि छँटाई लागू करना सीखें:

std::priority_queue<*MyClass> queue; 

class MyClass { 
    bool operator<(const MyClass* m) const; 
} 

कतार में आइटम छँटाई नहीं है।

क्या गलत है? मैं एक अलग (तुलना) कक्षा को लागू नहीं करना चाहता हूं।

उत्तर सारांश:, सूचक पतों हल कर रहे हैं

समस्या है। इससे बचने का एकमात्र तरीका एक वर्ग है जो 'पॉइंटर्स की तुलना करता है'।

अब लागू किया:

std::priority_queue<*MyClass, vector<*MyClass>, MyClass::CompStr > queue; 

class MyClass { 
    struct CompStr { 
     bool operator()(MyClass* m1, MyClass* m2); 
    } 
} 

Answer 1

que तुलना करें functor ptr_less की तुलना करें।

आप ptr_less एसटीडी पुस्तकालय के बाकी के साथ संगत होना करने के लिए (बाइंडरों, संगीतकारों, ...) चाहते हैं:

template<class T> 
struct ptr_less 
    : public binary_function<T, T, bool> { 
     bool operator()(const T& left, const T& right) const{ 
      return ((*left) <(*right)); 
     } 
}; 

std::priority_queue<MyClass*, vector<MyClass*>, ptr_less<MyClass*> > que; 

नहीं तो आप सरलीकृत संस्करण के साथ प्राप्त कर सकते हैं:

struct ptr_less { 
    template<class T> 
    bool operator()(const T& left, const T& right) const { 
     return ((*left) <(*right)); 
    } 
}; 

std::priority_queue<MyClass*, vector<MyClass*>, ptr_less > que; 

क्योंकि मैं इसे इस्तेमाल कभी नहीं किया है, लेकिन एक सीधी तरह करने के लिए

Answer 2

ऑपरेटर <() आप एक MyClass ऑब्जेक्ट के लिए एक सूचक के साथ एक MyClass वस्तु की तुलना करेंगे प्रदान की है। लेकिन आपकी कतार में केवल पॉइंटर्स हैं (मुझे लगता है)। आपको तुलनात्मक फ़ंक्शन की आवश्यकता है जो पैरामीटर के रूप में दो पॉइंटर्स लेता है।

यह सब कुछ अनुमानों पर आधारित है - कृपया कॉपी और पेस्ट का उपयोग करके अपना वास्तविक कोड पोस्ट करें।

Answer 3

चूंकि आपके priority_queue में केवल पॉइंटर मान हैं, तो यह पॉइंटर्स के लिए डिफ़ॉल्ट तुलना ऑपरेटर का उपयोग करेगा - इससे उन्हें पता द्वारा क्रमबद्ध किया जाएगा जो स्पष्ट रूप से आप नहीं चाहते हैं। यदि आप क्लास इंस्टेंस को मूल्य के अनुसार स्टोर करने के लिए priority_queue बदलते हैं, तो यह आपके द्वारा परिभाषित ऑपरेटर का उपयोग करेगा। या, आपको तुलनात्मक कार्य प्रदान करना होगा।

Answer 4

प्राथमिकता कतार सामग्री के बारे में सुनिश्चित नहीं हैं, तो आप ऐसा कर सकते हैं:

class A 
{ 
    friend struct ComparePtrToA; 
public: 
    A(int v=0):a(v){} 
private: 
    int a; 
}; 

struct ComparePtrToA 
{ 
    bool operator()(A* a1, A* a2) {return a1->a < a2->a;} 
}; 

#include <vector> 
#include <algorithm> 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    vector<A*> someAs; 
    someAs.push_back(new A(1)); 
    someAs.push_back(new A(3)); 
    someAs.push_back(new A(2)); 
    sort(someAs.begin(), someAs.end(), ComparePtrToA()); 
} 

मेमोरी लीक नोट करें, यह केवल एक उदाहरण है ...

आगे नोट: यह प्राथमिकता कतार का कार्यान्वयन नहीं है! वेक्टर बस मेरे पॉइंटर्स के माध्यम से दो ऑब्जेक्ट्स की तुलना करने के लिए बनाए गए मज़ेदार का उपयोग करने का एक उदाहरण है। हालांकि मुझे पता है कि प्राथमिकता कतार क्या है और मोटे तौर पर यह कैसे काम करती है, मैंने कभी भी एसटीएल सुविधाओं का उपयोग नहीं किया है जो उन्हें लागू करते हैं।

अपडेट: मुझे लगता है कि टिमडब्ल्यू कुछ मान्य अंक बनाता है। मुझे नहीं पता कि वह इतनी कम क्यों हो गया था। मुझे लगता है कि मेरा उत्तर इस प्रकार सुधार किया जा सकता:

class A 
{ 
public: 
    A(int v=0):a(v){} 
    bool operator<(const A& rhs) { return a < rhs.a; } 
private: 
    int a; 
}; 

struct ComparePtrToA 
{ 
    bool operator()(A* a1, A* a2) {return *a1 < *a2;} 
}; 

जो क्लीनर (खासकर यदि आप संकेत के बजाय मूल्यों की एक कंटेनर रखने पर विचार - कोई आगे काम करना आवश्यक हो जाता है)।