विषय पर बढ़ें

अंतिम अद्यतन：2026-10-12

STL array सोर्स कोड विश्लेषण

0.प्रस्तावना

सोर्स कोड विश्लेषण gcc4.9.1 पर आधारित है।

C++ tr1 का पूरा नाम Technical Report 1 है, जो C++ स्टैंडर्ड लाइब्रेरी का पहला एक्सटेंशन है। C++ स्टैंडर्ड c++0x में इसे शामिल किया जाना था, साथ ही भाषा में कुछ अन्य विस्तार भी। tr1 में बहुप्रतीक्षित smart pointer, रेगुलर एक्सप्रेशन तथा जेनेरिक प्रोग्रामिंग का समर्थन करने वाली अन्य सामग्री शामिल है। ड्राफ्ट चरण में नई जोड़ी गई क्लासों और टेम्प्लेट्स का नेमस्पेस std::tr1 था।

1.std::tr1::array

उपयोग: 

#include <tr1/array>
std::tr1::array<int ,10> a;

tr1 का array काफी सरल है: यह भाषा की अंतर्निहित array की नकल करता है और उसे इटरेटर ऑपरेशन्स का समर्थन देता है, ताकि वह अन्य कंटेनरों की तरह एल्गोरिद्म के साथ उपयोग की जा सके। tr1 के array में कोई कंस्ट्रक्टर या डिस्ट्रक्टर नहीं है। इटरेटर सीधे पास किए गए टाइप के पॉइंटर के रूप में परिभाषित है।

इस स्टैटिक array के सोर्स कोड पर एक संक्षिप्त नज़र डालते हैं:

template<typename _Tp, std::size_t _Nm>
struct array
{
    typedef _Tp                           value_type;
    typedef value_type&                           reference;
    typedef const value_type&                     const_reference;
    typedef value_type*                       iterator;
    typedef const value_type*                 const_iterator;
    typedef std::size_t                           size_type;
    typedef std::ptrdiff_t                         difference_type;
    typedef std::reverse_iterator<iterator>       reverse_iterator;
    typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
}
इसमें reverse_iterator का उपयोग rbegin तथा rend ऑपरेशन के इटरेटर के रूप में किया गया है। ऊपर एक इटरेटर दिखाई देता है, परंतु वास्तव में दो हैं; एक और iterator भी है, जो सीधे पास किए गए टाइप द्वारा परिभाषित पॉइंटर को इटरेटर के रूप में उपयोग करता है।

इसे vector के फॉरवर्ड तथा रिवर्स इटरेटर का समतुल्य समझा जा सकता है।

ध्यान देने योग्य है कि tr1::array में array का आकार 0 पास करने का समर्थन है, उदाहरण के लिए हम इस प्रकार उपयोग करते हैं:

std::tr1::array<int,0> a;
इस तरह की लिखावट नीचे दिए गए कोड पर मैप होती है: 
// Support for zero-sized arrays mandatory.
value_type _M_instance[_Nm ? _Nm : 1];
पास किए गए आकार के अनुसार: यदि वह 0 नहीं है, तो वही पास किया गया आकार होता है, अन्यथा 1।

2.std::array

उपयोग 

std::array<int ,10> a;

std के array में शामिल है

std_array.png

tr1 तथा std के array की तुलना

template<typename _Tp, std::size_t _Nm>
struct array
{
    typedef _Tp                           value_type;
    typedef value_type*               pointer;
    typedef const value_type*                       const_pointer;
    typedef value_type&                           reference;
    typedef const value_type&                     const_reference;
    typedef value_type*                       iterator;
    typedef const value_type*                 const_iterator;
    typedef std::size_t                           size_type;
    typedef std::ptrdiff_t                            difference_type;
    typedef std::reverse_iterator<iterator>       reverse_iterator;
    typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;

    // Support for zero-sized arrays mandatory.
    typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type;    // # define _GLIBCXX_STD_C std
    typename _AT_Type::_Type                         _M_elems;
}

array के भीतर दो जगहें ध्यान देने योग्य हैं: 

// Support for zero-sized arrays mandatory.
typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type;    // # define _GLIBCXX_STD_C std
typename _AT_Type::_Type                         _M_elems;

सोर्स कोड में __array_traits को खोजने पर हम देखते हैं: 

template<typename _Tp, std::size_t _Nm>
struct __array_traits
{
    typedef _Tp _Type[_Nm];

    static constexpr _Tp&
    _S_ref(const _Type& __t, std::size_t __n) noexcept
    { return const_cast<_Tp&>(__t[__n]); }
};

ऊपर की दो पंक्तियों का कोड निम्नलिखित रूप में समझा जा सकता है:

typedef _Tp _Type[100];
typedef _Type _M_elems;  // 一个含有100个元素的数组。

वास्तविक कोड लिखते समय, यदि हमें एक array परिभाषित करना हो, तो हम इस प्रकार लिख सकते हैं: 

int a[100];
//或者
typedef int T[100];
typedef T a;
पास किए गए size के संसाधन में, tr1 की तुलना में यह अधिक जटिल है — size 0 पास होने की स्थिति को संभालने के लिए टेम्प्लेट पार्शियल स्पेशलाइज़ेशन का उपयोग किया गया है।

template<typename _Tp, std::size_t _Nm>
struct __array_traits
{
    typedef _Tp _Type[_Nm];

    static constexpr _Tp&
    _S_ref(const _Type& __t, std::size_t __n) noexcept
    { return const_cast<_Tp&>(__t[__n]); }
};

template<typename _Tp>
struct __array_traits<_Tp, 0>
{
    struct _Type { };

    static constexpr _Tp&
    _S_ref(const _Type&, std::size_t) noexcept
    { return *static_cast<_Tp*>(nullptr); }
};

संबंधित विषय

टिप्पणियाँ