הבנת רצפי בריחה
רצפי בריחה ב-C++ מאפשרים לתווים שמבצעים את פונקציות הבקרה בתוך המחרוזות להיות חלק מהטקסט מבלי לטעות כקוד. אחת המלכודות הנפוצות למתחילים היא הבלבול לגבי הכללת מרכאות בתוך מחרוזת מילולית. לדוגמה, שורת הקוד הבאה תגרום לשגיאת קומפילציה מכיוון שהמרכאות סביב '\t escape sequence' מסיימות את המחרוזת בטרם עת:
מחרוזת txt = 'מאמר זה עוסק בחקר ה' \t רצף בריחה' בעזרת דוגמאות.' ;כדי לתקן זאת בתוכנת C++, נשתמש ב-Slash האחורי '\' בתור תו בריחה כדי לאותת למהדר שלתו הבא יש פרשנות מיוחדת. הנה איך זה נעשה:
מחרוזת txt = 'מאמר זה עוסק בחקר\' \\ t escape sequence\' בעזרת דוגמאות.' ;
צולל לתוך התו המיוחד (\t) ב-C++
הרצף '\t' הוא יותר מסתם כלי מרווח. הוא מייצג תו טאב שגורם לסמן לעבור לתחנת הטאב הבאה. זה שימושי במיוחד ליצירת תצוגות טקסט מעוצבות בצורה מסודרת ביישומי מסוף. מעבר ל-'\t', C++ תומך במגוון רצפי בריחה למטרות שונות - לדוגמה, '\n' יוצר שורה חדשה. עם זאת, במאמר זה, נתמקד אך ורק ברצף הבריחה '\t' ב-C++ על ידי מתן דוגמאות כדי להדגים את המטרה והשימוש שלו. זה ייתן לך את הידע להשתמש בכרטיסייה האופקית במשימות התכנות שלך ביעילות. הבה נעבור לדוגמאות כדי להבין את פעולתו של רצף הבריחה '\t' בתוכנת C++.
דוגמה 1:
דוגמה הקוד C++ הבאה כוללת תוכנית פשוטה המשמשת להדפסת הטקסט למסוף. עיין בקוד הבא ואנו נסביר אותו לאחר מכן:
#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
cout << 'זו שורת טקסט ראשונה.' << endl ;
cout << 'זוהי שורת הטקסט השנייה. \t ' ;
cout << 'אחרי הקו הזה מופיע א \\ לא רצף בריחה.' ;
לַחֲזוֹר 0 ;
}
להלן פירוט של כל חלק בקוד:
#include
שימוש במרחב שמות std; – קוד זה מאפשר לך להשתמש בשמות הכלולים בספרייה הסטנדרטית מבלי להקדים אותם עם 'std::'. לדוגמה, אתה יכול לכתוב 'cout' במקום 'std::cout'.
int main() { – זוהי ההצהרה ונקודת הכניסה של הפונקציה הראשית עבור כל תוכנית C++. ה'int' לפני 'main' מציין בדרך כלל שהפונקציה מחזירה ערך שלם.
cout << 'זוהי שורת הטקסט הראשונה.'<
cout << 'זוהי שורת הטקסט השנייה.\t'; – כאן, התוכנית מוציאה מחרוזת נוספת שהיא 'זוהי שורה שנייה של טקסט.\t'. שימו לב ל-'\t' בסוף. כאשר מודפס למסוף, הוא מוסיף חלל טאב אופקי מיד אחרי הטקסט.
cout << 'שורה זו מלווה ברצף בריחה \\t.'; – בשורה זו, התוכנית מדפיסה 'שורה זו מלווה ברצף בריחה \t'. רצף הבריחה '\\t' משמש כדי לכלול '\t' באופן מילולי בפלט, מכיוון שהלוכסן האחורי '\' נמלט בעצמו על ידי קו נטוי אחורי אחר כך ש-'\t' עצמו מודפס במקום לשונית אופקית.
החזר 0; – זה מסמן את סוף הפונקציה הראשית ומחזיר אפס מה שמסמל ביצוע מוצלח של התוכנית. כאשר תוכנית זו פועלת, הפלט נראה כך:
דוגמה 2:
כעת, הבה נסתכל על דוגמה נוספת ונראה את הקסם של דמות הבריחה '\t'. הדוגמה היא תוכנית C++ קלה הכוללת ספריית זרם קלט-פלט סטנדרטית ומשתמשת במרחב השמות הסטנדרטי. התוכנית נועדה להדפיס טבלה מעוצבת של שמות והעיר והמדינה המשויכים אליהם לקונסולה.
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
cout << 'שֵׁם \t | \t עִיר \t | \t מדינה' << endl ;
cout << '--------------------------------------------------------' << endl ;
cout << 'אליס \t | \t בייג'ין \t | \t חרסינה' << endl ;
cout << 'בוב \t | \t אוסטין \t | \t אמריקה' << endl ;
cout << 'קת'ה \t | \t פריז \t | \t צָרְפַת' << endl ;
cout << 'דייוויד \t | \t דרבן \t | \t דרום אפריקה' << endl ;
cout << '--------------------------------------------------------' << endl ;
לַחֲזוֹר 0 ;
}
להלן פירוט של הקוד:
שוב, #include
שימוש במרחב שמות std; - הוא מאפשר להשתמש בישויות ממרחב השמות 'std' ללא צורך להקדים אותם עם 'std::'.
ה int main() { היא נקודת הכניסה של כל תוכנית C++. כאשר אתה מפעיל את התוכנית, הביצוע מתחיל מכאן.
בתוך הפונקציה הראשית, יש לנו את הדברים הבאים:
cout << 'Name\t|\tCity\t|\tCountry'<
cout << “———————————————“<
ארבעת קווי הגזרה הבאים מדפיסים כל אחד שורה של הטבלה. שורות אלה עוקבות אחר אותו פורמט עם כרטיסיות והן חלק מיצירת פלט הטבלה. לאחר כל שורת נתונים, 'endl' משמש כדי לעבור לשורה הבאה. השורה האחרונה מדפיסה שוב את קו המפריד כדי לציין את סוף נתוני הטבלה.
החזר 0;: – שורה זו מציינת את הביצוע המוצלח של התוכנית. ערך החזרה של 0 מציין הצלחה.
כאשר תוכנית זו מורכבת ומופעלת, הפלט יופיע כטבלה בקונסולה עם שמותיהם, הערים והמדינות של האנשים אשר מיושרים בצורה מסודרת בעמודות המופרדות על ידי פסים אנכיים (|) וכרטיסיות. ראה את הפלט הבא:
הערה: זכור שהיישור בפועל של הטקסט במסוף תלוי ברוחב של הגדרות הכרטיסיות במסוף או במסוף שלך, מה שעלול לגרום להופעות טבלה שונות במערכות שונות.
דוגמה 3:
תוכנית C++ פשוטה אך מעניינת זו משתמשת ברצפי הבריחה של הכרטיסייה '\t' כדי להדפיס צורת יהלום על המסך. קוד זה משנה את גודל היהלום בהתבסס על משתנה 'יהלום' המציין את הגודל ומייצג את מספר הקווים ממרכז היהלום לחלק העליון או התחתון שלו. בדוק את הקוד הבא:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
int יהלום = 3 ;
ל ( int אני = 1 ; אני <= יהלום ; ++ אני ) {
ל ( int י = 0 ; י < יהלום - אני ; ++ י ) {
cout << ' \t ' ;
}
ל ( int י = 0 ; י < 2 * אני - 1 ; ++ י ) {
cout << '* \t ' ; }
cout << endl ;
}
ל ( int אני = יהלום - 1 ; אני >= 1 ; -- אני ) {
ל ( int י = 0 ; י < יהלום - אני ; ++ י ) {
cout << ' \t ' ;
}
ל ( int י = 0 ; י < 2 * אני - 1 ; ++ י ) {
cout << '* \t ' ; }
cout << endl ;
}
לַחֲזוֹר 0 ;
}
כפי שניתן לראות, תוכנית זו מורכבת משני חלקים: האחד מדפיס את החצי העליון של היהלום והשני מדפיס את החצי התחתון. המחצית העליונה של היהלום מודפסת על ידי הפלט תחילה של מספר הולך ופוחת של כרטיסיות כדי ליצור את ההזחה, ולאחר מכן מספר גדל והולך של כוכביות '*', מופרדות באמצעות כרטיסיות. זה מטופל בתוך לולאת 'ל' הראשונה.
החצי התחתון מודפס באופן דומה, אך כשהלולאות חוזרות לאחור כדי להקטין את מספר הכוכביות ולהגדיל שוב את השקע, וליצור את החצי התחתון של היהלום. זה מטופל בלולאת 'עבור' השנייה.
כאשר מפעילים את התוכנית עם 'יהלום= 3', הפלט נראה כמו יהלום אשר מרוכז על המסך בשל תווי הכרטיסייה. ראה את הפלט של תוכנית מסוימת זו:
שים לב שהמראה בפועל עשוי להשתנות בהתאם למסוף או למסוף שבהם אתה משתמש, מכיוון שרוחב הכרטיסיות עשוי להשתנות.
סיכום
רצפי בריחה ב-C++ הם כלי רב עוצמה לייצוג התווים שאינם ניתנים לתצוגה בקלות בחלון פלט סטנדרטי. בין הרצפים הללו, הכרטיסייה האופקית, המסומנת על ידי '\t', שימושית במיוחד להוספת הרווחים האופקיים המבוקרים בטקסט. באמצעות '\t', המתכנתים יכולים ליישר את פלט הטקסט שלהם, לשפר את הקריאה ולבנות את הנתונים באופן שיטתי. תו זה מחקה לחיצה על מקש 'טאב' במקלדת, ומקדם את הסמן למיקום הכרטיסייה הבאה. במאמר זה, חקרנו את הפונקציונליות של רצף הבריחה '\t' בשפת C++, תוך הדגשת היישום שלו עם דוגמאות פשוטות ומעשיות כדי להמחיש את התנהגותו.