कार्य करने के लिए मैट्रिक्स पास, सी - सी, समारोह, मैट्रिक्स

अपने आस-पास देखने के बाद मैंने एक ऐसा फ़ंक्शन बनाया है जो एक मैट्रिक्स को स्वीकार करता है और जो कुछ भी मुझे इसकी आवश्यकता है वह करता है, जो निम्नानुसार है:

float energycalc(float J, int **m, int row, int col){
...
}

मुख्य के भीतर सरणी का आकार परिभाषित और भरा हुआ है, हालाँकि मैं इसे फ़ंक्शन में ही नहीं भेज सकता:

int matrix[row][col];
...
E=energycalc(J, matrix, row, col);

यह संकलन के दौरान एक चेतावनी के परिणामस्वरूप होता है

"परियोजना।c: 149: चेतावनी: 'एनर्जीकालेक' के तर्क 2 को पास करना असंगत सूचक प्रकार project.c: 53: नोट: अपेक्षित ’int ** 'लेकिन तर्क प्रकार (int (*) [(लंबे अहस्ताक्षरित int) (col +) है -0x00000000000000001)] '

और एक विभाजन दोष की ओर जाता है।

किसी भी मदद की बहुत सराहना की है, धन्यवाद।

उत्तर:

जवाब के लिए 2 № 1

सी में एक समारोह के लिए दो आयामी सरणी पासिंग अक्सर newbies के लिए भ्रामक है।
कारण यह है कि वे मानते हैं कि एरियर पॉइंटर्स हैं और यह समझने में कमी है कि एरियर पॉइंटर की ओर कैसे बढ़ता है।
हमेशा याद रखें कि जब एक तर्क के रूप में पारित किया एरियर्स को पॉइंटर में बदलकर इसके पहले एलिमेंट पर ले जाया जाता है.
फ़ंक्शन कॉल में

E = energycalc(J, matrix, row, col);

matrix पॉइंटर को उसके पहले तत्व में बदल दिया जाता है matrix[0]। इसका मतलब है कि गुजरना matrix पास करने के बराबर है &matrix[0]। ध्यान दें कि के प्रकार &matrix[0] है int(*)[col] (सूचक एक सरणी के लिए col int) और इसलिए का है matrix। यह सुझाव देता है कि फ़ंक्शन का दूसरा पैरामीटर energycalc प्रकार का होना चाहिए int(*)[col]। फ़ंक्शन घोषणा को बदलें

 float energycalc(int col, int (*m)[col], int row, float J);

और अपने फ़ंक्शन को कॉल करें

 E = energycalc(col, matrix, row, J);

---

जवाब के लिए 3 № 2

समारोह की तरह घोषित किया जाना चाहिए

float energycalc( float J, int row, int col, int ( *m )[col] );

यदि आपका संकलक चर लंबाई सरणियों का समर्थन करता है।

अन्यथा घोषणा में है

int matrix[row][col];

col कुछ स्थिर है तो फ़ंक्शन को निम्न तरीके से घोषित किया जा सकता है

float energycalc(float J, int m[][col], int row );

बशर्ते कि निरंतर col फ़ंक्शन से पहले परिभाषित किया गया है।

आपका फ़ंक्शन घोषणा

float energycalc(float J, int **m, int row, int col);

उपयुक्त है जब आपके पास एक ऐरे जैसा ऐलान हो

int * matrix[row];

और सरणी के प्रत्येक तत्व को उदाहरण के लिए गतिशील रूप से आवंटित किया गया है

for ( int i = 0; i < row; i++ ) matrix[i] = malloc( col * sizeof( int ) );

---

जवाब के लिए 3 № 3

यदि सरणी के रूप में घोषित किया गया है

int matrix[row][col];

फिर फ़ंक्शन घोषणा को बदल दें

float energycalc(float J, int m[][col], int row, int col){

एक प्रकार के दो आयामी सरणी का नाम T का क्षय नहीं होता है T**.

अगर col एक स्थानीय चर है, फिर आपको फ़ंक्शन को कॉल करना होगा col पहले पैरामीटर matrix। ऐसा इसलिए किया जाता है col फ़ंक्शन में दिखाई देता है।

---

जवाब के लिए 0 № 4

मुझे लगता है कि आप सी में ऐसा कुछ कर सकते हैं

float function_name(int mat_width, int mat_height, float matrix[mat_width][mat_height]) {
... function body...
}

---

जवाब के लिए 0 № 5

एक पॉइंटर-टू-पॉइंटर एक सरणी नहीं है, न ही यहएक दो आयामी सरणी की ओर इशारा करते हैं। इसका एरे, पीरियड से कोई लेना-देना नहीं है, इसलिए केवल पॉइंटर-टू-पॉइंटर्स और एक साथ ऐरे के बारे में सुना हुआ भूल जाते हैं।

(भ्रम की संभावना की भीड़ से आता हैभ्रमित हो-हो प्रोग्रामिंग शिक्षक / लेखक हर किसी को बता रहे हैं कि उन्हें गतिशील 2D सरणियों को आवंटित करते समय सूचक-से-सूचक का उपयोग करना चाहिए। जो सिर्फ सादा बुरी सलाह है, क्योंकि यह आसन्न मेमोरी कोशिकाओं में आवंटित एक वास्तविक सरणी को आवंटित नहीं करेगा, बल्कि ढेर में टुकड़ों में एक खंडित लुक-अप तालिका फट गई। यह देखो इस तरह के सरणियों को वास्तव में कैसे आवंटित किया जाए, इसके संदर्भ में।)

यह मानते हुए कि आपका कंपाइलर isn "t पूरी तरह से प्राचीन है, बस एक वैरिएबल लेंथ एरे (VLA) का उपयोग करें, जो C99 स्टैंडर्ड के साथ C लैंग्वेज में पेश किया गया फीचर है।

#include <stdio.h>

void print_matrix (size_t row, size_t col, int matrix[row][col]);


int main (void)
{
int matrix[2][3] =
{
{1,2,3},
{4,5,6}
};

print_matrix(2, 3, matrix);

return 0;
}

void print_matrix (size_t row, size_t col, int matrix[row][col])
{
for(size_t r=0; r<row; r++)
{
for(size_t c=0; c<col; c++)
{
printf("%d ", matrix[r][c]);
}
printf("n");
}
}

---