הבעיות עלולות להתרחש אם לא נשתמש במוקדמות נדיפות הכוללות, כאשר אופטימיזציה מופעלת, ייתכן שהקוד לא יפעל כמצופה. כאשר מופעלים פסיקות, הקוד לא יכול לתפקד כמתוכנן. הנתונים נשמרים רק באחסון נדיף בזמן שהחשמל פועל. כאשר האספקה מוסרת, אובדן נתונים מתרחש.
עם זאת, אחסון לא נדיף שומר נתונים גם אם החשמל נכבה. מידע תהליך מאוחסן לזמן קצר באחסון נדיף מכיוון שהוא מהיר בהרבה מאחסון לא נדיף. בניגוד לאחסון לא נדיף, אחסון נדיף מתאים יותר לשמירה על נתונים רגישים. הסיבה לכך היא שהנתונים אינם נגישים כאשר אספקת החשמל כבויה. אחסון נדיף עולה הרבה מכיוון שמערכות מחשב יכולות להכיל רק כמה מגה-בייט עד כמה ג'יגה-בייט ממנו.'
מאפייני ה-Vatile Qualifier ב-C++
אמצעי הסמכה הנדיפים של C++ יודגמו כאן. כאשר אנו מכריזים על משתנה, הערך 'נדיף' מוחל. זה משמש כתזכורת למהדר שהערך עשוי להשתנות בכל עת. לנדיפים יש כמה מהתכונות המפורטות למטה.
• לא ניתן לשנות את הקצאת הזיכרון עם מילת המפתח הפכפכה.
• לא ניתן לאחסן את המשתנים של המאגר.
• מבחינת ההקצאה, לא ניתן לשנות את הערך.
שימוש ב-Vatile Qualifier ב-C++
1. למרות שהקוד שלך לא משנה את ערך המשתנה, הוא בכל זאת עשוי לעשות זאת. כתוצאה מכך, בכל פעם שהמהדר בודק את מצב המשתנה, הוא לא יכול להניח שהוא זהה לערך האחרון שנקרא ממנו או לערך האחרון שנאגר; במקום זאת, עליו לרכוש את הערך של המשתנה פעם נוספת.
2. המהדר אינו נדרש לבטל את פעולת אחסון ערך מאחר ומדובר ב'תופעת לוואי' שניתן לראות מבחוץ ומתרחשת כאשר ערך נשמר במשתנה נדיף. לדוגמה, אם שני ערכים ממוקמים בשורה, המהדר חייב לשים את הערך פעמיים.
תחביר של ה-Vatile Qualifier ב-C++
# שם_משתנה_נתונים נדיפיםיש להשתמש במילת המפתח הנדיפה בהצהרה, וסוג הנתונים מתייחס לכל סוג נתונים, כולל כפול, צף או מספר שלם. לבסוף, נבחר שם למשתנה. אנו יכולים להגדיר משתנה נדיף באמצעות כל אחת מהשיטות מכיוון ששתי ההצהרות תקפות.
דוגמה: הסמכה הנדיפה משמשת לזיהוי אובייקטים שניתן לשנות על ידי שרשורים אחרים או פעולות חיצוניות ב-C++
אם האובייקט משתנה על ידי אות חיצוני או הליך שפועל כפסיקה, יש לאחזר את הערך שהשתנה מה-RAM מכיוון שמצב המטמון אינו מתאים יותר בינתיים. כתוצאה מכך, המהדר מטפל בגישה לאובייקטים נדיפים כראוי.
#include#include
#include
באמצעות std :: cout ;
באמצעות std :: endl ;
באמצעות std :: cerr ;
באמצעות std :: אֲכִילָה ;
נָדִיף int שניות = 0 ;
בָּטֵל DelayFiveSeconds ( ) {
בזמן ( שניות < 3 ) {
אתה ישן ( 200000 ) ;
cerr << 'הַמתָנָה...' << endl ;
}
}
בָּטֵל הגדל שניות ( ) {
ל ( int אני = 0 ; אני < 5 ; ++ אני ) {
לִישׁוֹן ( 1 ) ;
cerr << 'מוגברת' << endl ;
שניות = שניות + 1 ;
}
}
int רָאשִׁי ( ) {
מבנה התחלה בזמן { } ;
מבנה סוף זמן { } ;
סטד :: פְּתִיל חוט 1 ;
חוט 1 = סטד :: פְּתִיל ( הגדל שניות ) ;
DelayFiveSeconds ( ) ;
חוט 1. לְהִצְטַרֵף ( ) ;
לַחֲזוֹר EXIT_SUCCESS ;
}
כדי להמחיש את התרחיש הפוטנציאלי, השתמשנו במילת המפתח הפכפכה שהמשתנה הוכרז כ-Secons of data מסוג 'int' והקצינו לה ערך של 0. לאחר מכן, אנו בונים שתי פונקציות: אחת בתור 'DelayFiveSeconds' שמשנה את משתנה המספר השלם הנדיף הגלובלי, ואחרת כ'IncrementSeconds' שמבצעת את אותה הערכה בתוך לולאת ה-while. יש לציין שדוגמה זו מאפשרת ללולאת ה-while לעבור לולאה על פני השניות כאשר השניות צריכות להיות פחות מ-3.
כאשר התנאי מתקיים, אזי בלוק ה-while יבוצע. בתוך גוש ה-while, הפעלנו את שיטת Unsleep שמדפיסה את ההצהרה 'ממתין'. לפונקציה 'IncrementSceonds' יש את לולאת for. לאחר האיטרציה, מופעלת שיטת השינה, אשר מדפיסה את המשפט 'increment' ומגדילה את המשתנה 'seconds'. ביצוע ראשוני של הפונקציה 'IncrementSeconds' נעשה על ידי שרשור נפרד שנוצר על ידי הפונקציה הראשית. שיטת 'DelayFiveSeconds' נקראת אז על ידי השרשור הראשי, ונכנסת ללולאה שלא תסתיים אם משתנה השניות לא יעבור מעל הערך של 5.
ברגע שהשרשור הראשי יבחין שהערך של משתנה השניות השתנה, הוא יחזור מהשיטה כי שרשור אחר כבר התחיל להגדיל אותו במקביל.
כדי להפעיל את קוד השרשור ב-C++, עלינו להשתמש בפקודה 'g++ -pthread –o filename filename.cc'. אם לא תפרוס את ה-'-pthread' בפקודה, יש סיכוי שהמהדר יזרוק חריג. כתוצאה מכך, למעשה יצרנו פונקציית המתנה מותנית שמחכה עד שהאובייקט הנדיף ישתנה על ידי כוח חיצוני. חשוב לזכור שבלוק קוד העדכון יכול להגיע מקטע תרגום אחר או מפעולת אות חיצונית, למרות שקוד זה עדיין יפעל אותו הדבר אם המוקד הנדיף יוסר ומשתמש במשתנה גלובלי רגיל.
סיכום
כאן אנו עוברים על סקירה כללית של Volatile ב-C++ יחד עם התחביר, השימוש והדוגמאות המתאימות להבנה טובה יותר. מכיוון שהמהדר אינו יכול לחזות את הערך, נדיף הוא קריטי בתכנות C. היתרון העיקרי בשימוש ב-volatile הוא שערכו עשוי להשתנות בכל פעם שמשתמש מבקש לשנות אותו או כאשר שרשור אחר המשתמש באותו משתנה פעיל.