💆🏽 ✅ 👝 एक टेम्पलेट पैरामीटर के साथ सहयोगी एसटीएल कंटेनरों का एकीकरण

कोड पर विचार करें:

std::multiset<int> set0, set1; for (auto it = set0.begin(); it != set0.end(); ++it) { //  //  // *it } for (auto it = set1.rbegin(); it != set1.rend(); ++it) { //  //  // *it }

चक्रों के निकायों में प्रसंस्करण समान है, दूसरे शब्दों में, दो मल्टीसेट के तत्वों को एक ही तरीके से संसाधित करना आवश्यक है: सीधे क्रम में पहला, विपरीत में दूसरा।

कार्य इन दो चक्रों को लगभग निम्नलिखित तरीके से संयोजित करना है:

 size_t const N = 2; std::multiset<int> sets[N] = {/*  ? */}; for (size_t i = 0; i < N; ++i) { for (auto const& val: sets[i]) { //  //  // val } }

यह स्पष्ट है कि सेट 1 प्रसंस्करण चक्र के लिए तत्वों को रिवर्स ऑर्डर में क्रमबद्ध किया जाता है, और सेट क्रम में [1] प्रसंस्करण क्रम को संरक्षित करने के लिए यह आवश्यक है कि सेट [1] सेट 1 के संबंध में तत्वों को विपरीत क्रम में संग्रहीत करें। एसटीएल सहयोगी कंटेनरों में, एक टेम्पलेट पैरामीटर प्रदान किया जाता है - एक तुलनित्र, डिफ़ॉल्ट मान std :: कम है। तो पहले सन्निकटन में, कोड काम करने के लिए, आपको लगभग इस प्रकार सेट को इनिशियलाइज़ करने की आवश्यकता है:

 std::multiset<int> sets[N] = {std::multiset<int, std::less>(), std::multiset<int, std::greater>()};

Std :: multiset <int, std :: less> और std :: multiset <int, std :: बड़ा> वर्ग अलग-अलग हैं और एक सामान्य पूर्वज नहीं हैं, इसलिए उन्हें एक ही सरणी में संग्रहीत नहीं किया जा सकता है और कोड को केवल संकलित नहीं किया जा सकता है। (वैसे, iterators std :: multiset :: const_iterator और std :: multiset :: const_reverse_iterator भी एक सामान्य पूर्वज के बिना अलग-अलग वर्ग हैं, इसलिए समस्या को पुनरावृत्तियों की एक सरणी के साथ हल नहीं किया जा सकता है)। कार्य एक सामान्य सरणी में संग्रहीत करने के लिए कंटेनरों के एकीकरण को उबालता है।

एसटीएल सहयोगी कंटेनरों में, तुलनित्र न केवल प्रकार का, बल्कि प्रत्येक कंटेनर उदाहरण का एक पैरामीटर है। तुच्छ मामलों के लिए, जैसे std :: डिफ़ॉल्ट रूप से कम, तुलनित्र वर्ग में कोई डेटा नहीं होता है और इसलिए, सभी कंटेनर एक ही तुलना ऑपरेशन करते हैं, विशेष रूप से, वे एक ही क्रम में तत्वों को संग्रहीत करते हैं। अधिक जटिल मामले के लिए, आप तुलनित्र में डेटा स्टोर कर सकते हैं, उदाहरण के लिए, सॉर्ट क्रम के बारे में। इस मामले में, एक ही वर्ग के कंटेनरों के अलग-अलग उदाहरणों को तुलनित्र उदाहरण में फ़ील्ड के मूल्य के आधार पर अलग-अलग आइटम सॉर्ट करेंगे, जो बदले में कंटेनर इंस्टेंस का क्षेत्र है। तो, एक तुलनित्र वर्ग जो आपको विभिन्न तरीकों से तुलना करने की अनुमति देता है:

 template <typename T> class Comparator { public: bool operator()(const T& l, const T& r) const { return ASC == order_ ? (l < r) : (l > r); } static Comparator const& Asc() { return asc_; } static Comparator const& Desc() { return desc_; } private: enum Order_ {ASC, DESC} const order_; Comparator(Order_ order) : order_(order) {}; static Comparator asc_; static Comparator desc_; }; template<typename T> Comparator<T> Comparator<T>::asc_(Comparator<T>::ASC); template<typename T> Comparator<T> Comparator<T>::desc_(Comparator<T>::DESC);

वास्तव में, प्रत्येक प्रकार के टी तत्व के लिए इस वर्ग के केवल 2 उदाहरणों की आवश्यकता होती है, इसलिए इन 2 उदाहरणों को सांख्यिकीय रूप से बनाया जाता है, और तुलनित्र वर्ग का इंटरफ़ेस ऐसा होता है कि इन दोनों के अलावा कोई भी उदाहरण प्राप्त नहीं किया जा सकता (प्रतिलिपि की गिनती नहीं)।

इसलिए, इस प्रकार सेट को इनिशियलाइज़ करें:

 typedef std::multiset<int, Comparator<int> > Set; Set sets[N] = { Set(Comparator<int>::Asc()), Set(Comparator<int>::Desc()) };

इस प्रकार, सहयोगी कंटेनरों के सही आरंभीकरण के लिए एक व्यावहारिक समाधान को कम कर दिया गया है।

दिलचस्प बात यह है कि चूंकि तुलनात्मक उदाहरण कंटेनर में मूल्य द्वारा संग्रहीत किया जाता है, और सूचक या संदर्भ द्वारा नहीं, समाधान मौलिक रूप से बहुरूपी नहीं है। हालांकि, कोई भी गतिशील बहुरूपता के समान एक समाधान का प्रस्ताव कर सकता है, जो एक अप्रत्यक्ष फ़ंक्शन कॉल पर आधारित है। कार्यों पर विचार करें:

 template<typename T> bool compareLess(const T& l, const T& r) { return l < r; } template<typename T> bool compareGreater(const T& l, const T& r) { return l > r; }

उनके पास एक ही हस्ताक्षर है, इसलिए, एक ही प्रकार, जो एक सहयोगी कंटेनर में एक तुलनित्र का प्रकार हो सकता है। समाधान निम्नलिखित सरणी आरंभीकरण के लिए नीचे आता है:

 typedef bool (*compareFn)(int const&, int const&); typedef std::multiset<int, compareFn> Set2; Set2 sets2[N] = { Set2(compareLess<int>), Set2(compareGreater<int>) };

UPD: एसटीडी का उपयोग करने के विचार के लिए धन्यवाद :: फ़ंक्शन, 4 और दो विकल्पों में जोड़े गए:
विकल्प 3: लाइबाडा कार्य
विकल्प 4: std :: std में लिपटे कम :: फ़ंक्शन, रिवर्स छँटाई के लिए, std के मापदंड :: कम std के साथ पुन: व्यवस्थित किए जाते हैं :: बाँध
विकल्प 5: एसटीडी :: कम और एसटीडी :: एसटीडी में अधिक लिपटे :: फ़ंक्शन
विकल्प 6: विकल्प 2 और 3 को जोड़ती है: std :: function cast to a function pointer

मैं एक संपूर्ण उदाहरण देता हूं जो सभी समाधानों के प्रदर्शन को प्रदर्शित करता है (प्रसंस्करण मल्टीसैट उनके तत्वों के उत्पादन में कम हो जाता है, जो सही क्रम क्रम को प्रदर्शित करता है):

 #include <iostream> #include <set> #include <functional> using namespace std::placeholders; template <typename T> class Comparator { public: bool operator()(const T& l, const T& r) const { return ASC == order_ ? (l < r) : (l > r); } static Comparator const& Asc() { return asc_; } static Comparator const& Desc() { return desc_; } private: enum Order_ {ASC, DESC} const order_; Comparator(Order_ order) : order_(order) {}; static Comparator asc_; static Comparator desc_; }; template<typename T> Comparator<T> Comparator<T>::asc_(Comparator<T>::ASC); template<typename T> Comparator<T> Comparator<T>::desc_(Comparator<T>::DESC); template<typename T> bool compareLess(const T& l, const T& r) { return l < r; } template<typename T> bool compareGreater(const T& l, const T& r) { return l > r; } int main() { static size_t const N = 2; int unsorted[] = {4, 6, 3, 4, 7, 8, 1, 2}; //1 { typedef std::multiset<int, Comparator<int> > Set; Set sets[N] = { Set(Comparator<int>::Asc()), Set(Comparator<int>::Desc()) }; for (size_t i = 0; i < N; ++i) { sets[i].insert(std::begin(unsorted), std::end(unsorted)); } for (size_t i = 0; i < N; ++i) { for (auto const& it : sets[i]) { std::cout << it << " "; } std::cout << "\n"; } } //2 { typedef bool (*compareFn)(int const&, int const&); typedef std::multiset<int, compareFn> Set2; Set2 sets2[N] = { Set2(compareLess<int>), Set2(compareGreater<int>) }; for (size_t i = 0; i < N; ++i) { sets2[i].insert(std::begin(unsorted), std::end(unsorted)); } for (size_t i = 0; i < N; ++i) { for (auto const& it : sets2[i]) { std::cout << it << " "; } std::cout << "\n"; } } //3 { typedef std::multiset<int, std::function<bool(int,int)>> Set3; Set3 sets3[N] = {Set3([](int a, int b){ return a < b; }), Set3([](int a, int b){ return a > b; })}; for (size_t i = 0; i < N; ++i) { sets3[i].insert(std::begin(unsorted), std::end(unsorted)); } for (size_t i = 0; i < N; ++i) { for (auto const& it : sets3[i]) { std::cout << it << " "; } std::cout << "\n"; } } //4 { typedef std::multiset<int, std::function<bool(int,int)>> Set4; Set4 sets4[N] = {Set4(std::less<int>()), Set4(std::bind(std::less<int>(), _2, _1))}; for (size_t i = 0; i < N; ++i) { sets4[i].insert(std::begin(unsorted), std::end(unsorted)); } for (size_t i = 0; i < N; ++i) { for (auto const& it : sets4[i]) { std::cout << it << " "; } std::cout << "\n"; } } //5 { typedef std::multiset<int, std::function<bool(int,int)>> Set5; Set5 sets5[N] = {Set5(std::less<int>()), Set5(std::greater<int>())}; for (size_t i = 0; i < N; ++i) { sets5[i].insert(std::begin(unsorted), std::end(unsorted)); } for (size_t i = 0; i < N; ++i) { for (auto const& it : sets5[i]) { std::cout << it << " "; } std::cout << "\n"; } } //6:   2  3 { typedef bool (*compareFn)(int const&, int const&); typedef std::multiset<int, compareFn> Set6; Set6 sets6[N] = {Set6([](int const& a, int const& b){ return a < b; }), Set6([](int const& a, int const& b){ return a > b; })}; for (size_t i = 0; i < N; ++i) { sets6[i].insert(std::begin(unsorted), std::end(unsorted)); } for (size_t i = 0; i < N; ++i) { for (auto const& it : sets6[i]) { std::cout << it << " "; } std::cout << "\n"; } } return 0; }

एक टेम्पलेट पैरामीटर के साथ सहयोगी एसटीएल कंटेनरों का एकीकरण - एक तुलनित्र

More articles: