c++ - How does memcpy work on pointers to arrays? -

मैं 2 arrays की तरह शुरू करता हूँ:

  x = (डबल *) malloc (sizeof (डबल) * एन); एक्सप्लस 1 = (डबल *) मॉलोक (आकारफ (डबल) * n);  

सबसे पहले, मैं निश्चित रूप से नहीं जानता कि एक्स या एक्सप्लस 1 अब क्या है, जो कि एक द्विपक्षीय पूर्ण सरणी के लिए एक संकेतक है, या संकेतों से भरा डैबल के लिए एक सरणी? : /

उस प्रश्न का उत्तर शायद इस पर प्रभाव डालता है, लेकिन अगर मैं इन विभिन्न कार्यों को करता हूं, तो मैं इसे जो करना चाहता हूं, वह नहीं कर सकता, जो सिर्फ एक्सप्लस 1 से एक्स के मूल्यों को कॉपी करना है। एक्सप्लस 1 और एक्स प्रत्येक इंडेक्स के लिए अलग-अलग मान रखते हैं, क्योंकि लूप के लिए सरल होने के बाद वांछित प्रभाव प्राप्त होता है:

  के लिए (int i = 0; i & lt; n; i ++) {x [ आई] = एक्सप्लस 1 [आई]; }  

लेकिन इसका उपयोग ...

  memcpy (x, xPlus1, sizeof (x)); मेम्क्पी (एक्स, एंड एक्सप्लस 1, आकारफ (एक्स));  

अगर मैं इनमें से किसी एक के बाद एक ही फ़ंक्शन में एक्स का उपयोग करता हूं, तो एक्स अपरिवर्तित है, इसे पुराने मान रखा गया है।

  memcpy (& amp; x, & amp; ; एक्सप्लस 1, आकारफ (एक्स));  

मेरा मानना ​​है कि यह एक्स और एक्सप्लस 1 बिंदु को एक ही मेमोरी स्थान को मेरे द्वारा प्राप्त आउटपुट द्वारा बनाता है। इसका कारण यह है कि अगर मैं इस प्रतिलिपि के बाद एक्स या एक्सप्लस 1 को संशोधित करता हूं, तो दोनों मान बदल जाते हैं यदि मैं दोनों सरणियों को प्रिंट करता हूँ।

  memcpy (& x, xPlus1, sizeof (x));  

मर जाता है, अपवाद: MPITemplate.exe में 0x011D5626 पर अनचाहे अपवाद: 0xC0000005: प्रवेश उल्लंघन स्थान 0x00000000 लिख रहा है।

फ़ंक्शन में एपरसैंड आमतौर पर संदर्भ से पास का संकेत देते हैं, यह कैसे खेलता है जब memcpy को दिया जाता है, और यह अंतर क्या करता है यदि यह अंत में एक ही ब्लॉक को लिखने वाला है?

मुझे खुशी होगी अगर कोई मुझे विस्तार से बता सकता है कि क्या हो रहा है इन कार्यों के साथ, क्योंकि मैं इसे काम करने के लिए बेला कर सकता हूं, लेकिन मैं यह समझता हूं कि जब ये कॉल हो जाए तो वास्तव में क्या हो रहा है।

धन्यवाद,

माइक

मैं इस तरह से 2 एरे की शुरुआत करता हूं:

नहीं, आप नहीं हैं। आपने x और xPlus1 परिभाषा को नहीं दिखाया है, लेकिन अगर वे इस तरह से arrays हैं:

  डबल एक्स [10];  

आपका कोड संकलित नहीं होगा इसलिए मान लें कि आपका कोड x और xPlus1 को संकेतक को दोहराता है। वे करीब हैं, लेकिन एक ही बात नहीं है।

सबसे पहले, मैं निश्चित नहीं हूँ कि x या xPlus1 अब क्या हैं, एक डबल्स से भरा सरणी का सूचक, या पूर्ण सरणी डबल्स के लिए संकेत? : /

फिर आप को अपनी परिभाषा प्रकाशित करनी चाहिए और फिर आपका प्रश्न किसी भी प्रकार का मतलब नहीं होगा। वे संकेतक होते हैं और जो भी आप उन्हें देते हैं वे उस तथ्य को नहीं बदलते हैं इसलिए वे स्मृति ब्लॉक आकार sizeof (double) * n का पता लगाने वाले संकेतक हैं। उस मेमोरी में क्या होगा जो आप पर निर्भर करता है, आप इसे डबल्स की सरणी के रूप में देख सकते हैं, या कुछ और जो कि sizeof (double) * n के बराबर या बराबर है।

लेकिन इसका उपयोग ...

  memcpy (x, xPlus1, sizeof (x)); मेम्क्पी (एक्स, एंड एक्सप्लस 1, आकारफ (एक्स)); इसलिए कोड प्रतिलिपियों के आकार की पहली पंक्ति (डबल *) शायद 8 बाइट्स यानी एक डबल (जो सिर्फ संयोग है कि 64 बिट प्लेटफ़ॉर्म आकार (डबल *) == आकार (डबल) पर) स्मृति से  xPlus1  द्वारा इंगित करके  x  द्वारा इंगित किया गया। तो आप मूल रूप से एक तत्व की प्रतिलिपि बना चुके हैं और उसी के रूप में (यदि आप 32 बिट प्लेटफॉर्म पर हैं तो आप केवल आधे से दो बार कॉपी करेंगे): 
 
  x [0] = xPlus1 [0];  
 
 दूसरी पंक्ति की प्रतिलिपि बनाई गई स्मृति जिसमें संकेतक  xPlus1  स्मृति ब्लॉक में स्थित  x  द्वारा इंगित किया गया है। तो आपने  डबल *  से  डबल  x [0] की प्रतिलिपि बनाई है जो बहुत अधिक समझ नहीं पा रहा है: 
 
  x [0] = (डबल) xPlus1;  
 
 यह कोड: 
 <पूर्व>  memcpy (& amp; x, & xPlus1, sizeof (x));  

मूल रूप से ऐसा किया (केवल जटिल तरीका):

  x = xPlus1;  

निम्न कोड:

  memcpy (& x, xPlus1, sizeof (x));  

इसके बराबर है:

  x = (डबल *) xPlus1 [0];  

जो x सूचक को गड़बड़ी का पता बनाता है जो अपवाद की ओर जाता है।

तो आपका वास्तविक कोड होना चाहिए:

< प्री> मेम्क्पी (एक्स, एक्सप्लस 1, आकारफ (डबल) * n);