ניהול הקונסולה עם שיעורי iostream ב- C ++

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

צפוי שהקורא כבר יודע כיצד להשתמש בשורת הפקודה או במסוף. מאמר זה מסביר כיצד לקרוא תווים ומחרוזות מהמקלדת ולשלוח תווים ומחרוזות למסוף (או שורת הפקודה). כל מתכנת C ++ צריך לדעת במאמר זה.

על מנת לקבל קלט מהמקלדת ופלט למסוף, התוכנית צריכה להתחיל עם:

תוכן המאמר

• אובייקטים של זרם צר של iostream הסטנדרטי
• השגת דמויות ומחרוזות מהמקלדת
• הצגה ומחיקה של תווים לפני לחיצה על Enter
• שליחת דמויות ומחרוזות לצג
• טיעונים לתוכנית C ++
• סיכום

אובייקטים של זרם צר של iostream הסטנדרטי

מחלקת ה- iostream, האובייקטים הסטנדרטיים, cout, cin, cerr ו- clog, הועברו מיידי וכבר בספרייה הסטנדרטית. המתכנת פשוט משתמש בהם מבלי לייצר אותם שוב.

עֲלוּת

המשפט הבא בפונקציה הראשית () שולח את הטקסט, זהו פלט. למסוף:

cout הוא אובייקט iostream פלט בספרייה הסטנדרטית, שכבר מופעל.<< is the insertion operator, which sent the bytes, This is output. to the output stream object, cout. When the statement is executed, the text appears on the screen.

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

endl הוא משתנה מוגדר מראש. ניתן לאלץ את תוכן המסך לשורה הבאה באמצעות:

בעזרת ' n', ייתכן שכל שורות הטקסט עדיין לא יופיעו על המסך באופן מיידי. endl שוטף את כל שורת הטקסט למסך.

הערה: מחרוזת שנשלחת ל- cout נמצאת במרכאות כפולות, בעוד שתו שנשלח נמצא במרכאות בודדות. ניתן לשלוח סדרה של מחרוזות וסימניות בהצהרה אחת, ולכל אחת מקדימה<< . All that will appear in one line at the output if ‘ ’ is not in the series.

ג'ין

cin הוא אובייקט הקלט הסטנדרטי של iostream, שכבר מופעל, וזמין בספרייה הסטנדרטית. שקול את קטע הקוד הבא בפונקציה הראשית ():

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

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

שימו לב להצהרה:

המילה הראשונה מחולקת ל- txt, לידה, והאחרונה ל- ft אם הקלט היה,

אז הפלט לפי קטע הקוד יהיה,

cerr

התוכנית הבאה מכילה שגיאה:

המשפט הראשון העיקרי () אינו נכון. אם שם הקובץ עם הקוד הוא temp.cc וקובץ ההפעלה המתקבל נקרא temp, אז הפקודה g ++ הבאה תשלח את הודעת השגיאה של המהדר לקובץ, error.txt:

אם הקובץ error.txt אינו קיים, הוא ייווצר. שים לב למקטע 2> error.txt של הפקודה g ++.

המסך הוא יעד הפלט הסטנדרטי, והוא גם יעד השגיאה הסטנדרטי. אם 2> error.txt מושמט מהפקודה g ++, הודעת השגיאה של המהדר תישלח ליעד השגיאה הסטנדרטי, שהוא עדיין המסך (צג).

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

לִסְתוֹם

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

אם טקסט הקלט הוא 'קלט_טקסט', אז סתימה תציג מחדש 'קלט_טקסט' למסך.

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

שים לב לשימוש בפונקציה, freopen () וטיעוניה. הטענה הראשונה שלו היא שם קובץ היומן. אם הקובץ אינו קיים, הוא ייווצר. הטענה השנייה שלה היא 'w' עבור 'לכתוב'. הטענה השלישית שלו היא stdout לפלט סטנדרטי. המשפט השני בפונקציה הראשית () משתמש ב- cout כדי לשלוח את טקסט הרישום לקובץ. הערה: קוד הקלט בפועל לא הוצג בתוכנית זו.

השגת דמויות ומחרוזות מהמקלדת

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

לאובייקט cin יש שיטות, שמקטע זה עוסק בהן.

קריאת הדמות הראשונה

get (char_type & c):
קטע הקוד הבא מראה כיצד לקרוא את התו הראשון, מתוך מאגר זרם הקלט:

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

גם אם המשתמש הקליד יותר מתו אחד, התו הראשון ייקח על ידי קטע הקוד.

לקבל():
get () ללא ארגומנט, מחזיר את קוד ASCII העשרוני. שקול את קטע הקוד הבא:

