सी

Question

में संरचना की 2-आयामी सरणी को कैसे कार्यान्वित करें मैं वर्तमान में सी में संरचना के 2-आयामी सरणी को कार्यान्वित करने के तरीके को समझने की कोशिश कर रहा हूं। मेरा कोड हर समय क्रैश हो रहा है और मैं वास्तव में जाने देना चाहता हूं यह मेरे सभी दृष्टिकोणों की तरह समाप्त होता है जैसे सी: कचरा।

typedef struct { 
    int i; 
} test; 

test* t[20][20]; 
*t = (test*) malloc(sizeof(test) * 20 * 20); 

मेरे गौरवशाली त्रुटि:

error: incompatible types when assigning to type ‘struct test *[20]’ from type ‘struct test *’

मैं हर 2 आयाम के लिए अलग से स्मृति को आबंटित करने है यह मैं क्या मिला है? मुझे पागल हो रहा है यह इतना आसान होना चाहिए। एक दिन मैं एक समय मशीन का निर्माण और कुछ सी संकलक फ्लोपी चुंबकित होगा ...

Answer 1

यह पर्याप्त होना चाहिए:

typedef struct { 
    int i; 
} test; 

test t[20][20]; 

कि की test की एक 2-आयामी सरणी घोषणा करेंगे आकार 20 x 20. मॉलोक का उपयोग करने की कोई आवश्यकता नहीं है।

आप गतिशील रूप से आपकी सरणी आवंटित करने के लिए चाहते हैं तो आप ऐसा कर सकते हैं:

// in a function of course 
test **t = (test **)malloc(20 * sizeof(test *)); 
for (i = 0; i < 20; ++i) 
    t[i] = (test *)malloc(20 * sizeof(test)); 

Answer 2

test **t; 

t = (test **)malloc(sizeof(test *) * 20); 
for (i = 0; i < 20; i++) { 
    t[i] = (test *)malloc(sizeof(test) * 20); 
} 

Answer 3

अन्य उत्तर इसे ठीक करने पर वे क्यों की व्याख्या नहीं करते दिखाई देते हैं। जैसा कि संकलक संकेत देते हैं, आपके मूल उदाहरण में t का प्रकार वास्तव में test *[20] है, यही कारण है कि test * पर आपकी कास्ट पर्याप्त नहीं थी।

सी में, एक सरणी का नाम टी आयाम एन वास्तव में *T[dim0][dim1]...[dimN-1] प्रकार का है। मज़ा।

Answer 4

मेरे अवलोकन से, आप शायद नहीं जानते कि आप क्या चाहते हैं और संरचना और सूचक अंकगणित पर भ्रमित हैं। कृपया निम्नलिखित 2 संभावनाओं से गुज़रें।

1) प्रत्येक तत्व के साथ एक दो आयामी सरणी में test पर पॉइंटर होता है। इस मामले में सभी पॉइंटर्स की स्मृति test s पहले से ही स्थिर हैं आवंटित। लेकिन, वास्तविक test एस की स्मृति तैयार नहीं है। इस मामले में आपको test [i][j] एक-एक करके भरना होगा।

test प्रत्येक स्मृति में अलग है और आपके पास अलग-अलग गतिशील रूप से उन्हें बनाने या नष्ट करने का लाभ है।

typedef struct { 
    int i; 
} test; 

test* t[20][20]; 
/* or instead of statically allocated the memory of all the pointers to tests 
    you can do the following to dynamically allocate the memory 
    test ***t; 
    t = (test***)malloc(sizeof(test *) * 20 * 20); 
*/ 

for (int i=0; i < 20; i++){ 
    for (int j=0; j < 20; j++){ 
     t[i][j] = malloc(sizeof(test)); 
    } 
} 

2) प्रत्येक तत्व के साथ एक दो आयामी सरणी एक test है। इस मामले में सभी test एस की स्मृति पहले से ही आवंटित है। इसके अलावा, वास्तविक test एस की स्मृति अतिरिक्त तैयारी के बिना उपयोग करने के लिए तैयार हैं।

test एस सभी बड़े ब्लॉक के रूप में स्मृति में निरंतर हैं और हमेशा वहां रहते हैं। इसका मतलब यह है कि यदि आप केवल कुछ test एस को कुछ शीर्ष समय पर ही चाहते हैं तो आप स्मृति का एक हिस्सा बर्बाद कर सकते हैं और अधिकांश समय आप उनमें से कुछ का उपयोग करते हैं।

typedef struct { 
    int i; 
} test; 

test t[20][20]; 
/* or instead of statically allocated the memory of all tests 
    you can do the following to dynamically allocate the memory 
    test **t; 
    t = (test**)malloc(sizeof(test) * 20 * 20); 
*/ 

Answer 5

इसके अलावा, जब तक अपने भीतर के आयाम आकार स्थिर है के रूप में, आपको लगता है कि आंतरिक आयाम

int n = ...; 
test (*t)[20] = malloc(sizeof (*t) * n); 
t[0 .. (n-1)][0 .. 19] = ...;