दिलचस्प पोस्ट
सरणी के लिए अल्पविराम से अलग स्ट्रिंग कन्वर्ट करें एंड्रॉइड इन्टेंट को अनुकूलित करें। ACTION_SEND क्या अजगर का एकमात्र परीक्षण समानांतर में हो सकता है, नाक की तरह? 1-अनुक्रमित प्रोग्रामिंग भाषाओं की सूची? एएसपी .नेट बटन ईवेंट हैंडलर्स पहली क्लिक पर आग नहीं लगाते, लेकिन एक पोस्टबैक के बाद दूसरे क्लिक पर क्यों ढलाई होना चाहिए? IOS पर सीएसएस के साथ आईफ़्रेम आकार बूस्ट के साथ INI फ़ाइल को पार्स करने के लिए कैसे करें SQL सर्वर एक्सप्रेस की सीमाएं विधि प्रविष्टि डीबगिंग का उपयोग करते समय डीबग किए गए प्रोग्राम धीमा क्यों करता है? चयन कथन में BOOLEAN प्रकार का उपयोग कैसे करें आईओएस 9 की नई सुविधा निशुल्क प्रोविजनिंग (ऐप्पल डेवलपर सदस्यता के बिना, केवल आपकी ऐप्पल आईडी के साथ, डिवाइस पर अपना ऐप चलाएं) डुप्लिकेट HTTP प्रतिसाद हेडर स्वीकार्य हैं? एएसपी एमवीसी दृश्य के अंदर AJAX.beginform का उपयोग करके डिवेल को अपडेट करें XMLHttpRequest प्रवेश 10 से नीचे किसी भी IE संस्करण पर AngularJS के साथ मना कर दिया

एक फ़ंक्शन में बहुआयामी सरणी का उपयोग करें

मैंने यहां बहुत सारे सामान पढ़ा और कई प्रयास किए, लेकिन मुझे सी में फ़ंक्शन के लिए एक बहुआयामी सरणी को पारित करने का कोई तरीका नहीं मिला, कुछ मानों को परिवर्तित करें और किसी तरह नए सरणी वापस लौटाएं यह सरणी को आगे किसी अन्य फ़ंक्शन पर पास करने और एक ही काम करने का तरीका ढूंढना महत्वपूर्ण है।

मैं एक समारोह में सरणी को पारित करने का एक रास्ता खोजना चाहता हूं। फिर पहले समारोह से इसे दूसरी बार में पारित करने के लिए, कुछ करें (शायद प्रिंट, शायद मान बदल), फिर इसे पहले फ़ंक्शन पर दोबारा प्रयोग करें और अंत में उपयोग करें मुख्य में उस सरणी

मेरा आखिरी प्रयास है:

void func(int multarray[][columns]){ multarray[0][0]=9; } int main(){ int rows; int columns; int multarray[rows][columns]; func(multarray); return 0; } 

मैंने यह भी कोशिश की:

 void func(int multarray[rows][columns]){ multarray[0][0]=9; } int main(){ int rows; int columns; int multarray[rows][columns]; func(multarray); return 0; } 

मैंने यह भी कोशिश की:

 int getid(int row, int x, int y) { return (row*x+y); } void printMatrix(int*arr, int row, int col) { for(int x = 0; x < row ; x++) { printf("\n"); for (int y = 0; y <col ; y++) { printf("%d ",arr[getid(row, x,y)]); } } } main() { int arr[2][2] = {11,12,21,22}; int row = 2, col = 2; printMatrix((int*)arr, row, col); } 

यहां से

मैंने भी दोहरे संकेत दिए। मैंने यह भी पढ़ा कि एक अलग दृष्टिकोण है यदि संकलक VLAs का समर्थन नहीं करता है। मैं gnu का उपयोग कर रहा हूँ

Solutions Collecting From Web of "एक फ़ंक्शन में बहुआयामी सरणी का उपयोग करें"

बिल्कुल निश्चित नहीं, समस्या क्या है लेकिन यह काम करता है (और मूल्य "9" प्रिंट करता है):

 #include <stdio.h> #define ROWS 10 #define COLUMNS 10 void func2(int multarray[][COLUMNS]){ multarray[1][4]=10; } void func1(int multarray[][COLUMNS]){ multarray[0][3]=9; func2(multarray); } int main(){ int multarray[ROWS][COLUMNS]; func1(multarray); printf("%d\n", multarray[0][3]); printf("%d\n", multarray[1][4]); return 0; } 

