הקדמה לתכנות MFC עם Visual C++ גרסה 6.x
דף הבית	C\C++ סדרת המדריכים לשפת

חלק 2: תוכנית MFC פשוטה

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

הקדמה ל MFC

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

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

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

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

• ארכיטקטורת אפליקציה
• ציור גרפי וציור עצמים
• שירותים לקבצים
• יוצאים מן הכלל
• מבנים - רשימות, מערכים, מפות
• שירותי אינטרנט
• OLE 2
• בסיס נתונים
• מטרה כללית

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

• CObject
• CCmdTarget
• CWinThread
• CWinApp
• CWnd
• CFrameWnd
• CDialog
• CView
• CStatic
• CButton
• CListBox
• CComboBox
• CEdit
• CScrollBar

יש מספר דברים אליהם צריך לשים לב ברשימה זו. קודם כל, רוב המחלקות ב MFC נגזרות ממחלקת בסיס שנקראת CObject. מחלקה זו מכילה data members ופונקציות חברות שמשותפים לרוב מחלקות MFC. הדבר השני אליו צריך לשים לב הוא הפשטות של הרשימה. במחלקה CWinApp נעשה שימוש בכל פעם שאתה יוצר יישום, ונעשה בה שימוש רק פעם אחת בכל תוכנית. המחלקה CWnd אוספת את כל התכונות המשותפות שנמצאות בחלונות, תיבות דו-שיח, ובקרות. המחלקה CFrameWnd נגזרת מ CWnd ומיישמת חלון יישום ממוסגר רגיל. CDialog מטפלת בשני הסוגים הרגילים של תיבות דו-שיח: modeless ו modal בהתאמה. ב CView משתמשים כדי לאפשר למשתמש גישה למסמך דרך חלון. לבסוף, חלונות תומך בשישה סוגי בקרות שמובנות בו: טקסט סטטי, טקסט ניתן לעריכה, לחצנים, פסי גלילה, רשימות ותיבות קומבו (צורה מורחבת של רשימה). ברגע שהבנת את מספר הקטעים הקטן למדי הזה, אתה בדרך להבנה שלימה של MFC. המחלקות האחרות בהיררכית MFC מיישמות תכונות אחרות כגון ניהול זיכרון, בקרת מסמכים, תמיכה בבסיסי נתונים, וכן הלאה.

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

תכנון תוכנית

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

יישום "hello world" צריך קודם כל ליצור חלון על המסך שמכיל את המילים "hello world". לאחר מכן הוא צריך להכניס את המילים "hello world" עצמן למסך. שלושה עצמים דרושים כדי לבצע את המשימה הזו:

1. עצם יישום שמאתחל את היישום ומקשר אותו לחלונות. עצם היישום מטפל בכל עיבוד התהליכים ברמה הנמוכה.

2. עצם חלון שפועל כחלון היישום הראשי.

3. עצם טקסט סטטי שיחזיק את תווית הטקסט הסטטית "hello world".

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

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

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

הבנת הקוד ל "hello world"

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

אם לא עשית זאת עדיין, אנא הדר והרץ את הקוד שלהלן באמצעות מעקב אחר ההוראות שניתנו בשיעור 1.

1 //hello.cpp
 
2 #include <afxwin.h>
 
3 // Declare the application class
4 class CHelloApp : public CWinApp
5 {
6 	public:
7 		virtual BOOL InitInstance();
8 };
 
9 // Create an instance of the application class
10 CHelloApp HelloApp;

11 // Declare the main window class
12 class CHelloWindow : public CFrameWnd
13 { 
14 	CStatic* cs;
15 	public:
16 	CHelloWindow();
17 };
 
18 // The InitInstance function is called each
19 // time the application first executes.
20 BOOL CHelloApp::InitInstance()
21 {
22 	m_pMainWnd = new CHelloWindow();
23 	m_pMainWnd->ShowWindow(m_nCmdShow);
24 	m_pMainWnd->UpdateWindow();
25 	return TRUE;
26 }
 
27 // The constructor for the window class
28 CHelloWindow::CHelloWindow()
29 { 
30 	// Create the window itself
31 	Create(NULL, 
32 		"Hello World!", 
33 		WS_OVERLAPPEDWINDOW,
34 		CRect(0,0,200,200)); 
35 	// Create a static label
36 	cs = new CStatic();
37 	cs->Create("hello world",
38 		WS_CHILD|WS_VISIBLE|SS_CENTER,
39 		CRect(50,80,150,150),
40 		this);
41 }

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

התוכנית קודם מכלילה את afxwin.h (שורה 2). קובץ הכותרת הזה מכיל את כל הטיפוסים, המחלקות, הפונקציות, והמשתנים בהם משתמשים ב MFC. הוא גם מכליל קבצי כותרת אחרים לדברים כמו ספריות ה API של חלונות.

שורות 3 עד 8 גוזרות מחלקת יישום חדשה בשם CHelloApp ממחלקת היישום הסטנדרטית CWinApp שמוצהרת ב MFC. המחלקה החדשה נוצרת כך שניתן לדרוס את הפונקציה InitInstance החברה ב InitInstance .CWinApp היא פונקציה וירטואלית שנקראת כאשר היישום מתחיל לרוץ.

בשורה 10, הקוד מצהיר על מופע של עצם היישום כמשתנה גלובלי. מופע זה הוא חשוב כיוון שהוא גורם לתוכנית לרוץ. כאשר היישום נטען לתוך הזיכרון ומתחיל לרוץ, היצירה של המשתנה הגלובלי הזה גורמת לבנאי ברירת המחדל של המחלקה CWinApp לרוץ. בנאי זה קורא אוטומטית לפונקציה InitInstance שמוגדרת בשורות 18 עד 26.

בשורות 11 עד 17, המחלקה CHelloWindow נגזרת מהמחלקה CFrameWnd שמוצהרת ב MFC. CHelloWindow פועלת כחלון היישום על המסך. מחלקה חדשה נוצרת כך שניתן ליישם בנאי, הורס, ו data members חדשים.

שורות 18 עד 26 מיישמות את הפונקציה InitInstance. פונקציה זו יוצרת מופע של המחלקה CHelloWindow, ועל ידי כך גורמת לבנאי המחלקה בשורות 27 עד 41 לרוץ. היא גם מביאה את החלון החדש למסך.

שורות 27 עד 41 מיישמות את הבנאי של החלון. הבנאי למעשה יוצר את החלון ואז יוצר בקרה סטטית בתוכו.

דבר מעניין אליו יש לשים לב בתוכנית זו הוא שאין שום פונקצית main או WinMain, ושום לולאת תהליכים נראית לעין. אבל אנחנו יודעים מההרצה שלה בשיעור 1 שהיא מעבדת מאורעות. ניתן למזער את החלון, לפרוס, להזיז אותו, וכן הלאה. כל הפעילות הזו חבויה במחלקה הראשית של היישום CWinApp ולכן אנחנו לא צריכים לדאוג לה - הטיפול במאורעות הוא אוטומטי לחלוטין ובלתי נראה ב MFC.

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

עצם היישום

כל תוכנית שאתה יוצר ב MFC תכיל עצם יישום בודד שאתה גוזר מהמחלקה CWinApp. על העצם הזה יש להצהיר גלובלית (שורה 10) והוא יכול להיות קיים רק פעם אחת בכל תוכנית נתונה.

עצם שנגזר מהמחלקה CWinApp מטפל באתחול של האפליקציה, ובלולאת המאורעות המרכזית לתוכנית. במחלקה CWinApp יש מספר data members, ומספר פונקציות חברות. בינתיים, כמעט הכל לא חשוב. אם אתה רוצה לעיין בחלק מהפונקציות האלה, בכל אופן, חפש את CWinApp בקובץ העזרה של MFC באמצעות בחירת האופציה Search בתפריט ה Help והדפסה "CWinApp". בתוכנית לעיל, דרסנו רק פונקציה וירטואלית אחת ב CWinApp, פונקציה זו הייתה InitInstance.

המטרה של עצם היישום היא לאתחל ולשלוט ביישום שלך. כיוון שחלונות מאפשר למספר מופעים של אותו היישום לרוץ בו זמנית, MFC מפרקת את תהליך האתחול לשני חלקים ומשתמשת בשתי פונקציות - InitApplication ו InitInstance - כדי לטפל בו. כאן השתמשנו רק בפונקציה InitInstance בגלל הפשטות של היישום. היא נקראת בכל פעם שמופע חדש של היישום מתחיל להתקיים. הקוד בשורות 3 עד 8 יוצר מחלקה בשם CHelloApp שנגזרת מ CWinApp. היא מכילה פונקצית InitInstance חדשה שדורסת את הפונקציה הקיימת ב CWinApp (שלא עושה דבר):

3 // Declare the application class
4 class CHelloApp : public CWinApp
5 {
6 	public:
7 		virtual BOOL InitInstance();
8 };

בתוך הפונקציה InitInstance שנדרסה בשורות 18 עד 26, התוכנית יוצרת ומציגה את החלון תוך שימוש ב data member של CHelloApp שנקרא m_pMainWnd:

18 // The InitInstance function is called each
19 // time the application first executes.
20 BOOL CHelloApp::InitInstance()
21 {
22 	m_pMainWnd = new CHelloWindow();
23 	m_pMainWnd->ShowWindow(m_nCmdShow);
24 	m_pMainWnd->UpdateWindow();
25 	return TRUE;
26 }

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

כאשר עצם היישום נוצר בשורה 10, ה data members שלו (שעברו בירושה מ CWinApp) מאותחלים אוטומטית. לדוגמא, m_pszAppName ,m_lpCmdLine, ו m_nCmdShow מכילים כולם ערכים מתאימים. עיין בקובץ העזרה של MFC למידע נוסף. נראה שימוש של אחד המשתנים האלה בעוד רגע.

עצם החלון

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

בקוד שמוצג ברישום העליון, מחלקה חדשה בשם CHelloWindow נגזרת מהמחלקה CFrameWnd בשורות 11 עד 17:

11 // Declare the main window class
12 class CHelloWindow : public CFrameWnd
13 { 
14 	CStatic* cs;
15 	public:
16 	CHelloWindow();
17 };

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

בדרך כלל, לכל יישום שאתה יוצר יהיה חלון יישום ראשי יחיד. מחלקת היישום CHelloApp לפיכך מגדירה data member בשם m_pMainWnd שיכול להצביע לחלון הראשי הזה. כדי ליצור חלון ראשי לאפליקציה זו, הפונקציה InitInstance (שורות 18 עד 26) יוצרת מופע של CHelloWindow ומשתמשת ב m_pMainWnd כדי להצביע לחלון החדש. עצם ה CHelloWindow נוצר בשורה 22:

18 // The InitInstance function is called each
19 // time the application first executes.
20 BOOL CHelloApp::InitInstance()
21 {
22 	m_pMainWnd = new CHelloWindow();
23 	m_pMainWnd->ShowWindow(m_nCmdShow);
24 	m_pMainWnd->UpdateWindow();
25 	return TRUE;
26 }

יצירת חלון מסגרת אינה מספיקה, בכל אופן. שני צעדים אחרים דרושים כדי לוודא שהחלון החדש מופיע על המסך בצורה נכונה. ראשית, הקוד צריך לקרוא לפונקציה ShowWindow של החלון כדי לגרום לחלון להופיע על המסך (שורה 23). שנית, התוכנית צריכה לקרוא לפונקציה UpdateWindow כדי לוודא שכל בקרה, וכל ציור שנעשה בפנים החלון, נצבע כראוי על המסך (שורה 24).

אתה עשוי לתהות איפה הפונקציות ShowWindow ו UpdateWindow מוגדרות. לדוגמא, אם אתה רוצה לבדוק אותן כדי ללמוד עליהן עוד, אתה עשוי להסתכל בקובץ העזרה של MFC (השתמש באופציה Search בתפריט Help) על תיאור המחלקה CFrameWnd .CFrameWnd לא כוללת אף אחת מהפונקציות החברות הללו, בכל אופן. יוצא ש CFrameWnd יורשת את ההתנהגות שלה - כפי שעושות כל הבקרות והחלונות ב MFC - מהמחלקה CWnd (ראה תרשים 2.1). אם תפנה ל CWnd בתיעוד של MFC, תמצא שזו מחלקה ענקית שמכילה מעל 200 פונקציות שונות. כמובן, אתה לא הולך להתמחות במחלקה המסוימת הזו תוך מספר דקות, אבל בין הפונקציות השימושיות הרבות נמצאות ShowWindow ו UpdateWindow.

