वेक्टर का वेक्टर स्मृति में गठबंधन कैसे होता है?

Question

मैं समझता हूँ के रूप में Set size of vector of vectors at run time का वर्णन करता है, एक के रूप में

vector<vector<int> > ref; 

वेक्टर के वेक्टर घोषणा कर सकते हैं तब तक

ref.resize(i); 

प्रथम स्तर का आकार बदलने और 2 स्तर पर तत्व धक्का:

ref[i].push_back(23); 

लेकिन स्मृति में वेक्टर के वेक्टर कैसे गठबंधन होते हैं?

सरल वेक्टर के लिए, यह एक कंटेनर है और array की तरह लगातार इसके तत्व को संरेखित करता है; लेकिन वेक्टर के वेक्टर के मामले में, मैं तस्वीर नहीं देख सका।

प्रत्येक भीतरी वेक्टर आकार बदल सकता है (वेक्टर के वेक्टर में वेक्टर) के आकार के रूप में, लगातार भीतरी वैक्टर संरेखित (वेक्टर की में वेक्टर) वेक्टर के बाहरी वेक्टर करता है? बाहरी वेक्टर प्रत्येक आंतरिक वेक्टर के लिए यादगार जगह शोध करता है? क्या होगा अगर एक वेक्टर overshoot?

Answer 1

संरचना का आकार ref में संग्रहीत है जो स्थिर है। सामान्य कार्यान्वयन में यह तीन पॉइंटर्स, या 32-बिट आर्किटेक्चर पर लगभग 12 बाइट्स, या चमकदार नए 64-बिट आर्किटेक्चर पर 24 बाइट्स हैं।

तो ref निरंतर भंडारण की लगभग ref.capacity() * 12 बाइट्स का प्रबंधन करता है।

प्रत्येक तत्व/vector<int> रेफरी में ref तत्वों से स्वतंत्र अपने स्वयं के पूर्णांक प्रबंधित करता है। सादगी के लिए ref.size() == ref.capacity() से नीचे कलात्मक प्रतिपादन में।

तो अपने

ref.resize(i); 

केवल शीर्ष पंक्ति को प्रभावित करता है। आपका

ref[i].push_back(23); 

केवल i-th कॉलम को प्रभावित करता है।

Answer 2

vector<vector <int>> m; 

1. भीतरी वेक्टर या पंक्तियों मुक्त दुकान पर स्वतंत्र वस्तुओं के रूप में लागू किया जाता है।
2. प्रत्येक पंक्ति में तत्व कॉम्पैक्टली संग्रहीत, push_back और resizing के माध्यम से गतिशील आवंटन करने में सक्षम हैं।
3. vector< vector<int> > में प्रत्येक आंतरिक वेक्टर के लिए एक ही आकार के लिए आवश्यक नहीं है। इसलिए, आंतरिक-वेक्टर (उनके तत्व नहीं) संगत रूप से संग्रहीत नहीं होते हैं। इसका मतलब है कि m[i] की पहले तत्व तुरंत अगले m[i-1] की पिछले तत्व को पता में संग्रहीत नहीं है।

करता वेक्टर (सदिश के सदिश में वेक्टर) के बाहरी वेक्टर लगातार भीतरी वैक्टर संरेखित?

सं देखें बिंदु # 2

करता है प्रत्येक भीतरी वेक्टर के लिए बाहरी वेक्टर researve memeory अंतरिक्ष?

नहीं। बिंदु # 1 देखें। आपको resize की आवश्यकता है या push_back आंतरिक वेक्टर में करें।

स्मृति में वेक्टर के वेक्टर कैसे संरेखित होते हैं?

vector<T> vec; 

इतना स्मृति

sizeof(vector<T>) + (vec.size() ∗ sizeof(T)) 

जहां,

sizeof(vector<T>) = 12 बाइट्स

और T वेक्टर के वेक्टर के लिए vector<int> है खपत करता है।

तो, 3-बाय -4 vector<vector<int>> के लिए उपभोग की गई स्मृति होगी।

= sizeof(vector<vector<int>>) + (vec.size() * sizeof(vector<int>)) 
= 12 + 3 * 12 
= 48 

क्या एक अगर वेक्टर overshoot?

vector.resize function corrupting memory when size is too large

Answer 3

एक vector<vector<int>> स्मृति में ऐसा दिखाई दे सकता:

+-+-+-+ 
|b|e|c| vector<vector<int> 
+-+-+-+ 
| | | 
| | +-------------------+ 
| |      | 
| +---------------+  | 
|     |  | 
V     V  V 
+-+-+-+-+-+-+-+-+-+ 
|b|e|c|b|e|c|b|e|c| 3x vector<int> 
+-+-+-+-+-+-+-+-+-+ 
| | | | | | | | | 
| | | | | | | | +-------------+ 
| | | | | | | |    | 
| | | | | | | +-------+  | 
| | | | | | |   |  | 
| | | | | | V   V  V 
| | | | | |+-+-+-+-+-+  
| | | | | ||i|i|i|i|i| 5x int 
| | | | | |+-+-+-+-+-+  
| | | | | |  
| | | | +-+---+ 
| | | |  | 
| | | V  V 
| | |+-+-+-+-+ 
| | ||i|i|i|i| 4x int 
| | |+-+-+-+-+ 
| | | 
| +-+-----------+ 
|    | 
V    V 
+-+-+-+-+-+-+-+-+ 
|i|i|i|i|i|i|i|i| 8x int 
+-+-+-+-+-+-+-+-+ 

यहाँ b को दर्शाता है begin() poiner, eend() सूचक को दर्शाता है और c को दर्शाता है capacity() सूचक।

तुम देखो, कि पंक्तियों स्मृति में सन्निहित के रूप में आप एक मैट्रिक्स संरचना से उम्मीद होती है नहीं हैं। प्रत्येक वेक्टर (आंतरिक और बाहरी वैक्टर) इसकी स्मृति स्मृति आवंटन का ख्याल रखता है। बाहरी वेक्टर इस बात पर परवाह नहीं करता कि यह तत्व क्या कर रहा है।