כיצד לעבוד עם הקצאת זיכרון דינמית C ++?

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

• זקוק להקצאת זיכרון דינמי?
• הקצאת זיכרון באמצעות חָדָשׁ מילת מפתח
• חלוקת זיכרון באמצעות לִמְחוֹק מילת מפתח
• הקצאת מערכים באופן דינמי
• הקצאת זיכרון דינמית לאובייקטים

אז בואו נתחיל במאמר זה על הקצאת זיכרון דינמי ב- C ++

זקוק להקצאת זיכרון דינמי?

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

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

במקרה שלעיל, אין לנו את הרעיון לגבי הגודל המדויק של המערך עד זמן ההידור (כאשר המחשב מחבר את הקוד והמחרוזת מוזנת על ידי המשתמש). במקרים כאלה אנו משתמשים ב- חָדָשׁ מַפעִיל.

C ++ מגדיר שני אופרטורים לא אחידים חָדָשׁ ו לִמְחוֹק המבצעים את משימת הקצאת הזיכרון וההקצאה בו בזמן ריצה. מכיוון שמפעילים אלה (חדשים ומחקים) פועלים על פי זיכרון חנות פנוי (זיכרון ערימה), הם נקראים גם מפעיל חנויות חינם. מצביעים מספקים את התמיכה הדרושה למערכת הקצאת זיכרון דינמית ב- C ++.

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

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

ההבדלים בין הקצאת זיכרון סטטי להקצאת זיכרון דינמי:

זוהי ארכיטקטורת זיכרון בסיסית המשמשת לכל תוכנית C ++:

אלגוריתם מיזוג של c ++

נצטרך תמונה כזו

הערימה משמשת להקצאת זיכרון סטטי ו- Heap להקצאת זיכרון דינמי, שניהם מאוחסנים בזיכרון ה- RAM של המחשב.

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

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

ממשיך הלאה עם מאמר זה על הקצאת זיכרון דינמי ב- C ++

הקצאת זיכרון באמצעות חָדָשׁ מילת מפתח

ב- C ++ ה- חָדָשׁ אופרטור משמש להקצאת זיכרון בזמן ריצה והזיכרון מוקצה בתים. ה חָדָשׁ המפעיל מציין בקשה להקצאת זיכרון דינמי בערימה. אם יש זיכרון מספיק אז חָדָשׁ מפעיל מאותחל את הזיכרון ומחזיר את כתובת הזיכרון שהוקצה ומאותחל לאחרונה למשתנה המצביע.

תחביר:

סוג נתונים * מצביע_שם = סוג נתונים חדש

דוגמא:

int * ptr = int int // אנו יכולים להכריז על משתנה תוך הקצאה דינמית בשתי הדרכים הבאות. int * ptr = int int (10) int * ptr = int int {15} // אופרטור חדש משמש גם להקצאת בלוק (מערך) של זיכרון מסוג נתונים מסוג. int * ptr = new int [20] // המשפט הנ'ל מקצה דינמית זיכרון ל -20 מספרים שלמים ברציפות מהסוג int ומחזיר מצביע לאלמנט הראשון של הרצף לסמן 'ptr'.

הערה : אם לערימה אין מספיק זיכרון להקצאה, הבקשה החדשה מצביעה על כישלון על ידי השלכת חריג std :: bad_alloc, אלא אם כן נעשה שימוש ב- nothrow עם המפעיל החדש, ובמקרה זה הוא מחזיר מצביע NULL. לכן, נוהג טוב לבדוק אם משתנה המצביע מיוצר על ידי חדש לפני השימוש בו בתוכנית.

ממשיך הלאה עם מאמר זה על הקצאת זיכרון דינמי ב- C ++

חלוקת זיכרון באמצעות לִמְחוֹק מילת מפתח:

לאחר זיכרון הערמה מוקצה למשתנה או לאובייקט מחלקה באמצעות ה- חָדָשׁ אנו יכולים להתמודד עם מקום הזיכרון באמצעות לִמְחוֹק מילת מפתח.

תחביר:

