दिलचस्प पोस्ट
जावा enum सदस्यों की तुलना: == या बराबर ()? कैसे ग्रिडव्यू में हैडर और उपशीर्षक जोड़ने के लिए डेटा विशेषता मान के आधार पर jquery सॉर्ट सूची <B> और <strong>, <i> और <em> के बीच अंतर क्या है? विस्तारित तरीकों को केवल गैर-नेस्टेड, गैर-सामान्य स्थैतिक वर्ग में क्यों स्वीकार्य है? विजेट से गतिविधि शुरू करना सख्त अलियासिंग नियम क्या है? सीरियल वीरियोनयूआईडी क्या है और मुझे इसका उपयोग क्यों करना चाहिए? कैसे <mvc: annotation-driven /> से छुटकारा पाने के लिए? बाहरी वीएस2013 बिल्ड त्रुटि "त्रुटि MSB4019: आयातित प्रोजेक्ट <पथ> नहीं मिला" किसी अन्य डोमेन के लिए कुकी कैसे सेट करें कैसे ठीक से बंद जावा निष्पादक सेवा टेक्स्टफील्ड में इनपुट दृश्य जोड़ने में त्रुटि आईओएस 8 मैं अपने एक्लिप्स प्रोजेक्ट में javax.servlet API को कैसे आयात कर सकता हूं? AppCompat-v7 21 के साथ एक्शनबार / टूलबार में आइकन दिखाएं

तुलनित्र के रूप में सदस्य समारोह का उपयोग कर समस्या छँटाई

निम्न कोड को संकलित करने की कोशिश कर रहा हूं, मैं इस संकलन त्रुटि को प्राप्त करता हूं, मैं क्या कर सकता हूं?


आईएसओ सी ++ सदस्य फंक्शन में एक सूचक बनाने के लिए एक अयोग्य या संरक्षित गैर-स्थैतिक सदस्य फ़ंक्शन का पता लेने से मना करता है।

class MyClass { int * arr; // other member variables MyClass() { arr = new int[someSize]; } doCompare( const int & i1, const int & i2 ) { // use some member variables } doSort() { std::sort(arr,arr+someSize, &doCompare); } }; 

वेब के समाधान से एकत्रित समाधान "तुलनित्र के रूप में सदस्य समारोह का उपयोग कर समस्या छँटाई"

doCompare static होना चाहिए यदि doCompare को MyClass से डेटा की आवश्यकता होती है तो आप doCompare MyClass को एक तुलनात्मक चिकित्सक बना सकते हैं:

