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

חלק 3: סגנונות MFC

בקרות הן עצמי ממשק המשתמש בהם משתמשים כדי ליצור ממשקים ליישומי חלונות. רוב יישומי החלונות ותיבות הדו-שיח שאתה רואה אינם אלא אוסף בקרות המסודרות בצורה שמיישמת כנדרש את התפקודיות של התוכנית. כדי לבנות יישומים יעילים, עליך להבין לחלוטין איך להשתמש בבקרות הזמינות בחלונות. יש רק שש בקרות בסיסיות - CStatic ,CButton ,CEdit ,CList ,CComboBox, ו CScrollBar - עם שונויות קלות (שים לב שבחלונות 95 נוסף אוסף של כ 15 בקרות משופרות גם כן). אתה צריך להבין מה כל בקרה יכולה לעשות, איך אתה יכול לכוון את ההופעה ואת ההתנהגות שלה, ואיך לגרום לבקרות להגיב כראוי למאורעות משתמש. על ידי צירוף ידע זה עם הבנה של התפריטים ותיבות הדו-שיח אתה רוכש את היכולת ליצור כל יישום חלונות שאתה יכול לדמיין. אתה יכול ליצור בקרות או באמצעות תכנות כפי שמוצג בשיעור זה, או באמצעות קבצי משאבים על ידי שימוש בעורך משאבי הדו-שיח. בעוד שעורך הדו-שיח הוא הרבה יותר נוח, זה שימושי ביותר שתהיה לך הבנה כללית של בקרות אותה אתה רוכש על ידי עבודה אתם באמצעות תכנות כפי שמוצג כאן ובשיעור הבא.

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

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

היסודות

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

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

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

CStatic *cs;	
...	
cs = new CStatic();	
cs->Create("hello world",		
	WS_CHILD|WS_VISIBLE|SS_CENTER,		
	CRect(50,80, 150, 150),		
	this);

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

הפונקציה Create מקבלת עד חמישה פרמטרים, כפי שמתואר בקובץ העזרה של MFC. בחר באופציה Search בתפריט ה Help של Visual C++ ואז הקש Create כך שתוכל לבחור את CStatic::Create מהרשימה. לחלופין, הקש CStatic בתיבת הדו-שיח של החיפוש ולאחר מכן הקש על כפתור ה Members שלה בדף הסקירה הכללית (overview).

רוב הערכים הללו לא מובנים מאליהם. הפרמטר lpszText מפרט את הטקסט המוצג על ידי התווית. הפרמטר rect, שולט במיקום, בגודל, ובצורה של הטקסט כאשר מציגים אותו בחלון האב. הפינה השמאלית העליונה של הטקסט נקבעת לפי הפינה השמאלית של הפרמטר rect והמלבן החוסם נקבע על ידי הרוחב והגובה של פרמטר ה rect. הפרמטר pParentWnd מצביע על האבא של בקרת ה CStatic. הבקרה תופיע בחלון האב, והמיקום של הבקרה יהיה יחסי לפינה השמאלית העליונה של אזור הלקוח של האב. הפרמטר nID הוא מספר שלם שמשמש כת.ז. לבקרה שבו משתמשות מספר פונקציות ב API. נראה דוגמאות לפרמטר זה בשיעור הבא.

הפרמטר dwStyle הוא הפרמטר החשוב ביותר. הוא שולט בהופעה ובהתנהגות של הבקרה. הקטעים הבאים מתארים את הפרמטר הזה לפרטים.

סגנונות CStatic

לכל הבקרות יש מגוון של סגנונות תצוגה. סגנונות נקבעים ביצירה תוך שימוש בפרמטר dwStyle שמועבר לפונקצית ה Create. הפרמטר של הסגנון הוא מסיכת סיביות שאתה בונה על ידי שימת or בין קבועי מסיכה שונים. את הקבועים הזמינים לבקרת CStatic ניתן למצוא בקובץ העזרה של MFC (מצא את הדף לפונקציה CStatic::Create כפי שמתואר בקטע הקודם, והקש על הקישור Static Control Styles ליד ראש הדף) והם גם מתוארים בקצרה להלן:

סגנונות תקפים למחלקה CStatic -

סגנונות שעברו בירושה מ CWnd:

• WS_CHILD הכרחי ל CStatic.
• WS_VISIBLE הבקרה צריכה להיות גלויה למשתמש.
• WS_DISABLED הבקרה צריכה לדחות מאורעות משתמש.
• WS_BORDER הטקסט של הבקרה מוקף במסגרת.

סגנונות שטבעיים ל CStatic:

• SS_BLACKFRAME הבקרה מציגה את עצמה כמסגרת מלבנית. הצבע זהה לזה של מסגרות חלון.
• SS_BLACKRECT הבקרה מציגה את עצמה כמלבן מלא. הצבע זהה לזה של מסגרות חלון.
• SS_CENTER הטקסט ממורכז.
• SS_GRAYFRAME הבקרה מציגה את עצמה כמסגרת מלבנית. הצבע זהה לזה של שולחן העבודה.
• SS_GRAYRECT הבקרה מציגה את עצמה כחלון מלא. הצבע זהה לזה של שולחן העבודה.
• SS_ICON הבקרה מציגה את עצמה כסמלון. מחרוזת הטקסט משמשת כשם הסמלון בקובץ משאבים. פרמטר המלבן שולט רק בהצבה.
• SS_LEFT הטקסט המוצג מיושר לשמאל. טקסט עודף גולש לשורה הבאה.
• SS_LEFTNOWORDWRAP הטקסט מיושר לשמאל, אבל טקסט עודף מקוצץ.
• SS_NOPREFIX תווי "&" במחרוזת הטקסט מצביעים על תחיליות ל accelerator (כרטיס המשמש להאצת ביצועי המחשב או התצוגה) אלא אם כן משתמשים בתכונה זו.
• SS_RIGHT הטקסט המוצג מיושר לימין. טקסט עודף מוסתר עובר לשורה הבאה.
• SS_SIMPLE שורת טקסט בודדת מוצגת מיושרת לשמאל. ההורה צריך להתעלם מכל ההודעות של CTLCOLOR.
• SS_USERITEM פריט שמוגדר על ידי המשתמש.
• SS_WHITEFRAME הבקרה מציגה את עצמה כמסגרת מלבנית. הצבע זהה לזה שברקע של חלונות.
• SS_WHITERET הבקרה מציגה את עצמה כמלבן מלא. הצבע זהה לזה שברקע של חלונות.

קבועים אלה מגיעים משני מקורות שונים. קבועי ה (Static Style) "SS" מתייחסים רק לבקרות CStatic. קבועי ה (Window Style) "WS" מתייחסים לכל החלונות ולכן הם מוגדרים בעצם CWnd שממנו CStatic יורשת את ההתנהגות שלה. יש הרבה קבועי סגנון "WS" נוספים שמוגדרים ב CWnd. ניתן למצוא אותם על ידי חיפוש הפונקציה CWnd::Create בתיעוד של MFC. הארבעה הנ"ל הם היחידים שמתייחסים לעצם CStatic.

לעצם CStatic יהיו תמיד לפחות שני קבועי סגנון שמחוברים באמצעות WS_CHILD :or ו WS_VISIBLE. הבקרה לא נוצרת אלא אם כן היא בן של חלון אחר, והיא תהיה סמויה אל אם כן WS_VISIBLE כלול במפרט. WS_DISABLED שולט בתגובה של התווית למאורעות, וכיוון שלתווית אין כל רגישות למאורעות כמו הקשות על מקשים או הקשות על העכבר בכל מקרה, נטרולו מפורשות הוא מיותר.

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

הופעת טקסט ב CStatic

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

//static1.cpp
#include <afxwin.h>

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

// Create an instance of the application class
CTestApp TestApp;  

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

// The InitInstance function is called
// once when the application first executes
BOOL CTestApp::InitInstance()
{
	m_pMainWnd = new CTestWindow();
	m_pMainWnd->ShowWindow(m_nCmdShow);
	m_pMainWnd->UpdateWindow();
	return TRUE;
}

// The constructor for the window class
CTestWindow::CTestWindow()
{ 
	CRect r;
	// Create the window itself
	Create(NULL, 
		"CStatic Tests", 
		WS_OVERLAPPEDWINDOW,
		CRect(0,0,200,200));
	
	// Get the size of the client rectangle
	GetClientRect(&r);
	r.InflateRect(-20,-20);
	
	// Create a static label
	cs = new CStatic();
	cs->Create("hello world",
		WS_CHILD|WS_VISIBLE|WS_BORDER|SS_CENTER,
		r,
		this);
}

הקוד המעניין ברישום 3.1 הוא בפונקציה לבנאי החלון, שחוזרת להלן עם מספרי שורות:

CTestWindow::CTestWindow()
{ 
	CRect r;
	
	// Create the window itself
1	Create(NULL, 
		"CStatic Tests", 
		WS_OVERLAPPEDWINDOW,
		CRect(0,0,200,200));
	// Get the size of the client rectangle
2	GetClientRect(&r);
3	r.InflateRect(-20,-20);
	// Create a static label
4	cs = new CStatic();
5	cs->Create("hello world",
		WS_CHILD|WS_VISIBLE|WS_BORDER|SS_CENTER,
		r,
		this);
}

