תבנית הסינגלטון משמשת בדרך כלל כאשר אתה צריך משאב יחיד משותף שאליו יש לגשת באופן גלובלי, כגון חיבור למסד נתונים, לוגר או מנהל תצורה. על ידי אכיפת מופע בודד, הוא מאפשר לחלקים מרובים של התוכנית לגשת ולשנות את אותו אובייקט, מקדם עקביות נתונים ומפחית את הצורך במשתנים גלובליים. ניתן להשתמש ב-Singleton כמטמון אובייקטים שבו האובייקטים הנפוצים או היקרים ליצירה מאוחסנים ועושים בהם שימוש חוזר לאורך היישום. גישה זו מסייעת לשפר את הביצועים על ידי הימנעות מיצירה ואתחול של אובייקטים מיותרים.
במאמר זה נסביר את יצירת הסינגלטון ונדגים דוגמה לסגנון סינגלטון בתוכנת C++.
דוגמה 1: יצירת סינגלטון פשוט עם אתחול להוט
סינגלטון פשוט עם אתחול מוקדם הוא דפוס עיצוב המבטיח שרק מופע אחד של מחלקה נוצר, והוא נוצר בשקיקה במהלך אתחול סטטי.
נדגים את קטע הקוד הבסיסי ליצירת סינגלטון פשוט עם אתחול נלהב. נתחיל עם התוכנית:
#include
כיתה סינגלטון {
פְּרָטִי :
סטָטִי קְלָף בּוֹדֵד * למשל ;
קְלָף בּוֹדֵד ( ) { }
פּוּמְבֵּי :
סטָטִי קְלָף בּוֹדֵד * getInstance ( ) {
לַחֲזוֹר למשל ;
}
} ;
קְלָף בּוֹדֵד * קְלָף בּוֹדֵד :: למשל = סינגלטון חדש ( ) ;
int רָאשִׁי ( ) {
קְלָף בּוֹדֵד * singletonInstance1 = קְלָף בּוֹדֵד :: getInstance ( ) ;
קְלָף בּוֹדֵד * singletonInstance2 = קְלָף בּוֹדֵד :: getInstance ( ) ;
סטד :: cout << 'singletonletonInstance1: ' << singletonInstance1 << סטד :: endl ;
סטד :: cout << 'singletonletonInstance2: ' << singletonInstance2 << סטד :: endl ;
לַחֲזוֹר 0 ;
}
הקוד כולל את הכותרת
לאחר הכללת קובץ ה-header, אנו מגדירים את המחלקה 'Singleton' המייצגת את יישום דפוס הסינגלטון. יש לו בנאי פרטי ומשתנה חבר סטטי פרטי בשם 'מופע'.
לאחר מכן, הפונקציה getInstance() מיושמת כפונקציית חבר סטטית ציבורית של המחלקה 'Singleton'. הוא מחזיר את המופע של הסינגלטון המאוחסן במופע המשתנה האיבר הסטטי. מופע משתנה האיבר הסטטי מוגדר ומאוחל מחוץ למחלקה עם 'Singleton* Singleton::instance = new Singleton();'. שורה זו מאתחלת את המופע של המחלקה 'Singleton' בשקיקה במהלך אתחול סטטי.
בפונקציה main() אנו מכריזים על שני מצביעים, 'singletonInstance1' ו-'singletonInstance2', ומקצים את הערך המוחזר על ידי קריאה ל-Singleton::getInstance(). מכיוון שהמופע מאותחל בשקיקה, שני המצביעים מצביעים על אותו מופע. ההצהרות 'std::cout' מדפיסות את כתובות הזיכרון של 'singletonInstance1' ו-'singletonInstance2' למסוף באמצעות האופרטור '<<' ו-'std::endl'.
הקוד מסתיים ב-'החזר 0' המעיד על ביצוע מוצלח של התוכנית.
כאשר אתה מפעיל את הקוד הזה, הפלט הוא משהו כזה:
הפלט מציג את כתובות הזיכרון של 'singletonInstance1' ו-'singletonInstance2'. מכיוון ששני המצביעים מוקצים לאותו מופע שמתקבל מ-Singleton::getInstance(), יש להם אותה כתובת זיכרון. זה מדגים כיצד תבנית הסינגלטון מבטיחה שיש מופע בודד של המחלקה ושהקריאות העתידיות ל-getInstance() תמיד מביאות לאותו מופע.
דוגמה 2: יישום דפוס יחיד עם אתחול עצלן
הדגמה זו מסבירה את יישום דפוס הסינגלטון עם אתחול עצלן ומראה את השימוש בו בפונקציה main() . ההסבר שלב אחר שלב של קטע הקוד מסופק לאחר תוכנית זו:
#includeכיתה סינגלטון {
פְּרָטִי :
סטָטִי קְלָף בּוֹדֵד * למשל ;
קְלָף בּוֹדֵד ( ) {
סטד :: cout << 'מופע יחיד נוצר.' << סטד :: endl ;
}
פּוּמְבֵּי :
סטָטִי קְלָף בּוֹדֵד * getInstance ( ) {
אם ( למשל == nullptr ) {
למשל = סינגלטון חדש ( ) ;
}
לַחֲזוֹר למשל ;
}
בָּטֵל הצג הודעה ( ) {
סטד :: cout << 'שלום מסינגלטון!' << סטד :: endl ;
}
~סינגלטון ( ) {
סטד :: cout << 'מופע יחיד נהרס.' << סטד :: endl ;
}
} ;
קְלָף בּוֹדֵד * קְלָף בּוֹדֵד :: למשל = nullptr ;
int רָאשִׁי ( ) {
קְלָף בּוֹדֵד * singletonInstance1 = קְלָף בּוֹדֵד :: getInstance ( ) ;
singletonInstance1 -> הצג הודעה ( ) ;
קְלָף בּוֹדֵד * singletonInstance2 = קְלָף בּוֹדֵד :: getInstance ( ) ;
singletonInstance2 -> הצג הודעה ( ) ;
לַחֲזוֹר 0 ;
}
התוכנית מתחילה בהוספת קובץ הכותרת
בכל פעם שנקרא הבנאי של המחלקה 'Singleton', הוא יוצר מופע של המחלקה 'Singleton'. הוא מוציא את ההודעה 'מופע יחיד שנוצר' לקונסולה באמצעות ה-'std::cout << … << std::endl;'. לבנאי אין פרמטרים מכיוון שהוא בנאי ברירת מחדל. הוא מוגדר כסינגלטון() ללא כל ארגומנטים. אנו מצהירים עליו כפרטי, כלומר ניתן להפעיל אותו רק מתוך הכיתה. זה מונע מופע ישיר של המחלקה 'Singleton' ומבטיח שהדרך היחידה להשיג מופע היא באמצעות הפונקציה getInstance() .
שיטת getInstance() של המחלקה 'Singleton' מוכרזת כפונקציית חבר סטטית ציבורית. זה בתפקיד של ביסוס והענקת נגישות למופע הסינגלטון. בתוך getInstance(), הוא בודק אם המופע הוא 'nullptr'. אם כן, מה שמסמל שהמופע אינו קיים כבר, הוא משתמש בבנאי הפרטי כדי ליצור אובייקט חדש של המחלקה 'Singleton'.
הפונקציה showMessage() היא פונקציית חבר פשוטה שמציגה את 'שלום מסינגלטון!' הוֹדָעָה. ההורס של סינגלטון מוגדר. זה נקרא באופן מרומז כאשר התוכנית מסתיימת ומדפיסה את 'מופע יחיד הושמד'. הודעה שמציינת שמופע הסינגלטון מושמד. מופע משתנה האיבר הסטטי מוגדר בתחילה כ'nullptr'.
ה-int main() מתחיל את ההגדרה של הפונקציה main() . לאחר מכן, ה-'Singleton* singletonInstance1 = Singleton::getInstance();' קורא לפונקציה getInstance() של המחלקה 'Singleton' כדי להשיג מצביע למופע הסינגלטון. הוא מקצה את המצביע הזה למשתנה 'singletonInstance1'.
לאחר מכן, 'singletonInstance1->showMessage();' משתמש באופרטור החץ (->) כדי לקרוא לפונקציה showMessage() במצביע 'singletonInstance1'. פונקציה זו מציגה את ההודעה המצוינת בה לקונסולה. לאחר מכן, ה-'Singleton* singletonInstance2 = Singleton::getInstance();' קורא שוב לפונקציה getInstance() ומשיג מצביע נוסף למופע הסינגלטון. הפעם, הוא מקצה את המצביע למשתנה 'singletonInstance2'. ה-'singletonInstance2->showMessage();' קורא לפונקציה showMessage() במצביע 'singletonInstance2'. פונקציה זו מציגה את 'שלום מסינגלטון!' הודעה שוב לקונסולה.
לבסוף, 'החזר 0;' מסמל את סוף הפונקציה main(), והתוכנית מחזירה את הערך של 0 שמסמל ביצוע מוצלח של תוכנית.
הנה הפלט של קטע הקוד שהוסבר קודם לכן:
תוצאה זו מאשרת שהמחלקה 'Singleton' מבטיחה יצירה של מופע אחד בלבד ושקריאות נוספות לפונקציה getInstance() מניבות באופן מהימן את אותו מופע.
סיכום
יצירת יחיד ב-C++ הוא מושג מאוד שימושי. בפוסט זה, כיסינו בתחילה את קטע ההקדמה של סינגלטון. יתר על כן, שתי דוגמאות מופקות ליישום הסינגלטון ב-C++. האיור הראשון מציג את היישום של אתחול הסינגלטון הנלהב. ואילו יישום האתחול העצל של דפוס הסינגלטון מסופק בדוגמה השנייה של מאמר זה. יתר על כן, התמונות של הפלט המופק מוצגות גם עבור התוכניות המתאימות.