Saturday, February 29, 2020

Arrays and 2d array उदाहरण के साथ C प्रोग्रामिंग में



एक सरणी समान डेटा प्रकारों का एक समूह (या संग्रह) है। उदाहरण के लिए एक int array int प्रकार के तत्वों को रखती है जबकि एक float array फ्लोट प्रकारों के तत्वों को रखती है।

c programing array
c programing array

हमें सी प्रोग्रामिंग में ऐरे की आवश्यकता क्यों है? (Why we need Array in C Programming):

एक परिदृश्य पर विचार करें जहां आपको उपयोगकर्ता द्वारा दर्ज किए गए 100 पूर्णांक संख्याओं के औसत का पता लगाना होगा। C में, आपके पास ऐसा करने के दो तरीके हैं: 1) int डेटा प्रकार के साथ 100 चर परिभाषित करें और फिर चर में दर्ज मानों को संग्रहीत करने के लिए 100 scanf () संचालन करें और फिर उनमें से औसत की गणना करें। 2) सभी मूल्यों को संग्रहीत करने के लिए एक पूर्णांक सरणी है, सरणी में सभी दर्ज मूल्यों को संग्रहीत करने के लिए सरणी को लूप करें और बाद में औसत की गणना करें।




आपके अनुसार कौन सा उपाय बेहतर है? स्पष्ट रूप से दूसरा समाधान, समान डेटा प्रकारों को एक एकल चर में संग्रहीत करना और बाद में ऐरे इंडेक्स का उपयोग करके उन्हें एक्सेस करना सुविधाजनक है (हम इस ट्यूटोरियल में बाद में चर्चा करेंगे)।

सी में ऐरे की घोषणा कैसे करें (How to declare Array in C)

int num[35];  /* An integer array of 35 elements */
char ch[10];  /* An array of characters for 10 elements */

इसी तरह एक सरणी किसी भी डेटा प्रकार की हो सकती है जैसे डबल, फ्लोट, शॉर्ट आदि।
कैसे सी में एक सरणी के तत्व का उपयोग करने के लिए

आप सरणी में संग्रहीत किसी भी तत्व तक पहुंचने के लिए सरणी सबस्क्रिप्ट (या इंडेक्स) का उपयोग कर सकते हैं। सदस्यता 0 से शुरू होती है, जिसका अर्थ है कि गिरफ्तारी [0] सरणी गिरफ्तार में पहले तत्व का प्रतिनिधित्व करती है।

सामान्य रूप से गिरफ्तार [n-1] का उपयोग किसी सरणी के nth तत्व तक पहुंचने के लिए किया जा सकता है। जहां n कोई पूर्णांक संख्या है।


उदाहरण के लिए: 

int mydata[20];
mydata[0] /* first element of array mydata*/
mydata[19] /* last (20th) element of array mydata*/

Example of Array In C programming to find out the average of 4 integers

#include <stdio.h>
int main()
{
    int avg = 0;
    int sum =0;
    int x=0;

    /* Array- declaration – length 4*/
    int num[4];

    /* We are using a for loop to traverse through the array
     * while storing the entered values in the array
     */
    for (x=0; x<4;x++)
    {
        printf("Enter number %d \n", (x+1));
        scanf("%d", &num[x]);
    }
    for (x=0; x<4;x++)
    {
        sum = sum+num[x];
    }

    avg = sum/4;
    printf("Average of entered number is: %d", avg);
    return 0;
}
Output:
Enter number 1 
10
Enter number 2 
10
Enter number 3 
20
Enter number 4 
40
Average of entered number is: 20

उपरोक्त कार्यक्रम के महत्वपूर्ण भागों पर चर्चा करते हैं:

सरणी में इनपुट डेटा (Input data into the array)


