C++
std :: सरणी

पैरामीटर

टिप्पणियों

एक std :: array को इनिशियलाइज़ करना

प्रारंभिक std::array<T, N> , जहां T एक अदिश प्रकार है और N प्रकार T के तत्वों की संख्या है

यदि T एक अदिश प्रकार है, तो std::array को निम्नलिखित तरीकों से आरंभ किया जा सकता है:

// 1) Using aggregate-initialization
std::array<int, 3> a{ 0, 1, 2 };
// or equivalently
std::array<int, 3> a = { 0, 1, 2 };

// 2) Using the copy constructor
std::array<int, 3> a{ 0, 1, 2 };
std::array<int, 3> a2(a);
// or equivalently
std::array<int, 3> a2 = a;

// 3) Using the move constructor
std::array<int, 3> a = std::array<int, 3>{ 0, 1, 2 };

प्रारंभिक std::array<T, N> , जहां T एक गैर-स्केलर प्रकार है और N प्रकार T के तत्वों की संख्या है

यदि T एक गैर-स्केलर प्रकार std::array को निम्नलिखित तरीकों से आरंभ किया जा सकता है:

struct A { int values[3]; }; // An aggregate type

// 1) Using aggregate initialization with brace elision
// It works only if T is an aggregate type!
std::array<A, 2> a{ 0, 1, 2, 3, 4, 5 };
// or equivalently
std::array<A, 2> a = { 0, 1, 2, 3, 4, 5 };

// 2) Using aggregate initialization with brace initialization of sub-elements
std::array<A, 2> a{ A{ 0, 1, 2 }, A{ 3, 4, 5 } };
// or equivalently
std::array<A, 2> a = { A{ 0, 1, 2 }, A{ 3, 4, 5 } };

// 3)
std::array<A, 2> a{{ { 0, 1, 2 }, { 3, 4, 5 } }};
// or equivalently
std::array<A, 2> a = {{ { 0, 1, 2 }, { 3, 4, 5 } }};

// 4) Using the copy constructor
std::array<A, 2> a{ 1, 2, 3 };
std::array<A, 2> a2(a);
// or equivalently
std::array<A, 2> a2 = a;

// 5) Using the move constructor
std::array<A, 2> a = std::array<A, 2>{ 0, 1, 2, 3, 4, 5 };

तत्व की पहुँच

1. at(pos)

स्थान पर तत्व के लिए संदर्भ लौटाता pos सीमा जाँच के साथ। अगर pos कंटेनर की सीमा के भीतर नहीं है, तो टाइप std::out_of_range का अपवाद फेंका जाता है।

जटिलता निरंतर ओ (1) है।

#include <array>

int main()
{
    std::array<int, 3> arr;

    // write values
    arr.at(0) = 2;
    arr.at(1) = 4;
    arr.at(2) = 6;
        
    // read values
    int a = arr.at(0); // a is now 2
    int b = arr.at(1); // b is now 4
    int c = arr.at(2); // c is now 6

    return 0;
}

2) operator[pos]

स्थिति की pos में तत्व के संदर्भ को बिना सीमा जाँच के लौटाता है। अगर pos कंटेनर की सीमा के भीतर नहीं है, तो रनटाइम सेगमेंटेशन उल्लंघन त्रुटि हो सकती है। यह विधि क्लासिक सरणियों के बराबर तत्व प्रदान करती है और इसके at(pos) तुलना at(pos) अधिक कुशल है।

जटिलता निरंतर ओ (1) है।

#include <array>

int main()
{
    std::array<int, 3> arr;

    // write values
    arr[0] = 2;
    arr[1] = 4;
    arr[2] = 6;
        
    // read values
    int a = arr[0]; // a is now 2
    int b = arr[1]; // b is now 4
    int c = arr[2]; // c is now 6

    return 0;
}

3) std::get<pos>

इस गैर सदस्य समारोह संकलन समय निरंतर स्थान पर तत्व के लिए एक संदर्भ रिटर्न pos सीमा जाँच के बिना। अगर pos कंटेनर की सीमा के भीतर नहीं है, तो रनटाइम सेगमेंटेशन उल्लंघन त्रुटि हो सकती है।

जटिलता निरंतर ओ (1) है।

#include <array>

int main()
{
    std::array<int, 3> arr;

    // write values
    std::get<0>(arr) = 2;
    std::get<1>(arr) = 4;
    std::get<2>(arr) = 6;
        
    // read values
    int a = std::get<0>(arr); // a is now 2
    int b = std::get<1>(arr); // b is now 4
    int c = std::get<2>(arr); // c is now 6

    return 0;
}

4) front()

कंटेनर में पहले तत्व का संदर्भ देता है। खाली कंटेनर पर front() कॉलिंग अपरिभाषित है।

जटिलता निरंतर ओ (1) है।

नोट: एक कंटेनर सी के लिए, अभिव्यक्ति c.front() *c.begin() बराबर है।

#include <array>

int main()
{
    std::array<int, 3> arr{ 2, 4, 6 };

    int a = arr.front(); // a is now 2

    return 0;
}

5) back()

कंटेनर में अंतिम तत्व का संदर्भ देता है। खाली कंटेनर पर back() कॉल back() अपरिभाषित है।

जटिलता निरंतर ओ (1) है।

#include <array>

int main()
{
    std::array<int, 3> arr{ 2, 4, 6 };

    int a = arr.back(); // a is now 6

    return 0;
}

6) data()

तत्व भंडारण के रूप में सेवारत अंतर्निहित सरणी के लिए सूचक लौटाता है। पॉइंटर ऐसा है जो range [data(); data() + size()) हमेशा एक मान्य श्रेणी है, भले ही कंटेनर खाली हो ( data() उस स्थिति में निष्क्रिय नहीं है)।

जटिलता निरंतर ओ (1) है।

#include <iostream>
#include <cstring>
#include <array>

int main ()
{
    const char* cstr = "Test string";
    std::array<char, 12> arr;
    
    std::memcpy(arr.data(), cstr, 12); // copy cstr to arr
    
    std::cout << arr.data(); // outputs: Test string
    
    return 0;
}

सरणी का आकार जाँच रहा है

C शैली सरणी की तुलना में std::array का मुख्य लाभ यह है कि हम size() कमांड फ़ंक्शन का उपयोग करके सरणी के आकार की जांच कर सकते हैं

int main() {
    std::array<int, 3> arr = { 1, 2, 3 };
    cout << arr.size() << endl;
}

ऐरे के माध्यम से Iterating

std::array एक STL कंटेनर है, vector जैसे अन्य कंटेनरों के समान लूप के लिए रेंज-आधारित का उपयोग कर सकता है

int main() {
     std::array<int, 3> arr = { 1, 2, 3 };
     for (auto i : arr)
         cout << i << '\n';
}

एक बार में सभी सरणी तत्वों को बदलना

सदस्य फ़ंक्शन fill() का उपयोग एक बार प्रारंभ होने के बाद मान बदलने के लिए std::array पर किया जा सकता है

int main() {
    
    std::array<int, 3> arr = { 1, 2, 3 };
    // change all elements of the array to 100
    arr.fill(100);
    
}