कंटेनर और ऑब्जेक्ट पॉइंटर्स का प्रदर्शन परीक्षण

प्रविष्टि

यह आलेख विभिन्न डेटा प्रकारों के लिए विभिन्न प्रकार के पॉइंटर्स वाले ऑब्जेक्ट्स के साथ कंटेनर (पुश_बैक) भरने के प्रदर्शन परीक्षण पर चर्चा करता है। परीक्षण जटिल है, किसी ऑब्जेक्ट के लिए एक पॉइंटर बनाने के विशिष्ट कार्यों के संयोजन, एक ऑब्जेक्ट की प्रतिलिपि बनाना, एक कंटेनर भरना, स्मार्ट पॉइंटर का उपयोग करके ऑब्जेक्ट के लिए आवंटित मेमोरी को मुक्त करना और मानक डिलीट ऑपरेटर। मानक टेम्प्लेट लाइब्रेरी के तीन कंटेनरों का परीक्षण किया जाएगा - वेक्टर, सूची, डीकेई, तीन प्रकार के पॉइंटर्स - एसटीडी :: साझा_प्रटी, एसटीडी :: ऑटो_प्रेट और एक सरल पॉइंटर। परीक्षण डेटा प्रकारों के रूप में (जो संकेत बनाए जाएंगे) लंबे, एसटीडी :: स्ट्रिंग, चार, एक मनमाना वर्ग।

टेस्ट विवरण

स्रोत कोड एमएस विज़ुअल स्टूडियो 2010 में लिखा गया है, और लंबो कार्यों के लिए संकलक समर्थन की आवश्यकता है।
बता दें कि कुछ क्लास में डेटा टाइप टाइप करने के लिए पॉइंटर टी का विवरण होता है। निर्माता एक ऑब्जेक्ट बनाएगा, और पारित पैरामीटर के साथ आरंभ करेगा। कॉपी कंस्ट्रक्टर निर्दिष्ट ऑब्जेक्ट के पते पर स्थित मूल्य की प्रतिलिपि करेगा, साथ ही इसका नाम और कंसोल में ऑब्जेक्ट के जीवन के बारे में संदेश प्रदर्शित करने की आवश्यकता होगी।

template< class T, typename Type > class test_type_and_smart_pointer { public: test_type_and_smart_pointer( std::string const& val, bool msg, Type type_val ) : _msg( msg ), _name( val ) { if( _msg ) std::cout << "created " << _name << std::endl; x.reset( new Type ); *x = type_val; } ~test_type_and_smart_pointer() { if( _msg ) std::cout << "deleted " << _name << std::endl; } test_type_and_smart_pointer(const test_type_and_smart_pointer & W) { if( W._msg ) std::cout << "copied " << W._name << std::endl; this->x.reset( new Type ); *(this->x) = *(Wx); this->_name = W._name; this->_msg = W._msg; } private: T x; bool _msg; std::string _name; }; 

टेम्पलेट विकल्प:

• क्लास टी - एक स्मार्ट पॉइंटर के निहित वर्ग,
• typename Type - निर्मित वस्तु का डेटा प्रकार।

Test_type_and_smart_pointer वर्ग के सदस्य:

• T x - सूचक स्वयं वस्तु के लिए,
• बूल _msg - सूचना संदेश के उत्पादन के लिए ध्वज,
• std :: string _name निर्मित वस्तु का नाम है।

यदि केस टाइप टू स्टैंडर्ड है तो पॉइंटर टी केस के लिए एक समान क्लास बनाते हैं।

 template< class T, typename Type > class test_type_and_simple_pointer { public: test_type_and_simple_pointer( std::string const& val, bool msg, Type type_val ) : _msg( msg ), _name( val ) { if( _msg ) std::cout << "created " << _name << std::endl; x = new Type; *x = type_val; } ~test_type_and_simple_pointer() { delete x; if( _msg ) std::cout << "deleted " << _name << std::endl; } test_type_and_simple_pointer(const test_type_and_simple_pointer & W) { if( W._msg ) std::cout << "copied " << W._name << std::endl; this->x = new Type( *(Wx) ); this->_name = W._name; this->_msg = W._msg; } private: T x; bool _msg; std::string _name; }; 

