कैसे एक सदिश C ++ में मुख्य रूप से काम करता है?

Question

यह एसओ जवाब देता है कि कुंजी के लिए वेक्टर के साथ एसटीएल मानचित्र एक कुंजी के रूप में इस्तेमाल किया जा सकता है। इसलिए जब हम एक सदिश का उपयोग एक कुंजी के रूप में करते हैं। यह वास्तव में कैसे काम करता है क्योंकि कुंजी को अद्वितीय होने की आवश्यकता होती है, इसलिए जब हम एक ही वेक्टर डालते हैं उसी तत्वों के साथ mapतत्व द्वारा डुप्लिकेट तत्व की जांच होगी या वेक्टर का नाम कुछ निर्दिष्ट करता है? जैसे सरणी का नाम आधार पते का प्रतिनिधित्व करता है। इसलिए एक सरणी को कुंजी के रूप में उपयोग किया जा सकता है क्योंकि आधार पते को इस मामले में कुंजी के रूप में उपयोग किया जा सकता है लेकिन वेक्टर के मामले में कुंजी क्या है। यह आंतरिक रूप से कैसे काम करता है।

क्योंकि जब मैं वेक्टर का नाम प्रिंट करता हूं, तो मुझे एक त्रुटि मिलती है

vector<int> v;
cout<<v; //error

Comments

वेक्टर नाम छापने से आपका क्या मतलब है?

— बार्ट

has operators == and <वह कैसे मदद करता है? मेरा प्रश्न यह था कि डुप्लिकेट तत्वों की जांच करने के लिए तत्व द्वारा वेक्टर कुंजी तत्व की तुलना करेंगे

— पुलकित भटनागर

@PulkitBhatnagar लेकिन ... कोई भी आपको कभी भी std::vectorकुंजी के रूप में उपयोग करने के लिए मजबूर नहीं करेगा std::map। आप जो उपयोग करते हैं उसके लिए भुगतान करते हैं । यह किया जा सकता है, और शायद इसके लिए कुछ उपयोग-मामले हैं, लेकिन निश्चित रूप से आप अपनी पसंद के डेटा संरचना को बदल सकते हैं। STL कंटेनरों को अधिकतम बहुमुखी और किसी भी तरह से उपयोग करने के लिए डिज़ाइन किया गया है जिसे उपयोगकर्ता कभी भी उपयोग करना चाहते हैं।

— यक्षिसरवीन

@PulkitBhatnagar देखें, उदाहरण के लिए, std :: मानचित्र को लाल-काले पेड़ के रूप में क्यों लागू किया गया है? ।

— डैनियल लैंगर

@PulkitBhatnagar स्टोर सीधे। std::mapकुंजी और मान दोनों को ही कॉपी करेगा। std::unordered_mapकुंजी का हैश स्टोर कर सकते हैं।

— यक्षीसारविनन

Answer 1

क्लास टेम्पलेट std :: वेक्टर के लिए एक अतिभारित ऑपरेटर <है।

template <class T, 
class Allocator>
bool operator< (const vector<T, Allocator>& x, const vector<T, Allocator>& y);

यह मानक एल्गोरिथ्म पर आधारित है std::lexicographical_compare ।

यहाँ एक प्रदर्शन कार्यक्रम है।

#include <iostream>
#include <iomanip>
#include <vector>
#include <iterator>
#include <algorithm>

int main() 
{
    std::vector<int> v1 = { 1, 2 };
    std::vector<int> v2 = { 1, 2, 3 };
    std::vector<int> v3 = { 2 };

    std::cout << std::boolalpha << ( v1 < v2 ) << '\n';
    std::cout << std::lexicographical_compare( std::begin( v1 ), std::end( v1 ),
                                               std::begin( v2 ), std::end( v2 ) )
             << '\n';                                              

    std::cout << std::boolalpha << ( v1 < v3 ) << '\n';
    std::cout << std::lexicographical_compare( std::begin( v1 ), std::end( v1 ),
                                               std::begin( v3 ), std::end( v3 ) )
             << '\n';                                              

    std::cout << std::boolalpha << ( v2 < v3 ) << '\n';
    std::cout << std::lexicographical_compare( std::begin( v2 ), std::end( v2 ),
                                               std::begin( v3 ), std::end( v3 ) )
             << '\n';                                              

    return 0;
}

इसका आउटपुट है

true
true
true
true
true
true

इसलिए कक्षा को मानचित्र में एक कुंजी के रूप में उपयोग किया जा सकता है।

डिफ़ॉल्ट रूप से क्लास टेम्पलेट मैप फ़ंक्शन ऑब्जेक्ट std :: कम का उपयोग करता है जो बदले में ऑपरेटर <का उपयोग करता है

template <class Key, class T, class Compare = less<Key>,
class Allocator = allocator<pair<const Key, T>>>
class map 
{
    //...
};

हालाँकि, क्लास टेम्पलेट std :: वेक्टर के लिए कोई अतिभारित ऑपरेटर << नहीं है।

Comments

मैं एसओ पर लगभग सभी सी ++ प्रश्न में हाल ही में आपके उत्तर देखता हूं, मुझे नहीं पता कि क्या मैं अपने पूरे जीवन में कभी भी वह हासिल करने में सक्षम हूं जो आपके पास है लेकिन मैं अपना सर्वश्रेष्ठ प्रयास करूंगा। उत्तर के लिए धन्यवाद

— पुलकित भटनागर

Answer 2

किसी वस्तु का नाम और उस वस्तु की सामग्री हमेशा असंबंधित चीजें होती हैं।

operator ==के लिए std::vectorपहले वैक्टर की लंबाई की तुलना करेंगे और फिर इसके प्रत्येक तत्व का operator ==भी उपयोग करेंगे।

operator <वेक्टर लेक्सिकोग्राफ़िक रूप से तत्वों की तुलना करता है, अर्थात यह x[i] < y[i]वैक्टर में पहले गैर-बराबर तत्व के लिए वापस आता है xऔर y।

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