सी में 2 डी सरणी और सूचक - तत्वों का उपयोग कैसे करें?

Question

मेरे पास एक उदाहरण है जिसमें 2 डी सरणी के लिए पॉइंटर शामिल है। क्या कोई इस बात में मेरी मदद कर सकता है कि इस उदाहरण में क्या चल रहा है?

int main() 
{ 

    int i = 0, j=0, sum0=0, sum1=0; 
    int data[4][3] = { {23,55,50},{45,38,55},{70,43,45},{34,46,60}}; 
    int *Ptr; 
    Ptr = *data; //Why is the indirection operator used here? 
        // Does Ptr = 23 by this assignment? 

    for (i=0; i<4; i++) { 
     sum1 = 0; 
     for (j = 0; j < 3; j++) { 
      sum1 += data[i][j]; 
     } 
     if (sum1 > sum0) { 
       sum0 = sum1; 
       Ptr = *(data + i);  // Seems like this statement makes Ptr 
     }        // point one row below ... what syntax 
    }         // can you use to access columns then? 
             // Is it possible to use pointer arithmetic 
    for (i=0; i<3; i++)     // to access elements of data[i][j] that 
     printf("%d\n", Ptr[i]);   // are not at j = 0? 

    return 0; 
} 

Answer 1

data एक 2 आयामी सरणी है, जिसमें 4 पंक्तियां हैं और प्रत्येक पंक्ति में 3 तत्व हैं (यानी 4 एक्स 3)।

अब, Ptr = *data; का अर्थ है कि आप पहली पंक्ति के शुरुआती पते को पॉइंटर चर Ptr पर संग्रहीत कर रहे हैं। यह कथन Ptr = *(data + 0) के बराबर है। Ptr = *(data + 1) - इसका मतलब है कि हम दूसरी पंक्ति के शुरुआती पते को आवंटित कर रहे हैं।

फिर *Ptr या *(Ptr + 0) आपको पंक्ति के पहले तत्व का मान देगा जो इंगित कर रहा है। इसी प्रकार, *(Ptr + 1) आपको पंक्ति के दूसरे तत्व का मूल्य देगा।

for आपके प्रोग्राम में लूप का उपयोग यह पता लगाने के लिए किया जाता है कि किस पंक्ति में इसके तत्वों (3 तत्व) के योग का अधिकतम मूल्य है। एक बार जब नियंत्रण for लूप से निकलता है, Ptr उस पंक्ति पर इंगित करेगा जिसमें अधिकतम तत्व हैं और sum0 में योग का मूल्य होगा।

एक सरणी int a[5]; पर विचार करें, मुझे आशा है कि आपको पता है कि a[0] और 0[a] समान है। ऐसा इसलिए है क्योंकि a[0] का अर्थ है *(a+0) और 0[a] का अर्थ *(0 + a) है। यह वही तर्क 2 आयामी सरणी में उपयोग किया जा सकता है।

data[i][j]*(*(data + i) + j) के समान है। हम इसे i[data][j] के रूप में भी लिख सकते हैं।

अधिक जानकारी के लिए कृपया यशवंत कनानेकर द्वारा "समझने वाले पॉइंटर्स इन सी" पुस्तक देखें।

Answer 2

data पूर्णांक के 3-तत्व सरणी की एक सरणी है। उन संदर्भों में जो "पॉइंटर टू फू" की अपेक्षा करते हैं, आप "foo की सरणी" का उपयोग कर सकते हैं और यह अपने पहले तत्व के लिए सूचक की तरह व्यवहार करेगा, इसलिए *datadata के पहले तत्व के लिए एक सूचक है, अर्थात् (बोलने के लिए) {23,55,50}।

तो, टिप्पणियों में पहले प्रश्न का उत्तर: नहीं, यह सच नहीं है कि Ptr = 23। (यह नहीं हो सकता है, Ptr एक int * और 23 एक int है।)

