फ़ंक्शन से मैट्रिक्स (2 डी सरणी) कैसे वापस करें? (सी)

Question

मैंने एक ऐसा फ़ंक्शन बनाया जो एक बिंगो बोर्ड उत्पन्न करता है और मैं बिंगो बोर्ड वापस करना चाहता हूं।

जैसा कि मैंने उम्मीद नहीं की थी, यह काम नहीं करता है।

int** generateBoard() { 
    int board[N][M], i, j , fillNum; 
    Boolean exists = True; 
    // initilize seed 
    srand(time(NULL)); 
    // fill up.. 
    for(i = 0; i < N; ++i) { 
     for(j = 0; j < M; ++j) { 
      exists = True; 
      while(exists) { 
       fillNum = rand()%MAX_RANGE + 1; // limit up to MAX_RANGE 
       if(beenAdded(board, fillNum) == Exist) { 
        continue; 
       } else { 
        board[i][j] = fillNum; 
        exists = False; 
       } 
      } 
     } 
    } 
    return board; 
} 

"वापसी बोर्ड" लाइन पर मैं एक compilcation त्रुटि (लाल subline) है:

यहाँ कार्य है।

structs \ गति आवंटन का उपयोग कर के बिना 2 डी सर वापस करने का कोई तरीका है?

मैं माइक्रोसॉफ्ट विज़ुअल सी ++ एक्सप्रेस का उपयोग कर रहा हूँ 2010

Answer 1

किसी कि बोर्ड कहीं की स्मृति ही है, और अधिक महत्वपूर्ण बात यह है कि स्वामित्व इस समारोह के फोन करने वाले के लिए वापस का विस्तार करना होगा। गतिशील आवंटन के बिना, आपका एकमात्र अन्य वास्तविक विकल्प इसे फ़ंक्शन में इन/आउट पैरामीटर में भेजना है।

void generateBoard(size_t N, size_t M, int board[N][M]) 
{ 
    int i, j , fillNum; 
    Boolean exists = True; 
    // initilize seed 
    srand(time(NULL)); 
    // fill up.. 
    for(i = 0; i < N; ++i) { 
     for(j = 0; j < M; ++j) { 
      exists = True; 
      while(exists) { 
       fillNum = rand()%MAX_RANGE + 1; // limit up to MAX_RANGE 
       if(beenAdded(board, fillNum) == Exist) { 
        continue; 
       } else { 
        board[i][j] = fillNum; 
        exists = False; 
       } 
      } 
     } 
    } 
} 

और अपने फोन करने वाले से इस तरह आह्वान:

int main() 
{ 
    const size_t N = 10; 
    const size_t M = 10; 
    int board[N][M]; 

    generateBoard(N,M,board); 

    ... 
} 

मैं भी main() में स्टार्टअप कोड को srand() कॉल relocatting पर विचार करेंगे। यह आदर्श रूप से कुछ संभावित दोहराव-कॉल करने योग्य फ़ंक्शन में कभी नहीं होना चाहिए, और प्रति प्रक्रिया निष्पादन के बाद केवल निष्पादित होने की गारंटी दी जानी चाहिए। (नोट: मैं ईमानदारी से याद नहीं कर सकता कि यह थ्रेड निष्पादन है, लेकिन इस बिंदु पर आपके कोडिंग सीखने की अवस्था में मैं अनुमान लगा रहा हूं कि बहु-थ्रेडिंग अभी तक रडार पर नहीं है)।

अंत में, आपका यादृच्छिक भरने वाला लूप अनिवार्य रूप से दोहराया जाता है। बेहतर विकल्प हैं जो आप स्पष्ट रूप से करने की कोशिश कर रहे हैं: संख्याओं के मौजूदा सेट का यादृच्छिक क्रमपरिवर्तन बनाएं। जैसा लिखा है कि आप पिछले कुछ स्लॉट को भरने की कोशिश कर रहे कुछ समय के लिए स्पिन कर सकते हैं, इस पर निर्भर करता है कि MAX_RANGE की तुलना में (N*M) की तुलना में कितनी बड़ी है।

Answer 2

आपने स्थानीय चर के रूप में board को परिभाषित किया है - इसकी मेमोरी डीलोकॉक्टेड है क्योंकि फ़ंक्शन स्कोप से बाहर हो जाता है।

आप बोर्ड वैश्विक घोषणा कर सकते हैं, या आप इतने तरह गतिशील रूप से यह बना सकते हैं:

int **allocate_board(int Rows, int Cols) 
{  
    // allocate Rows rows, each row is a pointer to int 
    int **board = (int **)malloc(Rows * sizeof(int *)); 
    int row; 

    // for each row allocate Cols ints 
    for (row = 0; row < Rows; row++) { 
     board[row] = (int *)malloc(Cols * sizeof(int)); 
    } 

    return board; 
} 

आप गतिशील रूप से बोर्ड को मुक्त करने की आवश्यकता होगी: बोर्ड 2 डी सरणी आवंटन के लिए

// you must supply the number of rows 
void free_board(int **board, int Rows) 
{ 
    int row; 

    // first free each row 
    for (row = 0; row < Rows; row++) { 
     free(board[row]); 
    } 

    // Eventually free the memory of the pointers to the rows 
    free(board); 
}