ध्यान दें, सरणी एक समारोह के लिए पारित जब एक संकेतक को decays

याद करने के लिए कई चीजें:

  1. जब आप किसी फ़ंक्शन के तर्क के रूप में एक सरणी अभिव्यक्ति को पास करते हैं, तो इसे "N-element array of T " से "सूचक से T " तक अभिव्यक्ति से कनवर्ट किया जाएगा, और अभिव्यक्ति का मान पहले का पता होगा सरणी का तत्व फ़ंक्शन को एक सूचक मूल्य प्राप्त होता है

  2. [] ऑपरेटर का उपयोग सरणी या सूचक प्रकार के भाव के साथ किया जा सकता है; IOW, घोषित घोषणाएं int a[10]; int *p = a; int a[10]; int *p = a; , फिर p[i] और a[i] उसी तत्व का संदर्भ देता है

  3. एक फ़ंक्शन जो एक पैरामीटर के रूप में वीएलए को स्वीकार करते हैं, घोषित करते समय, आपको पैरामीटर निर्दिष्ट करना होगा जो कि आप सरणी को घोषित करने से पहले आयाम निर्दिष्ट करते हैं।

इसलिए, एक फ़ंक्शन के लिए जो 2 डी वीएलए का उपयोग करता है, आप कुछ लिखना चाहते हैं

 void foo( size_t rows, size_t cols, int (*multiarray)[cols] ) // or multiarray[][cols] { size_t i, j; for ( i = 0; i < rows; i++ ) for ( j = 0; j < cols; j++ ) multiarray[i][j] = some_value(); } 

int (*multiarray)[cols] साथ क्या हो रहा है int (*multiarray)[cols] ? याद रखें कि एक तर्क के रूप में सरणी अभिव्यक्ति को पारित करने में, सरणी अभिव्यक्ति का प्रकार "N-element array of T " से "pointer to T " में बदल जाता है। इस स्थिति में, T " cols -एलेमेंट ऐरे ऑफ int " है, इसलिए हम " rows -अनुक्रमित ऐलनों के cols -इलेमेंट एरे के int " से "पॉइन्टर टू cols -एलेमेंट एरे ऑफ int " से जा रहे हैं। फ़ंक्शन पैरामीटर घोषणा के संदर्भ में, T a[N] , T a[] , और T *a सभी समान हैं; सभी तीन मामलों में, T को T लिए एक सूचक के रूप में घोषित किया जाता है। इसलिए int (*multiarray)[cols] int multiarray[][cols] समतुल्य है, जो int multiarray[rows][cols] बराबर है। मैं पहले प्रपत्र का उपयोग करना पसंद करता हूं क्योंकि यह स्थिति को सबसे सटीक प्रतिनिधित्व करता है।