यहां हम सरणी को 0 से 3 तक दोहरा रहे हैं क्योंकि सरणी का आकार 4. है। लूप के अंदर हम मूल्यों को दर्ज करने के लिए उपयोगकर्ता को एक संदेश प्रदर्शित कर रहे हैं। सभी इनपुट मान स्कैन फ़ंक्शन के उपयोग से संबंधित सरणी तत्वों में संग्रहीत किए जाते हैं।


for (x=0; x<4;x++)
{
    printf("Enter number %d \n", (x+1));
    scanf("%d", &num[x]);
}

किसी सरणी से डेटा पढ़ना (Reading out data from an array)


मान लीजिए, यदि हम सरणी के तत्वों को प्रदर्शित करना चाहते हैं तो हम सी में लूप के लिए इस तरह का उपयोग कर सकते हैं।

for (x=0; x<4;x++)
{
    printf("num[%d]\n", num[x]);
}

एक सरणी को इनिशियलाइज़ करने के विभिन्न तरीके (Various ways to initialize an array)


उपरोक्त उदाहरण में, हमने केवल ऐरे को घोषित किया है और बाद में हमने इसे उपयोगकर्ता द्वारा मान इनपुट के साथ आरंभीकृत किया है। हालाँकि आप इस तरह घोषणा के दौरान सरणी को इनिशियलाइज़ कर सकते हैं:


int arr[5] = {1, 2, 3, 4 ,5};

OR (both are same)

int arr[] = {1, 2, 3, 4, 5};

Un-initialized array में हमेशा कचरा मान होते हैं।

सी ऐरे - मेमोरी प्रतिनिधित्व(C Array – Memory representation)

 

c-arrays
Memory representation


 

सी में ऐरे पर अधिक विषय (More Topics on Arrays in C)

2D सरणी - हम C में 2D और 3D सरणी की तरह बहुआयामी सरणियाँ रख सकते हैं। हालांकि सबसे लोकप्रिय और अक्सर इस्तेमाल किया जाने वाला सरणी 2 डी है - दो आयामी सरणी। इस पोस्ट में आप सीखेंगे कि 2D सरणी में डेटा को कैसे घोषित किया जाए, पढ़ा जाए और उसके साथ अन्य सुविधाओं को भी लिखा जाए।

किसी फ़ंक्शन के लिए एक सरणी पास करना- आमतौर पर हम फ़ंक्शन को कॉल करते समय मूल्यों और चर को पास करते हैं, इसी तरह हम किसी फ़ंक्शन को एरेज़ भी पास कर सकते हैं। आप किसी फ़ंक्शन के लिए सरणी के तत्व के साथ-साथ पूरे सरणी (केवल सरणी का नाम निर्दिष्ट करके, जो सूचक के रूप में काम करता है) पास कर सकते हैं।

पॉइंट टू एरे - एरे तत्वों को सी में पॉइंटर्स का उपयोग करके एक्सेस किया जा सकता है और हेरफेर किया जा सकता है। पॉइंटर्स का उपयोग करके आप आसानी से एरे को हैंडल कर सकते हैं। आप सरणी चर के आधार पते को सूचक चर में निर्दिष्ट करके किसी सरणी के सभी तत्वों का उपयोग कर सकते हैं।

 उदाहरण के साथ C प्रोग्रामिंग में दो आयामी (2D) सरणियाँ  (Two dimensional (2D) arrays in C programming with example)


सरणियों की एक सरणी को 2D सरणी के रूप में जाना जाता है। C प्रोग्रामिंग में दो आयामी (2D) सरणी को मैट्रिक्स के रूप में भी जाना जाता है। मैट्रिक्स को पंक्तियों और स्तंभों की तालिका के रूप में दर्शाया जा सकता है। इससे पहले कि हम दो आयामी सरणी के बारे में अधिक चर्चा करते हैं, निम्नलिखित सी प्रोग्राम पर एक नज़र डाल सकते हैं।

सरल दो आयामी (2 डी) सरणी उदाहरण (Simple Two dimensional(2D) Array Example)