הפונקציה קודם קוראת לפונקציה CTestWindow::Create עבור החלון בשורה 1. זו פונקצית ה Create לעצם CFrameWnd, כיוון ש CTestWindow יורשת את התנהגותה מ CFrameWnd. הקוד בשורה 1 מתאר שהחלון צריך להיות בגודל 200 על 200 פיקסל ושהפינה השמאלית העליונה של החלון צריכה להיות ממוקמת בהתחלה במיקום 0,0 על המסך. הקבוע rectDefault יכול להחליף את הפרמטר CRect אם רוצים.

בשורה 2, הקוד קורא ל CTestWindow::GetClientRect, ומעביר לו את הפרמטר r&. הפונקציה GetCientRect עוברת בירושה מהמחלקה CWnd (עיין בתפריט הצדדי באסטרטגיות חיפוש בהן ניתן להשתמש כאשר מנסים לחפש פונקציות בתיעוד של מיקרוסופט). המשתנה r הוא מטיפוס CRect והוא מוגדר כמשתנה מקומי בהתחלת הפונקציה.

שתי שאלות עולות כאן בניסיון להבין את הקוד: 1) מה הפונקציה GetCientRect עושה? ו 2) מה המשתנה CRect עושה? בואו נתחיל עם שאלה 1. כאשר אתה מחפש את הפונקציה CWnd::GetCientRect בתיעוד MFC אתה מוצא שהיא מחזירה מבנה מטיפוס CRect שמכיל את הגודל של מלבן הלקוח של החלון המפורט. הוא מאחסן את המבנה בכתובת המועברת כפרמטר, במקרה זה r&. הכתובת הזו צריכה להצביע למיקום מטיפוס CRect. הטיפוס CRect מוגדר כמחלקה ב MFC. זו מחלקת נוחות שמשמשת לטיפול במלבנים. אם אתה מחפש את המחלקה בתיעוד של MFC, תמצא שהיא מגדירה מעל 30 פונקציות חברות ואופרטורים לתפעול מלבנים.

במקרה שלנו, אנחנו רוצים למרכז את המילים "Hello World" בחלון. לכן, אנחנו משתמשים ב GetClientRect כדי לקבל את קואורדינטות המלבן לשטח הלקוח. בשורה 3 אנחנו אז קוראים ל CRect::InflateRect, שמגדילה או מקטינה באופן סימטרי את הגודל של מלבן (ראה גם CRect::DeflateRect). כאן הקטנו את המלבן ב 20 פיקסל בכל הצדדים. אם לא היינו עושים זאת, המסגרת שמקיפה את התווית הייתה מעורבבת עם מסגרת החלון, ולא היינו יכולים לראות אותה.

תווית ה CStatic עצמה נוצרת בשורות 4 ו 5. תכונות הסגנון מציינות שהמילים שמוצגות על ידי התווית צריכות להיות ממורכזות ומוקפות במסגרת. הגודל והמיקום של המסגרת נקבעים על ידי הפרמטר r של CRect.

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

CTestWindow::CTestWindow()
{ 
	CRect r;
	// Create the window itself
	Create(NULL, 
		"CStatic Tests", 
		WS_OVERLAPPEDWINDOW,
		CRect(0,0,200,200));
	
	// Get the size of the client rectangle
	GetClientRect(&r);
	r.InflateRect(-20,-20);
	
	// Create a static label
	cs = new CStatic();
	cs->Create("Now is the time for all good men to \
come to the aid of their country",
		WS_CHILD|WS_VISIBLE|WS_BORDER|SS_CENTER,
		r,
		this);
}

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

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

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

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

צורות הצגה מלבנית ל CStatic

עצם ה CStatic גם תומך בשתי צורות הצגה מלבנית שונות: מלבנים מוצקים מלאים ומסגרות. בדרך כלל משתמשים בשני סגנונות אלה כדי לקבץ באופן חזותי בקרות שונות בתוך חלון. לדוגמא, אתה עשוי לשים מסגרת מלבנית שחורה בחלון כדי לאסוף יחד מספר שטחים ניתנים לעריכה שקשורים אחד לשני. אתה יכול לבחור מבין שישה סגנונות שונים כאשר אתה יוצר את המלבנים האלה: ,SS_BLACKRECT ,SS_BLACKFRAME ,SS_GRAYFRAME ,SS_GRAYRECT
,SS_WHITEFRAME ו SS_WHITERECT. הצורה RECT היא מלבן מלא, בעוד שהצורה FRAME היא מסגרת. שמות הצבעים הם מעט מטעים - לדוגמא, SS_WHITERECT מציג מלבן באותו צבע כמו רקע החלון. למרות שברירת המחדל של צבע זה היא לבן, המשתמש יכול לשנות אותה באמצעות לוח הבקרה והמלבן עשוי למעשה לא להיות לבן במכונות מסוימות.

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

