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

חלק 1: הקדמה ל MFC

Visual C++ היא הרבה יותר ממהדר. היא סביבת פיתוח אפליקציה שלימה, שכאשר משתמשים בה כמו שצריך, מאפשרת לך לנצל את האופי מונחה העצמים של ++C כדי ליצור אפליקציות חלונות מקצועיות. כדי לנצל את התכונות האלה, עליך להבין את שפת התכנות ++C. אם אף פעם לא השתמשת ב ++C, פנה בבקשה אל המדריכים של ++C ב C/C++ Tutorials page להקדמה. לאחר מכן עליך להבין את היררכית מחלקות היסוד של מיקרוסופט (MFC - Microsft Foundation Class). היררכית מחלקות זו סוגרת בבועה את החלק של ממשק המשתמש של ה Windows API, ועושה את זה הרבה יותר קל ליצור אפליקציות חלונות בצורה מונחית עצמים. היררכיה זו זמינה ומתאימה לכל הגרסאות של חלונות. הקוד שאתה יוצר ב MFC הוא מאוד נייד.

שיעורים אלה מציגים את המושגים הבסיסיים ואת אוצר המילים מאחורי MFC ותכנות מונחה תהליכים. בשיעור זה תכניס, תהדר, ותריץ תוכנית MFC פשוטה על ידי שימוש ב Visual C++. שיעור 2 מספק הסבר מפורט של הקוד בו נעשה שימוש בשיעור 1. שיעור 3 דן בבקרות MFC והתאמה אישית שלהן. שיעור 4 מכסה מפות הודעות, שמאפשרות לך לטפל במאורעות ב MFC.

מהי ספריית מחלקות היסוד של מיקרוסופט?

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

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

השלב הבא הוא ליישם את הקוד. כאשר יוצרים תוכנית עבור פלטפורמת חלונות כלשהי, למתכנת יש שתי אפשרויות: C או ++C. ב C, המתכנת כותב קוד ברמת הממשק לתכנות יישומים של חלונות (API). ממשק זה מורכב מאוסף של מאות פונקציות C שמתוארות בספרי היעץ של ה API של חלונות. עבור חלונות NT (מערכת הפעלה המספקת סביבת חלונות ל PC), ה API מאוזכר בדרך כלל כ "Win32 API", כדי להבדיל אותו מה API המקורי של 16 סיביות של מוצרי חלונות ברמה נמוכה יותר כמו חלונות 3.1.

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

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

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

אוצר מילים של חלונות

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

אפליקציות חלונות משתמשות במספר בקרות משתמש סטנדרטיות:

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

ניתן ליצור את הבקרות האלה או באמצעות קוד או באמצעות "עורך משאבים" שיכול ליצור תיבות דו-שיח ואת הבקרות שבתוכם. בסדרה זו של שיעורים נבחן איך ליצור אותם בקוד. עיין בשיעורים על ה AppWizard ו ClassWiazrd ב דף מדריכי MFC להקדמה לעורך המשאבים עבור תיבות דו-שיח.

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

אפליקציות החלונות הפשוטות ביותר משתמשות במסגרת של ממשק מסמכים בודד, או SDI
(Single Document Interface). ה Clock, עורך PIF, ופנקס הרשימות (Notepad) הם דוגמאות לאפליקציות SDI. חלונות גם מספק תרשים ארגון בשם ממשק רב מסמכים, או MDI
(Multiple Document Interface) עבור אפליקציות מורכבות יותר. מערכת ה MDI מאפשרת למשתמש לראות מספר מסמכים באותו זמן בתוך מופע יחיד של אפליקציה. לדוגמא, עורך טקסט עשוי לאפשר למשתמש לפתוח מספר קבצים בו-זמנית. כאשר היא מיושמת עם MDI, האפליקציה מציגה חלון יישום גדול שיכול להכיל מספר תת-חלונות, שכל אחד מהם מכיל מסמך. התפריט הראשי היחיד נמצא בחלון היישום הראשי והוא מתייחס לחלון העליון ביותר שמוחזק בתוך מסגרת ה MDI. ניתן להפוך חלונות בודדים לסמלים או להרחיב אותם כמבוקש בתוך מסגרת ה MDI, או שניתן להקטין את כל מסגרת ה MDI לסמל בודד על שולחן העבודה. ממשק ה MDI נותן את הרושם של שולחן עבודה שני על שולחן העבודה, והוא עושה כברת דרך לקראת ארגון והסרת ערבוביה בחלונות.

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

תוכנה ואוצר מילים מונחי תהליכים

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

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

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

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

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

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

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

דוגמא:

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

//hello.cpp

#include <afxwin.h>