यदि आप किसी अन्य फ़ंक्शन के तर्क के रूप में इस सरणी को पारित करना चाहते हैं, तो आप उसी प्रकार का उपयोग करेंगे:

 void bar( size_t rows, size_t cols, int (*multiarray)[cols] ) { foo( rows, cols, multiarray ); } int main( void ) { size_t rows = 0; size_t cols = 0; // you must assign values to rows and cols before declaring a VLA with them rows = ...; cols = ...; int arr[rows][cols]; bar( rows, cols, arr ); ... } 

foo में बनाई गई सरणी सामग्री में कोई भी बदलाव bar और main में दिखाई देगा।

वीएलए उपयोगी हो सकते हैं, लेकिन उनके पास उनकी सीमाएं हैं उन्हें static घोषित नहीं किया जा सकता है, न ही उन्हें किसी फ़ंक्शन के बाहर परिभाषित किया जा सकता है। वे {} -स्टाइल आरंभीकरण वाक्यविन्यास का उपयोग नहीं कर सकते इसके अलावा, VLA समर्थन अब 2011 मानक के रूप में वैकल्पिक है , इसलिए आप उन पर भरोसा नहीं कर सकते जो हर जगह समर्थित हैं।

इस घटना में आपके पास वीएलए उपलब्ध नहीं है और आपके ऑरेंज का आकार रनटाइम तक ज्ञात नहीं है, आपको डायनामिक स्मृति आवंटन ( calloc या calloc ) का उपयोग करना होगा, और आपके कार्यों को जो प्रकार आप पास करते हैं वह अलग होगा:

 void foo( size_t rows, size_t cols, int **multiarray ) { size_t i, j; for ( i = 0; i < rows; i++ ) for ( j = 0; j < cols; j++ ) multiarray[i][j] = some_value(); } void bar( size_t rows, size_t cols, int **multiarray ) { foo( rows, cols, multiarray ); } int main( void ) { size_t rows; size_t cols; int **multiarray = NULL; ... // get rows and cols // allocate memory for pointers to each row multiarray = malloc( sizeof *multiarray * rows ); if ( multiarray ) { size_t i; // allocate each row for ( i = 0; i < rows; i++ ) { multiarray[i] = malloc( sizeof *multiarray[i] * cols ); if ( !multiarray[i] ) break; } if ( i < rows ) { // malloc failed for one of the multiarray rows; we need to // free whatever memory has already been allocated and exit while ( i-- ) free( multiarray[i] ); free( multiarray ); exit(0); } } bar ( rows, cols, multiarray ); ... if ( multiarray ) { size_t i; for ( i = 0; i < rows; i++ ) free( multiarray[i] ); free( multiarray ); } } 

इस दृष्टिकोण के साथ एक दोष यह है कि आवंटित स्मृति संकीर्ण होने की गारंटी नहीं है (यानी, पंक्तियों को स्मृति में आसन्न नहीं होगा)। यदि यह मामला है, तो आपको एक और दृष्टिकोण के साथ जाना होगा। अलग-अलग पंक्तियों और स्तंभों को आवंटित करने के बजाय, आप एक ही ब्लॉक में सब कुछ आवंटित करते हैं, और मैन्युअल रूप से सरणी सूचकांक मैप करें:

 void foo( size_t rows, size_t cols, int *fakemultiarray ) { size_t i, j; for ( i = 0; i < rows; i++ ) for ( j = 0; j < rows; j++ ) fakemultiarray[ i * rows + j ] = some_value(); } void bar( size_t rows, size_t cols, int *fakemultiarray ) { foo( rows, cols, fakemultiarray ); } int main( void ) { size_t rows; size_t cols; int *fakemultiarray = NULL; ... // get rows and cols fakemultiarray = malloc( sizeof *fakemultiarray * rows * cols ); if ( fakemultiarray ) bar( rows, cols, fakemultiarray ); ... free( fakemultiarray ); } 

इस मामले में, हमने सभी तत्वों के लिए पर्याप्त एक एकल बफर आवंटित किया है, लेकिन हमें इसे 1 डी सरणी के रूप में इंडेक्स करना होगा, इंडेक्स को i * rows + j रूप में कंप्यूटिंग करना होगा।

अपने 2 आयामी arrays के लिए मैं इसके लिए एक प्रकार परिभाषित होगा

 typedef int my2DArray_t[ROWS][COLUMNS]; 

तब आप इस प्रकार और पॉइंटर्स के वेरिएबल घोषित कर सकते हैं। इससे चीजों को पार करने में आसान होता है

 void someFuncOther (my2DArray_t *someArray) { /* Set some values in array */ (*someArray)[1][1] = 4; } void someFunc (my2DArray_t *someArray) { /* Set some values in array */ (*someArray)[1][0] = 7; /* Have someFuncOther do some more work */ someFuncOther (someArray); } int main (void) { /* This is the actual array */ my2DArray_t myArray; /* Set some values in array */ myArray[0][2] = 6; /* Have someFunc do some work on myArray by passing a pointer to it */ someFunc (&myArray); } 

स्मृति को संकेतक के रूप में सरणियों के बारे में सोचना उपयोगी है फिर संकेतक के रूप में एक 2d सरणी के बारे में सोचना आसान है (संकेत)

यह काम करने वाला नहीं है

  int arr[2][2] = {11,12,21,22}; //not going to work 

लेकिन यह मेरे लिए ठीक काम किया

  1 #include <stdio.h> 2 3 4 main() 5 { 6 int arr[2][2] = {{11,1},{2,21}}; 7 int row = 2, col = 2; 8 int i,j; 9 10 for(i=0;i<row;i++) 11 for(j=0;j<col;j++) 12 printf("%d - ",arr[i][j]); 13 14 15 }