में समारोह की तुलना में कम बाध्य

Question

मैं संरचना

enum quality { good = 0, bad, uncertain }; 

    struct Value { 
     int time; 
     int value; 
     quality qual; 
    }; 

    class MyClass { 

public: 
    MyClass() { 
     InsertValues(); 
    } 

     void InsertValues(); 

     int GetLocationForTime(int time); 

private: 

    vector<Value> valueContainer; 
}; 

void MyClass::InsertValues() { 
    for(int num = 0; num < 5; num++) { 
     Value temp; 
     temp.time = num; 
     temp.value = num+1; 
     temp.qual = num % 2; 
     valueContainer.push_back(temp); 
    } 
} 


int MyClass::GetLocationForTime(int time) 
{ 

    // How to use lower bound here. 
    return 0; 
} 

ऊपर कोड मैं त्रुटियों संकलन के बहुत से फेंका गया है में निम्नलिखित है। मुझे लगता है कि मैं यहां गलत कर रहा हूं मैं एसटीएल प्रोग्रामिंग के लिए नया हूं और क्या आप कृपया मुझे सही कर सकते हैं त्रुटि कहां है? क्या ऐसा करने के लिए बेहतर है?

धन्यवाद!

class MyClass { 

और अपने शरीर अर्धविराम ; द्वारा पालन किया जाना चाहिए:

Answer 1

भविष्यवाणी को दो पैरामीटर लेने और बूल लौटने की आवश्यकता है।

चूंकि आपका फ़ंक्शन एक सदस्य फ़ंक्शन है, इसमें गलत हस्ताक्षर है।

इसके अतिरिक्त, आपको अपने मज़ेदार का उपयोग करके मूल्य से मूल्य, मूल्य से मूल्य, मूल्य से मूल्य और int int की तुलना करने में सक्षम होना पड़ सकता है।

struct CompareValueAndTime 
{ 
    bool operator()(const Value& v, int time) const 
    { 
     return v.time < time; 
    } 

    bool operator()(const Value& v1, const Value& v2) const 
    { 
     return v1.time < v2.time; 
    } 

    bool operator()(int time1, int time2) const 
    { 
     return time1 < time2; 
    } 

    bool operator()(int time, const Value& v) const 
    { 
     return time < v.time; 
    } 
}; 

यही नहीं बल्कि बोझिल है, तो चलो इसे कम करते हैं:

struct CompareValueAndTime 
{ 
    int asTime(const Value& v) const // or static 
    { 
     return v.time; 
    } 

    int asTime(int t) const // or static 
    { 
     return t; 
    } 

    template< typename T1, typename T2 > 
    bool operator()(T1 const& t1, T2 const& t2) const 
    { 
     return asTime(t1) < asTime(t2); 
    } 
}; 

तो:

std::lower_bound(valueContainer.begin(), valueContainer.end(), time, 
    CompareValueAndTime()); 

वहाँ अन्य त्रुटियों की एक जोड़ी भी हैं, जैसे कक्षा घोषणा के अंत में कोई अर्धविराम नहीं, साथ ही तथ्य यह है कि कक्षा के सदस्य डिफ़ॉल्ट रूप से निजी होते हैं जो इस मामले में आपकी पूरी कक्षा को निजी बनाता है। क्या आपने निर्माता से पहले public: याद किया था?

आपका फ़ंक्शन GetLocationForTime कोई मान नहीं देता है। आपको निम्न_बाउंड का परिणाम लेने और उससे शुरू() घटाएं। समारोह भी होना चाहिए।

यदि इस कॉल का इरादा यहां डालना है, तो इस तथ्य पर विचार करें कि वेक्टर के बीच में डालने वाला ओ ओ (एन) ऑपरेशन है और इसलिए वेक्टर यहां गलत संग्रह प्रकार हो सकता है।

ध्यान दें कि lower_bound एल्गोरिदम केवल पूर्व-क्रमबद्ध संग्रहों पर काम करता है। class - आप विभिन्न सदस्यों पर लगातार सहारा के बिना को देखने के लिए सक्षम होना चाहते हैं, तो आप संभवतः बढ़ावा के multi_index

Answer 2

class कीवर्ड और नहीं "वर्ग" है।
अन्य त्रुटियां हो सकती हैं, लेकिन आपको आगे की सहायता के लिए उन्हें प्रश्न में पेस्ट करना पड़ सकता है।

Answer 3

एक त्रुटि यह है कि आपके कोड में निम्न_बाउंड (compareValue) का चौथा तर्क सदस्य कार्य नहीं हो सकता है। यह एक मजेदार या एक मुफ्त समारोह हो सकता है। इसे एक फ्री फ़ंक्शन बनाना जो MyClass का मित्र है, आपके मामले में सबसे सरल लगता है। इसके अलावा आप रिटर्न कीवर्ड खो रहे हैं।

class MyClass { 
    MyClass() { InsertValues(); } 
    void InsertValues(); 
    int GetLocationForTime(int time); 
    friend bool compareValue(const Value& lhs, const Value& rhs) 
    { 
     return lhs.time < rhs.time; 
    } 

Answer 4

आप बस एक सामान्य फ़ंक्शन compareValue() बनाना चाहते हैं। जिस तरह से आपने इसे अभी लागू किया है, आपको MyClass के प्रकार की ऑब्जेक्ट की आवश्यकता है। जिस तरह से std::lower_bound() इसे कॉल करने का प्रयास करेगा, यह केवल दो तर्क, कोई अतिरिक्त वस्तु में गुजर जाएगा। यदि आप वास्तव में यह कार्य सदस्य बनना चाहते हैं, तो आप इसे static सदस्य बना सकते हैं।

उस ने कहा, सीधे कार्यों का उपयोग करने के लिए एक प्रदर्शन दंड है। आप एक inline समारोह कॉल ऑपरेटर के साथ तुलनित्र प्रकार के लिए चाहते हो सकता है:

struct MyClassComparator { 
    bool operator()(MyClass const& m0, MyClass const& m1) const { 
     return m0.time < m1.time; 
    } 
}; 

... और तुलनित्र के रूप में MyClassComparator() का उपयोग करें।

Answer 5

1. Class कीवर्ड का उपयोग कम c से शुरू करनी चाहिए, इन क्षेत्रों पर अनुक्रमणिका बनाने के लिए चाहते हैं।
2. struct Value बजाय गलत प्रकार qualtiyquality
3. मैं using namespace std देखें कि यह बिना एसटीएल प्रकार का उपयोग करने न है।
4. vector<value> - गलत प्रकार value के बजाय Value
5. आदि

आप यहाँ इस तरह के सरल त्रुटियों मुझे लगता है कि के साथ पोस्ट करने से पहले पहले यह जांच करने के लिए किया है। और यहां मुख्य समस्या यह है कि तुलना फ़ंक्शन कक्षा का सदस्य नहीं हो सकता है। इसे मुफ्त फ़ंक्शन के रूप में उपयोग करें:

bool compareValue(const Value lhs, const int time) { 
    return lhs.time < time ; 
}