अब हमें उन कार्यों की आवश्यकता है जो ऊपर वर्णित वस्तुओं को बनाते हैं:

 template< typename _Ptr, typename T, typename Container, bool msg > void test_smart_ptr( bool big_data, T val ) { using namespace std; test_type_and_smart_pointer< _Ptr, T > x( "a001", msg, val ); test_type_and_smart_pointer< _Ptr, T > x2( x ); Container cnt; cnt.push_back( x ); cnt.push_back( x2 ); if( big_data ) for( int i = 0; i <= 100; i++ ) { test_type_and_smart_pointer< _Ptr, T > xx( "a002", msg, val ); test_type_and_smart_pointer< _Ptr, T > xx2( xx ); cnt.push_back( xx ); cnt.push_back( xx2 ); } cnt.clear(); } template< typename T, typename Container, bool msg > void test_simple_ptr( bool big_data, T val ) { using namespace std; test_type_and_simple_pointer< T*, T> x( "b001", msg, val ); test_type_and_simple_pointer< T*, T> x2( x ); Container cnt; cnt.push_back( x ); cnt.push_back( x2 ); if( big_data ) for( int i = 0; i <= 100; i++ ) { test_type_and_simple_pointer< T*, T> xx( "b002", msg, val ); test_type_and_simple_pointer< T*, T> xx2( xx ); cnt.push_back( xx ); cnt.push_back( xx2 ); } cnt.clear(); } 

उदाहरण के लिए, ये फ़ंक्शन दो मोड में काम करेंगे: ऑब्जेक्ट के लिए पॉइंटर्स की एक जोड़ी बनाना और उन्हें एक कंटेनर में रखना, और चक्रीय वस्तुओं को पॉइंटर्स बनाना और कंटेनर को भरना।
Test_smart_ptr और test_simple_ptr फ़ंक्शन निष्पादित करने के लिए लिया गया समय _time_est द्वारा मापा जाएगा:

 double _time_test( std::function< void() > test_func, unsigned int times ) { using namespace std; double start = 0, end = 0; start = GetTickCount(); for( unsigned int i = 0; i < times; i++ ) { test_func(); } end = GetTickCount() - start; //cout << "Elapsed ms: " << end << // " for " << times << " times " << endl; return end; } 

आवश्यक हेडर फाइलें:

 #include "iostream" #include "string" #include "vector" #include "list" #include "deque " #include <Windows.h> #include "functional" 

एक मनमाना प्रकार की वस्तु के रूप में, गतिशील मेमोरी आवंटन के बिना सबसे सरल वर्ग का उपयोग किया जाता है।

 class some_obj { public: some_obj() { i = 90000; s = "1231231231231231231232"; d = 39482.27392; } ~some_obj() { } private: int i; std::string s; double d; }; 

तो, परीक्षण कैसे आयोजित किया गया था। 72 लंबो कार्यों का वर्णन किया गया है, जिनमें से प्रत्येक पूरा होने पर, ढेर को उसकी मूल स्थिति में लाता है।

 int main() { using namespace std; const long long_val = 900000000; const char ch = 'a'; const string str = "abc"; /////////////////////////////////////////////////////////////////////////////////////////////////////// auto f_01 = [&]() -> void { test_smart_ptr< shared_ptr< long >, long, vector< test_type_and_smart_pointer< shared_ptr< long >, long > >, false >( false, long_val ); }; auto f_02 = [&]() -> void { test_smart_ptr< shared_ptr< char >, char, vector< test_type_and_smart_pointer< shared_ptr< char >, char > >, false >( false, ch ); }; auto f_03 = [&]() -> void { test_smart_ptr< shared_ptr< string >, string, vector< test_type_and_smart_pointer< shared_ptr< string >, string > >, false >( false, str ); }; auto f_04 = [&]() -> void { some_obj x; test_smart_ptr< shared_ptr< some_obj >, some_obj, vector< test_type_and_smart_pointer< shared_ptr< some_obj >, some_obj > >, false >( false, x ); }; ... _time_test( f_01, 100000 ); _time_test( f_02, 100000 ); _time_test( f_03, 100000 ); _time_test( f_04, 100000 ); ... return 0; } 

मुख्य समारोह का पूरा कोड बोझिलता के कारण नहीं दिया गया है, लेकिन साझा_पार्टर पॉइंटर के लिए लंबो कार्यों के पहले ब्लॉक के अनुसार, टेम्पलेट मापदंडों के संयोजन की सामान्य प्रवृत्ति दिखाई देती है।

प्रत्येक f_nn फ़ंक्शन को 15 बार निष्पादित किया गया था और माप परिणाम औसत था (लॉन्च स्टूडियो के नीचे से रिलीज मोड में था)। सबसे छोटा बीता हुआ समय, अर्थात्। अन्य मूल्य अनुपात में दिए गए हैं।

परीक्षण के परिणाम

रंग सभी कंटेनरों के बीच प्रत्येक प्रकार के सूचक के लिए सबसे तेज़ डेटा प्रकार को इंगित करता है:



सभी सूचक प्रकारों में प्रत्येक कंटेनर के लिए सबसे तेज़ डेटा प्रकार:



सभी प्रकार के डेटा और सभी संकेतकों के लिए भरने पर सबसे तेज़ कंटेनर:

क्या सीखा जाना उपयोगी है?

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