שפות תכנות שיעור מספר 5: זכרון ומשתנים הבסיס לתכנות אימפרטיבי בית הספר למדעי המחשב אוניברסיטת תל אביב
נושאים עיקריים משתנים פרימיטיביים ומורכבים מודל זכרון אורך החיים של משתנים הפקודות שמעדכנות משתנים תופעות לוואי בביטויים 2
משתנים ועידכונם משתנה )בתכנות אימפרטיבי ומונחה עצמים( הוא מיכל שבתוכו יש ערך ניתן לבחון את הערך ולשנותו משתנים משמשים למידול עצמים מעולם הבעיה שיש להם "מצב" שמשתנה עם הזמן לדוגמא - מספר התושבים במדינה שני סוגים עיקריים לפי אורך החיים: קצר - משתני תכנית. משתנים בעיקר ע"י השמה. ארוך - בלתי תלויים בביצוע של תכנית מסוימת. נתונים, קבצים. 3 בסיסי
משתנים לעומת משתנים מתמטיים משתנה מתמטי מייצג כמות קבועה אך לא ידועה. אין אנלוגיה לעדכון שנעשה למשתנה בשפת תכנות: n := n + 1 write (x) אבל משתנה בשפת תכנות פונקציונלית הוא אנלוגי למשתנה מתמטי משתנים ממומשים בזכרון פיזי. לא כל התכונות של מדיום זכרון פיזי רלבנטיות לעניין גודל מלה, שיטות מיעון, וכו' 4
מודל מופשט של זכרון { זכרון הוא אוסף תאים שלכל אחד כתובת ייחודית לתא יש סטטוס נוכחי 5 - מוקצה או לא מוקצה allocated, unallocated לכל תא מוקצה יש תוכן, שהוא ערך בר אחסון (storable) או בלתי מוגדר. int n; /* unallocated cell becomes allocated, value undefined */ n = 1; /* content of cell denoted by n changes to 1 n = n+1; /* content inspected, then changed */ } /* cell dealloctaed */
תאור בתמונה { } int n; n = 1; n = n+1; אפשר לתאר תא כקופסה, n 12? "לא מוגדר" והתוכן בתוכה.? מסמן 6
התייחסות למשתנה )reference( לכל משתנה יש תכונה שנקראת התייחסות או רפרנס )reference( הפשטה של הרעיון של "מיקום המשתנה בזיכרון". טיפוס מצביע בפסקל מייצג רפרנס, אבל רק למשתני ערימה.)heap( לעומת זאת ב- C מצביע הוא מושג "נמוך" יותר: כתובת בזיכרון. עוד על מצביעים, כשנדבר על משתני ערמה באופן כללי אין אחידות לגבי המשמעות המדוייקת של "רפרנס" ביניהם. ו"מצביע" (pointer/reference) וההבחנה 7
אתחול משתנים אתחול משמעותו מתן ערך למשתנה בזמן ההקצאה. יש שפות שמאפשרות זאת )לדוגמא C(. יש שפות שמחייבות זאת )לדוגמא (. ML יש שפות שמאתחלות באופן אוטומטי לערך מחדל אם אין אתחול מפורש )לדוגמא אייפל, ג'אוה רק לשדות מופע ומחלקה, אך לא למשתנים מקומיים(. יש שפות שמתייחסות לגישה למשתנה שלא קיבל קודם ערך )באתחול או בהשמה( כאל שגיאה. 8
משתנים מורכבים ערך מטיפוס מורכב סלקטיבי בנוי מרכיבים שניתן לבחון באופן באופן דומה משתנה מורכב בנוי מרכיבים שגם הם משתנים, וניתן לבחון ולשנות כל אחד מהם בנפרד. בדרך כלל למשתנה מטיפוס T מבנה זהה לערך מטיפוס. T משתנה מורכב עשוי לתפוס מספר תאים. 9
דוגמא type Month = )jan, feb,., dec(; Date = record m : Month; d : 1..31; end; var today : Date; dates : array [1..3] of Date; today.d:= 23; today.m := feb; dates[1].m:= may; dates[1].d := 5; dates[2] := dates[1]; feb 23 today 10
עדכון מלא או סלקטיבי dates[1] today =: מעדכן את כל המשתנה )עדכון מלא(. today.d:= 25 מבצע עדכון סלקטיבי של רכיב אחד )במקרה זה שדה ברשומה(. ניתן לראות זאת כעדכון כל המשתנה, לערך ששווה לערך הקודם בחלקים האחרים שלו: today := (today.m,25) כלומר עדכון סלקטיבי אינו חיוני בשפת תכנות שתומכת באגרגטים. אבל בלי עדכון סלקטיבי הקוד נעשה מסורבל. 11
עדכון ב ML משתנה מטיפוס T ref ניתן לעדכון מלא, אך לא ניתן לעדכן את רכיביו. לדוגמא המשתנה today1 datatype month = jan feb dec; type date = month * int; val today1 : date ref = ref (feb,23) אם הרכיבים הם מטיפוס ref אפשר לעדכן כל רכיב, אך לא ניתן לעדכן את השלם. לדוגמא.today2 type datevar = month ref * int ref; val today2 : datevar = (ref feb, ref 23) מערכים אפשר לעדכן סלקטיבית, האברים הם T. ref פרטים בהמשך 12
משתנים מטיפוס מערך משתנה מערך הוא מיפוי מקבוצת אינדקס לאוסף משתנים )אברי המערך(. קביעת קבוצת האינדקס: בזמן קומפילציה : מערך סטטי. בזמן יצירת משתנה המערך: מערך דינמי. קבוצת האינדקס אינה קבועה: מערך גמיש. קבוצת האינדקס היא בדרך כלל תחום רצוף של ערכים מטיפוס דיסקרטי, שמוגדר ע"י ערכי הקצה. 13
מערכים סטטיים ערכי הקצה של האינדקסים חייבים להיות קבועים, או ביטויים שכל רכיביהם קבועים )ניתנים לחישוב בזמן קומפילציה(. בפסקל, קבוצת האינדקס של מערך היא חלק מהגדרת הטיפוס. ערכי הקצה הם ליטרלים או קבועים. המדובר בפסקל הסטנדרטי. נעשו הרחבות שונות. ב C ו ++C טיפוס המערך כולל רק את טיפוס האבר האינדקסים תמיד שלמים, גבול תחתון תמיד 0 נקבעים על פי ההצהרה או האתחול המערך לא "יודע" את גודלו )פונקציה על מערך צריכה לקבל את גודלו כפרמטר נוסף( 14
דוגמא: מערכים סטטיים ב ++C float v1[ ] = {2.0, 3.0, 5.0, 7.0 }; // index range 0-3 float v2[10]; // index range 0-9, type of both is float[ ] פונקציה שמטפלת במערך צריכה לקבל גם את אורכו כפרמטר void print_vector (float v[ ], int n) { // print the array elements in the form [. ] cout << [ << v[0]; for (int i=1; i<n; i++) cout << << v[i] ; cout << ] ; שפות תכנות,שיעור מספר } 5 15
מערכים דינמיים קבוצת האינדקסים נקבעת בזמן ריצה, כשהמשתנה נוצר. ערכי הקצה הם ביטויים שערכם מחושב בזמן הזה. קבוצת האינדקס אינה יכולה להיות חלק מהגדרת הטיפוס )אחרת לא ניתן לבצע בדיקת טיפוסים בזמן קומפילציה(. פעולות מסוימות דורשות בדיקה בזמן ריצה לגבי קבוצת האינדקס. בעדה, טיפוס מערך כולל את הטיפוס של ערכי הקצה, אך לא את הערכים עצמם. 16
מערכים דינמיים - דוגמא בעדה m : integer := type vector is array (integer range <>) of float; a: vector (1..10); b : vector (0..m); procedure readvector(v : out vector) is begin for i in v first to v last loop put(v(i)) end loop; end; a:=b; -- compiler warning, possible runtime exception -- ok at runtime only if m is 9 readvector(a); readvector(b); -- always ok גוף הפרוצדורה מתייחס לגבולות המערך כ v last v first ו 17
מערכים גמישים קבוצת האינדקסים אינה קבועה. השמה לכל המערך יוצרת קבוצת אינדקסים חדשה. דוגמא )בשפה היפוטתית דמוית עדה(: type vector is array (integer range <>) of float; a : vector := (1 => 1.0, 2 => 2.0, 3 => 0.0); b : vector := (2=> 3.0, 3 => 2.0); a:=b; מערך דינמי או גמיש חייב להכיל את ערכי הקצה של האינדקסים. המערך בדוגמאות הוא מטיפוס integer integer (integer -> float) בג'אוה הגבול התחתון של האינדקסים הוא תמיד, 0 ולכן טיפוס המערך הוא integer (integer -> float) 18
מערכים גמישים - דוגמא בג'אוה float [ ] v1 = {2.0, 3.0, 5.0, 7.0 }; // index range 0-3 float [ ] v2 = {0.0, 0.0, 0.0 }; // index range 0-2 v1 = v2; //v1 now points to array with index range 0-2 void print_vector (float [ ] v) { // print the array elements in the form [. ] system.out.print) [ + v[0]); for (int i=1; i<v.length; i++) system.out.print) + v[i]); system.out.print) ] (; אפשר לקרוא ל print_vector עם כל ארגומנט מטיפוס ] [ float בלי תלות בתחום האינדקסים } 19
מערכים ב ML מערכים נתמכים ב SML בספריה הבסיסית Basis Library קיימים שני סוגים של מערכים: vector הוא טיפוס פולימורפי למימוש סדרות אברים מאותו טיפוס, המאפשר גישה יעילה לאבר ה, n מספק מגוון פעולות אך לא מאפשר שינוי האלמנטים. )האינדקסים הם..,0,1 (. array דומה ל vector אך מאפשר בנוסף גם שינוי אלמנטים "במקום" בלי צורך ליצור מערך חדש. הפונקציה extract המוגדרת עבור וקטורים ומערכים יוצרת "נתח" - וקטור שמכיל תת סדרה רצופה של אברים )עפ"י אינדקס התחלה ואורך התת סדרה(. מוגדרים גם מספר טיפוסי וקטורים ומערכים מונומורפיים )למשל של שלמים(. 20
מערכים ב ML )המשך( גודל המערך נקבע בזמן יצירתו )מערך דינמי( אבל משתנים )רפרנס( הם למעשה מערכים גמישים: val x = Array.array(3,5.0); > val x = [ 5.0,5.0,5.0 ] : real array val z = ref x; Array.length(!z); > 3 z := Array.array(4,1.0); Array.length(!z); > 4 21
מערך אסוציאטיבי מערך שהאינדקסים שלו מטיפוס שאינו דיסקרטי )נקראים מפתחות ( בדרך כלל מחרוזות. בשפות סקריפט כגון מערך מוכלל(. perl ולפניה ב awk ב python זה נקרא מילון (dictionary) בשפות אחרות זמין בספריות. )נקרא גם 22
מערך אסוציאטיבי ב perl אין סדר מוגדר לאברים (מימוש בטבלת )hash my %table; # declare an a associative array $table{ schmoe } = joe ; $table{7.5}= 2.6; print $table{ schmoe } ; # prints joe --$table{7.5}; # $table{7.5} now 1.6 ניתן לכתוב לולאה לכל ערכי האינדקסים המוגדרים. while (($key, $value) = each (%table)) {.. } ניתן לבדוק אם אינדקס מסוים מוגדר. $table{10} # undef (not in table) ניתן להסב למערך רגיל ע"י השמה למשתנה מערך רגיל שיכיל לסירוגין אינדקס וערך. )גודל כפול(. ניתן גם להסב מערך רגיל באורך זוגי למערך אסוציאטיבי. 23
מערך אסוציאטיבי ב python >>> tel = {'jack': 4098, 'sape': 4139} >>> tel['guido'] = 4127 >>> tel {'sape': 4139, 'guido': 4127, 'jack': 4098} >>> tel['jack'] 4098 >>> del tel['sape'] >>> tel['irv'] = 4127 >>> tel {'guido': 4127, 'irv': 4127, 'jack': 4098} >>> tel.keys() ['guido', 'irv', 'jack'] >>> 'guido' in tel True 24
הערות על מערך אסוציאטיבי מערך אסוציאטיבי צריך לכלול בנוסף למיפוי, קבוצת האינדקסים. האם השם מערך אסוציאטיבי מוצדק? גם את )דומה למערך?( 25
משמעות ההשמה: סמנטיקה של העתקה ושל התייחסות משמעות ההשמה של ערך מורכב למשתנה מאותו טיפוס תלויה בשפה. שני סוגי סמנטיקה: סמנטיקת העתקה: semantics) (copy ההשמה מעתיקה את כל רכיבי הערך המורכב לרכיבים המתאימים במשתנה. ב ++C, C, עדה. בג'אוה רק לערכים פרימיטיביים סמנטיקת התייחסות: semantics) (reference ההשמה גורמת למשתנה להכיל התייחסות )או מצביע( לערך המורכב. בג'אוה לעצמים )כולל מערכים( ניתן להשיג אפקט של סמנטיקת התייחסות )ב C למשל( ע"י שימוש מפורש במצביעים ניתן להשיג אפקט של סמנטיקת העתקה )בג'אוה עבור עצמים למשל( ע"י פעולת שיבוט (clone) 26
דוגמא בג'אוה class Date { int y, m, d; } Date date1 = new Date(2009,3,16); Date date2 = new Date(2008,1,1); date2 = date1; Date date3 = date1.clone( ); date1 date2 date3 2009 3 16 2008 1 1 סמנטיקת התייחסות 2009 3 16 שיבוט יוצר אפקט של סמנטיקת העתקה 27
דוגמא ב ++C struct Date { int y, m, d; } Date date1 = {2009,3,16}; Date date2; date2 = date1; date1 date2 2009 3 16 סמנטיקת העתקה 2009 3 16??? כדי להשיג אפקט של סמנטיקת התייחסות, משתמשים במצביעים. דומה לרפרנסים בג'אוה Date* date3 = new Date; Date* date4 = new Date; *date3 = date1; 28 date4 = date3;
משמעות פעולת השוויון בדיקת שוויון ששפת התכנות מספקת צריכה להיות תואמת לסמנטיקה של השמה. המתכנת צריך לדעת שמייד לאחר השמה של V ל U, V יהיה שווה ל U, בין אם הסמנטיקה של השמה היא העתקה או התייחסות לכן בדיקת שוויון צריכה להתנהג כך: סמנטיקה של העתקה: בדיקת שוויון צריכה לבדוק אם ערכי הרכיבים של שני הערכים המורכבים שווים סמנטיקה של התייחסות: בדיקת שוויון צריכה לבדוק אם המצביעים לשני הערכים המורכבים שווים )המצביעים פונים לאותו משתנה( 29
משך חיים פרק הזמן בין יצירה וביטול נקרא משך חיים של המשתנה. 30 )lifetime( משך החיים הוא תכונה של המשתנה )תא זיכרון( ויש להבחין בינו לבין scope של מזהה. משך החיים הוא תכונה דינמית )בציר הזמן( בעוד scope הוא תכונה סטטית )לרוב( אורך חיי משתנה הוא מושג חשוב לניהול יעיל וחסכוני של הזיכרון סוגים שונים של אורך חיים: משתנה אוטומטי, סטטי, מתמיד,(persistent) ערמה בהמשך נדבר על משתנה מארז, ומשתנה מחלקה
משתנים אוטומטיים משתנה אוטומטי קשור לבלוק פקודות. בלוק במובן הכללי ביותר, פונקציה בפסקל ו C, }... אקטיבציה של בלוק 31 כגון גוף פרוצדורה או { ב, C ביטוי let ב.ML - אינטרוול זמן בו הבלוק פעיל. אורכי חיים של משתנים הם מקוננים, לא נכון כאשר יש חוטים )threads לא חופפים למשתנה מקומי יכולים להיות מספר אורכי חיים. כאשר יש רקורסיה ניתן לנהל אותם במחסנית. - מספר אורכי חיים מקוננים. )זה המושג משתנה מקומי או גלובלי נוגע בעקר ל scope
משתנים סטטיים ב C ו : PL/I משתנים שאורך החיים שלהם הוא התכנית כולה, בלי תלות באיזה מקום הוגדרו. כמו משתנה גלובלי מבחינת אורך החיים. אבל כמו משתנה מקומי מבחינת זמינותו.(scope) משמש בעיקר כשמשתנה מקומי צריך לשמור את ערכו לקריאה הבאה של הפונקציה. בתכנות מוכוון עצמים יש דרך עדיפה לטפל בזה: שדות מופע או שדות מחלקה 32
משתנים פרסיסטנטיים משתנה מתמיד (Persistent) של תכנית מסוימת. - לעומת משתנה בן-חלוף התכנית שיצרה אותו. )transient( קבצים הם משתנים מורכבים מתמידים. קובץ סדרתי הוא סדרה, אורך חייו הוא מעבר לביצוע קובץ ישיר דומה למערך - משך חייו מקונן בביצוע בשפות מסוימות )פסקל( קבצים הם טיפוסי נתונים בשפה. תמיכה במשתנים מתמידים. בשפות אחרות יש פרוצדורות ספריה לטיפול בקבצים זוהי למה לא לאפשר שכל טיפוס יהיה זמין כמתמיד או כבן-חלוף? 33
משתני ערמה heap משתנים שנוצרים ומבוטלים באופן מפורש, לא לפי מבנה הבלוקים. משתנה ערמה נוצר ע"י פקודה מפורשת, אין לו שם, והגישה אליו באמצעות מצביע. משתנה מקומי או גלובלי נוצר בהצהרה ויש לו מזהה מצביע הוא ערך מסדר ראשון. מאפשר יצירת מבני נתונים מורכבים כלשהו(. מאפשר עדכון המבנה, לא רק התוכן סלקטיבי(. )גרף מכוון )יותר מעדכון 34
דוגמא בפסקל type IntList = ^IntNode; IntNode = record hd : integer; tl : IntList end; var odds, primes : IntList; function cons (h: integer; t: IntList) : IntList; var l : IntList; begin new(l); l^.hd:=h; l^.tl:=t; cons :=l; end; odds := cons (3, cons (5, cons (7, nil))); primes := cons (2,odds); 35
הדוגמא בפעולה primes 2 3 5 7 nil odds odds:= cons (3, cons (5, cons (7, nil) ) ) primes:= cons (2,odds) 36
עוד על משתני ערמה פעולת יצירה (allocator) מפורשת ליצירת משתנה ערמה, מחזירה מצביע למשתנה. בפסקל malloc, בג'אוה,new ב C new(l) פעולת השמדה בפסקל,dispose (deallocator) משמידה משתנה ערמה,free ב C בג'אוה אין פעולת השמדה משתנה ערמה נשאר נגיש (reachable) כל זמן שניתן להגיע אליו באמצעות מצביעים ממשתנה מקומי או גלובלי אורך החיים של משתנה ערמה מתחיל בפעולת היצירה, ומסתיים בפעולת השמדה או כשהוא מפסיק להיות נגיש 37
מצביעים מצביע (pointer) הוא התייחסות למשתנה מסוים, שנקרא המשתנה המוצבע (referent) ערך null הוא ערך מיוחד למצביע שמציין שאין לו מוצבע במודל הזכרון שלנו, מצביע הוא בעצם כתובת המוצבע. אבל למצביע יש טיפוס, שנגזר מטיפוס המוצבע T בפסקל הטיפוס נקרא ^ T בעדה access T ב T* c++ וב c 38
מצביעים ומשתני ערמה משתני ערמה עם מצביעים מייצגים טיפוסים רקורסיביים. מצביע הוא מושג ברמת הפשטה נמוכה. תוכניות עם מצביעים קשות לניפוי שגיאות. שיתוף (sharing) בין מבנים primes:= odds איזה רשימה )או רשימות( מעודכנת סלקטיבית ע"י המשפט הבא? אולי נוצר מעגל ברשימה? p^.tl := q רוב שפות התכנות מספקות מצביעים במקום תמיכה ישירה בטיפוסים רקורסיביים )מדוע? ראה בשקף הבא( 39
מצביעים לעומת טיפוסים רקורסיביים אם שפה אימפרטיבית רקורסיביים כמו ב ML )פסקל או C( תתמוך בטיפוסים מה תהיה המשמעות של השמה list1 =: list2 כאשר אלה משתנים מטיפוס שמייצג רשימות שלמים? סמנטיקת העתקה: יש להעתיק את כל הרשימה.list2 שינוי עתידי ברשימה אחת לא משפיע על השנייה יקר מאד בזיכרון ובזמן סמנטיקת התייחסות: מצביעים בתחפושת פשרה?: 5 40 נוצר שיתוף בין הרשימות לא לאפשר עדכון סלקטיבי של רשימות שפות תכנות,שיעור מספר
dangling references dangling reference הוא מצביע למשתנה שהושמד. עלול לקרות באחד משני המקרים הבאים: מצביע למשתנה ערמה קיים לאחר שמשתנה הערמה עצמו הושמד )כשהשפה תומכת בפעולת השמדה(. מצביע למשתנה אוטומטי קיים )למשל ערכו נשמר במשתנה גלובלי( לאחר שיצאנו מהבלוק בו הוצהר המשתנה המקומי 41
דוגמא dangling references { } int *r ; { int v; r = &v; } *r = 1; דוגמא ב C. מחסנית זמן ריצה גדלה כלפי מעלה. תאים שמעל ל top הם במצב לא מוקצה top v 1 top r top נסיון לגשת למשתנה מקומי שחייו הסתיימו 42
השמה של פונקציה )1( כאשר פונקציות או פרוצדורות הן ערכים מדרגה ראשונה, נוצרת אפשרות נוספת ל dangling references התכנית הבאה מתייחסת להרחבה היפוטתית של פסקל שמאפשרת השמת פונקציה למשתנה מקומי. 43
השמה של פונקציה )2( var fv : integer -> boolean procedure p; var v : function f(n : integer) : boolean; begin v:=1 end; begin // body of p fv := & f end; // body of p begin // main program p; fv (0) end // main program top (v was here) top f היא קריאה ל fv(0) הקריאה code of f v n 10 fv ניסיון לגשת למשתנה מקומי v שחייו הסתיימו. עלול לדרוך על משתנה אחר )אולי n( 44
השמה של פונקציה )3( במהלך הביצוע של p נעשית השמה של הפונקציה המקומית f למשתנה. fv הקריאה fv(0) היא בעצם קריאה לערך של fv שהוא הפונקציה f בביצוע f יש גישה למשתנה v שאינו חי. dangling reference נוצר גם כאשר מוחזרת פונקציה כערך. 45
)1( מניעת dangling references בפסקל הבעיה עם משתנים נמנעת בכך שהתיחסויות )רפרנס( למשתנים מקומיים אינם מדרגה ראשונה. ref התייחסות למשתנה מקומי יכולה לעבור כפרמטר כלומר להיקשר לפרמטר הפורמלי. אבל אורך חיי הפרמטר מקונן באורך חיי הארגומנט פתרון חלקי באלגול - 68 השמת בתנאי שאורך חיי המשתנה מוכל או שווה לאורך חיי ה מחייב בדיקה בזמן ריצה מגביל את המתכנת באופן שרירותי reference מותרת: המקרה שמוצג בשקף שלפני הקודם לא יכול לקרות ב C בגלל שאין קינון פונקציות ב C 46
מניעת )2(dangling references השמה של התייחסות למשתנה ערמה לא תגרום לבעייה אם משתנה הערמה אף פעם לא מבוטל. ביטול משתנה ערמה )ביטול הקצאה( עלול להפוך כל התייחסות אליו ל dangling לכן בג'אוה אין ביטול משתנה ( deallocate או dispose לא קיים( משתנה חי כל זמן שיש התייחסות )ישירה או עקיפה( אליו דורש איסוף זבל בעדה ניתן לבטל משתנה רק ביחידת תכנית שמכריזה with Ada.Unchecked_Deallocation 47
ניהול זכרון הקצאה ושחרור של זיכרון אורך חיים של משתנים מקומיים מקונן קל לנהל אותם במחסנית. אורכי חיי משתני ערמה אינם מקוננים דרוש ניהול מפורש של זיכרון - בהקצאה - בהשמדה יש לספק תאים כנדרש. יש להחזיר לזיכרון החופשי. מערכת זמן הריצה מטפלת בהקצאת הזיכרון, את הזיכרון החופשי. ומנהלת 48
שתי גישות להחזרה לזכרון החופשי גישה 1: החזרת הזכרון מוטלת על המתכנת (++C,C) שמבצע פעולת השמדה באופן מפורש. בעיות: זליגת זכרון: זכרון ללא שימוש שלא בוטלה הקצאתו references : dangling גישה למשתנים שאינם חיים. גישה 2: איסוף זבל garbage collection המתכנת לא מבצע השמדה. מערכת זמן הריצה אחראית למצוא זבל )תאים שאין אליהם גישה( ולהחזיר לזיכרון החופשי מתי יתבצע איסוף הזבל? 49
איסוף זבל garbage collection אלגוריתם סימון ואיסוף מתבצע בדרך כלל כאשר הזכרון )כמעט( נגמר יתרון: לא צריך לבזבז משאבים אם כמות הזכרון מספיקה לשיטה הזאת מספר חסרונות )למשל בתוכנת זמן אמת( יש פתרונות אחרים )העתקה, אזורי זכרון, דורות של זכרון( חסרונות לגישה: אם המתכנת השאיר מצביע למבנה לא נחוץ, הוא לא ייאסף מתאים במיוחד לתכנות פונקציונלי. נחוץ גם במונחה עצמים ככלל, איסוף זבל הרבה פחות יעיל מניהול זכרון במחסנית, ולכן עדיף שימוש במשתנים אוטומטיים כשזה אפשר 50