היררכיית מחלקות זרם
מחלקה C++ מורכבת משיטות הנדרשות לניהול ולניהול הנתונים שהיא מכילה.
float, doubles ו-classs הם סוגי נתונים הדומים ל-int. משתנה ייחודי עם מחלקה כסוג הנתונים שלו מכונה אובייקט C++. לאובייקטים המיוחדים שצוינו מראש 'cin' ו-'cout' יש מחלקות שונות כסוגי הנתונים שלהם.
הנתונים שנכתבו ל-'cout' או נקראים מ-'cin' הם דוגמאות לזרימת נתונים לתוך או מחוץ לתוכניות ב-C++. נכון לעכשיו, אנו שוקלים את ארבעת השיעורים הבאים עבור השיעור הזה:
הזרם את זה
זרם קלט זה עשוי לשרת כל מטרה. איור של istream הוא cin.
אוסטרים
זהו זרם פלט עם מספר שימושים. Ostreams מגיעים בצורות של cout ו-cin.
אם זרם
זהו זרם של קבצי קלט.
של זרם
זהו זרם של קבצי פלט. ירושה הוא מושג שנמצא בשימוש רב בתכנות מונחה עצמים, כמו ב-C++, שבו מחלקות מסוימות מקבלות את המאפיינים של מחלקות אחרות שכבר נוצרו. כיתות האבות הופכות אז להתמחויות של עצמם באמצעות הכללת תכונות חדשות.
אם כיתת זרם
ניתן להתייחס ל-ifstream באותו אופן כמו istream, וזה מה שהוא.
מכיתה זרם
באותו אופן שבו ifstreams מתפקד, אבל עם פלט במקום קלט, אוסטרים הוא זרם קובץ פלט. ב-ofstream נעשה שימוש באותו אופן כמו cout לאחר שנבנה, נפתח ומאומת שאין בו שגיאות.
שיעור Ios
מכיתה זו ירדו כל כיתות הזרם. זרמי קלט ופלט הם שני סוגים שונים.
הוא מגדיר את חלקי הזרם שאינם תלויים במצב הקלט או הפלט של הזרם בבסיס ה-ios.
בניגוד לאיברים הנדונים בבסיס ios, האיברים התלויים בפרמטרי התבנית מתוארים בחלק זה.
זרם (קלט)
בשל המורכבות של ספריית iostream, לא נוכל לכסות אותה במלואה בשיעורים אלה. עם זאת, נדגיש את הפונקציות בהן נעשה שימוש רב. בחלק זה, נסתכל על מחלקת הקלט ממגוון זוויות (istream).
למדנו שמפעיל החילוץ (>>) ישמש לרכישת הנתונים מזרם קלט.
זרם
בשפת התכנות C++, זרם הקלט מטופל על ידי מחלקת istream. הקלט נקרא ומובן כסדרה של תווים באמצעות אובייקטי זרם קלט אלה. הקלט מטופל על ידי ה-cin.
כיתות חברים
istream::sentry
מחלקה המבצעת משימות רבות ובכל פעם מתבצע הליך קלט. המשמיד שלה אינו נדרש לבצע פעולות כלשהן. עם זאת, יישומים עשויים לבצע משימות אתחול או ניקוי נוספות בזרם המשותפות לכל פעולות הקלט באמצעות יצירה והשמדה של אובייקטי זקיף.
פונקציות
istream::gcount
נותן את ספירת התווים שהתקבלה מפעולת הקלט הלא מעוצבת האחרונה של האובייקט. נהלי הקלט הלא מעוצבים - get, getline, ignore, peek, read, read some, putback ו-unget- משנים את הערך המוחזר על ידי פונקציה זו. עם זאת, זכור שקריאת הצצות, החזרה או unget אינה מחלצת אף תווים. כתוצאה מכך, הספירה תמיד תחזיר 0.
istream::get
הדמות הבודדת מוציאה דמות אחת מהזרם. התו מוגדר כערך הארגומנט או מוחזר (חתימה ראשונה) (חתימה שנייה).
מחרוזת C: אם התו התוחם קיים, הוא לא יוסר מרצף הקלט במקום זאת נשמר בתור התו הבא שיש לאחזר מהזרם אם הוא קיים.
istream::getline
מסיר תווים מהזרם כקלט לא מעוצב ושומר אותם כמחרוזת c במשתנה 's' עד שהתו שחולץ הופך לתו המפריד או שתווים 'n' נכתבו ל-'s'. בנוסף, השיטה תפסיק לחלץ תווים אם היא תגיע לסוף הקובץ.
באופן פנימי, הפונקציה יוצרת אובייקט לפני גישה לרצף הקלט. לבסוף, הוא הורג את האובייקט לפני החזרה, מחלץ תווים מאובייקט מאגר הזרם המשויך לו (בהנחה שהכל בסדר) כאילו הוא מבצע את אחת משיטות החברים שלו, sbumpc או sgetc.
istream::תעלם
תווים נלקחים מרצף הקלט ומושלכים אחד בכל פעם עד שמוציאים תווים 'n' או אחד משווה שווה לדלים. בנוסף, אם מגיעים לסוף הקובץ, הפונקציה עוצרת את חילוץ התווים. הפונקציה מגדירה את הדגל 'eofbit' אם היא מגיעה לנקודה זו מוקדם מדי (לפני חילוץ n תווים או גילוי דלים).
לפני הגישה לרצף הקלט, הפונקציה בונה אובייקט זקיף באופן פנימי (עם noskipws יהיה נכון). לבסוף, הוא הורג את אובייקט הזקיף לפני החזרה, מחלץ תווים מאובייקט מאגר הזרם המשויך לו (בהנחה שהכל בסדר) כאילו מבצע את אחת משיטות החבר שלו: sbumpc או sgetc.
istream::operator >>
אופרטור החילוץ (>>) מחיל אופרטור זה על זרם קלט. יש לו יותר מדי חברים כפונקציה.
סוג אריתמטי
תווים נשלפים מהזרם ומנתחים אותם ברצף כדי לייצג ערך מהסוג הנכון, שנשמר לאחר מכן כערך 'val'. לפני הגישה לרצף הקלט, הפונקציה בונה אובייקט זקיף באופן פנימי (noskipws יהיה false). אם הכל מסתדר היטב, הוא מפעיל את num get::get כדי להשלים את תהליכי החילוץ והניתוח תוך שינוי דגלי המצב הפנימיים של הזרם. חפץ הזקיף מושמד בסופו של דבר לפני שהוא עוזב.
הפונקציה מייצרת באופן פנימי אובייקט זקיף לפני קריאת רצף הקלט, היא נתפסת כמבצעת קלט מעוצב. לבסוף, הוא הורג את אובייקט הזקיף לפני החזרה, מחלץ תווים מאובייקט מאגר הזרם המשויך לו (בהנחה שהכל בסדר) כאילו מבצע את אחת משיטות החבר שלו, sbumpc או sgetc.
מניפולטורים
ה-pf (*זה) נקרא, כאשר pf יכול להיות מניפולטור. מניפולטורים הם שגרות שנוצרו במיוחד כדי להיקרא כאשר המפעיל הזה מופעל. רצף הקלט אינו מושפע מהליך זה ולא חולצים תווים.
istream::putback
התו המשוחזר מנסה להזיז את הסמן למטה תו אחד בזרם, כך שניתן יהיה לחלץ שוב את התו האחרון שאוחזר מהזרם על ידי פעולות קלט.
לפני הגישה לרצף הקלט, הפונקציה בונה אובייקט זקיף באופן פנימי. לאחר מכן, הוא קורא ל-sputbackc(c) על אובייקט מאגר הזרם המשויך לו (אם טוב). חפץ הזקיף מושמד בסופו של דבר לפני שהוא עוזב.
istream::read
קרא בלוק נתונים:
התווים 'n' נלקחים מהזרם ואז מאוחסנים במערך שאליו מצביע 's'. פונקציה זו רק משכפלת גוש נתונים מבלי לבדוק את תוכן הנתונים או להוסיף תו ריק בסוף.
בתוך הפונקציה, אובייקט זקיף נוצר תחילה לפני הגישה לרצף הקלט. לבסוף, הוא הורג את אובייקט הזקיף לפני החזרה, מחלץ תווים מאובייקט מאגר הזרם המשויך לו (בהנחה שהכל בסדר) כאילו מבצע את אחת משיטות החבר שלו: sbumpc או sgetc.
ספירת החברים המתקשרים תחזיר את המספר הכולל של התווים שפונקציה זו קראה ואוחסנה כהלכה.
istream::readsome
פונקציה זו תלויה בפעולה הפנימית של אובייקט מאגר הזרם הספציפי המקושר לזרם, שהתנהגותו מוגדרת ברובה למימוש עבור מחלקות סטנדרטיות.
בתוך הפונקציה, אובייקט זקיף נוצר תחילה לפני הגישה לרצף הקלט. לאחר מכן (אם זה מצליח), הוא קורא לפונקציית החבר בשימוש של אובייקט מאגר הזרם כדי לקבוע כמה תווים זמינים כעת לפני קורא 'sbumpc' כדי לחלץ עד מספר זה של תווים (או sgetc). חפץ הזקיף מושמד בסופו של דבר לפני שהוא עוזב.
istream::seekg
המיקום בשורת הקלט קובע היכן יימשך התו הבא מזרם הקלט. לפני קריאת רצף הקלט, הפונקציה בונה באופן פנימי אובייקט זקיף. לאחר מכן (אם בסדר), הוא מבצע אחת משתי קריאות לאובייקט המאגר המתאים: pubseekpos (1) או pubseekoff (2), (אם יש). לבסוף, הוא מוחק את פריט הזקיף ויוצא.
istream::sync
יישר את מאגר הקלט:
מביא לסנכרון את רצף הקלט המבוקר של מאגר הזרם המקושר. היישום הספציפי של אובייקט מאגר הזרם המחובר לזרם קובע את הפרטים של הפעולה.
istream::telg
השג את המיקום של רצף הקלט:
זה נותן את המיקום של הדמות הנוכחית בזרם הקלט. לאחר מכן הפונקציה מחזירה -1. אם החבר נכשל, הוא מחזיר אמת.
זה מחזיר את rdbuf()->pubseekoff אם לא (0,cur,in). חפץ הזקיף מושמד בסופו של דבר לפני שהוא עוזב.
istream::unget
הסר תו:
מנסה להזיז את הסמן למטה תו אחד בזרם כך שניתן יהיה לחלץ שוב את התו האחרון שאוחזר מהזרם על ידי פעולות קלט.
לא חבר
מפעיל >> (istream)
אופרטור החילוץ (>>) מספק קלט מעוצב עם פעולה זו כאשר הוא מוחל על זרם קלט.
תו אחד: רצף התווים מוציא ממנו את התו הבא ומאחסן אותו כערך 'c'. תהליך חילוץ התווים מ- הוא ואחסוןם ב-s, כמחרוזת c, נעצר (אם הרוחב אינו אפס) כאשר נתקלים בתו רווח או חילוץ תווים (רוחב ()-1).
חילוץ של rvalue: מאפשר חילוץ מ-rvalue istream אובייקטים, אשר יש לו אותה תוצאה כמו חילוץ מ-lvalues: הוא קורא is>>Val.
דוגמה 1
במקרה זה, נבדוק כיצד נוכל לקבל ערך כלשהו מהמשתמש ולאחר מכן נציג אותו כתוצאה על המסך.
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
int לא ;
cout << 'בבקשה הכנס מספר ' ;
אֲכִילָה >> לא ;
cout << 'הערך שהוזן הוא:' << לא << ' \n ' ;
}
נכלול את קובץ הכותרת
המשתמש יזין כל ערך אקראי לאחר שהטקסט הזה הוצג על המסך. לאחר מכן, הצהרת 'cin' הייתה מנוצלת. פקודה זו דורשת מהמשתמש לציין את הערך. המספר שהוזן של המשתמש יישמר במשתנה. הערך שסופק על ידי המשתמש יוצג על המסך באמצעות הפקודה 'cout'.
דוגמה 2
במקרה זה, נראה כיצד אנו מקבלים שם כלשהו מהמשתמש ולאחר מכן מציגים אותו על המסך כתוצאה.
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
לְהַשְׁחִיר שֵׁם [ 125 ] ;
cout << 'הזן את שמך' << endl ;
אֲכִילָה >> ws ;
אֲכִילָה . getline ( שֵׁם, 125 ) ;
cout << שֵׁם << endl ;
לַחֲזוֹר 0 ;
}
נשלב את קובץ הכותרת
פקודה זו לוקחת את הערך מהמשתמש. השם שסופק יאוחסן במשתנה 'ws'. כאן, שוב, נשתמש בפקודה 'cin'. בתוך פקודה זו, הפונקציה getline() מוחלת. פונקציה זו מכילה את הפרמטר הכולל את השם שהוזן על ידי המשתמש ואת אורך השם. הפקודה 'cout' תשמש כדי להציג את השם שסופק על ידי המשתמש. כדי לסיים את הקוד, תשתמש בפקודה 'החזר 0'.
סיכום
ראשית, דיברנו על מה זה פונקציות istream C++. לאחר מכן אנו רואים כמה פונקציות והגדרות חשובות שהוזכרו. במאמר זה, הרצנו קודים שונים המכילים מגוון של פונקציות istream. בקוד הראשון, אנחנו לוקחים כל מספר מהמשתמש ומציגים את המספר הזה על המסך. בשני, המשתמש הזין את השם והדפיס את השם הזה על המסך.