जी ++ मेरे साधारण मज़ेदार को "अपेक्षित एक प्रकार, मिला 'xyz'"

Question

के साथ अस्वीकार करता है मैं सी ++ में फ़ैक्टर के साथ खेल रहा हूं। विशेष रूप से, मुझे जोड़ों का एक वेक्टर मिला है जो मैं जोड़ी के पहले तत्व द्वारा क्रमबद्ध करना चाहता हूं। मैंने एक पूरी तरह से विशेष मज़ेदार लिखना शुरू कर दिया (यानी कुछ "जैसे बूल माईलेशन (माईपैयर & एलएचएस, माईपैयर & आरएएस)")। फिर, सिर्फ इसलिए कि इस तरह की चीजें दिलचस्प है, मैं एक सामान्य "इस जोड़ी के पहले तत्वों में एफ लागू करें" मज़ेदार लिखने की कोशिश करना चाहता था। मैंने नीचे लिखा है, लेकिन जी ++ इसे पसंद नहीं करता है। मैं:

त्रुटि: 'टेम्पलेट struct Pair1stFunc2' त्रुटि के लिए टेम्पलेट पैरामीटर सूची में तर्क 2 में टाइप/मूल्य बेमेल: एक प्रकार की उम्मीद, 'कम'

#include <algorithm> 
#include <functional> 
#include <utility> 
#include <vector> 

template <class P, class F> 
struct Pair1stFunc2 
{ 
    typename F::result_type operator()(P &lhs, P &rhs) const 
    { return F(lhs.first, rhs.first); } 

    typename F::result_type operator()(const P &lhs, const P &rhs) const 
    { return F(lhs.first, rhs.first); } 
}; 

typedef std::pair<int,int> MyPair; 
typedef std::vector<MyPair> MyPairList; 

MyPairList pairs; 

void foo(void) 
{ 
    std::sort(pairs.begin(), 
       pairs.end(), 
       Pair1stFunc2<MyPair, std::less>()); 
} 

किसी को भी किसी भी प्रकाश पर डाला जा सकता है मिल गया मैं यहाँ क्या गलत कर रहा हूँ? मुझे पता है कि यह थोड़ा कृत्रिम उदाहरण है, लेकिन मैं जानना चाहता हूं कि क्या हो रहा है, अगर केवल मेरे एसटीएल-फू को बेहतर बनाने के लिए।

Answer 1

आपको तुलनात्मक प्रकार के साथ std :: कम करने की आवश्यकता है।

Pair1stFunc2<MyPair, std::less<int> >() 

चाल करेगा। अपने ऑपरेटर के भीतर() आपको तुलनात्मक प्रकार की ऑब्जेक्ट को तुरंत चालू करने की आवश्यकता होगी, क्योंकि आप सीधे कक्षा को कॉल नहीं कर सकते हैं। जैसे बदल

return F(lhs.first, rhs.first); 

F func; 
return func(lhs.first, rhs.first); 

को तुम भी functor में विशेषज्ञता के लिए कदम सकता है, के रूप में एक और उत्तर पता चलता है।

Answer 2

ध्यान दें कि std::less स्वयं एक टेम्पलेट है और जब आप इसे foo() फ़ंक्शन के sort से कॉल करते हैं तो आप टेम्पलेट टेम्पलेट पैरामीटर निर्दिष्ट नहीं करते हैं! यहां less एक अपूर्ण प्रकार है और इसलिए समस्या है।

Answer 3

dirkgently के जवाब पर विस्तार करने के लिए यहां काम हो सकता है क्या के रूप में आप चाहते हैं का एक उदाहरण है:

template <typename T, template <typename> class F> 
struct Pair1stFunc2 
{ 
    template <typename P> 
    typename F<T>::result_type operator()(P &lhs, P &rhs) const 
    { F<T> f; return f(lhs.first, rhs.first); } 

    template <typename P> 
    typename F<T>::result_type operator()(const P &lhs, const P &rhs) const 
    { F<T> f; return f(lhs.first, rhs.first); } 
}; 

void foo(void) 
{ 
    std::sort(pairs.begin(), 
       pairs.end(), 
       Pair1stFunc2<int, std::less>()); 
} 

ध्यान दें कि यह काम करता है, लेकिन यह वास्तव में क्या आप मन में था नहीं हो सकता है।

template<typename P, bool (*F)(P,P)> struct Pair1stFunc2 { ... } 

इस मामले में, दूसरा तर्क के रूप में एक समारोह टेम्पलेट गुजर अधिभार संकल्प का कारण होगा:

Answer 4

सरल समाधान के राज्य के लिए एक तर्क, एक उपयुक्त हस्ताक्षर के साथ एक समारोह के रूप में आप क्या चाहते हो जाएगा पी, पी के साथ तर्क प्रकार के रूप में किया। यह काम करता है क्योंकि आप में से अधिभार संकल्प ले जाने struct Pair1stFunc2::operator()

तुम भी एक functor में उत्तीर्ण होने की संभावना चाहते हैं, लेकिन उन एक टेम्पलेट प्रकार तर्क के रूप में पारित होने के लिए और उसके बाद ऑपरेटर() के अंदर बनाई गई की क्या ज़रूरत है:

typename F::result_type operator()(const P &lhs, const P &rhs) const 
{ return F()(lhs.first, rhs.first); } 

यहां, एफ मज़ेदार प्रकार और एफ() उस मज़ेदार का एक उदाहरण है।

तीसरा मामला पहले से ही पहले से ही कवर किया गया है, फ़ैक्टर टेम्पलेट। std :: कम ऐसा टेम्पलेट है। उस स्थिति में, आपको एक टेम्पलेट टेम्पलेट तर्क की आवश्यकता है।

Answer 5

अवांछित के समान। लेकिन आपको टेम्पलेट टेम्पलेट्स का उपयोग करने की आवश्यकता नहीं है।

#include <algorithm> 
#include <functional> 
#include <memory> 
#include <vector> 

typedef std::pair<int,int> MyPair; 
typedef std::vector<MyPair> MyPairList; 
MyPairList pairs; 


// Same as original. 
template <typename T,typename F> 
struct Pair1stFunc2 
{ 
    template <typename P> 
    typename F::result_type operator()(P &lhs, P &rhs) const 
    { F f; // Just need to create an anstance of the functor to use. 
     return f(lhs.first, rhs.first); } 

    template <typename P> 
    typename F::result_type operator()(const P &lhs, const P &rhs) const 
    { F f; // Just need to create an anstance of the functor to use. 
     return f(lhs.first, rhs.first); } 
}; 


void foo(void) 
{ 
    std::sort(pairs.begin(), 
       pairs.end(), 
       Pair1stFunc2<int, std::less<int> >()); // initialize the version of less 
}