גופנים

ניתן לשנות את הגופן של עצם CStatic על ידי יצירת עצם CFont. פעולה כזו מדגימה איך מחלקת MFC אחת יכולה לפעול הדדית עם מחלקה אחרת במקרים מסוימים כדי לשנות התנהגות של בקרה. המחלקה CFont ב MFC מכילה מופע יחיד של גופן חלונות מסוים. לדוגמא, מופע אחד של המחלקה CFont עשוי להכיל גופן Times בגודל 18 נקודות בעוד שאחר עשוי להכיל גופן Courier בגודל 10 נקודות. ניתן לשנות את הגופן בו משתמשת התווית הסטטית באמצעות קריאה לפונקציה SetFont ש CStatic יורשת מ CWnd. הקוד להלן מציג את הקוד הדרוש כדי ליישם את הגופנים.

CTestWindow::CTestWindow()
{ 
	CRect r;
	// Create the window itself
	Create(NULL, 
		"CStatic Tests", 
		WS_OVERLAPPEDWINDOW,
		CRect(0,0,200,200));
	// Get the size of the client rectangle
	GetClientRect(&r);
	r.InflateRect(-20,-20);
	// Create a static label
	cs = new CStatic();
	cs->Create("Hello World",
		WS_CHILD|WS_VISIBLE|WS_BORDER|SS_CENTER,
		r,
		this);
	
	// Create a new 36 point Arial font
	font = new CFont;
	font->CreateFont(36,0,0,0,700,0,0,0,
                ANSI_CHARSET,OUT_DEFAULT_PRECIS,
                CLIP_DEFAULT_PRECIS,
                DEFAULT_QUALITY,
                DEFAULT_PITCH|FF_DONTCARE,
                "arial");                                     
	// Cause the label to use the new font
	cs->SetFont(font);
}

הקוד לעיל פותח ביצירת החלון ועצם ה CStatic כרגיל. לאחר מכן הקוד יוצר עצם מטיפוס CFont. משתנה הגופן צריך להיות מוצהר כ data member במחלקה CTestWindow באמצעות השורה "CFont *font". לפונקציה CFont::CreateFont יש 15 פרמטרים (ראה קובץ העזרה של MFC), אבל רק שלושה משמעותיים ברוב המקרים. לדוגמא, ה 36 מתאר את הגודל של הגופן בנקודות, ה 700 מתאר את הצפיפות של הגופן (400 זה "Normal", ו 700 זה "bold", והערכים יכולים להיות בתחום של 1 עד 1000. לקבועים FW_NORMAL ו FW_BOLD יש את אותה משמעות. עיין בקבועי FW בקובץ העזרה של API), והמילה "ariel" היא שם הגופן בו משתמשים. חלונות בדרך כלל עובד עם חמישה גופנים שהם true type:
(Ariel, Courier New, Symbol, Times New Roman, ו Wingdings), ועל ידי היצמדות לאחד מהם אתה יכול להיות בטוח למדי שהגופן יהיה קיים על כמעט כל מכונה. אם אתה מציין שם גופן שלא ידוע למערכת, אז מחלקת ה CFont תבחר בגופן ברירת המחדל שנראה בכל הדוגמאות האחרות בהן השתמשנו בשיעור זה.

למידע נוסף על המחלקה CFont עיין בתיעוד של MFC. יש גם סקירה כללית טובה על הגופנים בקובץ העזרה המקוון של API. חפש את "Fonts and Text Overview".

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

סיכום

בשיעור זה התבוננו בהרבה יכולות שונות של עצם ה Static. השמטנו כמה מפונקציות ה Set שעוברות בירושה מהמחלקה CWnd כך שניתן לדון בהן בשיעור 4 שם הן יותר מתאימות.

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

ב Visual C++ גרסה 5.x, חיפוש פונקציות שאתה לא מכיר הוא פשוט מאוד. כל פונקציות הספרייה הסטנדרטיות של MFC ,SDK ,Windows API, ו C++/C מוזגו כולן לאותה מערכת עזרה. אם אתה לא בטוח איפה פונקציה מוגדרת או מה התחביר בו היא משתמשת, פשוט השתמש באופציית ה Search בתפריט העזרה. כל המופעים של הפונקציות מוחזרים ואתה עשוי לעבור עליהם כדי לבחור את העזרה לפונקציה המסוימת שאתה רוצה.

הידור מספר קבצי ריצה

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

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

לדף הראשון

<< לדף הקודם

לדף הבא >>