आप सही हैं कि Ptr = *(data+i)data की i वीं पंक्ति को Ptr बिंदु बनाता है। अधिक सटीक, data int के 3-तत्व सरणी की एक सरणी है, जो int के 3-तत्व सरणी के लिए सूचक की तरह व्यवहार करती है; i जोड़कर i ऐसे सरणी चलाते हैं।

सरणी के अन्य कॉलम तक पहुंचने का सामान्य तरीका सामान्य सरणी अनुक्रमण है। यदि आप data[i][j] देखें, तो आपको पंक्ति i पंक्ति j मिल रहा है। यदि आप इसे स्पष्ट सूचक अंकगणितीय के साथ करना चाहते हैं, तो ध्यान दें कि उदाहरण के कोड में "उदा। Ptr" पूर्णांक के लिए सूचक "प्रकार है, इसलिए Ptr+1 (उदाहरण के लिए) जो भी पंक्ति Ptr का तत्व 1 इंगित कर रहा है। (लेकिन, शैली के मामले में, आपको आमतौर पर स्पष्ट सूचक अंकगणित नहीं करना चाहिए जब आपको वास्तव में आवश्यकता नहीं होती है।)

Answer 3

आपके उदाहरण में लूप सभी मैट्रिक्स पंक्तियों के माध्यम से जाता है, जिसमें सभी तत्वों का योग होता है अधिकतम मूल्य रखता है।

शुरुआत पहली पंक्ति के लिए सूचक असाइन किया गया है पर:

Ptr = *data; 

जिसका मतलब है कि निम्न सत्य है:

(Ptr[0] == 23 && Ptr[1] == 55 && Ptr[2] == 50) 

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

Answer 4

Ptr = *data;*(data+0)+0 के लिए छोटा है जो पहली पंक्ति के पहले कॉलम तत्व के लिए सूचक है। डेटा के साथ जोड़ा गया पहला 0 पंक्ति संख्या है, जो अप्रत्यक्ष है और हमें पहली पंक्ति में ले जाता है। * (data+0) अभी भी एक पता है और यह मान नहीं है कि यह इंगित करता है (2 डी सरणी के लिए)। तो, पीआरटी अब पहली पंक्ति में पहले कॉलम के पते पर इंगित करता है। दूसरा शून्य स्तंभ संख्या है .. तो, पहली पंक्ति और पहले कॉलम का मेमोरी पता चुना गया है। संकेत (*) का उपयोग करना फिर से केवल उस मूल्य को देगा जो पता रखता है। * (*(data+0)+0) या **data की तरह।

आम तौर पर, अगर पी सूचक नाम है, मैं पंक्ति संख्या और जे स्तंभ संख्या,

1. (*(p+i)+j) 2 डी सरणी में एक तत्व की एक स्मृति पता देना होगा। मैं पंक्ति संख्या है। और जे कॉल नंबर है,
2. *(*(p+i)+j) उस तत्व का मूल्य देगा।
3. *(p+i) कॉलम तक पहुंचने के लिए ith पंक्ति
4. तक पहुंच जाएगा, कॉलम संख्या *(p+i) पर जोड़ें। आपको *p के बजाय पॉइंटर को (*p)[columns] के रूप में घोषित करना पड़ सकता है। ऐसा करने से, आप पॉइंटर को 2 डी सरणी में घोषित कर रहे हैं।

पॉइंटर अंकगणित का उपयोग करना 2 डी सरणी जैसे 2 डी सरणी का इलाज कर रहा है। पॉइंटर * पीआरआर को पहले तत्व (int *Ptr = *data) में शुरू करें और फिर कोई संख्या जोड़ें। (Ptr + n) कॉलम तक पहुंचने के लिए। स्तंभ संख्या से अधिक संख्या जोड़ना, यदि मौजूद है, तो अगली पंक्ति के पहले कॉलम से तत्वों को गिनना जारी रखेगा।