חבר'ה בוקר טוב מה שלומכם נדב, שומעים אותי, הכל בסדר? כן. כן, שומעים. טוב, בסדר.
אנחנו בתרגול במערכות הפעלה, ואנו רוצים ככה לדבר על שני דברים. קודם כל, להתחיל איתכם את הנושא של פייל סיסטם קול, בפייל סיסטם, במערכת הקבצים. ואחר מכן לדבר איתכם על המטלה, העליתי לכם מטלה אתמול שעוסקת בעבודה עם כבשים, היא מחולקת לשני חלקים, כבר אחרי השיעור של היום תוכלו לעשות את החלק הראשון, עדיין לא לעשות את החלק השני משום שהחלק השני יהיה הנושאים המתקדמים יותר, ולא סתם נתתי לכם עוד הגשה של קרוב לחודש מהיום, מכיוון שעדיין לא הספקנו לתרגל את כל הנושאים למטלה, אבל החלק הראשון כבר אחרי התגובות של היום תוכלו לרוס עליו. אבל בואו נתחיל מהחומרים. לגבי כל הנושא של כתובת שרת, העליתי לכם כתובת שרת, הבנתי שחלק מהסטודנטים עובדים עם מחשבי מק, אז יש לכם גם את תקודת הטרמינל במק שבמשאותה אפשר להתחבר לשרת.
ואולי חלק מהסטודנטים רוצים להתקין מכונה וירטואלית, אז גם כאן, אלה אצלכם מדריך, מאוד מאוד פשוט, להתקנת מכונה וירטואלית, בכתב, להריס קודות לינוקס, לקמפל כבשים, בשפה C, על לינוקס, להריס אותם, ועוד מאוד. היי, עדיוני שהקובץ וינרר, של המחשבה, נמצא ממדריך התקנה. הוא שוקל 11.2 ג'יגבייט?
מה, פתאום? מה, קובץ התרגול? אתה שומע?
אני שומע ממש חלט. איזה קובץ שוקל 11.2 ג'יגבייט? אני שואל, במדריך להתקנה מכונת וירטואלית, שאלת, יש קובץ... זה כבד, זה כבד, כן.
אה, אוקיי, בסדר, 11 ג'יגבייט. נשמע הגיוני, כי חשבתי שאתה מדבר על התרגולים, כן. נשמע הגיוני.
כי מכונת ויטואלית זה בעצם סימולטור של מערכת הפעלה, ולתוכה אתה טוען אימג'בבקרה שלנו של מערכת הפעלה לינוס, ובום-בום, אז זה אמור לשקול כמה ג'יגות מכובדות, נקרא לזה ככה. אוקיי, בסדר. עכשיו, מי שלא רוצה להתקין את כל הסיפור הזה, יכול גם להתקין ביט-בייזר. הרציתי לכם בשבוע שעבר.
ואני יודע שחלק גדול מכם אפילו למד רשתות תקשורת למעט סטודנט אחד, אם אני זוכר נכון. עשינו כל כך הרבה דברים על הביטוויז ועל הפוטי, אני לא חושב שצריך יותר מזה, אבל מי שרוצה בכל זאת מכונה וירטואלית יש לו אפשרות שכזאת. אוקיי, אז אני רוצה לדבר איתכם על מעט הקבצים, ויש למעשה שיעור שלם שאנחנו מדברים על מבנה מעט הקבצים.
מבנה נ תונים, אני שם את הדבר הזה בצד. בלינוקס יש מערכת הקבצים שנקראת מערכת קבצים מסוג iNode, iNode Index Node, סמטי אינדקס, ובאישות כלל ויותר מאוחר במהלך השמסטר אתם תדברו בהרחבה על מערכת הקבצים. היא שונה ממערכות קבצים של NTFS, או FAT32 של ווינדוס, והיא שונה ממערכת הקבצים של מק, כנראה זה אותה מערכת קבצים של מק במידה מסוימת, כי מק...
יש בה הרבה מין המשותף ללינוקס, והסיסטם קול שאני מקווה להציג לכם היום, קריאות המערכת, אלה מעשה קריאות מערכת שעוסקות במערכת הקבצים של לינוקס. במידה ותנסו להריס אותם, את קריאות המערכת הללו, על מערכת הפעלה אחרת, ברור לכם שזה לא יעבוד. אין בעיה לכתוב את הקוד בווינדוס, או אפילו בוויזיאל סטודיו או על נודפד, אבל לקמפל ולהריס...
תעבירו זה לנינוקס אז המלצה חמה ממני זה להתקין את הביט וייז שמאפשר לכם להעביר קובץ מהמחשב הלוקלי שלכם לשרת המכללה או בכל שירת לינוק שתמחרו או שתעבדו על המכונה הווירטואלית, אז פשוט אפשר לעבוד באופליין ורק שמה לקמפל ולעבוד. אם זאת, בתוך הלינוק זה שגם מעבדי תמלילים מכובדים, יפים, שהם מאוד מאוד נוחים, שגם בהם תוכלו להשתמש, אני יודע שחלק מהסטודנטים העדיתים משתמש בנוטפד, ויזואל סטודיו, ויזואל קוד, ועוד ועוד, אבל ממש לא צורך, זה סך הכל מעבד תמלילים, אוקיי? עכשיו, בואו נראה רשימה של System Course, זה שיעור נורא נורא חשוב, כי אתם תעסקו בדברים הללו בתרגיל, בחלק הראשון שבתרגיל, אז בואו נעבור על זה לפרטי פרטים, יש לי גם דוגמת קוד בהמשך התרגול, שבו אני כך פחות או יותר מסכם את כל מה שלמדנו. ובשארית הזמן נעבור על התרגיל, מה הדרישה בתרגיל, בסדר?
זה לא אמור לקחת יותר מדי. אז, System.Core.Open למעשה פותח פייל דיסקריפטור, רפרנס למעשה, מזהה קובץ, אם תרצו, לקובץ בתוך מערכת הקבצים, בתוך הפייל סיסטם של לינוקס. Open.
זה לא פותח את הקובץ ברמה של בוא נפתח ונראה את הקובץ, זה פשוט פותח... פייד סקריפטור מתאר קובץ שאפשר לזהות אותו באופן חד משמעי על ידי מספר זהות, תכף נראה מהו, כאשר השם של הקובץ אתם מכניסים אותו פה בארגומנט הראשון, ואילו בארגומנט השלישי פלג שמכיר כל מיני פרמטרים שמגדירים את אופן פתיחת הפייד סקריפטור. תכף נדבר על הפרמטרים.
עכשיו, במידה ואתם מעוניינים לפתוח קובץ, בספרייה הלוקלית, משמע מהספרייה שממנה אתם מריצים את הפרוסס, נכון? כולנו יודעים מה זה פרוסס, נכון? מה זה פרוסס?
תהליך. פרוסס זה תוכנית בהרסה, נכון? תוכנית מופעלת, ומה אתה עפה לה? תוכנית שהיא לא מופעלת היא סתם קטע קוד שנמצא בדיסק. פרוסס זה תוכנית מופעלת, היא דורשת משאבים, יש לה מבנה נתונים שמתחזקת כל הפרמטרים עליה ועוד ועוד.
אז כאשר אני מכניס פה רק את שם הקובץ, אז למעשה הקובץ נפתח מהספרייה שממנה מופעל התהליך, הפרוסס. במידה ואני מכניס כאן נתיב אבסולוטי, נתיב אבסולוטי הכוונה היא slash, הוא דירקטורי, הום דירקטורי, יוזר וכן הלאה, הנתיב המלא מה שנקרא, אז אתם יכולים לפתוח גם את הקובץ גם במקום חיסוני, במקום אחר, בתוך מערכת הכבשים. צריך לדבר על הפלג.
הפלג זה למעשה כל קומבינסיה אפשרית של הרשאות, של סוגי קובץ, כמו למשל אני רוצה להקנות הרשאת read, write, execute, append, create, קבצים בינאריים, קבצי טקסט, קבצים סינכרונים ואסינכרונים, יש אפשרות לדבר כזה במערכת, ועוד ועוד, נראה דוגמאות, אבל מה שחשוב להבין זה שחוזר ערך אינדי. מספר שלם. אם המספר השלם הזה הוא מינוס אחד, זה בגלל כך שלא צריכים לפתוח את המטאי הקובץ, את הפאיידס קריפטו. למה זה קורה?
יכול שאני מנסה לפתוח קובץ שלא קיים, יכול שאני מנסה לפתוח קובץ מספרייה שלא קיימת, יכול שאני מנסה לפתוח קובץ שאין להרשאות, יכול שאני מנספיק מקום בדיסק, ועוד כאלה וכאלה סיבות. אני בטוח שבשיעורים אתם למדתם את התפקידים של מערכת ההפעלה, לומדים את זה בדרך כלל בשיעור הראשון. אז נכון שהתפקידים המרכזיים של מערכת ההפעלה הם שניים, א', לנהל את החומרה, מעין עבודת רואה חשבון כזאת, עבודת פנקסנות, שמתחשבנת על המשאבים בחומרה, הפרוסס הזה מקבל את הכתובת הזאת, הפרוסס הזה מקבל את הכתובת הזאת, הוא מקבל את המשאב הזה, הוא מקבל זמן עיבוד.
זה אחד התפקידים של מערכת ההפעלה. התפקיד אחר זה להקנות את הפונקציונליות של המערכת בפני המשתמש. המשתמש יכול לעשות כל מיני פעולות כדי ליהנות מהמערכת, מהחומרה עצמה שהוא רכש. אלה שני תפקידים עיקריים של מערכת ההפעלה. אבל יש למערכת ההפעלה גם תפקידים נוספים, קצת יותר מינוריים, כמו למשל טיפול באירורים, גם בזיהוי של אירורים, error detectors, נקרא לזה ככה.
וגם בהתאוששות או טיפול מסוים באירורים. אירורים ברמת החומרה ואירורים ברמת התוכנה. למה אני אומר לכם את זה?
משום ש-System Call Open מחזיר מינוס אחד, מינוס אחד מעיד על שוגיה. שוגיה הקאג'וטיו אחרת, שאני מנסה לעשות בתוך הקוד, ומה הייתה פעלה מטפלת לנו בזה? אז היא מחזירה לנו מינוס אחד, דרך הקרנל, דרך גרעין המערכת. עם זאת, כאשר אני רוצה להגיד מהי השוגיה, אני צריך להשתמש בספרירת עזר, שנקראת error number נקודה h, אנחנו רואים אותה במהלך השיעור היום, ואז נוכל לא רק להגיד שיש גייה, אלא גם לומר מה יש גייה.
בתרגיל התכנותי, למעשה בכל התרגילים התכנותיים בקורס הזה, אתם לא צריכים להגיד מה יש גייה, למרות שאני משמחה אקבל תשובות שבהן תשתמשו בספרירת העזר הזאת, היא error number. כדי להטריע בפני המשתמש מה השגיאה שקרתה במערכת. בתרגילים התכנותיים אתם נדרשים רק להגיד שקרתה שגיאה כלשהי. מעין הודעה גנרית כזאת, יש איזשהו אירור, להודיע למשתמש קרה משהו, אירור, אחרי זה לשחרר את המשאבים, נניח לשחרר את העקפות הדינמיות, לסגור את הקבצים ועוד ועוד, ולצאת מהתוכנית. בסדר?
בדרישה שלי? למסגרת כל התרגילים, אתם נדרשים רק להודיע שקרה משהו, לטפל בשגיאות, אתם לא חייבים להגיד איזו שגיאה קרתה. מי שרוצה ללכת יותר רחוק, יכול להשתמש בספרייה, שנראה אותה עוד מעט, שבאמצעותה אפשר להגיד גם מה קרה, ועד לקבל פלץ יותר אינפורמטיבי, כלפי המשתמש.
מה שחוזר במידה ואין שגיאה, זה מספר מזהב, מספר מזהב, זה נקרא פייל דסקריפטור, זה כמו מספר הזהות, לא מדובר על הקובץ עצמו, זה ברור לכם שמספר הזהות זה לא הקובץ עצמו, כמו תעודת זהות של בן אדם, נכון? תעודת זהות זה לא הבן אדם עצמו, זה רק הדרך שלנו לזהות אותו. והמספר מזהה הזה הוא מספר שמתאר איזשהו דיסקריפטור, מתאר, דיסקריפטור הוא מתאר, קובץ.
הקובץ נמצא בכלל בהתקן של הדיסק הקשיח. אנחנו, ברמת הקוד, נעבוד רק מהמספר מזהה הזה. נוכל במציאות המספר מזהה לכתוב נתונים מהכובס, לקרוא נתונים מהכובס ועוד ועוד פעולות.
לא נצטרך לעבוד באופן ישיר עם הכובס. למעשה לא נצטרך אפילו לומר באיזה מקום בדיסק הקשיח הכובס נמצא. למה זה קורה? משום שהדרך שלנו לדבר עם הקרנל בתוך מערכת ההפעלה, היא במציאות המספר מזהה זה.
בתוך מערכת ההפעלה יש טבלה ומזהה כובס. בזהים כאלו ואחרים שנפתחו בתוך התהליכים שבתוך מערכת ההפעלה, ובמצואות המספרי מזהים האלה, הקרנל מדבר עם החומרה. אני רק מזכיר לכם שהקרנל זה הליבה של המערכת, החלק במערכת, התוכנית במערכת, או אוסף התוכניות במערכת שמדברות עם החומרה. אנחנו לא מדברים באופן ישיר עם החומרה, אלא מדברים באופן ישיר עם מערכת ההפעלה. וזו הסיבה שאנחנו משתמשים בסיסטם קולס, לא בפונקציות ה-I-level, משום ש...
פונקציות גבוהות יותר הן לא מדברות ישירות עם החומרה או מדברות ישירות עם הקרנל, הן ממומשות באמצעות System Calls או ממומשות על ידי פונקציות. שהן ממומשות על ידי פונקציות ככה לסירוגין עד ל-System Calls. אנחנו בקורס מחות הפעלה רוצים ללמוד איך מעט הפעלה עובדת ולדבר ישירות עם המעט הפעלה, כי זה נותן לנו גם מהירות טובה יותר וגם גמישות גבוהה יותר ואנחנו נעבוד עם System Calls.
ולכן כל הפונקציות שאני מראה לכם בתרגול הזה וגם בתרגולים הבאים, כולן יהיו System Calls. אני לא אשתמש בפרינט F, בסקל F, ב-STR Compare, כל מיני פעולות כאלה שאין לו System Calls. בסדר? אם זאת בתרגולים, בתרגילים, אני אאפשר בחלק מהם להשתמש בפונקציות עזר שאין לו System Call.
אבל בחלק הראשון של המטלה הראשונה, אנחנו מדבר על זה כבר היום, אני רוצה שתשתמשו רק ב-System Calls. לא להשתמש בסקנים, בפרינטים, ב-STR-Compare, STR-Cut, כל הדברים האלו, בספריות כאלו ואחרות, כי לפחות בחלק האנושי הם רוצים שתעבדו עם סיסטם קורסטי שלמדנו. מה חוזר בעצם מהאופן? המזהה. מה זה המזהה הזה?
המזהה הזה זה מספר ייחודי ברמת הפרוסס, שבמצורתו אני יכול לדבר עם הקורס, לכתוב ולקרוא לקורס. חשוב לומר כמה דברים. אפשר לפסוח...
כמה מזהים לאותו הקובץ, אוקיי? הדיוויס הוא אחד, אבל כמה מזהים, כלומר כמה רפרנסים לאותו הקובץ, אין מניעה לעשות דבר כזה. בואו נתחיל מזה.
דבר שני, המזהה הוא לוקלי ברמת הפרוסס. בשיעור אתם למדתם מבנה נתונים שנקרא PCB, מוכר לכם המושג הזה? PCB? באנגלית Process Control Block, בטוח למדתם, אוקיי?
חד משמעית. PCB זה בעצם טיפוס נתונים, מבנה נתונים בתוך מערכת ההפעלה, שמתחזק את כל מה שמערכת ההפעלה צריכה לדעת על פרוסס. על כל אחד מן הפרוססים יש PCB בשלו. בתוך ה-PCB ברמה הלוקלית, יש וקטור של פייל דסקריפטורים, אוקיי?
כלומר, לכל פרוסס יש רשימה של מזהים שנפתחו בתוך הפרוסס. אז אין בעיה שבפרוססים שונים נפתח מזהים, אפילו לאותו כובע, ואפילו שהמטברים יהיו זהים, כי המזהה הזה הוא ייחודי בתוך הפרוסס עצמו. אוקיי, בואו נראה דוגמה, למשל. אני מעוניין לפתוח פיידסקריפטור לקובץ דוגמה 1.txt, אני לא כתבתי כאן נתים מלא ולכן הכוונה היא לקובץ דוגמה 1.txt מהספרייה הלוקלית, שממנה אני מפעיל את הפרוסס, ואני פותח את הקובץ הזה עם הרשעת read-only. עכשיו, מה זה הדבר הזה?
מה זה הקבוע הזה? קודם כל, הקבוע הזה זה סך הכל דיפיינים, יש רשימה של דיפיינים, שמוגדרים בתוך הספרייה של הסיסטם קולסט. יש הפריעה לסיסטם קולס, יש רשימה של כמה עשרות דיפיינים, כאשר קולד דיפיין מגדיר משהו אחר שאני רוצה לעשות. אני רוצה לפתוח לכתיבה, אני רוצה לפתוח לכתיבה ולקריאה, אני רוצה לפתוח כובע סיכרוני, אסיכרוני, כל מיני דברים מן הסוג הזה.
תרף אנחנו נכנס למדריך הפורמלי של לינוקס, נראה שבאמת יש הרבה דברים. מה שחשוב שתזכרו, זה שיש אפשרות לפתוח כובע במגוון וריאציות, וקולד דיפיין... זה סך הכל מספר, אל תשכחו כי זה סך הכל אינטר, זה 32 ביטים. הוא פשוט מדליק ומחווה ביטים, כאשר לכל ביט יש תפקיד אחר, זה ממש עבודה ברמת ה-beatwise, אוקיי? במידה שהצלחתי לפתוח את הקובץ הזה לקריאה, אז מן הסתם, מתוך הפיילדס קריטורי המספר, המספר בדרך כלל במרבית המערכות הפעלה, זה מספר בין 4 עד 6 ספרות, אוקיי?
4 עד 6 ספרות, שזה מספר מספיק רחב. תחום מספיק גדול בכדי לייסג את כל הפיימס קריפטורים הפוטנציאליים עבור כל פרוסס, ובמידה וחזר מינוס אחד, יש קשל, אוקיי? צריך לבדוק, בכל התרגילים תבדקו האם יש קשל, האם חזר מינוס אחד, אם כן תטרירו, תסגרו את המשאבים, ותסעו מהתוכנית.
מה קורה כאשר אני רוצה לעשות כמה דברים? למשל, אני רוצה לפתוח קורס עם הרשעת רייט, שתהיה לי קשרות לכתוב עליו, אבל אני רוצה גם לייסר אותו. נניח והכובס הזה לא קיים, אני רוצה לבנות אותו.
הדרך לעשות את זה זה על ידי שימוק באופרטורים של אור בביטוויז. הרי מה זה אור בביטוויז? אתם למדתם עבודה עם ביטים?
למדתם בקורס קודם? כן, למדתי. למדת?
מעולה. מי שלא זוכר, אני מזכיר, לאבדים מאור כפול, שזה אור בוליאני, אור יחיד זה פשוט... עבודה עם ביטים, למשל, עם הפלג הזה, נניח אני לא חושב שלוחים לשני ביטים, אני אכתוב למשל ב-100, והפלג הזה זה 010, אז האור ביניהם יפיק לנו את 110. כי 1 אור 0 זה 1, 0 אור 1 זה 1, כלומר אני עושה ייחוד, או במילים אחרות, הביט בתוצאה של ידלוק הוא ביט שלפחות דלוק, או באגף שמאל או באגף ימין של האור. וככה אני יכול בעצם לאחד שתי הרשאות, שלוש הרשאות או חמישים הרשאות שאני מעוניין. עכשיו, איפה נמצא את כל טבלת הדפיינים הללו, של כל הרשאות שאני יכול לשים על קורס?
אז יש מדריך, מדריך פורמלי, כדאי לכם להשתמש באתר הזה, זה אתר שמשתמשים בו בכל מיני היבטים, man7, זה כמה man7.org, אני פותח אותו. אוקיי? חולי, מלסבן.אור, תכף אתם תראו, אתם רואים את האתר? אז זה האתר, מלסבן, הוא יש לו מדריך לכל מה שקשור ללינוקס, מפקודות, והסיסטם כל, וכל הנוסף של הרשות, הכל, הכל ברמה פירוט מאוד גבוהה.
אז, תעמידו כמו, אתם עושים מעצבים מוחדורים, ואתם עושים דקות מה שעמד. אתם צריכים לעשות כמובן אין כלו בספריית הסיסטמקול, וכאן יש לכם תיאור של כל הדברים שאפשר לעשות עם אופן, ולמטה יש לכם את כל ההרשאות, את כל הפלגים, הרשאת הפרד, פתיחה של קובץ בצורה אסינכרונית, סינכרונית, קריייט, חבר'ה, זה באמת כמות מאוד מאו ד גדולה של אפשרויות. אתם לא צריכים לשנן את הכל, כן, אתם לא צריכים לשנן בכלל, מה שאתם צריכים לעשות זה על פי צורך. למשל אם בתרגיל אני מבקש לבקש מה משתמש שמות שני קבצים ולפתוח אותם עם הרשאת ריד, תיכנסו למדריך הזה, למעשה אתם יכולים להיכנס גם לכל מדריך אחר, ולראות איך אתם פותחים מרשאת ריד, במקרה ריד מופיע לכם גם פה, הנה, זה הרשאת ריד אונלי.
אם אתם רוצים גם ריד וגם רייט, תעשו אור ביניהם, אם אתם רוצים גם ליישר את הקורת, תעשו אור גם עם קריאת, אין מניעה לעשות הרבה אורים בדרך. עכשיו שימו לב למשהו מעניין, אם אני פותח קובץ קיים ואני אומר שיש לי הרשעת ריד עליו, ואילו במערכת ההפעלה לקובץ אין הרשעת ריד, אתם זוכרים שבשבוע שעבר עשינו קודות של change mode, לתת הרשעות, לתת הרשעות, יש הבדל בין הרשעות במערכת ההפעלה לבין הרשעות ברמת הפרוסס, אם ההרשעה ברמת הפרוסס... המתבקשת בשגרת האופן היא הרשאה שהיא מתנגשת עם ההרשאה במערכת ההפעלה, ההרשאה במערכת ההפעלה גוברת, בסדר?
למשל, אם אני מנסה לפתוח את דוגמה 1.txt עם הרשאת read, אבל במערכת ההפעלה אין לי כמפעיל הפרוסס הרשאה של read, אני אקבל תוסעה של מינוס 1, exception, בסדר? כלומר, ההרשאות שאני נותן ברמת הפרוסס, הן יכולות רק להחמיר את ההרשאות במערכת ההפעלה, ולא להקל על ההרשאות במערכת ההפעלה. אם אני מקל על ההרשאות דרך מערכת ההפעלה, מערכת ההפעלה גוברת ולכן חוזר לי מינוס אחד. חבר'ה, זה ברור?
כן? כן. שימו לב שההרשאות שאני מקבל פה, זה רק למען העבודה עם הקובץ בתוך הפרוסס. שתהיה ברור, זה לא שעכשיו אני מנסה לעשות משהו מתוך מעלת הפעלה, מעלת הפעלה זה משהו אחר, שאין דמות ומשנה את הערך. למרות כל מה שאמרתי, אם אתם מייסרים קובץ, אם אתם נותנים לקובץ הרשעת קריאת, ובאמת המעלת הפעלה נתנה לכם לייסר את הקובץ, אז אתם אוטומטית הופכים להיות בעלי הקובץ.
ואני מזכיר לכם שבתור בעלי הקובץ, יש לכם אפשרות להחליט מהן ההרשעות במעלת הפעלה. כי בעלי הקובץ... הם בעלים של הרשאות, יש לנו את ההרשאות, נכון?
ולכן, במידה, ואתם פותחים פה עם הפלג, את הרשאת קריאה, ומהס הפעלה נותנת לכם את התשורות ל-10 קובץ, אז אתם מקבלים פה ארגומן שלישי, שבו אתם יכולים להחליט, מה יהיו ההרשאות של הקובץ, במעמד מערכת ההפעלה. איך זה נראה? בואו רק אתן לכם דוגמה מפה.
שככה תראו גם בדוגמה רלוונטית, איפה זה היה, הנה פה, אתם רואים פה למשל, אתם סביבים לב, פתחתי קורס בדוגמת 2.txt, עם הרשת create, וread write, כלומר אנחנו יכולים לעשר, לכתוב ולקרוא, מכיוון שאני עכשיו הקריאיטור של הקורס, אז למעשה אני יכול לקבוע מה יהיה הרשעה במערכת ההפעלה. אז אני כותב כאן הרשעה 466. 4 זה 1, 0, 0. 6 זה 1, 1, 0 בבינארי. ו-6 עוד הפעם זה 1, 1, 0. המשמעות היא שאני פותח את הקובץ דוגמה 2, אני מייצר אותו מתוך מערכת ההפעלה, כך שלאיוזר, שזה אני, יש הרשעת read, end, write, end, execute, לגרופ שלי. יש read, יש write ואין execute, ולאדר שלי, זאת אומרת אלה שבחוץ, מחוץ לגרופ, יש read, יש write ואין execute.
את הדבר הזה אני יכול להכניס, רק כאשר אני הקריאיטור, כאשר אני לא קריאיטור, אני משתמש בכובע שקיים, אין לי אפשרות להחליט, מה היו הרשות במעמד מערכת ההפעלה. חבר'ה זה ברור? אני רק לא הבנתי איך נגידת תודה ש... מה כל הרשאה נגיד ארבע מייצג הרשאה מסוימת? תמיד יש לי אותו סדר, השלשה הראשונה זה ה-user, השלשה הבאה זה ה-group והשלשה השלישית זה ה-other.
כאשר כל שלשה כזאת היא מחולקת ל-read-write-executive, היא הסדר הזה. הבנתי, ונגיד, אבל איך אתה, כי מה זה אומר שזה 6? איך אני יודעת מה זה 6? זה בבינארי, 6 בבינארי. 6 זה 4 ועוד 2. אה, זה כאילו כל, ברגע שכל הדלקתי ביט, אז זה כאילו read-write ו...
כן, כן, כן. ביט דנוק, כמו כשעשינו בשנגמוד בשבוע שעבר, כל ביט דנוק זה true, כל ביט קבול זה false. בסדר? הבנתי.
מה זה סמאל חלט? תקיחה. בשביל מה 0 בהתחלה?
אה, זה, קודם כל אתה יכול לוותר על ה-0 הזה, פשוט בדרך כלל מתחילים מספר ב-0, כאשר מדובר פה על בסיס אוקטלי, אוקיי? ספרות, ספרות. כי הספרות מתפלגות בין 0 ל-7, בסדר?
בסדר. אבל אני כבר אומר לך, גם כתוביות ה-0 זה יעבוד, אבל תשמעו 0, כי מי שקורא את הקוד מבין שהספרות פה מתפלגות בין 0 ל-7, כי 7 זו הרשאה מלאה, ו-0 זה הרשאה הפסית, נכון? אז למשל...
OX זה באקסה דצימאלי, 0 זה אוקטלי, B זה בינארי, בסדר? אוקיי, בסדר. אוקיי, עכשיו, מה קרה למשמח וורד, מתקה לי, סליחו לי, מתקה, זר של מתקה, אוקיי.
יפה, אז אנחנו יודעים איך לפתוח פיידסקריפטור בתוך הפרוסס, והשאלה שלי זה איך אנחנו סוגרים את הפיידסקריפטור הזה. הדג זו נשתמת ב-close. close מקבל את המספר פיידסקריפטור שאותו פתחנו מקודם, והוא מחזיר 0 או מינוס 1 במידה שיש הצלחה או כישלון.
כישלון יכול לקרות כאשר אני מנסה לסגור כובע שלא פתחתי, או מנסה לסגור כובע נעול, או כל מיני דברים מעשו בזה. חשוב מאוד לסגור את הפיילד סקריפטור, זה בעצם מה שחרר מה שאבים. שימו לב ש-Close לא שומר קובס או סוגר אותו בדיסק.
ה-Close רק סוגר את הפיילד סקריפטור. הוא מפנה את הפיילד סקריפטור ברמת הפרוסס. עכשיו, אם פתחנו קובס ואנחנו גם יודעים איך לסגור אותו, הדבר הבא שרוצים לעשות זה להיות בעלי יכולת לקרוא ולכתוב מהקובס, כי זה מה שעושים מקבצים.
אז ה-System.read תודה. קורה מתוך הקובע שה-FileDescriptor מתייחס אליו, זה שעשיתי לו Open, Count בתים, קורא ממנו Count בתים, לתוך ה-Buffer, מתוך ה-FileDescriptor אל תוך ה-Buffer. שי��ו לב שה-Prototype של ריד מקבל Buffer גנרי, בוד כוכבית. בטח למדתם את זה במבוא, אני יודע שיש סטודנטים שלא עשו קורס מבוא, כי היו פטורים, אז אני מסביר.
בויד כוכבית זה כך הכל פוינטר גנרי. אני יכול לשלוח פה בארגומנט השני, באפר של אינטים, באפר של דאבלים, באפר של תווים, באפר של פלוטים ואפילו באפרים של סטרקטים. למעשה הכל עניין של כתובת.
כל באפר זה כך הכל כתובת לתא הראשון. אז ברמת הפרוטוטייק, בווי כוכבית זה מימוש של טמפלייט, נכון? זה באפר גנרי, כי אני לא רוצה עכשיו לכתוב ריד עבור כל אחד מהטיפוסים, אז בווי כוכבית אומר אני יכול לקבל כל צורך של כתובת, כתובת לכל טיפוס, בסופו של דבר למעט הפעלה לא מעניין אותה, מה אני מתחזק? אם למשל הבאפר הזה הוא בגודל 100 בייט, count שווה ל-100, אז 100 בייט או 200 בייט, בוא נניח 200 בייט, אז 200 בייט יכול להיות 50 אינפים, כי כל אין שוקל ארבעה בתים, 200 בית יכול להיות 25 דאבלים, כי כל דאבל שוקל שמונה, 200 בית יכול להיות 50 פלוט, או 200 תבים, כל תב שוקל בית מודל, או אפילו שני סטודנטים, כאשר הגברתי מחלק הסטודנט, או סטראקט סטודנט, וכל סטודנט שוקל 100 בית. למעשה למעט הפעלת זה ממש לא מעניין.
מה שהיא עושה, היא קוראת מתוך הקובץ הזה, count בתים, לתוך הבאפר שהגדרתי, כמובן הגדרתי אותו לפני זה, כיחידת דיכרון, ואני שולח אותו לתוך הארגומטה שלי. הערך שחוזר מהריב הוא עוד הפעם מינוס אחד במידה ויש קשל, נניח ולא סלחנו לקרוא מתוך הקורס, מכל הסיבות האפשריות, או שחוזר מספר שמיישג את כמות הבתים בפועל שהסלחנו לקרוא. לדוגמה, רציתי לקרוא מהבית, אבל בתוך הקובץ לא היה מספיק, בתוך הקובץ היה רק 50 בייט, אבל במקרה שכזה, יוחדר 50, אם הצלחתי לליקוח 50. שימו לב שהסיסטם כל הזה קורה, לא מתחילת הקובץ.
אלא מאיחן שהסמן נמצא למשל יש לנו קובץ, והסמן כרגע נמצא פה. עד מפה הוא קורא את אקאונט בתים. לא רק שהוא קורא את אקאונט בתים, הוא כבר מעביר אוטומטית את הסמן מעבר לקריאה, כלומר הוא יעבור מעל ה-50 בתים. הריד גם מקדם את הסמן, בהמשך נראה, חששה לשחק עם הסמן קדימה ואחורה בקלות, אבל שימו לב שכל ריד קורא בתים ומקדם את הסמן קדימה.
זו הסיבה שהרבה פעמים, כאשר עושים לקרוא קובץ, עושים לו לאחל רידים. ריד של מהבית, ריד של מהבית, ריד של מהבית, עד שהגענו לשאריד של הקובץ. ברגע שהגענו לשאריד של הקובץ, יוחזר את הערך שהוא קטן מ-100. למשל אם הקובץ היה בגודל 270, אז קראנו 100-100, ואז השאריד היא 70. אז יוחזר לנו המספר 70 בסוף של כמות הבתים בפועל שהצלחנו לקרוא בריד האחרון. זו הדרך שלנו.
לטעון קובץ לתוך באפר. אני לא רוצה לטעון את כל הקובץ לתוך באפר, אני רוצה לטעון אותו בפרגמנטים, כלומר בשלבים, וזאת משום שקובץ הוא יכול להיות מאוד מאוד גדול. קובץ נמצא על הדיסק הקשיח למשל, דיסקים קשיחים מודרניים, נמדדים היום בהתרות, ממש ככה, אלפי ג'יגות או מיליוני מגות, אם תרסו, או ביליוני בתים, ממש כך. וזה עדכן שיכול להחסם בתוכו כמות גדולה מאוד של מידע, ולו כאשר אני עושה קריאה לתוך באפר, אני בעצם טוען מידע מהדיסק הקשיח לתוך הרם.
הרם למי שלו מכיר, הוא סדר גודל, כן, בעולם המודרני, יש כמה ג'יבות, אפילו כמה ג'יבות בודדות, 4, 8, 16, 32, 64, זאת אומרת שאני לא רוצה לקרוא את כל הקורס בבת אחת, כי לא תמיד אני יכול, אז מה שאני עושה, אני פשוט טוען אותו בפרגמנטים, בשמה... עושה לו לאחל רידי וכל פעם מטפל בחלק מהקובץ. אז איך אני יודע שהגעתי לסוף הקובץ? לפי הערך המוחזר, ברגע שחזר לי מספר שהוא קטן מקאונט, אני יודע שזה השרד.
ברגע שחזר לי המספר אפס, אני יודע שהגעתי לסוף הקובץ. ואם חזר לי מינוס אחד, זה בכלל מעיד על קשל. חבר'ה, זה ברור? אוקיי. אז הפעולה ההפוכה.
הפונקציה הפוכה, היא פונקציה טרייט, אבל לפני לבוא נראה דוגמה לריד, הנה דוגמה קלאסית. תקרא מתוך הפייל הסקריפטור הזה שהוא נפתח עבור קובץ, 30 בתים, ותכניס אותם מתוך באפר, הבאפר נמצא ברם של המחשב, היפ ה חוזר, יהיה לכל היותר 30. 30 אם הצלחתי לקרוא 30, 0 אם לא הצלחתי לקרוא בכלל, מספר באמצע זה אם אין מספיק בתים בקובץ שהצלחתי לקרוא, ומינוס 1 במידה ויש קשר. מה לגבי רייט?
רייט זאת החונציה שכותבת לתוך קובץ, אז תשכחו שאני חייב לכתוב את הקובץ, זה מרשעה אני לא יכול סתם לכתוב לתוך קובץ אם לא עשיתי לו אופן עם מרשעה כנעל גם לגבי ריד, ואם מרשעה מתנגשת עם מרשעה של נמר תהפלה אמרתי לכם גם אז, נמר תהפלה למעשה גוברת, אז מה רייט עושה? את הפעולה ההפוכה כותבת את הבאפר בגודל כמה בתים לתוך הקובץ. איפה המידע יקטם לתוך הקובץ, תלוי איפה השמן נמצא. אם הוא נמצא בתחילת הקובץ, אז הוא נכתב פה, ואז כל הקובץ, כל התוכן שלו, נדחף קדימה.
אם השמן נמצא באנדו פייל, אז נכתוב בסוף. אם השמן נמצא באמצע, נכתוב שם. אותו תואל אנחנו רגע, מאיך אפשר לשחק עם השמן הזה, קדימה ואחורה, איך שרופים. גם רייט מחזיר מינוס אחד במילה ויש קשל, או לחילופין מחזיר את כמות הבתים בפועל שהוא הצליח לכתוב בתוך הקובץ, למשל הוא רצה להכתוב 100 בתים אבל הצלח לו לכתוב רק 50, כי לא היה מספיק מקום בדיסק.
כל הזמן, בכל תרגיל, יש לבדוק האם חזר מינוס אחדים, בכל הסיסטם כל שנה אנחנו לומדים. וחשוב מאוד, אנחנו עושים פה בקורס במערכות הפעלה, זה לא סתם קורס בפיתוח. ולכן חשוב לי מאוד שתדקו את השגיאות הללו, להטריע, לשחרר משאבים ולצאת.
בסדר? אוקיי. ראית, גם הקדם את הסמן?
תוך כלי הכתיבה. כן, מעבר לתוכן שכתבת. בסדר? כלומר, הסמן מתקדם אוטומטית, גם בהתאם לכסף הקריאה וגם בהתאם לכסף הכתיבה.
אנחנו גם עוד מעט נראה דוגמת קוד מלאך, היא אמורה לסכם את כל מה שרומדים. אוקיי, מה לגבי סיסטם קול L-SICK? L-SICK, מנשון Long SICK, SICK לחפש, מאפיון לנו לשחק עם השמן קדימה ואחורה. ה-L-SICK הזה מקבל שלושה ארגומנטים.
הארגומת הראשון זה הפיילדסקריפטור, אותו פתחנו. הארגומת השני זה איזשהו אסט, אסט, אזחה, שיפט בתוך הקובץ, בבתים. והארגומת השלישה היא סטארטינג פוזישן דקלריישן, זה המיקום הבסיסי, היחסי שאליו אני מתייחס.
המיקום היחסי שאליו אני מתייחס יכול להיות אחד משלוח את הקבועים הבאים. סיג סט, הכוונה היא מתחילת הקובץ. סיג קארנט.
מהמקום הנוכחי שבו הסמן כבר נמצא, sick end, מסוף הקובץ. בואו נראה דוגמאות, אני בטוח שהכל יהיה ברור. נניח ואיתי רוצה להעביר את הסמן, 100 בתים מתחילת הקובץ, ה-bestarting position declaration, אני אשים sick set, כי זה מתחילת הקובץ, offset יהיה שווה ל-100, ו-file descriptor, ה-file descriptor של הקובץ. דוגמה שנייה. נניח ואיתי מעוניין, להעביר את הסמן להיות במקום של 100 בתים מסוף הקובץ, כלומר אחורה, בסוף הקובץ, start in position יהיה seek end, ו-offset יהיה מינוס 100, נכון?
כדי נעסוק להתחלה. דוגמה שלישית, נניח מהסמן כרגע נ מצא בבית האלה, ואני רוצה להעביר אותו עוד 200 בתים קדימה, אז מה שאני עושה, ב-start in position declaration, אני מכניס seek current, ובאוף זה שם 200 ואז הוא מתקדם 200 יחסית למשהו מנסה כרגע. ואילו מינוס 200, הוא יעבור ל-800, כהו ירד 200. כמה דברים שחשוב בהקשר של שימוש בסיק.
חשוב לא לגלוח מעבר לגבולות הקובץ. אם אני גולך מעבר לגבולות הקובץ, גם Overflow וגם Underflow משנה קסמות, אז יוחזר לי כאן מספר שלילי, בדומה למה שראינו קודם. מה קורה כאשר אני לא גולך מעבר לגבולות הקובץ?
נחזר לי המספר האבסורותי של איפה השמן כעת נמצא, יחשית לתחילת הקובץ. דוגמה, למשל אם כרגע אני נמצא בבית 200 בתוך הקובץ, 1000, סליחה, 1000 בתוך הקובץ, שםתי, נמצאתי ב-starting position, את 6 current, וה-offset שםתי 200. אז השמן עבר למקום ה-1200. המספר 1200 הוא זה שהוא יחזור לי.
כלומר, המספר שחוזר, הוא המספר... שעכשיו הסמן נמצא יחסית לתחילת הקובץ. זו הסיבה שהערך שאני מחזיר הוא ערך לונג, משום שכל קובץ יכול להכיל המון המון בתים.
ואחד מהשיעורים הבאים אנחנו גם נראה איך אני יכול לחשב את הגודל של הקובץ המקסימלי. אז כבשים אנחנו נראה שהם יכולים להיות ממש ממש גדולים. אז טיפוס פינט הוא לא מספיק רחב מבחינת כמות הספרות שלו. כדי להחסל את המספרים הללו, ולכן אנחנו מתאמשים בלונג. כל מי שרוצה יכול להסתכל באינטרנט.
לונג עושה לנו מספרים שיכולים להיות מאוד מאוד ארוכים, וזה מספיק טוב כדי לקסות את המיקום של הסמן בתוך קובץ, גם אם הקובץ הוא מאוד מאוד גדול. אז זה השימוש בהשיק, ואיזה דברים אפשר לעשות? הכל. למעשה, אם אני למשל יודע שהקובץ מכיר מספרים, כל מספר זה ציון.
וכל סיון זה int, ולכן זה 4 בתים, אני רוצה לקפוץ לסיון המאה, אז אני עובר לבית ה-400, מבחינת הקובץ. כי כל סיון זה 4 בתים, int, ואני רוצה לקפוץ לסיון המאה, אז אני קופץ 400 בית קדימה. אני יכול לפי הפורמה של הקובץ לטייל עליו. דוגמה שנייה, אם אני רוצה למחל לקרוא את הקובץ מהשופלת תחלה, אז אני מגיע לשופל קובץ, על ידי שיק end, ואז מתחיל לקרוא בית. קורא בית, חוזר שני בתים אחורה.
קורא בית, חוזר שני בתים אחורה. למה שני בתים? משום שכל קריאה מקדמת את הסמן באחד. אז היא קדימה אחד, שניים אחורה, קדימה אחד, שניים אחורה, וככה לסירוביל.
אוקיי. אוקיי, עכשיו, חבר'ה, זה דבר נורא נורא חשוב, שאני רוצה שתכירו, כי זה רלוונטי כבר לחלק ב'בתרגיל הטכנותי, וזה פונקציה שהיא קשה. אז תראו ככה המרוכזים, פונקציה דופ, מלשון דופליקייט, וגם סיסטם קול. מה שהסיסטם קול הזה עושה, הוא לוקח את הפיילד סקריפטור שפתחתי, פה זה, ומשכפל אותו לפיילד סקריפטור חדש שמצביע לאותו הקורס. למה צריך דבר כזה?
אז כמה דברים לפני. קודם כל, במערכת הפעלה לינוקס, שעובדת לפי סטנדרט של לינוקס, יש לחול פוסס PCB PCB שזו טבלה Process Control Block, שמתארת את כל האלמנטים עבור הפרוסס, שמערכת הפעלה צריכה לדעת. עכשיו, בתוך ה-PCB, יש רשימה של פייל דיסקריפטורים פתוחים, לכל פרוסס.
למשל, פרוסס 0, יש לו רשימה של פייל דיסקריפטורים פתוחים, פייל דיסקריפטור 0, פייל דיסקריפטור 1, 2, ככה, אלא. כמובן, מערך דינמי כזה, שבמצאותו אפשר... כן אפשר להגדיל אותו ולהגדיל אותו, ולהתייחס לכמות הפיילדסקריפטורים שנפתחו. בלינוקס, יש שלושה פיילדסקריפטורים משונים, פיילדסקריפטור 0, 1 ו-2, שיש להם תפקיד יהודי. התפקיד היהודי שלהם, זה שהפיילדסקריפטור 0, הוא מתייחס למסך, סקרין, סליחה, תורת שלי, למקלדת, קיבורד, הסטנדרט אינפוט, stdin אחד זהו המסך stdout זה המסך, סטרין שתיים זה std-error כאשר כל הדברים שהניתי אותו הוא גם מסך שימו לב, למשהו מעניין פה.
אין בפועל הבדל בין לכתוב לקובץ לבין לכתוב למסך. למה? כי right מקבל בארגומת הנוסדת הפיידסקריפטור.
אז אם אני מכניס כאן שם כל כובץ, פיידסקריפטור כל כובץ, זה כותב בתוך הכובץ. ואם אני כותב כאן אחד, מה זה אחד? אחד זה המסך.
זאת אומרת שאם אני עושה right ל-1, אני בעצם מטפיס למסך. יותר מכך, זה המימוש של פרינט F. זה המימוש של פרינט F.
פרינט F הידוע, משפט C, הוא לא סיסטם קול, הוא שרק קול פונקציה. אז אחר אנחנו מבינים איך פרינט F ממומש. פרינט F ממומש על ידי רייט לאחד.
כשייתי פרינט F ל-1, כתבתי ל-1 ל-1, בגודל כמה ותים? 2, 3, 4, 5, 4, 6, 11, כולל הבקסל 0 בסוף, 12. זה המימוש של פרינט F, רייט ל-1. אין הבדל בין לנתן פלט לקובץ, לקרפיס רשת, לבאפר, למסך.
זה הכל עניין של redirect, ניתוב להתקן הנכון. כולם הם מומשלים בסופו של דבר על ידי רייט. ובאופן זהה, אם אני רוצה לממש סכם, לקלוט משהו, כן, מה זה עושה? הוא קורא, נכון? זה ריד.
ריד מ-0, נכון? תקרא מתקן כלת הסטנדרטי מהקיבורד. כבר אנחנו הרווחנו פה, בגלל שאנחנו מבינים ש-printf is-kenf, זה פונקציות, והם לא סיסטם קול.
הם מומשלות על ידי ריד ורייק. עכשיו, למה אני אומר לכם את כל זה? משום שבסטנדרט של מינוק, במעט ההפעלה, לכל פרוסס, שלוח את הפיילדסקריפטורים הראשונים.
זה שאיפס, זה של אחד, זה ששתיים, הם בעצם פלא סטנדרטי, פלא סטנדרטי ופלא תשגיות הסטנדרטי. מה זה פלא תשגיות הסטנדרטי? כל עוד לא שוניתי אותו, הוא המסך.
אבל הרבה פעמים אני רוצה לקראת את השגיות במערכת ולשים אותן בתוך קורס. זאת אומרת, פלטים נורמטיביים יופסו למסך, ואילו פלטים שהם שגיות. כל מיני אקספשנים, אני אפיס אותם מתוך קובץ.
יש אפשרות לנתב את שתיים, שזה פלט השגיאות הסטנדרטי, למקום אחר. או הפוך. יכול להיות שאת השגיאות אני רוצה למסך, ואת הפלטים הרגילים, לקובץ. יכול להיות גם וגם. מה שאני טוען, זה שפלט הסטנדרטי, פלט הש גיאות הסטנדרטי, אף על פי שהם מוכחלים להיות המסך, אני יכול לשחק איתם.
תכף נראה איך עושים את זה. למעשה, כדי להפיס לשתיים, הוא רושם פי אירור. print error, print error hello, בעצם write ל-2, תפיס את ה-low, בגודל של שישה ותים. אם אני בהמשך אוכל לנתב את 2 להיות מטפסת, ואת 1 להיות מסך, אני אוכל להתפיס למטפסת את השגיות שקורות בתוכנית.
לא את כל הפלטים, אלא רק את השגיות. אני עושה גם את הפלטים הרגילים, אז אני נתב גם את 1. print error מטפיס ל-2, print f מטפיס ל-1. מסכנת קורא מ-0.
עכשיו אני יכול את זה רגע לדוק. כי זה חשוב. מה שדופ עושה, הוא לוקח את הפיידסקריפטור הזה שלפתח, ומשכפל אותו לפיידסקריפטור חדש, אבל שימו לב, הקטן ביותר שפנוי.
המספרי, הקטן ביותר שפנוי. אוקיי, נשמע מוזר משהו, בואו נסתכל על הקוד הזה, הכל יהיה ברור. תקנו על הקוד שיש פה. פתחתי את משה-filescriptor, משה.txt, נניח, נתתי לזה הרשעת right, הרשעת right, הנה היא פה, נניח ה-filescriptor של משה, זה filescriptor 100, נניח, אוקיי?
אז ה-filescriptor 100, הוא reference ל-moshe.txt, יש הרשעת right, עכשיו אני עושה cloud לאחד, cloud סוגר filescriptor, סגרתי את אחד, הנה אחד פה, נכון? המסך לא נכבר או משהו כזה, זה רק הרפרנס, נכון? זה רק הפיידסקריפטור, שלא תטעו. וגם הסגירה הזאת, היא שלחה, היא רפרנסית רק לפרוסס. כל הפרוססים האחרים יש להם פיידסקריפטור אחד משל עצמם.
זה משהו שהוא לוקלי ברמת התהליך. ואז אני עושה דבר כזה. דופ לוקח את הפיידסקריפטור של משה, שהוא 100, משחפל אותו לתוך FD. דוק מחפש את הפייד סקריפטור הקטן ביותר שפנוי.
מי הוא הפייד סקריפטור הקטן ביותר שפנוי עכשיו? אחד, כי עשיתי לו close. למעשה, הפכתי את אחד להיות ל-moshe.txt. אנחנו רואים שהכפנו אותו.
שהכפנו אותו. אחד היה סגור, הוא היה פנוי. שהכפנו אותו. מה יקרה עכשיו אם אני אעשה printf?
מי יכול לומר מה יקרה בשלב הזה? אני אעשה printf של hello world. אז פיס לקובץ. פיס לקובץ, נהדר.
למה? אנחנו רואים את זה פה. printf ממש על ידי write ל-1.
1 הוא כבר לא רפרנס למשך, 1 הוא כבר רפרנס למשה נקודה txt. למעשה אנחנו יכולים גם לעשות אפילו clone למשה find descriptor, אין טעם כפי דו בפייד דסקריפטור הזה. 1 הוא כבר משה נקודה txt.
אז אם אני אעשה printf, של מלל מסוים, המלל זה ייכנס בתוך הקובץ, הוא לא ידפש למסך. מה שעשיתי פה הוא בעצם redirect, ניתוב מחדש, במקרה הזה של הסטנדרט אוטפוט, של לתקן הפלט הסטנדרטי. אבל באופן זהה לחלוטין, אם הייתי רוצה לנתב את הכל את הסטנדרטי, במקום לקלוט מהמקלדת, לקלוט מקובץ, מה הייתי צריך לעשות? לסגור הפעם את מה, איזה התקן?
את 0, נכון? כי 0 זה הקלט הסטנדרטי. ואם הייתי רוצה למשל לנתב את פלט השוגיות הסטנדרטי, לא להיות למסך, אלא להיות למשל לקובץ error.txt, אז זה נושא קלוד ל-2, ועושה דופ לפיידס קריפטור של error.txt. כמה פשוט.
הדבר הזה מאפיון לי לנתב, או לשלוט בעצם, על התקני הקלט בפלט של המערכת. אבל שימו לב, זה רק בתוך הפרוסס. כמה תובנות? תובנה מספר אחת, אם אתם רוצים שמושה.txt יהפוך להיות פלט סטנדרטי, תיתנו לו הרשאת רייט.
אתם לא תוכלו לכתוב עליו אם לא פתחתם אותו עם הרשאת רייט, נכון? באופן אנלוגי, אם אתם רוצים לנתב את מושה.txt להיות קלט סטנדרטי, לקלוט מתוכו, תיתנו לו הרשאת ריד. אחרת לא תוכלו לסגור את אפס ולעשות לו דוק. שאתם רוצים לקרוא ממשל נקודה TXT ולא מהקיבורד, ולכן אתם צריכים לדאוג שההרשאות יהיו נכונות, דבר ראשון. ודבר שני, ואנו רוצים לשאול אתכם אותו, מה קורה אם עשיתי את מה שאנחנו ראינו פה, ממש זה, כן, מה שאתם רואים פה בסרטון, ועכשיו אני רוצה להחזיר את המסך להיות הפלט הסטנדרטי.
יש למישהו רעיון מה אפשר לעשות? מה אני צריך לעשות זה להחזיר בחגרת המסך להיות הפלט. close זה משה fd ולעשות open ל-1 או ל-0? לא, כשאתה עושה open אתה מקבל פייל דיסקריפטור.
זה עשה, אתה לא יכול לעשות כאילו, זה אני מנחש. לא, אתה לא יכול לעשות דבר כזה, כי ה-open הוא מחזיר פייל דיסקריפטור, הוא לא מקבל פייל דיסקריפטור שאתה רוצה. אה, אוקיי. אבל איך אני חוזר מ-open? הוא הפייל דיסקריפטור שהמערכת נתנה לך.
בסדר? אופן מאז דופה רב. קרוב, קרוב. אני אסביר, רגע לפני שאני סוגר את 1, נעשה דו פלי 1, נשכפל את 1 לתוך x, נניח x שווה ל-50, נעשה דופלי 1 לסטנדרט האוטפוט, ואז הפייד אסקריפטור 50, הוא רפרנס למסך. עכשיו אני עושה את כל התאריך הזה, ובסוף כאשר אני רוצה להחזיר את המסך, אני אעשה close ל-1, סגרתי את 1 לא להיות מושה, ואז אני עושה דוק בחזרה ל-50, נכון?
ובעצם משחזר, dbt, ועכשיו משחזר, אני עשיתי דוק ל-50, הוא לקח את 50, ומשחפל אותו, 50 זה המסך, אל תשכחו, ומשחפל אותו לתוך ה-file descriptor הקטן ביותר של פנוי, הרי הוא 1. חיים, עכשיו שאלה. כן. 0.1 ו-2, הפייל דיסקריפטורסים, הם כולם רפרנס לאותו קובץ, פשוט בפתיחות שונות? זה לא לאותו קובץ. 0.1 ו-2 זה לקלט הסטנדרטי, פלט הסטנדרטי ופלט השגיות הסטנדרטי.
זה הסטנדרט של UNIX. כן, אבל זה לא בהתחלה לאותו קובץ שהוא המסך? לא, לא, לא.
מה פתאום? זה לא כל תהליך שאתה מייסר בתוך המערכת, אוטומטית הפייל דיסקריפטורים שלו 0.1 ו-2 תפוסים, כפי שאתה רואה פה. כן, ברור, אבל הם לקבצים שונים.
הם לא לא אותו חודש. הם להתקנים שונים בתוך המערכת. ועכשיו אתה יכול, בגלל שהכל זה כל פתוח, ואתה יכול להתאחלת את זה איך שאתה רוצה, אתה יכול לשנות את זה.
אגב, בהצלחת עם מה שאמרתי קודם, יש שיטה אחרת, איך אני יכול לשחזר את הפיילד לסקריפטור אחד, לחזור לי את המסך. אני פשוט רוצה דופלש 2. הרי 2 זה פלט השדויות הסטנדרטי. וכל עוד לא שיניתי אותו, הוא גם המסך. אז אם אנ י עושה דוק ל-2, הוא משכפל ל-2 מתוך 1, ועל שני מסביבים למסך.
אבל אם נניח שניתי גם ל-2, אז הדרך הטובה ביותר לעשות את זה, לפי מה שאמרתי לכם פה, גיביתי את 1 לתוך 50, למשל, ועל שכזרתי את 50 בחדרה ל-1, כאשר סיימתי. אז טוב, אתה בדיוק אין פוטאות פוט, ובשגיעת הסטנדרטית. כאילו הסדר בזיכרון, נפיס 1, 2, תמיד יהיה ה-input, הסדר בזיכרון, תמיד יהיה input, output, ואז השקיעות. כן, זה ה-standard, כן. למעשה כל פרוסס שאתה מייצר במערכת, השלושה הראשונים מוקשים לטובת ה-devices עליו.
אז מצלם, אם אני אעשה close ל-handle, ואז אני אעשה dupe, אז הוא כאילו ייכנס במקור ה-handle בתכלס. נכון, כי dupe מחפש את הקטן ביותר שפנול. הוא לולא עתיק כזה, בתוכו יש לולאה של... הוא מחפש מה הוא null.
close הוא null. אז הוא מחפש את הראשון שהוא מנהל. אוקיי, תודה.
עכשיו, זה מעולה. תחשבו על זה, איזה אידיאלי זה. למשל, אני אתן לכם דוגמה ברמת המעט הפלאסמה. אני אתחבר רגע לשרת.
אני מחבר לשרת, אז תנו דוגמה, בתוך השל, בתוך המעטפת יש קודות אופרטורים, שממומשים בדיוק כמו שהראיתי לכם מקודם בקוד, למשל קודת LS אנחנו יודעים שהיא מראה לי את התוכן של התקייה, אבל אם נצא LS מקט, יותם נקודת יקטי, אז בעצם מה שאני עושה, אני לוקח את התוצאה של LS ומכניס אותו לתוך יותם נקודה TXT. כלומר, תחשבו על זה מה עשיתי פה. במקום לנתב את התוצאה של ה-LS למסך, כמו בהפעלה הקודמת, אני מעשה סוגרת אחד, הפרוסס של השל סוגרת אחד, פותח את הקובץ יותם נקודה TXT.
מקבל עליו פייל דסקריפטור עם הרשעת רייק, עושה דופ ליותם נקודת TXT לתוך אחד, ומערשב הפלט הסטנדרטי הופך להיות יותם נקודת TXT, מריס את הפקודת LS, הפלט מודפס לתוך יותם נקודת TXT, תכף נפתח את הקובץ, ומצוא כפרוסס נעלם, ומכיוון שהניתור הזה, הרי דיירקט הזה קורה רק ברמת פרוסס, אז בשל, של זה הטרמינל הזה שאתם רואים פה לפניכם. הוא בחדריו חוזר לפלט הסטנדרטי. עכשיו, אם אני אכנס לקובץ יותם נקודה תיירתי, אתם רואים פה את רשימת הקבצים בעתיקיות, נכון? בדיוק מה שהיה מקודם ב-LS. כלומר, המימוש של האופרטור הזה, redirect ימינה, הוא בדיוק מה שראיתם בקוד.
למעשה אפילו השאל נכתבה בשפת C. השאל שאתם רואים פה נכתבה בשפת C. הפקודות פה, כשאני מגניס למסתם הוא בשפה C. אנחנו פשוט ראינו את המימוש של האופרטור, ומה קורה מייציוס לדבר כזה? איך עוזל את PIS, כן?
hello world, לתוך, ותם. אז אנחנו רואים, אם ניכנס עכשיו ל-yotam.txt, אנחנו רואים את ה-hello world. למעשה אנחנו כבר מבינים שכאשר עשיתי redirect, הוא פתח את הקורס עם הרשאת כתיבה, וגם create. למה? כי מה שהיה ביותר נקודת txt, נדרש, נכון?
אם אני רוצה לצורך העניין לעשות שימוק באפנד, לפתוח את יותר נקודת txt עם הרשאת אפנד, זה נושא שני חסים. ההבדל בין חס אחד לשני חסים, זה שחס אחד ע ושה create ודורס, ושני חסים פותח את זה עם הרשאת אפנד. זה ממש הקוד שראינו.
הוא פותח פה, נותן לזה הרשאת append, להוסיף פה בארגומנט הזה. אז בואו נבדל, נכנס כעת לתוך לאותה מקודת נקציב, אנחנו רואים עכשיו שתי השורות, ולא השורה השנייה, של הרשאת השורה הראשונה. אתם מסכימים איתי שהמימוש של האופרטורים שאתם רואים פה בשל, הוא נכתב אגב בשפת C, זה אותו מימוש שהרציתי לכם בקורן, נכון, אחד לאחד.
אפשר גם לנתב את הקלט הסטנדרטי, אוקיי? אפשר לתקן את הקלט הסטנדרטי למשל, אם אני נושא פיקו, נוצר נקודה txt, הוא רואה מכאן errorים, בגלל bufferים בתוך הפיקו, אבל הנה קלט הסטנדרטי, זה חס, שמאלה, אולי נראה דוגמה יותר יפה, קלט wc world counter, wc, מה שהוא עושה, היא מפיסה לנו את כמות השורות, כמות המילים וכמות התווים בקובץ. אז אני לוקח את הקובץ יוטם.txt, ורוצה להפיס את הכמויות, ובאמת אנחנו רואים בתוך יוטם.txt יש שתי שורות, יש חמש מילים, נכון?
hello world ו-hello world again, ויש סך הכל שלושים תווים. אז זה מנתב את הקלט הסטנדרטי, זה מנתב את הפלט הסטנדרטי מרשעת create, וזה מנתב את הפלט הסטנדרטי מרשעת append. כל הקודות הללו פה בשל תוכנת תאומס פס-סי, ואנחנו ראינו בקובס וורד את המימוש שלהם בעצם. חבר'ה, זה ברור. יש את שירות גם לנתב את הפלט השגלות הסטנדרטי, למשל ככה.
הוא לא נותן לי, אוקיי, הוא לא נותן לי, זה לא בכל המערכות, אולי קטן פה, הנה. כאילו לפלט תשגיאות הסטנדרטי, אוקיי? 2, כי 0 זה קלט, 1 זה פלט ו-2 זה פלט סטנדרטי.
זה ברור לכולם? כן? אוקיי. חיים, מה זה מה שעשית עכשיו? שעשית 2 ו-1?
2 זה לפלט תשגיאות הסטנדרטי, זה עושה רייט ל-2. אה, אוקיי. ואם את לא רושמת 2, אז זה ל-1, בסדר?
את יכולה לפעילה, אתי גם נכתוב אפילו 1. אבל זה לא משנה נכון? אוקיי. מקודם אני אמרתי לכם שיש ספריית error number, ספריית כל השגיאות, שבתוכה אנחנו יכולים לקבל את האינפורמציה מהי השגיאה. לא רק האם קראתה השגיאה, אלא גם מהי השגיאה. וכדי להשתמש בספריית זאת, צריכים לעשות include ל-error number נקונה page.
ב-IBSM יש רשימה עשירה ביותר, שיש גליות שיכולות לקרות בתוך מההתאפלה, גם ברמת חומרה וגם ברמת תוכנה. הולדתי לכם פה לינק, לכל השגליות שיכולות לקרות בלינוקס, באמת מדובר פה על כמה מאות, ופה כל השגליות שיכולות לקרות בוונדוס. רגע, זה יסע, נכון? זה פתאום חצ?
אתם רואים את הקובץ פה? כן. אוקיי. אני אצלכם פה לינק לשגויות שקיימות בלינוקס, וכאן לינק לשגויות שקיימות בווינדוס, וגם לינקים אחרים לאפל, לאנדרויד.
הכוונה היא ברורה. למעשה, בתוך הספרייה הזאת, Error Number, יש הרבה קבועים. אתם רואים קבועים, הרבה Defining. כל Defining זה מספר סיבורי של שגיאה אחרונה שקרתה בתוך המערכת. והמשתנה את זה, Error Number, זה משתנה סביבה, משתנה Environment, שבעצם שומר ברמת הגלובל של מעט ההפעלה, את השגיאה האחרונה שמעט ההפעלה מצאה.
אז אם תשימו לב, למחל עשיתי פעולה החלרייט, כתבתי. וחזר לי מינוס 1, אז אני יודע שקרתה שגיאה. עכשיו אני יכול לעשות מעין switch case כזה, או if else, של כל השגיאות הקיימות, אם השגיאה היא כזאת, הרשימה הרשומה לכם ב-linkים עליו.
אם השגיאה כזאת, אי אפשר לפתוח לכתיבה. אם השגיאה היא שגיאה כזאת, אין מספיק מקום בדיסק. ואפשר לעשות ממש תפריט כזה הפה של כל השגיאות הקיימות.
אבל בשביל לקבל את השגיאות הללו למשתנה error number, אתם צריכים להשתמש בספרייה error number.h. אבל בתרגילים הטכנותיים, מישהו רוצה להגזיד ראש ולהדפיס גם מהי השגיאה, הוא יכול. מישהו רוצה להדפיס רק מה שקרתה שגיאה, שג'אד ראשן למעשה בתרגילים, זה גם בסדר.
חבר'ה, זה ברור? כן? כן.
אז עכשיו מה שאנחנו רוצים לעשות איתכם זה להראות לכם דוגמת קוד יפה כזאת, שפחות או יותר אולי מסכמת את כל מה שראינו. הנה, תראו, אני אכניס את זה ככה על המסך, שזה יראה על כל המסך. דוגמת קוד, שימו לב רק שמשתבק כאן בספרירת STDIO, ספרירת הסיסטם קולס, ומשתבק גם בספרירת אירור נאמבר של השוביון.
אז מה יש לנו פה? יש לנו בעצם תוכנית שיש בה שני אינטים, fd וfdout, אנחנו אמורים להיות פייל דיסקריפטורים בהמשך, buffer בגודל 11, גודל מוגדר להיות 10 בדפיים, שני משתנים נוספים, כמה read וכמה write, כדי להשתמש בהם, אחרי זה נעשה memory set, mem set, למי שלמדרקתות התשורת הוא יודע זה, זה B0, אבל אני מסב��ר למען מי שלא למד. ממוריסט זה גם סיסטם קול, שמקבל שלושה ארגומנטים. הארגומנט הראשון זה כתובת, הוא רק מכיר ששם של מערך זה כתובת, בשפת C.
הארגומן השני, 0 או 1. והארגומן השלישי זה כמות בתים. מה שממוריסט עושה, זה בעצם מאפס את 11 בתים. במקרה הזה זה 11, הבתים הללו, מכתובת באפר, מאפסת כולם, כבר עושה פלאש ברם, אוקיי? ממוריסט.
אני חוזר, כתובת בסיס, משתנה איפוס, בכמות בתים שאנחנו עושים. למה עושים את זה? הרבה פעמים מתאמשים את זה, רק כדי לאפס מקום, שיש בו ערך זבל, או כל דברים מן הסוג הזה. אוקיי? כי...
אם הייתי רוצה להפס עכשיו את כל הבאפר הייתי צריך לעשות לולה, בסדר? אז במקום להתאמן בלולה אני יכול לעשות ממוריסט וזה סוגר לנו את הפינה. אין איזה משמעות ברמת התרגיל שאתם רואים פה מתחת, זה רק להכיר משהו. אוקיי.
אופן. אני פותח את הקובץ דוגמה 1 לקונת איקסי. אני אשמח מאוד שכולם יסתכלו כי אני רוצה לשאול אתכם מה לפי דעתכם הקובץ הזה עושה.
מה הפודס זה עושה? בסדר? אז אני פותח את דוגמה 1.txt, עם הרשעת read.
יש לנו כאן file descriptor, אם הוא קטן מ-0, יש גיאה, אני מגפיס לפלט השגיאות הסטנדרטי, write ל-2, שיש גיאה ויוצא מהתוכנית. אוקיי? די ברור. פותח קובץ נוסף, ד וגמה 2, עם הרשעת create, מייסר אותו, יש לי הרשעת read וwrite, ונותן הרשאות של 466, כמו שראינו קודם.
כי ברגע שאני הקריאיטור, אני יכול למעשה לתת גם את הרשאות, ברמת מערכת ההפעלה. אם ה-open החזיר שגיאה, מודיע הודעה שגיאה, ויוסף. למעשה אני צריך לעשות פה גם cloud, נכון?
כי אם יש כאן שגיאה, אני רוצה לעשות cloud ל-fdin, כי fdin כן הסלחתי לפתוח, את fdr לא סלחתי לפתוח, אז אני רוצה לסגור את מה שכן הסלחתי. נכון? כדאי לעשות את זה.
לא להסתמך על המערכת הפנה שתנקח את כל הפיילדס קריפטורי. אוקיי. אז פתחתי דוגמה אחד עם הרשעת רד, ודוגמה שתיים עם הרשעת רייט. ועכשיו פה יש לולה, מה הלולה הזאת עושה? הלולה הזאת קורית מתוך דוגמה 1, נכון?
fdn זה פייל דסקריפטות לדוגמה 1, לתוך buffer, buffer זה מה שהם גרו למעלה, עשרה בתים, איך אני חוזר מהרידי כמות הבתים בפועל שהצלחנו לקרוא, לאחר מכן אני כותב בתוך דוגמה 2, את עשרת הבתים האלה, שימולת זאת או אותם בתים, בגודל עשרה בתים, איך החוזר זה כמה שהצלחתי לכתוב, ואז אני בודק אם כמה ראית קטן בגודל, יש שגיאה, אני מפיס כאן את השגיאה, זה רק בקרה שגיאות, על ידי ספריית Error Number, והעלולה הזאת היא חוזרת על הסמא כל עוד כמה ריד וכמה ראית, שניהם שווים בגודל, אני חוזר שוב ושוב ושוב. מה הקודז עושה? יש רעיונות? מה הקודז עושה? אולי סוג של שכפול כזה?
עוד פעם, עוד פעם. אולי סוג של שכפול, להתיק קובץ אחד לאחר. מעולה, מעולה, נכון לגמרי. סוג של תקודת קופיל.
מתיק את התוכן של דוגמה אחת לתוך התוכן של דוגמה שתיים, פקודת קופי. נכון שפקודת קופי היא פקודה הרבה יותר עשירה, היא מקבלת ארגומנטים, יש לה בקרה שקליות יותר, יותר יעילה, אבל הלוגיקה הזאת היא, קוראת עשרה בתים, כותבת עשרה בתים, קוראת עשרה בתים, כותבת, משכפלת את הקובץ, נכון? ומסתיימת מתי שנגמרו, כבר אין יותר מדי, אין יותר מעשרה בתים.
למעשה... עלולה הזאת מסתמת כאשר יש לימה את השארית של הקובץ. כי אף אחד לא אמר שגודל של קובץ הוא כפולה של עשר, נכון? חיים, אתה יכול להסביר את האיס הראשון עם הכמה ראית קטן לגודל? כן.
גם הריב וגם הראית מחזירים לך את כמות הבתים בפועל שהצלחת. למשל פה, כמה הצלחת לכתוב. אז אם לא הצלחת לכתוב גודל בתים, אז יש לך איזשהו קשל, נכון?
אז זה יכול להשתלט בצפריית error number ולהגיד, אתה צריך יותר מקום, תנקה את הדיסק, זה מתוך צפריית error number, בסדר? תיאורטית אפשר לעשות את זה גם על הריד, כן? אבל זה רק המחשה מסוימת. אבל חשוב לי שתבינו שיש את הכל שכפול של כובד, דוגמה אחד לתוך דוגמה שתיים. עכשיו רק לזכור, מה קורה כאשר אני עושה l-seq?
ל-FD out, שזה דוגמה 2, 0 ו-6 set, מה זה אומר? להעביר את השמן לאן? כאשר כתבתי, מעביר אותו להתחלה, נכון? ואז אני עושה write, כותב the start, כותב כאן, the start, הגודל הוא השרת הווים, שמוליו כולל ה-Base-6, ואז סוגר שני הקבצים, פתאום שמתי כותרת כזאת, שמתי כותרת לדוגמה 2, כדי להזכר מה זה L-SIG. חבר'ה זה ברור, מה שאנו עושה כעת זה להסביר לכם מה אתם צריכים לעשות במטלה.
המטלה מורכבת משני חלקים, חלק אחד, כבוד אתם נדרשים לכתוב קוד בשפה C. שמשווה בין שני קבצים, וחלק שני, שבו אתם מדרשים לעבוד עם החלק הראשון, בסוג של מערכת בדיקה אוטומטית כזאת, אוקיי? אז החלק השני כרגע תשימו בשד, כי עדיין לא דיברנו על זה ולא למדנו את החומר.
אבל בחלק הראשון, שאתם יכולים כבר עכשיו לעשות, למעשה אתם מדרשים לכתוב קודה, תקראו לה קום, שמקבל שני קבצים. פייל 1 ופייל 2. היא מקבלת את שמות הקבצים כארגומנטים לשורת הפקודה. אל תשכחו, עשינו את זה בשבוע שעבר, שימוק ב-rc ו-rc, נכון?
הפקודה מקבלת שמות הקבצים בשורת הפקודה, לא מבקשת מה משתמש. מה שהפקודה הזאת היא עושה, com, היא מחזירה לנו 0 או 1, או מינוס 1. מינוס 1 זה אם יש קשר כלשהו. בתוך הקוד תחזירו מינוס 1, תעשו exit מינוס 1. אבל הפקודה הזאת תחזיר לנו אפס, עם שני כבשים שמים, זהים, ותחזיר לנו אחד עם שני כבשים שונים. איך אני יודע לוודא שהם זהים?
בתוך התוכנית אני פותח fd1 לקובץ 2001, פותח קובץ נושא, f5 דיסקריפטור שלי, עושה open לקובץ השני, עושה open, שני מרשעת read, נכון? כי אני רק קורא מהם, הרי המטרה היא רק להשוות אותם, אז אין צורך לשים מרשעה אחרת. ועכשיו שימו לב למה אני עושה.
אני קורא בלולה, בשני הקבצים ביחד, תו אחר תו. אני עובד עם תווים, אני לא עובד עם אחוזות. קראתי את התו הראשון פה, וקראתי את התו הראשון פה. השתבטתי בריב.
אם שני התווים הללו שונים, אפשר לסגור את הקבצים ולהגיד, הקבצים הם שונים, נכון? אם שני התווים הללו זהים, שווים, עושים עוד איטרציה של הריד, לולה, קוראים את הטו השני, אם הם שונים, נגיד הכבשים שונים, אם הם שווים, ממשיכים קדימה. אתם איתי?
כל פעם תטענו בית בודד, אל תטענו מערך, כי אם אתם תטענו מערך, אתם תצטרכו להשתמש אחרי זה ב-str-compare, כדי להשמות אותם, ואני רוצה שתשתמשו בסיסטם כל בי-בד. אוקיי? אז תקרוא רק בית אחד, כל איטרציה.
עכשיו, מה יקרה כאשר הלולה בשניהם בוא בזמן? תגיע לאנדופייל בשניהם ביחד, אתם יודעים שלאורך כל השרשרת, שני הקבצים שווים, אבל יכול להיות מקרה שבו הקבצים, כאילו שני התאבים הם שווים לאורך כל השרשרת, ואז קובץ אחד מגיע לאנדופייל לפני קובץ אחר, אז המשמעות היא שהקובץ הקסר יותר, הוא ראישה של הקובץ השני, כי הרי מה קורה כאשר הם שווים, ואז אחד מגיע לאנדופייל. הוא רייש של הקבצ השני, זה מעיד על כך שישנה קבצים שונים. אם לאורך כל השאר שיירתם שווים והגעתם בו בזמן ל-end of file ביחד, המשמעות היא שישנה קבצים שווים, שיירתם את התוכנית, מודים.
בכל מקרה, לא נשכוח לשחרר את המשאבים, לסגור את הקבצים, לפני שאתם מסיימים את התוכנית. הדבר הזה תקמפלו ותפעילו אותו. תעשרו לכם.
ארבעה כבשים, תעשו את הכובס ABC, עוד כובס ABC, עוד כובס ABCD ועוד כובס AXY. תדקו שעל שני אלה הוא מחזיר לכם 0 כמשאבים, על שני אלה הוא מחזיר לכם 1 כמשונים, כי כובס אחד הוא ריישך של הכובס אחר. ועל שני אלה הוא מחזיר לכם גם אחד כי הם שונים.
תעשו את הטסטינג של כל הקומבינציות, ולא לשכוח לטפל במקרים שחזר לכם מינוס אחד. מהריד, מהרייט, מהקלוז, מהאופן. אם כן, תחזירו מינוס אחד, יש קשר.
דבר נוסף שחשוב לבדוק, זה שקיבלתם שלושה ארגומנטים. אז לבדוק בתחילת התוכנית ש-RXC. אם הוא שונה משלוש, תודיעו שיש לכם יותר מידה או פחות מידה ארגומנטים. אם הוא כן שווה לשלוש, תריסו את התוכנית. בסדר?
תדקו כל דבר, כל אקספציון שיכול לקרות במעמד הרצת התוכנית. אחרי זה חלק ב', כשאשר אנחנו נדבר עליו בהרחבה בהמשך, אתם תסתמכו על חלק א'. אבל חלק א'תבנו אותו כבר עכשיו, כאשר המידע שלכם מופרש, עדיין אין לכם מה להגיש, אל תגישו את חלק א', כי...
אתם צריכים להגיש את שני החלקים ביחד בעוד חודש, אבל תשמרו את זה בצד, כדי שאחר כך כאשר נדבר על חלק בטוח, בואו נשתמש פה באופן יעדי, ולחסוך מעצמכם כל מיני אומסים מלתיים. חבר'ה שאלות, זה טע ם, זה ברור? כן, ברור, תודה.
אוקיי, תופז? כן, ברור, תודה רבה. אוקיי, אני חושב שנסיים. תעשו, תעשו טובה תעשו את התרגיל הזה בימים הקרובים כי ככל שתחכו אתם תתחילו לשכוח נתונים, תעשו את זה בימים הקרובים שימו את זה בשד עד למועד שאנחנו נתחיל לעבוד על חלק בית בסדר?
זה הכל, שבת שלום ונתראה בעצם תודה רבה חיים, שבת שלום