delete pointer_variable // הנה, pointer_variable הוא המצביע המצביע על אובייקט הנתונים שנוצר על ידי חדש. מחק [] pointer_variable // כדי לפנות את זיכרון המערך המוקצה באופן דינמי המופנה על ידי משתנה מצביע אנו משתמשים בצורה הבאה של מחיקה:

דוגמא:

מחק ptr מחק [] ptr

הערה : היקף האובייקט או חייו של האובייקט הוא הזמן בו האובייקט נשאר בזיכרון במהלך ביצוע התוכנית. הקצאת זיכרון הערמה איטית יותר מערימה, מכיוון שבגובה אין סדר מסוים בו תוכלו להקצות זיכרון ואילו בערימה הוא עוקב אחר LIFO.

אדריכלות mvc בג'אווה עם דוגמה

ממשיך הלאה עם מאמר זה על הקצאת זיכרון דינמי ב- C ++

הקצאת מערכים באופן דינמי

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

בואו נראה, דוגמה להבנת השימוש בה.

# כלול באמצעות מרחב השמות std int main () {int len, sum = 0 cout<< 'Enter the no. of students in the class' <>len int * marks = new int [len] // זיכרון דינמי להקצאת זיכרון<< 'Enter the marks of each student' << endl for( int i = 0 i>* (מסמן + i)} עבור (int i = 0 i
 הֶסבֵּר:  
בדוגמה זו תחילה אנו מבקשים מהמשתמש את מספר התלמידים בכיתה ואנו שומרים את ערכו במשתנה len. לאחר מכן אנו מכריזים על מערך שלם ומקצים לו מקום בזיכרון השווה באופן דינמי לערך המאוחסן במשתנה len באמצעות הצהרה זו int * marks = new int [length] ולכן מוקצה לו שטח שווה ל- 'length * (גודל של 1 מספר שלם)'. שאר הקוד מובן מאליו.
ממשיך הלאה עם מאמר זה על הקצאת זיכרון דינמי ב- C ++
 הקצאת זיכרון דינמית לאובייקטים 
אנו יכולים גם להקצות דינמית אובייקטים.
כידוע כי קונסטרוקטור פונקציה מיוחדת של מחלקה מחלקה משמשת לאתחול אובייקט ו- Destructor היא גם פונקציית חבר מחלקה הנקראת בכל פעם שהאובייקט יוצא מהתחום.
ניתן להשתמש ב- Destructor לשחרור הזיכרון שהוקצה לאובייקט. זה נקרא בתנאים הבאים.
כאשר אובייקט מקומי יוצא מהתחום
עבור אובייקט גלובלי, כאשר אופרטור מוחל על מצביע לאובייקט המחלקה
אנו יכולים להשתמש שוב במצבעים תוך הקצאה דינמית של זיכרון לאובייקטים.
בואו נראה דוגמה למערך של אובייקטים.
#include באמצעות namespace std class אקראי {public: אקראי () {cout<< 'Constructor' << endl } ~Random() { cout << 'Destructor' << endl } } int main() { Random* a = new Random[3] delete [] a // Delete array return 0 } 
 תְפוּקָה: 
 הֶסבֵּר: 
הבנאי ייקרא שלוש פעמים מכיוון שאנו מקצים זיכרון לשלושה אובייקטים מהמחלקה אקראית. המשחית ייקרא גם שלוש פעמים במהלך כל אחד מהאובייקטים הללו. 'אקראי * a = אקראי חדש [3]' הצהרה זו אחראית על הקצאת זיכרון דינמית של האובייקט שלנו.
לפיכך הגענו לסוף מאמר זה בנושא 'הקצאת זיכרון דינמי C ++'. אם ברצונך ללמוד עוד, עיין ב   מאת אדוריקה, חברת למידה מקוונת אמינה. קורס ההכשרה וההסמכה של Java J2EE ו- SOA של אדוריקה נועד להכשיר אותך לקונספטים מרכזיים של Java וגם עם מסגרות Java שונות כמו Hibernate & Spring.
 יש לך שאלה עבורנו? אנא הזכיר זאת במדור התגובות בבלוג זה ונחזור אליך בהקדם האפשרי.