 doCompare( const int & i1, const int & i2 ) { // use some member variables } 

में

 bool operator () ( const int & i1, const int & i2 ) { // use some member variables } 

और कॉलिंग:

 doSort() { std::sort(arr,arr+someSize, *this); } 

इसके अलावा, doSort एक वापसी मूल्य गायब नहीं है?

मुझे लगता है कि यह std::mem_fun का प्रयोग करना संभव है और सदस्य फ़ंक्शन को मुफ्त फ़ंक्शन में बदलने के लिए बाध्यकारी है, लेकिन इस समय सटीक सिंटैक्स मुझे बचाता है

संपादित करें: Doh, std::sort वैक्टर द्वारा मज़ेदार लेता है जो एक समस्या हो सकती है। चारों ओर पाने के लिए कक्षा के अंदर फैक्टर को लपेटें:

 class MyClass { struct Less { Less(const MyClass& c) : myClass(c) {} bool operator () ( const int & i1, const int & i2 ) {// use 'myClass'} MyClass& myClass; }; doSort() { std::sort(arr,arr+someSize, Less(*this)); } } 

जैसा एंड्रियास ब्रिनक कहते हैं, डू कंपैपरेर स्थिर होना चाहिए (+1) यदि आपके तुलनित्र समारोह में एक राज्य है (कक्षा के अन्य सदस्यों का उपयोग करते हुए) तो आप फ़ंक्शन की बजाय बेहतर मकसद का उपयोग करेंगे (और यह तेज़ हो जाएगा):

 class MyClass{ // ... struct doCompare { doCompare( const MyClass& info ) : m_info(info) { } // only if you really need the object state const MyClass& m_info; bool operator()( const int & i1, const int & i2 ) { // comparison code using m_info } }; doSort() { std::sort( arr, arr+someSize, doCompare(*this) ); } }; 

मजेदार चिकित्सक का प्रयोग हमेशा बेहतर होता है, बस टाइप करने के लिए लंबा (जो कि असुविधाजनक हो सकता है लेकिन ओह ठीक है …)

मुझे लगता है कि आप सदस्य कार्य के साथ std :: bind का उपयोग भी कर सकते हैं, लेकिन मुझे यकीन नहीं है कि वैसे भी और कैसे पढ़ना आसान नहीं होगा।

2014 का अद्यतन करें: आज हमारे पास सी ++ 11 कंपाइलर तक पहुंच है, ताकि आप लैम्ब्डा का उपयोग कर सकते हैं, कोड छोटा होगा, लेकिन सटीक समान शब्दार्थ होगा।

आप boost::bind उपयोग कर सकते boost::bind :

 void doSort() { std::sort(arr,arr+someSize, boost::bind(&MyClass::doCompare, this, _1, _2)); } 

रॉब द्वारा प्रस्तावित समाधान अब मान्य C ++ 11 (बूस्ट के लिए कोई आवश्यकता नहीं है):

 void doSort() { using namespace std::placeholders; std::sort(arr, arr+someSize, std::bind(&MyClass::doCompare, this, _1, _2)); } 

दरअसल, जैसा कि क्लेम से वर्णित है, लम्ब्दास एक विकल्प हैं, थोड़ा और अधिक शब्दबोध (आपको "दोहराएँ" कि तर्क तर्कसंगत हैं):

 void doSort() { using namespace std::placeholders; std::sort(arr, arr+someSize, [this](int l, int r) {return doCompare(l, r); }); } 

सी ++ 14 auto का समर्थन करता है यहां:

 void doSort() { using namespace std::placeholders; std::sort(arr, arr+someSize, [this](auto l, auto r) {return doCompare(l, r); }); } 

लेकिन फिर भी, आपने घोषित किया है कि प्रतिलिपियां प्रति के पास हैं

फिर सवाल यह है कि "जो सबसे ज्यादा कुशल है" उस सवाल का ट्रैविस गॉकेल द्वारा किया गया था: लम्बा बनाम बाँध । उनका बेंचमार्क प्रोग्राम मेरे कंप्यूटर पर देता है (ओएस एक्स आई 7)

  Clang 3.5 GCC 4.9 lambda 1001 7000 bind 3716166405 2530142000 bound lambda 2438421993 1700834000 boost bind 2925777511 2529615000 boost bound lambda 2420710412 1683458000 

जहां lambda एक लैम्ब्डा का इस्तेमाल होता है, और lambda bound एक std::function में संग्रहीत std::function

इसलिए ऐसा प्रतीत होता है कि लम्ब्दास एक बेहतर विकल्प है, जो बहुत अधिक आश्चर्यचकित नहीं है क्योंकि संकलक उच्च स्तर की जानकारी प्रदान करता है जिससे वह लाभ कमा सकता है।

आप जो चाहें करने का एक तरीका है, लेकिन आपको एक छोटा एडाप्टर का उपयोग करने की आवश्यकता है जैसा कि एसटीएल आपके लिए नहीं लिखता है, इसे खुद लिख सकते हैं:

 template <class Base, class T> struct adaptor_t { typedef bool (Base::*method_t)(const T& t1, const T& t2)); adaptor_t(Base* b, method_t m) : base(b), method(m) {} adaptor_t(const adaptor_t& copy) : base(copy.base), method(copy.method) {} bool operator()(const T& t1, const T& t2) const { return (base->*method)(t1, t2); } Base *base; method_t method; } template <class Base, class T> adaptor_t<Base,T> adapt_method(Base* b, typename adaptor_t<Base,T>::method_t m) { return adaptor_t<Base,T>(b,m); } 

उसके बाद, आप इसका उपयोग कर सकते हैं:

 doSort() { std::sort(arr,arr+someSize, adapt_method(this, &doCompare)); } 

एक सदस्य का फ़ंक्शन प्रभावी ढंग से उपयोग करने का एक सरल तरीका है ऑपरेटर <का उपयोग करना। यही है, यदि आपके पास तुलना की गई एक फ़ंक्शन है, तो आप उसे ऑपरेटर से <कॉल कर सकते हैं < यहां एक उदाहरण है:

 class Qaz { public: Qaz(int aX): x(aX) { } bool operator<(const Qaz& aOther) const { return compare(*this,aOther); } static bool compare(const Qaz& aP,const Qaz& aQ) { return aP.x < aQ.x; } int x; }; 

तब आपको स्टडी :: सॉर्ट करने के लिए फ़ंक्शन का नाम भी देने की आवश्यकता नहीं है:

 std::vector<Qaz> q; q.emplace_back(8); q.emplace_back(1); q.emplace_back(4); q.emplace_back(7); q.emplace_back(6); q.emplace_back(0); q.emplace_back(3); std::sort(q.begin(),q.end()); 

ग्राहम आशेर को अपडेट करना, जैसा कि आपको तुलना की आवश्यकता नहीं है, लेकिन कम ऑपरेटर को सीधे उपयोग कर सकते हैं।

 #include <iostream> #include <vector> #include <algorithm> using namespace std; class Qaz { public: Qaz(int aX): x(aX) { } bool operator<(const Qaz& aOther) const { return x < aOther.x; } int x; }; int main() { std::vector<Qaz> q; q.emplace_back(8); q.emplace_back(1); q.emplace_back(4); q.emplace_back(7); q.emplace_back(6); q.emplace_back(0); q.emplace_back(3); std::sort(q.begin(),q.end()); for (auto& num : q) std::cout << num.x << "\n"; char c; std::cin >> c; return 0; }