अभी के लिए चिंता न करें कि एक दो आयामी सरणी को कैसे आरंभ करें, हम बाद में उस हिस्से पर चर्चा करेंगे। यह कार्यक्रम दर्शाता है कि 2d सरणी में उपयोगकर्ता द्वारा दर्ज किए गए तत्वों को कैसे संग्रहीत किया जाए और दो आयामी सरणी के तत्वों को कैसे प्रदर्शित किया जाए।

#include<stdio.h>
int main(){
   /* 2D array declaration*/
   int disp[2][3];
   /*Counter variables for the loop*/
   int i, j;
   for(i=0; i<2; i++) {
      for(j=0;j<3;j++) {
         printf("Enter value for disp[%d][%d]:", i, j);
         scanf("%d", &disp[i][j]);
      }
   }
   //Displaying array elements
   printf("Two Dimensional array elements:\n");
   for(i=0; i<2; i++) {
      for(j=0;j<3;j++) {
         printf("%d ", disp[i][j]);
         if(j==2){
            printf("\n");
         }
      }
   }
   return 0;
}

Output:
Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3 
4 5 6 
  

2 डी ऐरे की शुरुआत (Initialization of 2D Array)


घोषणा के दौरान दो आयामी सरणियों को शुरू करने के दो तरीके हैं। 

int disp[2][4] = {
    {10, 11, 12, 13},
    {14, 15, 16, 17}
};

OR

int disp[2][4] = { 10, 11, 12, 13, 14, 15, 16, 17};


यद्यपि उपरोक्त दोनों घोषणाएं मान्य हैं, मैं आपको पहली विधि का उपयोग करने की सलाह देता हूं क्योंकि यह अधिक पठनीय है, क्योंकि आप इस विधि में 2d सरणी की पंक्तियों और स्तंभों की कल्पना कर सकते हैं।

2 डी सरणी को इनिशियलाइज़ करते समय जिन बातों पर आपको विचार करना चाहिए (Things that you must consider while initializing a 2D array)

हम पहले से ही जानते हैं, जब हम घोषणा के दौरान एक सामान्य सरणी (या आप एक आयामी सरणी कह सकते हैं) को शुरू करते हैं, तो हमें इसके आकार को निर्दिष्ट करने की आवश्यकता नहीं है। हालाँकि यह 2 डी सरणी के मामले में नहीं है, आपको घोषणा के दौरान तत्वों को निर्दिष्ट करते हुए भी हमेशा दूसरा आयाम निर्दिष्ट करना चाहिए। आइए इसे कुछ उदाहरणों की मदद से समझते हैं - 

/* Valid declaration*/
int abc[2][2] = {1, 2, 3 ,4 }  
/* Valid declaration*/ 
int abc[][2] = {1, 2, 3 ,4 }  
/* Invalid declaration – you must specify second dimension*/
int abc[][] = {1, 2, 3 ,4 }   
/* Invalid because of the same reason  mentioned above*/
int abc[2][] = {1, 2, 3 ,4 }

 2 डी सरणी में उपयोगकर्ता इनपुट डेटा को कैसे स्टोर करें(How to store user input data into 2D array)

हम इस सूत्र का उपयोग करके एक दो आयामी सरणी के कितने तत्वों की गणना कर सकते हैं:
सरणी अरेस्ट [n1] [n2] में n1 * n2 तत्व हो सकते हैं। नीचे दिए गए उदाहरण में जो सरणी है, उसके आयाम 5 और 4 हैं। इन आयामों को सदस्यता के रूप में जाना जाता है। तो इस सरणी का पहला सबस्क्रिप्ट मान 5 और दूसरा सबस्क्रिप्ट मान 4 है।
तो सरणी एबीसी [5] [४] में ५ * ४ = २० तत्व हो सकते हैं।

