एक कस्टम तुलनित्र के साथ c ++ में प्रायोरिटी_क्व्यू घोषित करना

Question 1

मैं तुलनित्र फ़ंक्शन (जो नोड वर्ग के बाहर है) priority_queue of nodesका उपयोग करके, एक घोषित करने की कोशिश कर रहा हूं bool Compare(Node a, Node b)।

वर्तमान में मेरे पास क्या है:

priority_queue<Node, vector<Node>, Compare> openSet;

किसी कारण से, मुझे मिल रहा है Error: "Compare" is not a type name

के लिए घोषणा को बदलना priority_queue <Node, vector<Node>, bool Compare>

मुझे देता है Error: expected a '>'

मैंने भी कोशिश की है:

priority_queue<Node, vector<Node>, Compare()> openSet;
priority_queue<Node, vector<Node>, bool Compare()> openSet;
priority_queue<Node, vector<Node>, Compare<Node, Node>> openSet;

मुझे अपनी घोषणा सही ढंग से कैसे करनी चाहिए priority_queue?

Question 2

आपको एक वर्ग घोषित करना चाहिए Compareऔर operator()इस तरह से इसके लिए अधिभार देना चाहिए :

class Foo
{

};

class Compare
{
public:
    bool operator() (Foo, Foo)
    {
        return true;
    }
};

int main()
{
    std::priority_queue<Foo, std::vector<Foo>, Compare> pq;
    return 0;
}

या, यदि आप कुछ कारणों से इसे कक्षा के रूप में नहीं बना सकते हैं, तो आप इसके लिए उपयोग कर सकते हैं std::function:

class Foo
{

};

bool Compare(Foo, Foo)
{
    return true;
}

int main()
{
    std::priority_queue<Foo, std::vector<Foo>, std::function<bool(Foo, Foo)>> pq(Compare);
    return 0;
}

Question 3

स्वीकृत उत्तर आपको विश्वास दिलाता है कि आपको एक वर्ग या एक std::functionतुलनित्र का उपयोग करना चाहिए । यह सच नहीं है! जैसा कि क्यूट_प्रेट का उत्तर दिखाता है, आप कंस्ट्रक्टर को फ़ंक्शन पॉइंटर पास कर सकते हैं। हालाँकि, ऐसा करने के लिए सिंटैक्स वहाँ दिखाए गए की तुलना में बहुत सरल है:

class Node;
bool Compare(Node a, Node b);

std::priority_queue<Node, std::vector<Node>, decltype(&Compare)> openSet(Compare);

यही है, फ़ंक्शन के प्रकार को स्पष्ट रूप से एन्कोड करने की कोई आवश्यकता नहीं है, आप कंपाइलर का उपयोग करने के लिए कर सकते हैं decltype।

यह बहुत उपयोगी है अगर तुलनित्र एक लैम्ब्डा है। आप किसी अन्य तरीके से लैम्बडा के प्रकार को निर्दिष्ट नहीं कर सकते हैं decltype। उदाहरण के लिए:

auto compare = [](Node a, Node b) { return a.foo < b.foo; }
std::priority_queue<Node, std::vector<Node>, decltype(compare)> openSet(compare);

Question 4

तीसरा टेम्प्लेट पैरामीटर एक ऐसा वर्ग होना चाहिए जिसने operator()(Node,Node)ओवरलोड किया हो। तो आपको इस तरह से एक क्लास बनाना होगा:

class ComparisonClass {
    bool operator() (Node, Node) {
        //comparison code here
    }
};

और फिर आप इस वर्ग को इस तरह तीसरे टेम्पलेट पैरामीटर के रूप में उपयोग करेंगे:

priority_queue<Node, vector<Node>, ComparisonClass> q;

Question 5

सीधे अपने प्रश्न का उत्तर देना:

मैं एक priority_queueनोड की घोषणा करने की कोशिश कर रहा हूँ , का उपयोग करते हुएbool Compare(Node a, Node b) as the comparator function

वर्तमान में मेरे पास क्या है:
priority_queue<Node, vector<Node>, Compare> openSet;
किसी कारण से, मुझे त्रुटि मिल रही है:
"Compare" is not a type name

संकलक आपको बता रहा है कि वास्तव में क्या गलत है: Compareएक प्रकार का नाम नहीं है, लेकिन एक फ़ंक्शन का एक उदाहरण जो दो लेता है Nodesऔर एक रिटर्न देता है bool।
फ़ंक्शन पॉइंटर प्रकार निर्दिष्ट करने के लिए आपको क्या चाहिए:
std::priority_queue<Node, std::vector<Node>, bool (*)(Node, Node)> openSet(Compare)

Question 6

एक लाम्बा फ़ंक्शन का उपयोग भी कर सकता है।

auto Compare = [](Node &a, Node &b) { //compare };
std::priority_queue<Node, std::vector<Node>, decltype(Compare)> openset(Compare);

Question 7

आपको पहले तुलना को परिभाषित करना होगा। ऐसा करने के 3 तरीके हैं:

वर्ग का उपयोग करें
संरचना का उपयोग करें (जो वर्ग के समान है)
लैम्ब्डा फ़ंक्शन का उपयोग करें।

कक्षा / संरचना का उपयोग करना आसान है क्योंकि घोषित करने के लिए आसान है बस अपने निष्पादन कोड के ऊपर कोड की इस पंक्ति को लिखें

struct compare{
  public:
  bool operator()(Node& a,Node& b) // overloading both operators 
  {
      return a.w < b.w: // if you want increasing order;(i.e increasing for minPQ)
      return a.w > b.w // if you want reverse of default order;(i.e decreasing for minPQ)
   }
};

कॉलिंग कोड:

priority_queue<Node,vector<Node>,compare> pq;

Question 8

मामले में यह किसी को भी मदद करता है:

static bool myFunction(Node& p1, Node& p2) {}
priority_queue <Node, vector<Node>, function<bool(Node&, Node&)>> pq1(myFunction);

Question 9

संरचना पसंद करते हैं, और यह क्या std :: अधिक से अधिक है

struct Compare {
  bool operator()(Node const&, Node &) {}
}