2 डी गतिशील ऐरे आवंटन और सी

Question

में संदर्भ द्वारा उत्तीर्ण करना क्या कोई मुझे समझाने वाला है कि कृपया मुझे बताएं कि निम्न कोड सेगमेंट दोष क्यों है? संदर्भ द्वारा स्मृति आवंटित करने में कोई समस्या नहीं है, लेकिन जैसे ही मैं संदर्भ से कुछ भी मुक्त या मुक्त करने का प्रयास करता हूं, segfault होता है।

मुझे यकीन है कि मुझे पॉइंटर्स के बारे में कुछ मौलिक अवधारणा याद आ रही है और संदर्भ से गुजर रहा है, उम्मीद है कि कुछ प्रकाश शेड किया जा सकता है।

#include <stdlib.h> 
#include <stdio.h> 

void allocateMatrix(float ***); 
void fillMatrix(float ***); 
void freeMatrix(float **); 

int main() { 
    float **matrix; 

    allocateMatrix(&matrix);  // this function calls and returns OK 
    fillMatrix(&matrix);   // this function will segfault 
    freeMatrix(matrix);    // this function will segfault 

    exit(0); 
} 

void allocateMatrix(float ***m) { 
    int i; 
    m = malloc(2*sizeof(float*)); 
    for (i = 0; i < 2; i++) { 
     m[i] = malloc(2*sizeof(float)); 
    } 
    return; 
} 

void fillMatrix(float ***m) { 
    int i,j; 
    for (i = 0; i < 2; i++) { 
     for (j = 0; j < 2; j++) { 
      (*m)[i][j] = 1.0;  // SEGFAULT 
     } 
    } 
    return; 
} 

void freeMatrix(float **m) { 
    int i; 
    for (i = 0; i < 2; i++) { 
     free(m[i]);     // SEGFAULT 
    } 
    free(m); 
    return; 
} 

Answer 1

एक सेट यहाँ है:

void allocateMatrix(float ***m) { 
    int i; 
    m = malloc(2*sizeof(float*)); 
    for (i = 0; i < 2; i++) { 
     m[i] = malloc(2*sizeof(float)); 
    } 
    return; 
} 

जानकारी को वापस कॉल करने के लिए आपको *m पर असाइन करने की आवश्यकता है, और आपको लूप में (*m)[i] आवंटित करने की आवश्यकता होगी।

void allocateMatrix(float ***m) 
{ 
    *m = malloc(2*sizeof(float*)); 
    for (int i = 0; i < 2; i++) 
     (*m)[i] = malloc(2*sizeof(float)); 
} 

कम से कम एक मौका है कि अन्य कार्य ठीक हैं। fillMatrix() लिखा गया है और सही ढंग से लागू किया, हालांकि यह सूचक से तीसरे * खोने से सरल किया जा सकता है है:

void fillMatrix(float **m) 
{ 
    for (int i = 0; i < 2; i++) 
    { 
     for (int j = 0; j < 2; j++) 
      m[i][j] = 1.0;   
    } 
} 

यह इतना freeMatrix() को ट्रिपल-सूचक पारित करने के लिए आप में सूचक शून्य कर सकते हैं कि उचित हो सकता है बुला समारोह:

void freeMatrix(float ***m) 
{ 
    for (int i = 0; i < 2; i++) 
     free((*m)[i]); 
    free(*m); 
    *m = 0; 
} 

तो कॉलिंग हो जाता है:

allocateMatrix(&matrix); 
fillMatrix(matrix); 
freeMatrix(&matrix); 

Answer 2

संकेत का अच्छा उपयोग। बस प्रारूप के साथ संगत होने की कोशिश करें। यह पठनीयता में सुधार करता है और त्रुटियों को कम करता है। जैसे

फ़ंक्शन को कॉल:

allocateMatrix &matrix 
    fillMatrix &matrix 
    freeMatrix &matrix 

घोषणाओं

void allocateMatrix float ***m 
void fillMatrix float ***m 
void freeMatrix float ***m 

से निपटने की समस्याओं के

(*m)[i] = malloc(2 * sizeof(float)) 
    (*m)[i][j] = 1.0 
    free (*m)[i] 

Answer 3

अपने मज़ा से सूचक की रिटर्निंग उद्धरण शायद स्मृति आवंटित करने का बेहतर तरीका है:

float **allocateMatrix() { 
    int i; 
    float **m; 

    m = malloc(2*sizeof(float *)); 
    for (i = 0; i < 2; i++) { 
     m[i] = malloc(2*sizeof(float)); 
    } 

    return m; 
} 

int main() { 
    float **m; 

    m = allocateMatrix(); 

    /* do other things 
     fillMatrix(matrix); 
     freeMatrix(&matrix); 
    */ 
}