// Declare the application class
class CHelloApp : public CWinApp
{
public:		
  virtual BOOL InitInstance();
};

// Create an instance of the application class
CHelloApp HelloApp;

// Declare the main window class
class CHelloWindow : public CFrameWnd
{		
  CStatic* cs;
public:		
  CHelloWindow();
};

// The InitInstance function is called each
// time the application first executes.
BOOL CHelloApp::InitInstance()
{		
  m_pMainWnd = new CHelloWindow();		
  m_pMainWnd->ShowWindow(m_nCmdShow);		
  m_pMainWnd->UpdateWindow();		
  return TRUE;
}

// The constructor for the window class
CHelloWindow::CHelloWindow()
{		
  // Create the window itself		
  Create(NULL,				
    "Hello World!",				
    WS_OVERLAPPEDWINDOW,				
    CRect(0,0,200,200));		
  // Create a static label		
  cs = new CStatic();		
  cs->Create("hello world",				
    WS_CHILD|WS_VISIBLE|SS_CENTER,				
    CRect(50,80,150,150),				
    this);
}

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

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

הוראות ההידור שמסופקות כאן מתייחסות בייחוד ל Visual C++ גרסה 6.x תחת חלונות NT או חלונות 95. אם אתה משתמש ב Visual C++ גרסאות 1.5, 4.x ,2.x או 5.x תרצה לראות את השיעורים לגרסאות אלה ב דף מדריכי MFC.

התחל את Visual C++ על ידי הקשה כפולה על הסמל שלו בקבוצת מנהל התוכניות של Visual C++. אם רק עכשיו התקנת את המוצר, תראה חלון ריק עם שורת תפריט. אם נעשה שימוש בעבר ב ++VC על מכונה זו, ייתכן שהיא תעלה במספר שונה של מצבים כיוון ש ++VC זוכרת ופותחת מחדש אוטומטית את הפרוייקט וקבצים שנעשה בהם שימוש בפעם האחרונה שהיא יצאה. מה שאנחנו רוצים כרגע זה מצב בו לא טעון אף פרוייקט או קוד. אם התוכנית מתחילה בתיבת דו-שיח שאומרת שהיא לא הצליחה למצוא קובץ מסוים, נקה את תיבת הדו-שיח על ידי הקשה על כפתור ה "No". לך לתפריט ה Window ובחר באופציה Close All אם היא זמינה. לך לתפריט ה File ובחר באופציה Close אם היא זמינה כדי לסגור את כל החלונות הנותרים. עכשיו אתה בנקודת ההתחלה הנכונה. אם רק עכשיו התקנת את החבילה, תראה חלון שנראה בערך כך:

מסך זה יכול להיות מפחיד למדי בפעם הראשונה שאתה רואה אותו. כדי לסלק חלק מהאיום, הקש על התחתון מבין שני כפתורי ה "x" ( ) שאתה רואה בפינה הימנית העליונה של המסך אם הוא זמין. פעולה זו תאפשר לך לסגור את חלון ה "InfoViewer Topic". אם אתה רוצה להיפטר גם מסרגל הכלים InfoViewer, גרור אותו כך שהוא יעגון במקום כלשהו לאורך הצד של החלון, או סגור אותו ומאוחר יותר החזר אותו באמצעות בחירת האופציה Customize בתפריט ה Tools.

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

יצירת פרוייקט והידור הקוד

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

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

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

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

אם אתה מכיר makefiles, אז זה קל לחשוב על פרוייקט כ makefile שמחולל על ידי מכונה שיש לה ממשק משתמש קל מאוד להבנה שמתפעל אותו. בינתיים ניצור קובץ פרוייקט פשוט מאוד ונשתמש בו כדי להדר את HELLO.CPP.

כדי ליצור פרוייקט חדש ל HELLO.CPP, בחר באופציה New בתפריט ה File. תחת תווית ה Project, הדגש את Win32 Application. בשדה המיקום (Location) הדפס שם מסלול מתאים או הקש על כפתור העיון (Browse). הכנס את המילה "hello" לשם הקובץ, ותראה שהמילה מופיעה גם בשדה המיקום. הקש על כפתור ה OK. בחלון הבא, השתמש בברירת המחדל של פרוייקט ריק ("An empty project"), הקש על "Finish", ואז הקש "OK" פעם נוספת בחלון הבא. שים לב שיש אפשרות ליישום הטיפוסי "Hello World", אולם הוא מדלג על מספר צעדים חשובים שאתה עומד לעשות. Visual C++ תיצור תת ספריה חדשה בשם HELLO ותמקם את קבצי הפרוייקט שמכונים HELLO.OPT ,HELLO.NCB ,HELLO.DSP, ו HELLO.DSW בספריה זו. אם אתה יוצא ומאוחר יותר רוצה לפתוח מחדש את הפרוייקט, לחץ לחיצה כפולה על HELLO.DSW.

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

