כיצד לבצע את תבנית העיצוב של סינגלטון ב- C ++: 9 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:15

מבוא:

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

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

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

מדריך הדרכה זה יימשך בממוצע כ 10-15 דקות.

דרישות חומר:

-מחשב (יכול להיות PC או Mac) המסוגל להריץ Visual Studios (כל גרסה)

תוכנית פשוטה, שנוצרה באולפני Visual, שתוכל לבדוק איתה את הרווק שלך

הערה: ניתן לבצע את תבנית העיצוב של סינגלטון בכל C ++ תומך IDE או ממשק קידוד, אך עבור מערך הוראות זה נשתמש ב- Visual Studios Enterprise Edition.

שלב 1: צור את הכיתה שלך, עם קובץ כותרת וקובץ CPP

כדי ליצור את שני הקבצים האלה ואת המחלקה בבת אחת, פתח את הפרויקט / התוכנית שלך באולפני Visual, עבור אל סייר הפתרונות, לחץ לחיצה ימנית ותיבה אמורה להופיע ליד סמן העכבר שלך, מצא את האפשרות "הוסף", העבר את העכבר מעליו, ותיבה נוספת אמורה להופיע מימין. בתיבה זו, אתה רוצה למצוא את האפשרות "פריט חדש..", לחץ עליה וחלון הדומה לתמונת 1.1 להלן יופיע. בחלון זה אתה רוצה לבחור "C ++ Class" ולאחר מכן לחץ על "הוסף". פעולה זו תפתח חלון נוסף הדומה לתמונת התמונה 1.2. בחלון זה, אתה מקליד את שם הכיתה שלך בשדה "שם כיתה" ואולפני Visual יקראו את הקובץ בפועל על שם הכיתה באופן אוטומטי. לצורך הוראה זו, אנו מתכוונים לקרוא לכיתה שלנו "EngineDebugSingleton", אך זה יכול להיות כל שם מבוסס אותיות. כעת תוכל ללחוץ על "אישור" ולהמשיך לשלב 2.

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

שלב 2: הגדר את הבונה כפרטי

עם קובץ ה- CPP והקובץ הכותרת החדש שנוצר, אם הוא לא נפתח אוטומטית כאשר יצרת אותו, עבור אל סייר הפתרונות ולחץ על ופתח את "EngineDebugSingleton.h". לאחר מכן תתקבל בברכה עם "EngineDebugSingleton ()", בונה ברירת המחדל של הכיתה ו- "~ EngineDebugSingleton ()" הורס המחלקה. עבור שלב זה, נרצה להגדיר את הבונה כפרטי, המשמעות היא שפונקציה זו זמינה רק למחלקה ותו לא. עם זאת, לא תוכל לבצע משתנה או להקצות את המחלקה לזיכרון מחוץ למחלקה, רק בקובץ הכותרת של המחלקות ובפונקציות האחרות של המחלקות. הבניין הפרטי הוא המפתח לתבנית העיצוב ולאופן הפעולה של יחידות. נגלה בשלבים עתידיים כיצד מייצרים ונגשים לגבר.

המעמד אמור להיראות כך לאחר העברת הקונסטרוקטור לפרטי (תסתכל על התמונה המשויכת)

שלב 3: הגדר את ה- Destructor כפרטי

כמו שעשינו עם הבונה ב

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

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

שלב 4: יצירת משתנה מצביע סטטי בסינגלטון

בשלב זה ניצור א

משתנה מצביע סטטי מסוג "EngineDebugSingleton*". זה יהיה המשתנה שישמש להקצות את הסינגלטון שלנו לזיכרון ויצביע עליו במשך כל הזמן שהסינגל שלנו מוקצה לזיכרון.

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

שלב 5: יצירת פונקציית Instance

כעת אנו רוצים ליצור מופע

