सी ++ छंटाई कक्षा सरणी

Question

सी ++ छंटाई सरणी कक्षा

मैं एक सरणी वस्तु है कि निम्नलिखित रिकॉर्ड ..

यह classone.h

ClassOne 
{ 
string name; 
int data; 
float valueData; 
} 

और निर्माता पर बनाए जाते हैं है classone.cpp

main.cpp पर मैंने आकार 10 का क्लासऑन ऐरे बनाया

#include "classone.h" 

ClassOne cone[10]; 

अगला मैं वस्तु

और अब ClassOne मिला करने के लिए कई मूल्य दर्ज की गई 3 वस्तुओं

cone[0] 
name = "hello" 
data = 1 
valueData = 20 

cone[1] 
name = "panda" 
data = 2 
valueData = 15 

cone[2] 
name = "joe" 
data = 3 
valueData = 25 

क्या मैं हासिल करना चाहते हैं एक तरह से है कि मानडेटा द्वारा इस सरणी पुनर्व्यवस्थित कर सकते हैं करना है उच्चतम आरोही प्रपत्र तो .. यह

तो cone[2]cone[0] तो 012,357 हो जाएगा..

लेकिन मुद्दा अगर मैं बुलबुला तरह उपयोग करते हैं, मैं गूगल की कोशिश की और कुछ, वे int a[]={9,6,5,23,2,6,2,7,1,8};

e.g द्वारा छँटाई कर रहे हैं, लेकिन मैं वर्ग सरणी वस्तु के आधार पर चुनना चाहते हैं। और मूल्य को एक साथ व्यवस्थित करें, मैं इसे कैसे प्राप्त करूं।

तो जब मैं अदालत में यह हो जाएगा

-- Highest to lowest -- 
1) Name: Joe , Data = 3, Value =25 
2) Name: Hello , Data =1 , Value = 20 
3) Name: Panda, Data = 2, Value = 15 

सभी मदद के लिए धन्यवाद और मार्गदर्शन !!

Answer 1

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

#include <algorithm> 

std::sort(cone, cone + 10, 
      [](ClassOne const & a, ClassOne const & b) -> bool 
      { return a.value < b.value; }); 

आप विश्व स्तर पर एक तुलना ऑपरेटर परिभाषित करने के लिए तैयार हैं, तो आप भी लैम्ब्डा की जरूरत नहीं है:

bool operator<(ClassOne const & a, ClassOne const & b) 
{ 
    return a.value < b.value; 
} 

std::sort(cone, cone + 10); 

या

Answer 2

सबसे आसान तरीका मानक पुस्तकालय का उपयोग करने के लिए है आप तुलनित्र को एक सदस्य समारोह बना सकते हैं। या आप तुलनित्र को एक कस्टम नाम दे सकते हैं और sort के तीसरे तर्क के रूप में पास कर सकते हैं। इस मामले में एक अच्छा विचार हो सकता है, जहां तुलना अपनी स्थिति के लिए विशिष्ट है और "प्राकृतिक" नहीं:

bool ValueCmp(ClassOne const & a, ClassOne const & b) 
{ 
    return a.value < b.value; 
} 

std::sort(cone, cone + 10, ValueCmp); 

पिछले संस्करण उपयोगी है जब आप सी ++ 11 का समर्थन (की जरूरत नहीं है lambdas के लिए, जैसा कि पहले मामले में), या यदि आप कई अलग-अलग स्थितियों में तुलनित्र का पुन: उपयोग करना चाहते हैं।

Answer 3

उपयोग std::sort और एक उपयुक्त प्रकार समारोह/functor:

bool comp(const ClassOne& lhs, const ClassOne& rhs) 
{ 
    return lhs.valueData < rhs.valueData; 
} 

std::sort(cone, cone+10, comp); 

या, सी ++ 11 में, अपने बुलबुला तरह स्रोत पर

std::sort(std::begin(cone), std::end(cone), comp); 

Answer 4

देखो। किसी बिंदु पर, यह एक int की तुलना किसी दूसरे से तुलना कर सकता है, शायद ऑपरेटर (<) से कम या ऑपरेटर (>) से अधिक। यही वह जगह है जहां सॉर्ट फ़ंक्शन उन दो वस्तुओं के सापेक्ष क्रम को निर्धारित करता है। उस तुलना को कई बार दोहराकर, सॉर्ट फ़ंक्शन संग्रह के कुल क्रम को निर्धारित करने में सक्षम होता है।

आपको उस ऑपरेशन को अपने तुलनात्मक कार्य के साथ प्रतिस्थापित करने की आवश्यकता है। एक ऐसा फ़ंक्शन जो आपकी कक्षा के दो ऑब्जेक्ट लेता है, और यदि सत्य को दूसरे से कम माना जाना चाहिए, तो गलत होगा यदि दूसरा को पहले से कम माना जाना चाहिए, और झूठी अगर उन्हें समकक्ष समझा जाना चाहिए।

Answer 5

आप operator < विधि लागू कर सकते हैं जो std::sort हेडर पुनरावृत्त वस्तुओं को सॉर्ट करने के लिए उपयोग करता है।

struct One { 
string name; 
int data; 
float valueData; 

bool operator < (const one &a) const{ 
return valueData <a.valueData; 
} 

}; 

तो तुम सब करने की है इस struct की एक सरणी बनाने के लिए और मेरे सवाल पर तरह समारोह