सरल सूचक प्रारंभ

Question

यह कुछ समय हो गया है कि मैंने पॉइंटर्स का उपयोग किया और मैं बस जांचना चाहता हूं कि मैं एक पूर्णांक सूचक कैसे प्रारंभ कर सकता हूं?

a) int *tmpPtr = 0; 

b) int *tmpPtr = null; 

c) int a = 0; 
    int *tmpPtr = &a; 

संपादित

अपने सभी सवालों के जवाब अब तक के लिए धन्यवाद। मजाकिया बात यह है कि अगर मैं को निम्नानुसार पॉइंटर को इंटिलाइज करता हूं, तो mem :: कॉपी ऑपरेशन ठीक काम करता है।

int tmp = 0; 
int *tmpPtr = &tmp; 
Mem::Copy((void*)tmpPtr, basepointer(), sizeof(int)); 

हालांकि, अगर मैं इसे इस तरह कार्य करें:

int *tmpPtr = 0; 
Mem::Copy((void*)tmpPtr, basepointer(), sizeof(int)); 

तो मैं एक दुर्घटना मेम :: नकल के दौरान मिलता है ...

अजीब!

Answer 1

आप इसे किसी भी तरीके से कर सकते हैं सिवाय इसके कि यह शून्य नहीं है। मैं int * पी = 0 पसंद करते हैं; int * पी = न्यूल पर;

कुछ भ्रम को खत्म करने के लिए मुझे लगता है कि int * p = 0 सेट करना या MyObject * p = 0 सेट करना; परिणाम एक ही चीज़ में .... एक शून्य सूचक जो आमतौर पर आपके प्रोग्राम को क्रैश करेगा यदि आप इसे कम करने का प्रयास करते हैं, हालांकि तकनीकी रूप से यह अनिर्धारित व्यवहार है। उदाहरण आप सी में है दूसरों से अलग है क्योंकि आप वास्तव में सूचक एक पूर्णांक 0. के रूप में स्थापित

 
int *pNull = 0; 
int c = *pNull; // Undefined behavior. Most likely crashing your program! 

int a  = 0; 
int *pInt = &a; 

int x = *pInt; // x equals 0 

a = 10; 
int y = *pInt; // y equals 10 

Answer 2

सरल सवाल ठीक हैं पर बात करने के लिए सेट कर रहे हैं, मुझे लगता है कि यह अच्छी तरह से स्थापित है कि इतने करने के लिए है सभी स्तरों के लिए, सिर्फ एक कुलीन नहीं।

सी में कोई null नहीं है (जब तक कि आप इसे स्वयं परिभाषित न करें)। एक नल पॉइंटर को आरंभ किया जा रहा निम्नलिखित दो तरीकों में से एक में किया जा सकता है:

int *p = 0; 
int *p = NULL; 

आप p उसके बाद भिन्नता, आप एक पहुँच उल्लंघन की आशा कर सकते हैं (मेरा मानना ​​है कि यह मानक के अनुसार अपरिभाषित व्यवहार है, तो वास्तव में, कुछ भी हो सकता है, ब्रह्मांड के कुल विनाश तक और इसमें शामिल हो सकता है - यह भी ठीक चलना जारी रख सकता है, लेकिन मैं इस पर भरोसा नहीं करता)।

कोई वास्तविक पूर्णांक के लिए सूचक के लिए, बस का उपयोग करें:

int a = 7; 
int *p = &a; 

पते-के ऑपरेटर का उपयोग कर।

अपना संपादन पुनः पढ़ें, यह बिल्कुल अजीब नहीं है, आपको बस इसे देखने की आवश्यकता है। आइए दिखाएं कि सभी चर मेमोरी लोकेशन 100 से शुरू होते हैं और पूर्णांक और पॉइंटर्स लंबाई में 4 बाइट दोनों होते हैं। उनके सरलतम रूप के लिए अपने दो स्थितियों का विश्लेषण करना:

        int x = 2; 
int *px = 0;      int *px = &x; 

     +-----+       +-----+ 
px(100): | 0 |     x(100) | 2 | 
     +-----+       +-----+ 
            px(104) | 100 | 
              +-----+ 

