सी में फ़ंक्शन तर्क के रूप में बहुआयामी सरणी पास करना

सी में मैं एक बहुआयामी सरणी को एक समारोह में एक तर्क के रूप में पास कर सकता हूं जब मुझे नहीं पता कि सरणी के आयाम क्या होने जा रहे हैं?

इसके अलावा मेरे बहुआयामी सरणी में तारों के अलावा अन्य प्रकार हो सकते हैं।

0
ro fr bn

4 उत्तर

आप इसे किसी भी डेटा प्रकार से कर सकते हैं। बस इसे एक पॉइंटर-टू-पॉइंटर बनाएं:

typedef struct {
  int myint;
  char* mystring;
} data;

data** array;

लेकिन यह मत भूलना कि आपको अभी भी चर को मॉलोक करना है, और यह थोड़ा जटिल हो जाता है:

//initialize
int x,y,w,h;
w = 10; //width of array
h = 20; //height of array

//malloc the 'y' dimension
array = malloc(sizeof(data*) * h);

//iterate over 'y' dimension
for(y=0;y

संरचना को डिलीकेट करने के लिए कोड समान दिखता है - आपके द्वारा मॉल किए गए सब कुछ पर मुफ्त() को कॉल करना न भूलें! (साथ ही, मजबूत अनुप्रयोगों में आपको malloc() ।)

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

int whatsMyInt(data** arrayPtr, int x, int y){
  return arrayPtr[y][x].myint;
}

इस समारोह को इसके साथ कॉल करें:

printf("My int is %d.\n", whatsMyInt(array, 2, 4));

आउटपुट:

My int is 6.
0
जोड़ा
पॉइंटर सेगमेंट लुकअप टेबल के लिए एक पॉइंटर 2 डी सरणी नहीं है। सिर्फ इसलिए कि यह [] [] वाक्यविन्यास की अनुमति देता है, यह जादुई रूप से सरणी में बदल नहीं जाता है। आप memcpy() इत्यादि नहीं कर सकते हैं क्योंकि स्मृति को आसन्न स्मृति कक्षों में आवंटित नहीं किया जाता है, जो सरणी के लिए आवश्यक है। आपकी लुकअप टेबल पूरे ढेर पर बिखरी हुई है, लुकअप धीमा कर रही है और ढेर खंडित है।
जोड़ा लेखक Lundin, स्रोत
यहां सहायता की आवश्यकता है: stackoverflow.com/questions/ 16943909 / & hellip;
जोड़ा लेखक Dchris, स्रोत

अलग-अलग पैरामीटर के रूप में सरणी आयामों के साथ पहले तत्व में एक स्पष्ट सूचक पास करें। उदाहरण के लिए, int के मनमाने ढंग से आकार के 2-डी सरणी को संभालने के लिए:

void func_2d(int *p, size_t M, size_t N)
{
  size_t i, j;
  ...
  p[i*N+j] = ...;
}

जिसे कहा जाएगा

...
int arr1[10][20];
int arr2[5][80];
...
func_2d(&arr1[0][0], 10, 20);
func_2d(&arr2[0][0], 5, 80);

उच्च सिद्धांत आयामों के लिए समान सिद्धांत लागू होता है:

func_3d(int *p, size_t X, size_t Y, size_t Z)
{
  size_t i, j, k;
  ...
  p[i*Y*Z+j*Z+k] = ...;
  ...
}
...
arr2[10][20][30];
...
func_3d(&arr[0][0][0], 10, 20, 30);
0
जोड़ा
मैं और जे के मूल्य क्या है?
जोड़ा लेखक Akshay Immanuel D, स्रोत
<कोड> पी [i * वाई + जे * जेड + के] पी [i * वाई * जेड + जे * जेड + के] होना चाहिए।
जोड़ा लेखक David H, स्रोत

आप अपने कार्य को इस प्रकार घोषित कर सकते हैं:

f(int size, int data[][size]) {...}

कंपाइलर तब आपके लिए सभी पॉइंटर अंकगणित करेगा।

ध्यान दें कि आयाम आकार सरणी स्वयं पहले प्रकट होना चाहिए।

जीएनयू सी तर्क घोषणा अग्रेषण के लिए अनुमति देता है (यदि आपको वास्तव में सरणी के बाद आयाम पारित करने की आवश्यकता है):

f(int size; int data[][size], int size) {...}

पहला आयाम, यद्यपि आप भी तर्क के रूप में पारित कर सकते हैं, सी संकलक के लिए बेकार है (यहां तक ​​कि आकार के ऑपरेटर के लिए भी, जब सरणी पर लागू होता है तो तर्क हमेशा के रूप में व्यवहार करेगा क्योंकि पहले तत्व के लिए सूचक होता है)।

0
जोड़ा
आईएमओ यह स्वीकार्य उत्तर होना चाहिए। कोई अतिरिक्त कोड की आवश्यकता नहीं है और कोई अनावश्यक ढेर आवंटन नहीं है। सरल और साफ
जोड़ा लेखक imkendal, स्रोत
जैसा कि आपने कहा था, मैंने फ़ंक्शन घोषित किया है, मैं इसे मुख्य() से कॉल करता हूं और यह ठीक है, लेकिन अगर मुझे आकार (ओं) नहीं पता है तो मुझे अपने मुख्य() में परिवर्तनीय डेटा कैसे घोषित करना चाहिए? मैंने int * डेटा के साथ प्रयास किया लेकिन काम नहीं करेगा।
जोड़ा लेखक Glk-78, स्रोत
धन्यवाद @ kjh, मुझे यह भी लगता है कि यह सबसे साफ समाधान है। स्वीकृत उत्तर वह है जो उसके लिए काम करता है। देखो: ओपी 2008 से है, मेरे जवाब से लगभग 6 साल पहले। इसके अलावा, मुझे नहीं पता कि सीटी मानकों को सिंटैक्स के लिए अनुमति दी गई है, जिसका मैंने यहां उपयोग किया है।
जोड़ा लेखक rslemos, स्रोत
यह वह समाधान है जिसे मैंने अंततः एक पूर्णांक मैट्रिक्स (एक दो-आयामी सरणी) आकार एम एक्स एन को फ़ंक्शन तर्क के रूप में पास करने के लिए अपनाया है। शायद थोड़ी अधिक जानकारी सहायक होगी: फ़ंक्शन प्रोटोटाइप इस प्रकार है: शून्य एफ (int एन, int डेटा [] [एन], int एम); समारोह के शरीर में, तत्व [एम] [एन] डेटा के रूप में लिखा जा सकता है [एम] [एन] - बहुत सुविधाजनक, कोई सूचकांक गणना की आवश्यकता नहीं है।
जोड़ा लेखक jonathanzh, स्रोत
int matmax(int **p, int dim) // p- matrix , dim- dimension of the matrix 
{
    return p[0][0];  
}

int main()
{
   int *u[5]; // will be a 5x5 matrix

   for(int i = 0; i < 5; i++)
       u[i] = new int[5];

   u[0][0] = 1; // initialize u[0][0] - not mandatory

   // put data in u[][]

   printf("%d", matmax(u, 0)); //call to function
   getche(); // just to see the result
}
0
जोड़ा
यह 2 डी सरणी नहीं है, यह एक लुकअप टेबल है। इसके अलावा, यह टैग सी है।
जोड़ा लेखक Lundin, स्रोत