פוּנקצִיָה. הפונקציה תצטרך להיות פונקציה סטטית ותרצה להחזיר הפניה למחלקה שלנו ("EngineDebugSingleton &"). קראנו לפונקציה שלנו Instance (). בפונקציה עצמה, נרצה לבדוק תחילה אם ptrInstance == nullptr (ניתן לקצר ל-! PtrInstance), אם היא nullptr, המשמעות היא שהסינגלטון לא הוקצה ובהיקף הצהרת if, נוכל רוצה להקצות על ידי ביצוע ptrInstance = new EngineDebugSingleton (). כאן אתה בעצם מקצה את הסינגלטון לזיכרון. לאחר יציאה מהיקף הצהרת if, לאחר מכן נחזיר את מה שאליו ptrInstance מצביע, המסומן בתחביר "*ptrInstance". אנו נשתמש בפונקציה זו בכבדות בעת ביצוע הפונקציות הציבוריות הסטטיות שלנו, כך שנוכל לבדוק אם הסינגלטון נוצר והוקצה לזיכרון. בעצם, פונקציה זו הופכת אותו כך שתוכל לקבל הקצאה אחת בלבד מהמחלקה ולא יותר.

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

שלב 6: יצירת פונקציות ציבוריות סטטיות

לאחר שביצעת את הפונקציה מ

שלב 5, אתה יכול להתחיל לבצע פונקציות ציבוריות סטטיות. לכל פונקציה ציבורית צריכה להיות פונקציה פרטית שתלווה אליה, שם הפונקציה הזו לא יכול להיות זהה. מדוע להפוך את הפונקציה לסטטית? אנו הופכים את הפונקציות הציבוריות לסטטיות כך שניתן יהיה לגשת אליהם ללא אובייקט ממשי. אז במקום לעשות משהו כמו "EngineDebugSingleObj-> SomeFunction ()", אנו עושים "EngineDebugSingleton:: Some Function ()". זה מאפשר לגשת ל- singleton בעצם בכל מקום בקוד, בתנאי שכללת #את קובץ הכותרת בקובץ הפרויקט הספציפי שאיתו אתה עובד. בעזרת זה, אתה יכול גם ליצור את הסינגלטון באמצעות כל אחד מהפונקציות הציבוריות שלו.

למטרותינו בשלב זה יצרנו שתי פונקציות חלל סטטי ציבורי, "הוסף ()" ו "הפחת ()". בחלק הפרטי, יש לנו שתי פונקציות נוספות, "PrivAdd ()" ו- "PrivSubtract ()". הוספנו גם משתנה int בשם "NumberOfThings". ההגדרה לפונקציות אלה תיכנס לקובץ ה- CPP של השיעורים שלנו. כדי לגרום לפונקציה להיכנס בקלות לקובץ ה- CPP, אתה מסמן עם הסמן את הפונקציה, שאמורה להיות לה קו ירוק מתחתיה ולחץ על "ALT + ENTER שמאלי", היא תיתן לך את האפשרות ליצור את ההגדרה ב- קובץ ה- CPP המשויך של הכיתות. עיין בתמונה 6.1 כדי לראות כיצד קובץ הכותרת אמור להיראות ולאחר שיצרת את כל הגדרות הפונקציה, המחיר שלך צריך להיראות כמו תמונה 6.2 למעט הגדרות הפונקציה שלך לא יהיה בהן קוד.

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

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

שלב 7: יצירת הפונקציה 'סיום'

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

שלב 8: הגדרת PtrInstance ל- Nullptr

כדי להשלים את הסינגלטון שלך, אתה רוצה לעבור לקובץ EngineDebugSingleton. CPP ובחלק העליון של קובץ ה- CPP, במקרה שלנו, הקלד "EngineDebugSingleton* EngineDebugSingleton:: ptrInstance = nullptr."

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

שלב 9: בדיקה ומסקנה

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

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

קובץ הכותרת הסופי שלך צריך להיראות כמו התמונה 7.1. קובץ ה- CPP המשויך של הסינגלטון שלך צריך להיראות כמו תמונה 6.2 בתוספת, בחלק העליון של הקובץ, של הקוד המוצג בשלב 8. הוראה זו סיפקה לך מבנה פשוט של תבנית העיצוב של סינגלטון.

עצות לפתרון בעיות:

מקבלים שגיאות הקשורות לזיכרון?

הקפד להתייחס לשלב 7 ולשלב 8 כדי לוודא שאתה מגדיר את ptrInstance ל- nullptr.

מתרחשת לולאה אינסופית?

ודא שלפונקציות הציבוריות, בהגדרות שלהן, אתה קורא לפונקציה הפרטית, לא לאותה פונקציה ציבורית.

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

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