כיוון שאנחנו עוסקים בנושא, קח דקה עכשיו כדי לבדוק את הפונקציה CWnd::ShowWindow בקובץ העזרה של MFC. עושים זאת על ידי לחיצה על כפתור ה Search של קובץ העזרה והכנסת "ShowWindow". כאלטרנטיבה, מצא את הקטע שמתאר את המחלקה CWnd באמצעות כפתור ה Search, ולאחר מכן מצא את הפונקציה ShowWindow תחת הפונקציות Update/Painting ברשימת חברות המחלקה. שים לב ש ShowWindow מקבלת פרמטר בודד, ושהפרמטר יכול להיקבע לאחד מעשרה ערכים שונים. אנחנו קבענו אותו ל data member שמוכל ב CHelloApp בתוכנית שלנו, m_nCmdShow (שורה 23). המשתנה m_nCmdShow מאותחל בהתבסס על תנאים שנקבעים על ידי המשתמש באתחול היישום. לדוגמא, יכול להיות שהמשתמש התחיל את היישום ממנהל התוכניות (Program Manager) ואמר לו להתחיל את היישום במצב ממוזער על ידי כך שסימן את תיבת הסימון בתיבת הדו-שיח של מאפייני היישום. המשתנה m_nCmdShow ייקבע ל SW_SHOWMINIMIZED, והיישום יתחיל במצב של סמלון. המשתנה m_nCmdShow הוא אמצעי לעולם מבחוץ לתקשר עם היישום החדש באתחול שלו. אם תרצה לנסות, אתה יכול לנסות להחליף את m_nCmdShow בקריאה ל ShowWindow עם הקבועים האחרים שמוגדרים עבור ShowWindow. הדר מחדש את התוכנית ובדוק מה הם עושים.

שורה 22 מאתחלת את החלון. היא מקצה זיכרון בשבילו באמצעות קריאה לפונקציה new. בשלב זה בריצת התוכנית הבנאי ל CHelloWindow נקרא. הבנאי נקרא בכל פעם שמופע של המחלקה מוקצה. בתוך בנאי החלון, החלון צריך ליצור את עצמו. הוא עושה זאת באמצעות קריאה לפונקציה החברה Create עבור המחלקה CFrameWnd בשורה 31:

27 // The constructor for the window class
28 CHelloWindow::CHelloWindow()
29 { 
30 	// Create the window itself
31 	Create(NULL, 
32 		"Hello World!", 
33 		WS_OVERLAPPEDWINDOW,
34 		CRect(0,0,200,200));

ארבעה פרמטרים מועברים לפונקציה create. בעזרת התבוננות בתיעוד של MFC אתה יכול לראות את הסוגים השונים. פרמטר ה NULL ההתחלתי מצביע על כך שנעשה שימוש בשם מחלקה של ברירת מחדל. הפרמטר השני הוא הכותרת לחלון שתופיע בשורת הכותרת. הפרמטר השלישי הוא תכונת הסגנון לחלון. דוגמא זו מראה שאמור להיווצר חלון רגיל, ניתן לחפיפה. תכונות סגנון מכוסות לפרטים בשיעור 3. הפרמטר הרביעי מציין שהחלון צריך להיות ממוקם על המסך עם הפינה השמאלית העליונה שלו בנקודה 0,0, והגודל ההתחלתי של החלון צריך להיות 200 על 200 פיקסל. אם משתמשים בערך rectDefault כפרמטר הרביעי במקום זאת, חלונות ימקם ויקבע את הגודל של החלון אוטומטית בשבילך.

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

בקרת הטקסט הסטטי

התוכנית גוזרת את המחלקה CHelloWindow מהמחלקה CFrameWnd (שורות 11 עד 17). בכך שהיא עושה זאת היא מצהירה על data member פרטי חדש מטיפוס CStatic*, ועל בנאי.

כפי שראינו בפסקה הקודמת, הבנאי של CHelloWindow עושה שני דברים. ראשית הוא יוצר את חלון האפליקציה על ידי קריאה לפונקציה Create (שורה 31), ולאחר מכן הוא מקצה ויוצר את הבקרה ששייכת לפנים החלון. במקרה זה משתמשים בתווית סטטית יחידה כבקרה היחידה. יצירת אובייקטים היא תמיד תהליך של שני צעדים ב MFC. קודם כל, מוקצה הזיכרון למופע של המחלקה, ועל ידי זה קריאה לבנאי כדי לאתחל משתנים. לאחר מכן, נקראת פונקצית Create ברורה כדי ליצור למעשה את העצם על המסך. הקוד מקצה, בונה, ויוצר עצם טקסט סטטי יחיד תוך שימוש בתהליך בן שני הצעדים הזה בשורות 36 עד 40:

27 // The constructor for the window class
28 CHelloWindow::CHelloWindow()
29 { 
30 	// Create the window itself
31 	Create(NULL, 
32 		"Hello World!", 
33 		WS_OVERLAPPEDWINDOW,
34 		CRect(0,0,200,200)); 
35 	// Create a static label
36 	cs = new CStatic();
37 	cs->Create("hello world",
38 		WS_CHILD|WS_VISIBLE|SS_CENTER,
39 		CRect(50,80,150,150),
40 		this);
41 }

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

סיכום

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

לדף הראשון

<< לדף הקודם

לדף הבא >>