עכשיו הגיע הזמן להדפיס את הקוד לתוכנית. בתפריט File בחר את האופציה New כדי ליצור חלון עורך חדש. בתיבת הדו-שיח שמופיעה, וודא שתווית ה Files פעילה ובקש "C++ Source File". וודא שהאופציה "Add to Project" מסומנת לפרוייקט "hello", והכנס "hello" ל "File name".
Visual C++ מגיעה עם עורך ++C אינטליגנטי משלה, ואתה תשתמש בו כדי להכניס את התוכנית שהוצגה לעיל. הכנס (העתק/הדבק) את הקוד שברישום לתוך חלון העורך. תמצא שהעורך צובע אוטומטית קטעים שונים של טקסט כגון הערות, מילות מפתח, מחרוזות מילים, וכן הלאה. אם אתה רוצה לשנות את הצבעים או לכבות את הצביעה, לך לאופציה Options בתפריט ה Tools, בחר את תווית ה Format ובחר את האופציה Source Windows מהרשימה השמאלית. אם יש איזשהו מראה בעורך שמפריע לך, יכול להיות שתוכל לשנות אותו באמצעות תווית ה Editor של תיבת הדו-שיח Options.

לאחר שסיימת להכניס את הקוד, שמור את הקובץ על ידי בחירת האופציה Save בתפריט File. שמור אותו לקובץ בשם HELLO.CPP בספריה החדשה שנוצרה על ידי Visual C++.

בשטח שבצד השמאלי של המסך, הקש על תווית ה FileView והרחב את העץ בסמל שמכונה "hello files", לאחר מכן הרחב את העץ בתווית התיקייה המכונה "Source Files". אתה תראה את הקובץ HELLO.CPP. הקש על תווית ה ClassView והרחב את עץ ה "hello classes" ותראה את המחלקות ביישום. ניתן להסיר קובץ מפרוייקט בכל זמן שהוא על ידי הליכה ל FileView, הקשה על הקובץ, והקשה על כפתור ה delete.

לבסוף, עליך עכשיו לומר לפרוייקט להשתמש בספריית MFC. אם אתה משמיט את הצעד הזה הפרוייקט לא יקושר כראוי, והודעות השגיאה שהמקשר מייצר לא יעזרו בכלל. בחר באופציית Settings בתפריט Project. וודא שתווית ה General נבחרה בתווית בראש תיבת הדו-שיח שמופיעה. בתיבת הקומבו של Microsoft Foundation Classes, בחר באופציה השלישית: "Use MFC in a shared DLL". לאחר מכן סגור את תיבת הדו-שיח.

לאחר שיצרת את קובץ הפרוייקט והתאמת את הסביבה, אתה מוכן להדר את התוכנית HELLO.CPP. בתפריט ה Build תמצא שלוש אפשרויות הידור שונות:

1. Compile HELLO.CPP (זמין רק אם חלון הטקסט עבור HELLO.CPP נמצא בפוקוס)

2. Build HELLO.EXE

3. Rebuild All

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

במקרה זה, בחר באופציה Build HELLO.EXE בתפריט ה Build כדי להדר ולקשר את הקוד. Visual C++ תיצור תת ספריה חדשה בשם Debug ותשים את קובץ הריצה HELLO.EXE בתת ספריה זו. תת ספריה זו מחזיקה את כל הקבצים החד פעמיים (נוצרים מחדש בקלות) שנוצרים על ידי המהדר, כך שאתה יכול למחוק ספריה זו כאשר אוזל לך מקום בדיסק בלי לפחד מאיבוד דברים חשובים.

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

כדי להריץ את התוכנית, בחר באופציה Execute HELLO.EXE בתפריט ה Build. חלון מופיע עם המילים "hello world". לחלון עצמו יש את הקישוטים הרגילים: שורת כותרת, שטחי קביעת הגודל מחדש, כפתורי מזעור ופריסה, וכן הלאה. בתוך החלון יש תווית סטטית שמציגה את המילים "hello world". שים לב שהתוכנית הסתיימה. ניתן להזיז את החלון, לקבוע את גודל החלון מחדש, לצמצם אותו לסמלון, ולכסות ולהסיר את הכיסוי עם חלונות אחרים. עם כמות קטנה מאוד של קוד יצרת יישום חלון שלם. זה אחד מהיתרונות הרבים של שימוש ב MFC. כל הפרטים מטופלים במקום אחר.

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

סיכום

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

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

לדף הראשון

לדף הבא >>