שלום רציתי לשאול שאלה בקשר ל-malloc .
אני יודע שכאשר משתמשים בפונקציה הפונקציה מחזירה פוינטר ומאחסנת בית אחד לפני אותו פוינטר את הגודל שהיא הקצתה כדי ש-free תדע כמה הוקצה מקודם.
השאלה שלי היא :
נגיד שהקצתי 20 בתים בזכרון.
האם אני יכול עכשיו בעצם לתחמן את free לשלוח לה איזה שהוא פוינטר נגיד לבית מספר 10 מתוך ה-20 שהקצתי ובבית מספר 9 לרשום את המספר 10 שכאילו free תפנה לי את כל עשרת הבית האחרונים מההקצה המקורית של ה-20 בתים.
אני ממש יודע לכם אם תעזרו לי.
נמרוד.

א) למה שלא פשוט תנסה את זה?

ב) כנראה שלא. יהיה מאוד נאיבי לחשוב שרק על זה מסתמך ה FREE.

אולי זה נכון במקרה ספציפי, אבל לא במקרה הכללי.

השאלה הזאת הופיע ברעיון עבודה ולקוחה מהאתר:
http://forums.asat.org.il/viewtopic.php?t=145218

נתונות 2 פונקציות
void * big_malloc(int size)
void * small_malloc(int size)
פונקציות אלה מקצאות גודל בכפולות של 16, כאשר אם רוצים להקצאת יותר מ 512 בייט משתמשים בראשונה ואם פחות אז בשניה. (כנראה אם רוצים בדיוק 512 לא משנה באיזה להשתמש)
כמו כן, נתונות 2 פונקציות שחרור מתאימות:
void big_free(void *ptr)
void small_free(void* ptr)

המשימה: לממש malloc ו free רגילים, כלומר שיהיה ניתן להקצאת כל גודל (ולא רק כפולות של 16 ) בעזרת הפונקציות הנ"ל.

איך פותרים את זה? האם הפתרון שיש בלינק הוא נכון ואם כן אז מישהו מוכן להסביר??
(שימו לב יש בפורום פתרון ואחרי זה תיקון שלו.)

אני חושב שהם מתכוונים שתתכנן את הפונקציה כך שהיא תקבל מספר, תעגל אותו למספר הכי קרוב שמתחלק ב16 ואז תקצה בכפולות של 16

אפילו להעתיק משם את הפתרון כמו בנאדם אתה לא מסוגל....

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

הטריק בגדול הוא שצריך לשמור איזה מידע שתמיד תדע איך להגיע אליו ומה לחפש שם.
וביחד עם זה אתה צריך להקצות בכפולות של 16.

בעצם יש פה שני טריקים: 1) מה אתה שומר
2) איך אתה מחשב את הגודל שבאמת צריך להקצות.

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

2) איזה גודל צריך להוסיף? אחרי שהבנת שמספיק לך רק בית אחד נוסף לצרכים שלך, אתה מבין שכל מה שצריך זה לעגל את ל 16. ואם זה כבר 16, תוסיף 16.

עכשיו, תבדוק איזה גודל קיבלת, תלך בית אחד אחרוה, תסמן מה שצריך לסמן ותחזיר את הבאפר למשתמש.

הפרי מקבל פוינטר ופשוט בודק אם הערך שלפני הפוינטר....

כ"כ פשוט

void* my_malloc(int size)

{
int new_size, div;
void* ptr = NULL;

if(size<=0) return NULL;

/*
//the usage of sizeof(int) is for saving the function we use to allocate, we need this
//information later on my_free function
*/

size = size + sizeof(int) + 16;
div = size % 16;
new_size = div * 16;

if(new_size <= 512)
{
ptr = small_malloc(new_size);
*((char*)ptr) = 's';
}
else
{
ptr = big_malloc(new_size);
*((char*)ptr) = 'b';
}

((char*)ptr+1);

return ((void*)ptr);
}

void my_free(void* ptr)
{
char flag;

flag = *((char*)ptr-1);

if (flag == 's') small_free(ptr);
else big_free(ptr);
}

לא עובד. יש כאן לפחות שתי בעיות שמונעות מהקוד לפעול.

אם תרצה את הפתרון אוכל לספק לך אחד משלי
אך יותר כיף לפתור לבד.

Error: Keyboard not found

Press F1 to continue

אולי ב-Turbo C זה יעבור לך.
אני מאמין שבקומפיילרים מתקדמים יותר כמו Visual C או GCC המימוש הוא לא בדיוק ככה, בטח שמים איזה security_cookie בתחילת הבלוק כדי להגן על המתכנתת "מטעויות" כמו שאתה רוצה לעשות.
וגם ב-Turbo C זה לפחות שתי בתים או יותר כי אפשר להקצות עם malloc מעל 256 בתים, אז אתה צריך לדעת כמה בתים.

תדבג קוד שעושה malloc ו-free ותסתכל איך הזיכרון שהקצת מושפע.

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.fresh.co.il/scripts/birthday.php?date=27/04/1986]

כנראה ש-malloc ו-free פשוט יתורגמו ל-API של מערכת ההפעלה שלך (נגיד HeapAlloc, HeapRealloc, HeapFree בווינדוס ו-int 21 פונקציות 48, 49, 4a בדוס) אז זה בעצם הקוד שמעניין לבדוק.