שלום לכם

רציתי לדעת אם אפשר לעשות מן לולאה כזאת

שתבצע הקצאה דינמית לN מטריצות

במקום לרשום כל פעם

תודה

scanf("%d%d", &rowsMat2,&colsMat2);
  mat2= (int **)malloc(rowsMat2 * sizeof(int *));//dynamic alloc of the 2nd matrix
  for(i=0; i<rowsMat2; i++)
  mat2[i] = (int *)malloc(colsMat2 * sizeof(int));

ואותו דבר לשחרור בסוף

במקום לרשום

for(i=0; i<rowsMat1; i++)
   free(mat1[i]);
  free(mat1);

לעשות לולאה שעושה את זה עבור N מטריצות

עריכה

חשבתי לעשות את זה עם מערך

אבל זה נראה לי קצת בזבוז

אתה יכול להקצות את כל המטריצה במכה אחת, ואז להקצות מערך של מצביעים. יענו ככה:

int* tmp = (int*)malloc(rows * cols * sizeof(int));
int** mat = (int**)malloc(rows * sizeof(int*));

for (i=0 ; i < rows ; i++) {
 mat[i] = tmp + i*cols;
}

ככה יש לך רק שתי הקצאות, כל המטריצה יושבת בצורה רציפה בזכרון, ובשביל לשחרר רק צריך לשחרר שני דברים - את [mat[0 ואז את mat.

מעולה תודה רבה

עוד משהו קטן

אם אני בונה פונקצייה שמבצעת הקצאה דינמית

איפה אני צריך לעשות את השחרור?

כלומר באיזה חלק של התוכנית

איפה שבא לך כמובן.

כשפונקציה מקצה זכרון יש לה שתי אפשרויות: או שהיא משחררת אותו בסיום העבודה איתו, או שהיא מחזירה אותו למי שקרא לה. במקרה השני הפונקציה שקראה לה היא האחראית לזכרון הזה (כלומר באחריותה לשחרר אותו, או להחזיר אותו לפונקציה שקראה לה... וכן הלאה). אם פונקציה כלשהי מקצה זכרון (או קוראת לפונקציה שמקצה זכרון ולא משחררת אותו) אז באחריות המתכנת לתעד את זה היטב - שכל מי שקורא לפונקציה ידע שהפונקציה מקצה זכרון ולכן הוא צריך לשחרר אותו.

בד"כ כשעובדים עם מבני נתונים מורכבים, נהוג להגדיר זוג פונקציות - create ו-free - שהאחת דואגת לכל הקצאות הזכרון והאחרת משחררת את כל הזכרון. לדוגמה, במקרה שלך הפונקציה שיוצרת המטריצה תקרא create_matrix (מקבלת כפרמטרים אם האורך והרוחב ומחזירה את המטריצה) והפונקציה שמוחקת את המטריצה תקרא free_matrix (מקבלת את המטריצה ומשחררת את [mat[0 ו-mat). היתרון ככה הוא שמי שרוצה לשחרר את המטריצה לא "יתבלבל" וישחרר רק חלק מהזכרון, וכמובן אם תחליט לשנות את המימוש הפנימי של המטריצה אז זה יהיה יותר פשוט.