तो फिर तुम चर px द्वारा की ओर इशारा बदल करने की कोशिश में आदेश पर अमल

*px = 7; 

।

बाईं तरफ, आप स्मृति स्थान 0 पर मान 7 लिखने का प्रयास करेंगे।यह एक बुरी चीज है; बहुत कम सिस्टम आपको दुर्घटनाग्रस्त किए बिना ऐसा करने की अनुमति देंगे, यहां तक ​​कि कम से कम किसी भी प्रतिकूल प्रभाव के बिना इसे अनुमति देगा (एचपी-यूएक्स के कुछ संस्करण वास्तव में ठीक काम करते हैं)।

दायीं तरफ होना चाहिए। px से उठाया गया मान 100 है, इसलिए मान 7 उस स्मृति स्थान पर लिखा गया है, जिसका उद्देश्य x बदलना है।

मुझे अक्सर चित्रों (यहां तक ​​कि आदिम ASCII कलाएं भी मिलती हैं, क्योंकि मैं रूबेंस या बोटीसीली नहीं हूं) अवधारणाओं को स्पष्ट करने में मदद करता हूं। उम्मीद है कि यह आपके लिए थोड़ा सा साफ़ कर दिया गया है।

Answer 3

सी में कोई null कीवर्ड नहीं है (कम से कम एएनएसआई सी 99 में)। आप ए) या सी का उपयोग कर सकते हैं)।

सी में) आप पॉइंटर को शून्य के साथ प्रारंभ नहीं करेंगे, आप इसे स्थानीय चर के पते के साथ प्रारंभ करेंगे।

Answer 4

अपने पॉइंटर्स को प्रारंभ करें जो एक शून्य सूचक स्थिरांक से कुछ भी इंगित नहीं करते हैं। मूल्य 0 के साथ कोई निरंतर अभिव्यक्ति शून्य सूचक स्थिर के रूप में कार्य करता है। सी में NULL मैक्रो का उपयोग सम्मेलन द्वारा किया जाता है। संपादित में अपने प्रश्न का

Answer 5

उत्तर:

• जब आप ऐसा करते:

  int tmp = 0; 
  int *tmpPtr = &tmp; 
  Mem::Copy((void*)tmpPtr, basepointer(), sizeof(int)); 
  

tmpPtr चर tmp का पता की ओर इशारा करते है और यह stack में है। और ध्यान दें कि tmpPtr द्वारा इंगित "सुरक्षित क्षेत्र" tmp का आकार है (जो कि कुछ मशीनों में 4 है और 2 अन्य में)। यदि आप tmpPtr के आकार (int) बाइट्स से अधिक प्रतिलिपि बनाना चाहते हैं तो आपको स्टैक को क्रैश करने का खतरा होगा।

• जब आप ऐसा करते:

  int *tmpPtr = 0; 
  Mem::Copy((void*)tmpPtr, basepointer(), sizeof(int)); 
  

ताकि आप एक segment fault. है, जो एक स्मृति संरक्षण आपरेशन प्रणाली द्वारा की पेशकश की व्यवस्था नहीं है मिल जाएगा tmpPtr का मूल्य, 0 है। उदाहरण के लिए, आपको virtual address लिखने की अनुमति नहीं है जो 4K से कम है।

Answer 6

लाइन

int *tmpPtr = 0; 

0 पर सूचक मूल्य initializes तो tmpPtr इशारा कर रही है "कहीं नहीं"; यानी, मान्य स्मृति स्थान नहीं है। आपको पॉइंटर को पहले एक वैध मेमोरी लोकेशन असाइन करना होगा जैसा कि आपने पिछले स्निपेट में किया था।

Answer 7

मैं बस अपने सूचक ज्ञान को ताज़ा कर रहा था और इस पर ठोकर खा रहा था।

int *tmpPtr = 0; 

मैं यह आसान इस तरह यह सोचने के लिए लगता है:

int *tmpPtr ; 

tmpPtr = 0 ; 

मैं 'बिलीव' ऊपर 2 लाइनों है कि एक लाइन के बराबर हैं। इसलिए मूल रूप से डी-रेफरेंस किया जाने वाला पता 0 या NULL पर सेट किया गया है।