उपयोगकर्ता द्वारा दर्ज किए गए तत्वों को संग्रहीत करने के लिए हम दो छोरों के लिए उपयोग कर रहे हैं, उनमें से एक नेस्टेड लूप है। बाहरी लूप 0 से (प्रथम सबस्क्रिप्ट -1) तक चलता है और लूप के लिए आंतरिक 0 से (दूसरा सबस्क्रिप्ट -1) तक चलता है। इस तरह जिस क्रम में उपयोगकर्ता तत्वों में प्रवेश करता है वह एबीसी [0] [0], एबीसी [०] [१], एबीसी [०] [२] ... इत्यादि होगा।

#include<stdio.h>
int main(){
   /* 2D array declaration*/
   int abc[5][4];
   /*Counter variables for the loop*/
   int i, j;
   for(i=0; i<5; i++) {
      for(j=0;j<4;j++) {
         printf("Enter value for abc[%d][%d]:", i, j);
         scanf("%d", &abc[i][j]);
      }
   }
   return 0;
}

उपरोक्त उदाहरण में, मेरे पास पूर्णांक प्रकार का 2D सरणी एबीसी है। वैचारिक रूप से आप उपरोक्त सरणी की कल्पना इस प्रकार कर सकते हैं:
2D-array
2d-array in c
 


 हालाँकि स्मृति में इस सरणी का वास्तविक प्रतिनिधित्व कुछ इस तरह होगा:
memory-2D-diagram
array representation of 2d array

 संकेत और 2D सरणी (Pointers & 2D array)


जैसा कि हम जानते हैं कि एक आयामी सरणी नाम सरणी के आधार तत्व (पहला तत्व) के लिए एक सूचक के रूप में काम करता है। हालांकि 2 डी सरणियों के मामले में तर्क थोड़ा अलग है। आप कई एक आयामी सरणियों के संग्रह के रूप में 2 डी सरणी पर विचार कर सकते हैं।

तो एबीसी [0] में पहली पंक्ति के पहले तत्व का पता होगा (यदि हम उपरोक्त आरेख संख्या 1 पर विचार करते हैं)।
इसी तरह abc [1] में दूसरी पंक्ति के पहले तत्व का पता होगा। इसे बेहतर ढंग से समझने के लिए, हम C प्रोग्राम लिखते हैं -
#include <stdio.h>
int main()
{
   int abc[5][4] ={
            {0,1,2,3},
            {4,5,6,7},
            {8,9,10,11},
            {12,13,14,15},
            {16,17,18,19}
            };
    for (int i=0; i<=4; i++)
    {
        /* The correct way of displaying an address would be
         * printf("%p ",abc[i]); but for the demonstration
         * purpose I am displaying the address in int so that
         * you can relate the output with the diagram above that
         * shows how many bytes an int element uses and how they
         * are stored in contiguous memory locations.
         *
         */
     printf("%d ",abc[i]);
    }
    return 0;
}
Output:
1600101376 1600101392 1600101408 1600101424 1600101440


 वास्तविक पता प्रतिनिधित्व हेक्स में होना चाहिए जिसके लिए हम% d के बजाय% p का उपयोग करते हैं, जैसा कि टिप्पणियों में उल्लेख किया गया है। यह केवल यह दिखाने के लिए है कि तत्व सन्निहित स्मृति स्थानों में संग्रहीत हैं। आप ऊपर दिए गए आरेख के साथ आउटपुट से संबंधित देख सकते हैं कि इन पतों के बीच का अंतर वास्तव में उस पंक्ति के तत्वों द्वारा खपत बाइट्स की संख्या है।

आउटपुट में दिखाए गए पते प्रत्येक पंक्ति abc [0] [0], abc [1] [0], abc [2] [0], abc [3] [0] और abc [4] के पहले तत्व के हैं। [0]।



Next Chapter : -  Strings and string functions with examples with c in Hindi

0 Comments:

Post a Comment