אם הקלט הוא 'asdfg', 97 יוחזר, שהוא קוד ה- ASCII העשרוני עבור 'a'.

get (char_type* s, streamsize n)

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

אם הקלט הוא 'אנשים נהדרים', אז הפלט יהיה 'פאו גדול', של 9 תווים ולא 10. תו המחרוזת NUL ( 0) תופס את המיקום העשירי בארגומנט get. לכן, כדי שיהיו 9 תווים ב- str, גודל האחסון שלו חייב להיות לפחות 10, והארגומנט get () צריך להיות 11. אם כל קו הקלט רצוי, אז מספר אחסון המחרוזת חייב להיות לפחות המספר של תווים שהוקלדו, פלוס 1. לכן, אם הקלדה של 12 תווים לכל השורה, המספר צריך להיות 13 עבור גודל האחסון מחרוזת (str) ו -13 עבור הארגומנט get (). שים לב שמרחב אחד נספר כדמות אחת.

get (char_type* s, streamsize n, char_type delim)
אפשר לחלץ מחרוזת משנה, שתוחמת מימין, על ידי הופעה ראשונה של דמות מסוימת, או על ידי מידת הזרם של תת-המחרוזת, שבאה קודם כל. אם טקסט הקלט לקוד הבא הוא אנשים נהדרים, אז יחולץ נהדר:

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

אם טקסט הקלט לקוד הבא הוא אנשים נהדרים, אז יחולץ gr:

המופע הראשון של 'e', ​​מגיע קודם לפני המיקום העשירי.

קבלת כל דמויות השורה

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

הליהוק עם (char) ממיר כל מספר עשרוני לתו ASCII המתאים.

לְהָצִיץ()

פונקציות החברים get () אינן קוראות רק את הדמות הבאה; הם מסירים אותו ממאגר הזרם. עם זאת, פונקציית ה- peek () member simple קוראת את התו הבא (מתחיל מהראשון) מבלי להסיר אותו מהמאגר. בקוד הבא, כל תו נקרא לראשונה עם הפונקציה peek () לפני הסרתו, על ידי הפונקציה get (). כל מה שקורה לאחר שהמשתמש לוחץ על מקש Enter:

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

הצגה ומחיקה של תווים לפני לחיצה על Enter

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

שליחת דמויות ומחרוזות לצג

אובייקט cout הוא אובייקט זרם פלט, שכבר מופעל ומופיע בספרייה הסטנדרטית C ++. cout הוא האובייקט העיקרי המשמש לשליחת תווים ומחרוזות לצג. זה נעשה עם אופרטור ההכנסה,<< . With the cin object, the text is obtained line-by-line. With the cout object, the text is added onto the same line until ‘ ’ or endl is encountered.

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

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

הפלט הוא:

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

הפלט הוא 'כמה מילים'.

טיעונים לתוכנית C ++

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

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

יש כאן 5 טיעונים: מאמרים, 3, ספר, עט ובית גדול

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

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

כעת, בתחביר הפונקציה הראשית (), argc הוא מספר הארגומנטים לתוכנית, בתוספת 1. במקרה זה, ישנם 5 ארגומנטים לתוכנית. אז, argc הוא 6. בתחביר, argv [argc] הוא מערך של מצביעים למחרוזות. הערך הראשון עבור מערך זה ב- argv [0] ניתן על ידי המהדר. הוא מצביע על שם קובץ התוכנית. שאר הערכים הם מצביעים לארגומנטים של התוכנית בסדר המשתמש שהוקלד. גודל המערך הזה הוא argc. במקרה זה הגודל הוא 1 + 5 = 6.

נניח כי בעת הידור התוכנית הבאה נקראת temp:

שים לב כאן, כי המערך 'char*argv [argc]', הוכרז כ'צ'ר ** argv '.

אם תוכנית זו מופעלת באמצעות פקודת הטרמינל,

אז הפלט יהיה:

שים לב שנתיב הספרייה נכלל בשם קובץ ההפעלה.

כמו כן, שים לב כי בהפעלת התוכנית (קריאת התוכנית), הערך עבור argc לא נשלח.

סיכום

בכיתה iostream יש ארבעה אובייקטים חשובים שהם cout, cin, cerr ו clog. cin הוא אובייקט קלט, בעוד השאר הם אובייקטים של פלט. בזמן שתוכנית פועלת, הקלט לתוכנית שונה מזו שבה התוכנית אמורה להתחיל לפעול. כאשר תוכנית מתחילה לפעול, קלט לתוכנית מצטרף לפקודה להפעלת התוכנית, מופרדת ברווחים.