כיתה וחפצים
מחלקה היא קבוצת משתנים ופונקציות שעובדים יחד; כאשר למשתנים אין ערכים שהוקצו להם. כאשר מוקצים ערכים למשתנים, המחלקה הופכת לאובייקט. ערכים שונים הניתנים לאותה המעמד גורמים לאובייקטים שונים; כלומר, אובייקטים שונים הם אותו מעמד עם ערכים שונים. אומרים שיצירת אובייקט ממעמד מייצגת את האובייקט.
השם, מחרוזת, הוא מחלקה. לאובייקט שנוצר ממחלקת המחרוזות יש שם מתכנת שנבחר.
יש צורך בפונקציה השייכת למחלקה כדי לייצר אובייקט מהמחלקה. ב- C ++, לפונקציה הזו יש אותו שם כמו המחלקה. לאובייקטים שנוצרו (מיוצרים) מהכיתה יש שמות שונים שניתן להם על ידי המתכנת.
יצירת אובייקט ממעמד פירושה בניית האובייקט; זה אומר גם להזדהות.
תוכנית C ++ המשתמשת במחלקת המחרוזות, מתחילה בשורות הבאות בראש הקובץ:
#לִכלוֹל#לִכלוֹל
באמצעות מרחב שמות std;
השורה הראשונה מיועדת לקלט/פלט. השורה השנייה היא לאפשר לתוכנית להשתמש בכל התכונות של מחלקת המחרוזות. השורה השלישית מאפשרת לתוכנית להשתמש בשמות במרחב השמות הסטנדרטי.
עומס יתר של פונקציה
כאשר לשתי חתימות פונקציות שונות או יותר יש אותו שם, אומרים כי שם זה טעון יתר. כאשר נקראת פונקציה אחת, מספר וסוג הארגומנטים קובעים איזו פונקציה מבוצעת.
בְּנִיָה
חוּט()
המשפט הבא בונה מחרוזת באורך אפס ללא תו.
זה מתחיל בשם המחלקה (סוג האובייקט), מחרוזת. לאחר מכן מופיע שם מחרוזת האובייקטים, שניתן על ידי המתכנת. מפעיל ההקצאה עוקב אחריו; ואז שמו של הקונסטרוקטור עם סוגריים ריקים. כאן, strCol הוא האובייקט המייצב עם כל חברי הנתונים (מאפיינים) ופונקציות החברים (שיטות).
מחרוזת (str)
זה דומה לאמור לעיל, אבל לוקח מחרוזת מילולית או מזהה כארגומנט, בבנאי. ההצהרה הבאה ממחישה זאת:
בנייה עם רשימת אתחול
הקוד הבא ממחיש זאת:
string strCol=חוּט({'אני','','ה','אוֹ','v','וגם','','ו','אוֹ','אתה',' 0'});המחרוזת מילולית היא אני אוהב אותך. שים לב לתו nul בסוף רשימת האתחול.
מחרוזת (str, n)
זה יוצר אוסף מחרוזות, של n התווים הראשונים של מחרוזת אחרת. הקוד הבא ממחיש זאת:
לְהַשְׁחִירעמ[] = 'אני אוהב אותך';string strCol=חוּט(עמ, 6);
עֲלוּת<<strCol<< ' n';
הפלט הוא אני אוהב עם 6 הדמויות הראשונות מתוך אני אוהב אותך. זכור: המרחב היחיד הוא דמות.
מחרוזת (str, pos, n)
זה יוצר אוסף מחרוזות של n תווים, המתחיל במיקום האינדקס המבוסס על אפס, pos, של מחרוזת אחרת. הקוד הבא ממחיש זאת:
לְהַשְׁחִירעמ[] = 'אני אוהב אותך';string strCol=חוּט(עמ, 2, 4);
עֲלוּת<<strCol<< ' n';
הפלט הוא, אהבה.
בשני המקרים שלעיל, אם n גדול מגודל המחרוזת, חריג החוץ_מטווח נזרק - ראה מאוחר יותר.
מחרוזת (n, 'c')
יוצר אוסף של n תווים, כאשר כל הדמויות זהות. לשקול,
string strCol=חוּט(5,'וגם');עֲלוּת<<strCol<< ' n';
הפלט הוא, eeeee, 5 e's.
הקצאת מחרוזת
ניתן להקצות מחרוזת כדלקמן, לאחר שהצהיר על שתי המחרוזות:
string strCol1=חוּט('אני אוהב אותך');string strCol2;
strCol2=strCol1;
עֲלוּת<<strCol2<< ' n';
הפלט הוא, אני אוהב אותך.
בנייה עם Iterator
איטרטור מספק ייצוג כללי של סריקה, באמצעות ערכי אוסף. תחביר ליצירת מחרוזת עם איטרציה, הוא:
תבנית<class InputIterator>מחרוזת בסיסית(InputIterator מתחילים,סוף InputIterator, קבועמקצה&
ל=מקצה());
זה בונה מחרוזת לטווח [התחל, סיים) - ראה פרטים בהמשך.
הורס מחרוזת
כדי להרוס מחרוזת, פשוט תן לה לצאת מהיקף.
גישה למרכיבי מחרוזת מחרוזת
אובייקט מחרוזת מיידי יכול להיות בעל תסריט משנה (אינדקס) כמו מערך. ספירת המדדים מתחילה מאפס.
stringName [i]
String string operation [i] מחזיר הפניה לתו (אלמנט) ב- iהאינדקס אוסף הדמויות. פלט הקוד הבא v:
string strCol=חוּט('אני אוהב אותך');לְהַשְׁחִירצ'=strCol[4];
עֲלוּת<<צ'<< ' n';
stringName [i] קבוע
פעולת stringName [i] const מבוצעת במקום stringName [i] כאשר אובייקט המחרוזת הוא אובייקט קבוע. הוא משמש בקוד הבא למשל:
קבועstring strCol=חוּט('אני אוהב אותך');לְהַשְׁחִירצ'=strCol[4];
עֲלוּת<<צ'<< ' n';
הביטוי מחזיר התייחסות קבועה ל- iהאלמנט של אובייקט המחרוזת. לא ניתן לשנות אף אחד מרכיבי המחרוזת.
הקצאת תו עם כתב משנה
ניתן להקצות תו לאובייקט מחרוזת שאינו קבוע, כדלקמן:
string strCol=חוּט('אני מתקשר');strCol[2] = 'ו';
עֲלוּת<<strCol<< ' n';
הפלט הוא שאני נופל. 'C' השתנה ל- 'f'.
stringName.at (i)
stringName.at (i) דומה ל- stringName [i], אך stringName.at (i) אמין יותר. הקוד הבא מראה כיצד יש להשתמש בו:
string strCol=חוּט('אני אוהב אותך');לְהַשְׁחִירצ'=strCol.בְּ-(4);
עֲלוּת<<צ'<< ' n';
at () היא למעשה פונקציית חבר במחלקת מחרוזות.
stringName.at (i) const
stringName.at (i) const דומה ל- stringName [i] const, אך stringName.at (i) const הוא אמין יותר. stringName.at (i) const מבוצע במקום stringName.at (i) כאשר אובייקט המחרוזת הוא אובייקט מחרוזת קבוע. הוא משמש בקוד הבא, למשל:
קבועstring strCol=חוּט('אני אוהב אותך');לְהַשְׁחִירצ'=strCol.בְּ-(4);
עֲלוּת<<צ'<< ' n';
at () const היא למעשה פונקציית חבר במחלקת מחרוזות.
הקצאת ערך באמצעות הפונקציה at ()
ניתן להקצות ערך לאובייקט מחרוזת שאינו קבוע, עם הפונקציה at (), כדלקמן:
string strCol=חוּט('אני מתקשר');strCol.בְּ-(2) = 'ו';
עֲלוּת<<strCol<< ' n';
הפלט הוא שאני נופל.
בעיה בתת סקריפטים
הבעיה בתת סקריפטים (אינדקס) היא שאם האינדקס נמצא מחוץ לטווח, ייתכן שתתקבל התוצאה הלא נכונה, או שתתקבל שגיאה בזמן הריצה.
חֲזִית()
פעולה זו מחזירה הפניה לאלמנט הראשון של אובייקט המחרוזת, מבלי להסיר את האלמנט. הפלט של הקוד הבא הוא 'אני'.
string strCol=חוּט('אני אוהב אותך');לְהַשְׁחִירצ'=strCol.חֲזִית();
עֲלוּת<<צ'<< ' n';
התו אינו מוסר מאובייקט המחרוזת.
קדמית () קבועה
כאשר לבנייה של אובייקט המחרוזת קודמת const, הביטוי front () const מבוצע במקום הקדמי (). הוא משמש בקוד הבא, למשל.
קבועstring strCol=חוּט('אני אוהב אותך');לְהַשְׁחִירצ'=strCol.חֲזִית();
עֲלוּת<<צ'<< ' n';
הפניה קבועה מוחזרת. האלמנט אינו מוסר מאובייקט המחרוזת. לא ניתן לשנות תו עבור אובייקט מחרוזת קבוע.
חזור()
פעולה זו מחזירה הפניה לאלמנט האחרון של אובייקט המחרוזת, מבלי להסיר את האלמנט. הפלט של הקוד הבא הוא 'u'.
string strCol=חוּט('אני אוהב אותך');לְהַשְׁחִירצ'=strCol.חזור();
עֲלוּת<<צ'<< ' n';
גב () קבוע
כאשר לבנייה של אובייקט המחרוזת קודמת const, הביטוי back () const מבוצע במקום back (). הוא משמש בקוד הבא, למשל.
קבועstring strCol=חוּט('אני אוהב אותך');לְהַשְׁחִירצ'=strCol.חזור();
עֲלוּת<<צ'<< ' n';
הפניה קבועה מוחזרת. האלמנט אינו מוסר מאובייקט המחרוזת.
קיבולת מחרוזת
גודל_סוג קיבולת () const noexcept
המספר הכולל של התווים שהמחרוזת יכולה להכיל מבלי לדרוש מיקום מחדש, מוחזר על ידי פונקציית חבר קיבולת זו. קטע קוד לכך הוא:
string strCol=חוּט();intעל אחד=strCol.קיבולת();
עֲלוּת<<על אחד<< ' n';
הפלט הוא 15 במחשב שלי.
מילואים (n)
לא תמיד יש מקום בזיכרון בחנות החופשית. ניתן להזמין מקום נוסף מראש. שקול את קטע הקוד הבא:
string strCol=חוּט('אהבה');strCol.לְהַזמִין(6);
עֲלוּת<<strCol.קיבולת() << ' n';
הפלט הוא 15 במחשב שלי.
size () const noexcept
זה מחזיר את מספר התווים במחרוזת. הקוד הבא ממחיש:
string strCol=חוּט('אני אוהב אותך');intעל אחד=strCol.גודל();
עֲלוּת<<על אחד<< ' n';
הפלט הוא 10, שאינו כולל את התו nul, 0.
אורך () const noexcept
-זהה לגודל().הערה:גודל() <=קיבולת().
לכווץ כדי להתאים()
יכול להפחית את הקיבולת () לגודל () על ידי גרימת מיקום מחדש; זה לא חובה. הקוד הבא מדגים זאת:
string strCol=חוּט('אני אוהב אותך');strCol.לְהַזמִין(12);
strCol.לכווץ כדי להתאים();
intש=strCol.גודל();
עֲלוּת<<ש<< ' n';
הפלט הוא 10 ולא 12 או 16. הפונקציה מחזירה חלל.
שינוי גודל (sz), שינוי גודל (sz, 'c')
זה משנה את גודל המחרוזת. אם הגודל החדש קטן מהגודל הישן, אז האלמנטים לקראת הסוף נמחקים. אם הגודל החדש ארוך יותר, יתווסף איזה תו ברירת מחדל לקראת הסוף. כדי להוסיף תו מסוים, השתמש בפונקציה resize () עם שני ארגומנטים. קטע הקוד הבא ממחיש את השימוש בשתי הפונקציות:
string strCol=חוּט('אני אוהב אותך');strCol.לשנות את הגודל(6);
עֲלוּת<< 'גודל חדש של strCol:' <<strCol.גודל() << ' n';
string strCol1=חוּט('אני אוהב', 'וגם');
strCol1.לשנות את הגודל(12);
עֲלוּת<< 'גודל חדש של strCol1:' <<strCol1.גודל() << ' n';
הפלט הוא:
גודל חדש של strCol: 6גודל חדש של strCol1: 12
הפונקציה מחזירה ריק.
ברור () noexcept
מסיר את כל האלמנטים מהמחרוזת, כפי שמראה קטע הקוד הבא:
string strCol=חוּט('אני אוהב אותך');strCol.ברור();
עֲלוּת<<strCol.גודל() << ' n';
הפלט הוא 0. הפונקציה מחזירה חלל.
ריק () const noexcept
זה מחזיר 1 עבור true אם אין תו באובייקט המחרוזת, או 0 עבור false אם אובייקט המחרוזת אינו ריק. הקוד הבא ממחיש זאת:
string strCol1=חוּט('אני אוהב אותך');עֲלוּת<<strCol1.ריק() << ' n';
string strCol2=חוּט();
עֲלוּת<<strCol2.ריק() << ' n';
הפלט הוא:
01
איטרטורים חוזרים ומחלקת מחרוזות
איטרטור הוא כמו מצביע אך יש לו פונקציונליות רבה יותר מהמצביע.
begin () noexcept
מחזירה איטרציה המצביעה על התו (האלמנט) הראשון של אובייקט המחרוזת, כמו בקטע הקוד הבא:
string strCol=חוּט('אני אוהב אותך');מחרוזת בסיסית<לְהַשְׁחִיר> ::איטרציהאיטר=strCol.התחל();
עֲלוּת<< *איטר<< ' n';
הפלט הוא 'אני'. שים לב לאופן שבו הוכרזה ההכרזה המקבלת את האיטרטור. האיטרטור מופרד בביטוי החזרה כדי להשיג את הערך, באותו אופן, שמצביע מוסר.
begin () const noexcept;
מחזירה איטרציה המצביעה על האלמנט הראשון של אוסף אובייקטים המחרוזת. כאשר להקמת האובייקט קודמת ל- const, הביטוי begin () const מבוצע במקום להתחיל (). בתנאי זה, לא ניתן לשנות את האלמנט המתאים באובייקט. הוא משמש בקוד הבא, למשל.
קבועstring strCol=חוּט('אני אוהב אותך');מחרוזת בסיסית<לְהַשְׁחִיר> ::const_iteratorאיטר=strCol.התחל();
עֲלוּת<< *איטר<< ' n';
הפלט הוא 'אני'. שים לב כי const_iterator שימש הפעם, במקום רק איטרציה, לקבלת האיטרור המוחזר.
סוף () noexcept
מחזירה איטרציה המצביעה מיד מעבר לרכיב האחרון של אובייקט המחרוזת. שקול את קטע הקוד הבא:
string strCol=חוּט('אני אוהב אותך');מחרוזת בסיסית<לְהַשְׁחִיר> ::איטרציהאיטר=strCol.סוֹף();
עֲלוּת<< *איטר<< ' n';
הפלט הוא אפס, וזה כלום, מכיוון שאין אלמנט בטון מעבר לאלמנט האחרון.
סוף () const noexcept
מחזירה איטרציה המצביעה מיד מעבר לרכיב האחרון של אובייקט המחרוזת. כאשר לבנייה של אובייקט המחרוזת קודמת const, הביטוי end () const מבוצע במקום end (). שקול את קטע הקוד הבא:
קבועstring strCol=חוּט('אני אוהב אותך');מחרוזת בסיסית<לְהַשְׁחִיר> ::const_iteratorאיטר=strCol.סוֹף();
עֲלוּת<< *איטר<< ' n';
הפלט הוא אפס. שים לב כי const_iterator שימש הפעם, במקום רק איטרציה, לקבלת האיטרור המוחזר.
איטרציה הפוכה
אפשר לקבל איטרציה שחוזרת על עצמה מהקצה בפועל ועד לפני האלמנט הראשון:
rbegin () noexcept
מחזירה איטרציה המצביעה על האלמנט האחרון של האובייקט המייצב מחרוזת, כמו בקטע הקוד הבא:
string strCol=חוּט('אני אוהב אותך');מחרוזת בסיסית<לְהַשְׁחִיר> ::מדריך הפוךאיטר=strCol.התחל מחדש();
עֲלוּת<< *איטר<< ' n';
הפלט הוא 'u'. שים לב לדרך שבה הוכרזה ההכרזה המקבלת את האיטרור ההפוך. האיטרטור מופרד בביטוי החזרה כדי להשיג את הערך, באותו אופן, שמצביע מוסר.
rbegin () const noexcept;
מחזירה איטרציה המצביעה על האלמנט האחרון של אובייקט המחרוזת. כאשר להקמת האובייקט קודמת לב, הביטוי rbegin () const מבוצע במקום rbegin (). בתנאי זה, לא ניתן לשנות את האלמנט המתאים באובייקט. התכונה משמשת בקוד הבא, למשל.
קבועstring strCol=חוּט('אני אוהב אותך');מחרוזת בסיסית<לְהַשְׁחִיר> ::const_reverse_iteratorאיטר=strCol.התחל מחדש();
עֲלוּת<< *איטר<< ' n';
הפלט הוא 'u'. שים לב כי const_reverse_iterator שימש הפעם, במקום רק reverse_iterator, לקבלת האיטרור המוחזר.
render () noexcept
מחזירה איטרור המצביע ממש לפני האלמנט הראשון של אובייקט המחרוזת. שקול את קטע הקוד הבא:
string strCol=חוּט('אני אוהב אותך');מחרוזת בסיסית<לְהַשְׁחִיר> ::מדריך הפוךאיטר=strCol.עושה();
עֲלוּת<< *איטר<< ' n';
הפלט הוא אפס, וזה כלום, מכיוון שאין אלמנט בטון ממש לפני האלמנט הראשון.
render () const noexcept
מחזירה איטרור המצביע ממש לפני האלמנט הראשון של אובייקט המחרוזת. כאשר להקמת האובייקט קודמת ל- const, הביטוי rend () const מבוצע במקום rend (). שקול את קטע הקוד הבא:
קבועstring strCol=חוּט('אני אוהב אותך');מחרוזת בסיסית<לְהַשְׁחִיר> ::const_reverse_iteratorאיטר=strCol.עושה();
עֲלוּת<< *איטר<< ' n';
הפלט הוא אפס. שים לב כי const_reverse_iterator שימש הפעם, במקום רק reverse_iterator, לקבלת האיטרור המוחזר.
משני מחרוזות
משתנה שמשנה את אובייקט המחרוזת, יכול גם לקחת או להחזיר איטרציה.
מצטרף
מחרוזת בסיסית&מַפעִיל+ =(קבועמחרוזת בסיסית&עמ)מוסיף את אובייקט המחרוזת הימנית לאובייקט המחרוזת השמאלי. דוגמא:
string strCol1=חוּט('אני אוהב');string strCol2=חוּט(' אתה');
strCol1+ =strCol2;
עֲלוּת<<strCol1<< ' n';
הפלט הוא אני אוהב אותך. אל תשכח ש- strCol1 += strCol2 זהה ל- strCol1 = strCol1 +strCol2.
basic_string & operator+= (const charT* s)
מוסיף מחרוזת מילולית לאוסף אובייקטים של מחרוזות. דוגמא:
string strCol=חוּט('אני אוהב');strCol+ = ' אתה';
עֲלוּת<<strCol<< ' n';
פלט: אני אוהב אותך.
basic_string & operator+= (charT c)
מוסיף תו יחיד למחרוזת אובייקט. דוגמא:
string strCol=חוּט('אני אוהב אותך');strCol+ = 'אתה';
עֲלוּת<<strCol<< ' n';
פלט: אני אוהב אותך.
basic_string & operator+= (initializer_list)
מוסיף רשימת אתחול. דוגמא:
string strCol=חוּט('אני אוהב');strCol+ = {'','ו','אוֹ','אתה',' 0'};
עֲלוּת<<strCol<< ' n';
פלט: אני אוהב אותך. תמיד טוב להוסיף את nul, 0 בסוף רשימת אתחול תווים.
basic_string & append (const basic_string & str)
מוסיף את אובייקט מחרוזת הארגומנט לאובייקט המחרוזת הראשי. דוגמא:
string strCol1=חוּט('אני אוהב');string strCol2=חוּט(' אתה');
strCol1.לְצַרֵף(strCol2);
עֲלוּת<<strCol1<< ' n';
פלט: אני אוהב אותך.
basic_string & append (const charT* s)
מוסיף טיעון מילולי למחרוזת הראשית. דוגמא
string strCol=חוּט('אני אוהב');strCol=strCol.לְצַרֵף(' אתה');
עֲלוּת<<strCol<< ' n';
פלט: אני אוהב אותך.
basic_string & append (initializer_list)
מוסיף את רשימת האתחול, שהיא ארגומנט, למחרוזת הראשית. דוגמא:
string strCol=חוּט('אני אוהב');strCol=strCol.לְצַרֵף({'','ו','אוֹ','אתה',' 0'});
עֲלוּת<<strCol<< ' n';
פלט: אני אוהב אותך. תמיד טוב להוסיף את התו nul, 0 בסוף רשימת אתחול.
מחרוזת בסיסית והוספת (גודל_סוג n, תו ג)
מוסיף n מאותה דמות. דוגמא:
string strCol=חוּט('כרטיסייה');strCol=strCol.לְצַרֵף(2, 'אוֹ');
עֲלוּת<<strCol<< ' n';
פלט: טאבו.
string_string & append (const charT* s, size_type n)
מוסיף את n האלמנטים הראשונים של מחרוזת מילולית לאובייקט המחרוזת הראשי. דוגמא:
string strCol=חוּט('אני אוהב');strCol=strCol.לְצַרֵף(' אתה כל כך', 4);
עֲלוּת<<strCol<< ' n';
הפלט הוא: אני אוהב אותך. אם n גדול מאורך המילולי, יוצג חריג length_error.
basic_string & append (const basic_string & str, size_type pos, size_type n = npos)
מוסיף n תווים מהאינדקס, pos למחרוזת הראשית. דוגמא:
string strCol=חוּט('אני אוהב');strCol=strCol.לְצַרֵף(האם אתה כזה ', 2, 4);
עֲלוּת<<strCol<< ' n';
פלט: אני אוהב אותך. יוצאת מן הכלל גם כאן, ראה בהמשך.
הקצאה
מחרוזת בסיסית&לְהַקְצוֹת(קבועמחרוזת בסיסית&עמ)מקצה את אובייקט מחרוזת הארגומנט למחרוזת הראשית, ומחליף כל תוכן שהיה שם.
string strCol1=חוּט('אני אוהב אותך');string strCol2=חוּט('היא צריכה אותי');
strCol1=strCol1.לְהַקְצוֹת(strCol2);
עֲלוּת<<strCol1<< ' n';
פלט: היא צריכה אותי.
מחרוזת בסיסית&לְהַקְצוֹת(קבועתרשים*ש)מקצה טיעון מילולי למחרוזת הראשית, ומחליף כל תוכן שהיה שם.
string strCol=חוּט('אני אוהב אותך');strCol=strCol.לְהַקְצוֹת('היא צריכה אותי');
עֲלוּת<<strCol<< ' n';
פלט: היא צריכה אותי.
מחרוזת בסיסית&לְהַקְצוֹת(initializer_list<תרשים>)מקצה ארגומנט רשימת אתחול למחרוזת הראשית,החלפת כל תוכן שהיה שם.
[cc lang='ג'נמלט='נָכוֹן'רוֹחַב='780']
string strCol=חוּט('אני אוהב אותך');
strCol=strCol.לְהַקְצוֹת({'S','ח','וגם','','n','וגם','וגם','d','s','','M','וגם',' 0'});
עֲלוּת<<strCol<< ' n';
פלט: היא צריכה אותי. טוב להוסיף תמיד את ה- nul, 0 בסוף רשימת התווים, כדי ליצור מחרוזת מילולית.
מחרוזת בסיסית&לְהַקְצוֹת(קבועתרשים*ש,סוג_גודל n)מקצה את n התווים הראשונים של ארגומנט מילולי למחרוזת הראשית, ומחליף כל תוכן שהיה שם.
string strCol=חוּט('אני אוהב אותך');strCol=strCol.לְהַקְצוֹת('היא צריכה אותי', 9);
עֲלוּת<<strCol<< ' n';
פלט: היא צריכה.
מחרוזת בסיסית&לְהַקְצוֹת(סוג_גודל n,charT ג)מקצה ארגומנט של n של אותן תווים למחרוזת הראשית, ומחליף כל תוכן שהיה שם.
string strCol=חוּט('אני אוהב אותך');strCol=strCol.לְהַקְצוֹת(4, 'וגם');
עֲלוּת<<strCol<< ' n';
פלט: eeee
מחרוזת בסיסית&לְהַקְצוֹת(קבועמחרוזת בסיסית&עמ,גודל_סוג pos,סוג_גודל n=npos)
מקצה n תווים של ארגומנט אובייקט מחרוזת, המתחיל מ pos, למחרוזת הראשית, ומחליף כל תוכן שהיה שם.
string strCol=חוּט('אני אוהב אותך');strCol=strCol.לְהַקְצוֹת('היא צריכה אותי', 4, 5);
עֲלוּת<<strCol<< ' n';
פלט: צרכים. היה זורק חריג - ראה מאוחר יותר.
הכנסת
מחרוזת בסיסית&לְהַכנִיס(גודל_סוג pos, קבועמחרוזת בסיסית&עמ)מוסיף את ארגומנט אובייקט המחרוזת למחרוזת הראשית, באינדקס, pos.
string strCol1=חוּט('אני אוהב אותך');string strCol2=חוּט('שנאה ו');
strCol1=strCol1.לְהַכנִיס(2,strCol2);
עֲלוּת<<strCol1<< ' n';
פלט: אני שונא ואוהב אותך. היה זורק חריג - ראה מאוחר יותר.
מחרוזת בסיסית&לְהַכנִיס(גודל_סוג pos1, קבועמחרוזת בסיסית&עמ,גודל_סוג pos2,סוג_גודל n=npos)
מוסיף אורך של n תווים מ- pos2 של ארגומנט אובייקט מחרוזת, למחרוזת הראשית, באינדקס, pos1.
string strCol1=חוּט('אני אוהב אותך');string strCol2=חוּט('שונא, רוצה וצריך');
strCol1=strCol1.לְהַכנִיס(2,strCol2, 6, 9);
עֲלוּת<<strCol1<< ' n';
פלט: אני רוצה ואוהב אותך.
הכנס איטרציה (const_iterator p, charT c)
מוסיף דמות מסוימת, שהיא טיעון, לעמדה שאליה חוזר האיטרטור. מחזירה איטרציה למיקום התו שהוכנס לאחרונה.
string strCol=חוּט('אני אוהב אותך');מחרוזת בסיסית<לְהַשְׁחִיר> ::איטרציהאיטר=strCol.התחל();
++איטר; ++איטר; ++איטר; ++איטר; ++איטר; ++איטר;
מחרוזת בסיסית<לְהַשְׁחִיר> ::איטרציהרֶשֶׁת=strCol.לְהַכנִיס(איטר, 'd');
עֲלוּת<< *רֶשֶׁת<< ' n';
עֲלוּת<<strCol<< ' n';
הפלט הוא:
'ד'
אהבתי אותך
הכנס איטראטור (const_iterator p, size_type n, charT c)
מוסיף n מאותו אופי הטיעון, לעמדה שאליה חוזר האיטרטור. מחזירה איטרציה למיקום ההתחלה של אותן תווים שהוכנסו לאחרונה.
string strCol=חוּט('לשונית בארץ.');מחרוזת בסיסית<לְהַשְׁחִיר> ::איטרציהאיטר=strCol.התחל();
++איטר; ++איטר; ++איטר;
מחרוזת בסיסית<לְהַשְׁחִיר> ::איטרציהרֶשֶׁת=strCol.לְהַכנִיס(איטר, 2, 'אוֹ');
עֲלוּת<< *רֶשֶׁת<< ' n';
עֲלוּת<<strCol<< ' n';
הפלט הוא:
'אוֹ'
טאבו בארץ.
מחרוזת בסיסית&לְהַכנִיס(גודל_סוג pos, קבועתרשים*ש)מוסיף מחרוזת ארגומנט מילולית באינדקס, pos במחרוזת הראשית.
string strCol=חוּט('לשונית בארץ.');strCol=strCol.לְהַכנִיס(3, 'אוו');
עֲלוּת<<strCol<< ' n';
תפוקה: טאבו בארץ.
מחרוזת בסיסית&לְהַכנִיס(גודל_סוג pos, קבועתרשים*ש,סוג_גודל n)מוסיף את n התווים הראשונים של מחרוזת הארגומנט מילולית, באינדקס, pos במחרוזת הראשית.
string strCol=חוּט('לשונית בארץ.');strCol=strCol.לְהַכנִיס(3, 'אווווו', 2);
עֲלוּת<<strCol<< ' n';
תפוקה: טאבו בארץ.
מחליף
מחרוזת בסיסית&החלף(גודל_סוג pos1,גודל_סוג n1, קבועמחרוזת בסיסית&עמ))מחליף תווים n1 באובייקט המחרוזת הראשי מהאינדקס, pos1, באובייקט מחרוזת הארגומנט.
string strCol1=חוּט('אני אוהב אותך');string strCol2=חוּט('שונא אותך ו');
strCol1=strCol1.החלף(2, 4,strCol2);
עֲלוּת<<strCol1<< ' n';
פלט: אני שונא אותך ואתה. היה זורק חריג - ראה מאוחר יותר.
מחרוזת בסיסית&החלף(גודל_סוג pos1,גודל_סוג n1, קבועמחרוזת בסיסית&עמ,גודל_סוג pos2,גודל_סוג n2=npos)
מחליף תווים n1 באובייקט המחרוזת הראשי מהאינדקס, pos1, עם n2 תווים של אובייקט מחרוזת הארגומנט מהאינדקס, pos2.
string strCol1=חוּט('אני אוהב אותך');string strCol2=חוּט('אנחנו שונאים אותו והיא');
strCol1=strCol1.החלף(2, 4,strCol2, 3, 12);
עֲלוּת<<strCol1<< ' n';
פלט: אני שונא אותו ואתך.
מחרוזת בסיסית&החלף(גודל_סוג pos1,גודל_סוג n1, קבועתרשים*ש,גודל_סוג n2)
מחליף תווים n1 באובייקט המחרוזת הראשי מהאינדקס, pos1, בתווים n2 הראשונים של הארגומנט מחרוזת מילולית.
string strCol1=חוּט('אני אוהב אותך');strCol1=strCol1.החלף(2, 4, 'שונא אותו והיא', 12);
עֲלוּת<<strCol1<< ' n';
פלט: אני שונא אותו ואתך.
מחרוזת בסיסית והחלפה (גודל_סוג pos, גודל_סוג n, const charT* s)
מחליף n תווים באובייקט המחרוזת הראשי מהאינדקס, pos, בארגומנט מחרוזת מילולי.
string strCol1=חוּט('אני אוהב אותך');strCol1=strCol1.החלף(2, 4, 'שונא אותו ו');
עֲלוּת<<strCol1<< ' n';
פלט: אני שונא אותו ואתך.
מחרוזת בסיסית&החלף(גודל_סוג pos1,גודל_סוג n1,גודל_סוג n2,charT ג)מחליף תווים n1 באובייקט המחרוזת הראשי מהאינדקס, pos1, ב- n2 של אותו תו של הארגומנט.
string strCol1=חוּט('טאבלט גרוע שם.');strCol1=strCol1.החלף(9, 3, 2, 'אוֹ');
עֲלוּת<<strCol1<< ' n';
פלט: טאבו גרוע שם ..
מחיקת איטרור (const_iterator p)
מסיר דמות במיקום שאליו חוזר האיטרטור; ואז מחזירה את מיקום האיטרציה, שכעת תופסת אותו הדמות שהייתה ליד תו זה (או סוף ()). הקוד הבא ממחיש זאת:
string strCol=חוּט('א ב ג ד');מחרוזת בסיסית<לְהַשְׁחִיר> ::איטרציהאיטר=strCol.התחל();
++איטר; ++איטר;
strCol.לִמְחוֹק(איטר);
עֲלוּת<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' n';
הפלט: a b d
מחרוזת בסיסית&לִמְחוֹק(גודל_סוג pos= 0,סוג_גודל n=npos)מסיר n תווים מהאינדקס, pos.
string strCol=חוּט('א ב ג ד');strCol.לִמְחוֹק(1, 2);
עֲלוּת<<strCol[0] << '' <<strCol[1] << ' n';
פלט: א
לדחוף_חזרה (charT c) חלל
כדי להוסיף תו בודד בסוף המחרוזת:
string strCol=חוּט('א ב ג ד');strCol.התנגדות('5');
עֲלוּת<<strCol<< ' n';
פלט: abcd5
חלל pop_back ()
מסיר את הדמות האחרונה מבלי להחזיר אותה. גודל המחרוזת מצטמצם ב -1.
string strCol=חוּט('אבגדה');strCol.pop_back();
עֲלוּת<<strCol<< ' n';
פלט: abcd
החלפת חלל (מחרוזת בסיסית)
ניתן להחליף מילולית של שני אובייקטים של מחרוזות.
string strCol1=חוּט(<סיוע='post-69618 -__ DdeLink__781_3724385525'>ל>'אבגדה');string strCol2=חוּט('1234567');
strCol1.לְהַחלִיף(strCol2);
עֲלוּת<<strCol1<< ' n';
עֲלוּת<<strCol2<< ' n';
הפלט הוא:
'1234567''אבגדה'
פעולות מחרוזת
const charT* c_str () const noexcept
מחזירה מצביע לרכיב הראשון של המחרוזת. ניתן להגדיל את המצביע.
קבועstring strCol=חוּט('אבגדה');קבוע לְהַשְׁחִיר*עמ=strCol.c_str();
עֲלוּת<< *עמ<< ' n';
++עמ;
עֲלוּת<< *עמ<< ' n';
הפלט הוא:
לב
בגלל הקובץ השני בכותרת, התוכנית לא יכולה לשנות כל תו במחרוזת. לבנייה קודמת קונסט '.
const charT* data () const noexcept
מחזירה מצביע לרכיב הראשון של המחרוזת. ניתן להגדיל את המצביע.
קבועstring strCol=חוּט('אבגדה');קבוע לְהַשְׁחִיר*עמ=strCol.נתונים();
עֲלוּת<< *עמ<< ' n';
++עמ;
עֲלוּת<< *עמ<< ' n';
הפלט הוא:
לב
בגלל הקובץ השני בכותרת, התוכנית לא יכולה לשנות כל תו במחרוזת. לבנייה קודמת קונסט '.
substr_string basic (size_type pos = 0, size_type n = npos) const
מחזירה אובייקט מחרוזת של n תווים עבור מחרוזת המשנה המתחילה מהאינדקס, pos.
קבועstring strCol=חוּט('abcdefghij');קבועstring retStr=strCol.substr(2, 4);
עֲלוּת<<retStr<< ' n';
פלט: cdef
find () פונקציות חבר
size_type find (const basic_string & str, size_type pos = 0) const noexcept
מחפש אובייקט משנה המחרוזת החל מהאינדקס, pos. אם הוא נמצא, מחזירה את תחילת מחרוזת המשנה במחרוזת הראשית.
string strCol=חוּט('אנחנו העולם!');string strCol1=חוּט('ה');
intעל אחד=strCol.למצוא(strCol1, 2);
עֲלוּת<<על אחד<< ' n';
תְפוּקָה:
מדד: 7מחזירה -1, כאשר לא נמצא.
size_type find (const charT* s, size_type pos = 0) const
מחפש תת-מחרוזת מילולית המתחילה מהאינדקס, pos. אם הוא נמצא, מחזירה את תחילת מחרוזת המשנה במחרוזת הראשית.
string strCol=חוּט('אנחנו העולם!');intעל אחד=strCol.למצוא('הם', 0);
עֲלוּת<<על אחד<< ' n';
מכיוון ש- pos = 0 היא ברירת המחדל, אפשר היה להשמיט 0 בטענה.
פלט: 3
מחזירה -1, כאשר לא נמצא.
size_type find (const charT* s, size_type pos, size_type n) const
מחפש את n התווים הראשונים של מחרוזת משנה מילולית המתחילה מהאינדקס, pos. אם הוא נמצא, מחזירה את תחילת מחרוזת המשנה במחרוזת הראשית.
string strCol=חוּט('הילד הכי גדול');intעל אחד=strCol.למצוא('גדול יותר', 1, 3);
עֲלוּת<<על אחד<< ' n';
פלט: 4
מחזירה -1, כאשר לא נמצא.
size_type find (charT c, size_type pos = 0) const
מחפש את הדמות, c החל מהאינדקס, pos. אם הוא נמצא, מחזירה את תחילת מחרוזת המשנה במחרוזת הראשית. אם לא נמצא, מחזיר -1.
string strCol=חוּט('אנחנו העולם!');intעל אחד=strCol.למצוא('עם');
עֲלוּת<<על אחד<< ' n';
פלט: -1
קיימות הפונקציות החברתיות של Find ():
גודל_סוג rfind(קבועמחרוזת בסיסית&עמ,גודל_סוג pos=npos) קבועמשהו מלבד;גודל_סוג rfind(קבועתרשים*ש,גודל_סוג pos=npos) קבוע;
גודל_סוג rfind(קבועתרשים*ש,גודל_סוג pos,סוג_גודל n) קבוע;
גודל_סוג rfind(charT ג,גודל_סוג pos=npos) קבוע;
השוואת פונקציות של חברים
int להשוות (const basic_string & str) const noexcept
משווה את אובייקט מחרוזת הארגומנט עם אובייקט המחרוזת הראשי. אם המחרוזת הראשית מתרחשת לפני הארגומנט (במילון) היא מחזירה מספר חיובי. אם היא מופיעה אחרי המחרוזת הראשית, היא מחזירה מספר שלילי. אם שני המיתרים זהים, הוא מחזיר אפס.
string strCol1=חוּט('קָהָל');string strCol2=חוּט('אֲנָשִׁים');
intעל אחד=strCol1.לְהַשְׁווֹת(strCol2);
עֲלוּת<<על אחד<< ' n';
תפוקה: -13
int השווה (const charT* s) const
אותו דבר כמו לעיל, אבל הטענה היא מחרוזת מילולית.
string strCol1=חוּט('אֲנָשִׁים');intעל אחד=strCol1.לְהַשְׁווֹת('אֲנָשִׁים');
עֲלוּת<<על אחד<< ' n';
פלט: 0
מפעילי מחרוזת
אופרטורים אלה חלים על אובייקטים של מחרוזות ולאו דווקא מילולי מחרוזות.
+
מחבר שני אובייקטים של מחרוזות ומחזיר את השרשור.
string strCol1=חוּט('רוקדים הלאה');string strCol2=חוּט(' הירח');
string strCol=strCol1+strCol2;
עֲלוּת<<strCol<< ' n';
פלט: ריקוד על הירח.
==
מחזירה 1 עבור true, אם אובייקטים המחרוזת זהים; ואפס על שקר, אם הם לא.
string strCol1=חוּט('רוקדים הלאה');string strCol2=חוּט(' על הירח');
בול bl=strCol1==strCol2;
עֲלוּת<<bl<< ' n';
פלט: 0
! =
מחזירה 1 אם אובייקטים המחרוזת אינם זהים ואפס אם כן.
string strCol1=חוּט('רוקדים הלאה');string strCol2=חוּט(' על הירח');
בול bl=strCol1! =strCol2;
עֲלוּת<<bl<< ' n';
פלט: 1
<
מחזירה 1, אם האופרנד השמאלי קטן מהאופראנד הימני לפי המילון, או אפס אם הוא לא.
string strCol1=חוּט('רוקדים הלאה');string strCol2=חוּט(' על הירח');
בול bl=strCol1<strCol2;
עֲלוּת<<bl<< ' n';
פלט: 0
עבור תווים רגילים ב- C ++, בסדר עולה, מספרים מגיעים לפני אותיות גדולות, המגיעות לפני אותיות קטנות. דמות החלל באה לפני האפס וכולן.
C ++ סוגי תווים של מחרוזת ראשית
לְהַשְׁחִיר
סוג הצ'אר הוא סוג C ++ המקורי ובדרך כלל ישמור תו ב -8 סיביות.
char16_t
זה מאחסן תו ב -16 סיביות.
char32_t
זה מאחסן תו ב -32 סיביות.
wchar_t
char16_t ו- char32_t הם תווים רחבים. wchar_t הוא תו רחב שהוא קנייני ומוגדר יישום.
סוגים אלה נקראים תכונות. עם זאת, C ++ מתייחס אליהם מבחינה טכנית להתמחויות של תכונות. מאמר זה התמקד בסוג החרוכה. הגישה לסוגים האחרים מעט שונה - ראו בהמשך.
פעולות חבר של מבצע מחרוזות אחרות
החתימות של פונקציות פעולת מחרוזת אחרות הן:
סוג_גודל מצא_ראשון_מ(קבועמחרוזת בסיסית&עמ,גודל_סוג pos= 0) קבועמשהו מלבד;סוג_גודל מצא_ראשון_מ(קבועתרשים*ש,גודל_סוג pos,סוג_גודל n) קבוע;
סוג_גודל מצא_ראשון_מ(קבועתרשים*ש,גודל_סוג pos= 0) קבוע;
סוג_גודל מצא_ראשון_מ(charT ג,גודל_סוג pos= 0) קבוע;
גודל_גודל מצא_אחרון_מ(קבועמחרוזת בסיסית&עמ,גודל_סוג pos=npos) קבועמשהו מלבד;
גודל_גודל מצא_אחרון_מ(קבועתרשים*ש,גודל_סוג pos,סוג_גודל n) קבוע;
גודל_גודל מצא_אחרון_מ(קבועתרשים*ש,גודל_סוג pos=npos) קבוע;
גודל_גודל מצא_אחרון_מ(charT ג,גודל_סוג pos=npos) קבוע;
סוג_גודל מצא_ראשון_לא(קבועמחרוזת בסיסית&עמ,גודל_סוג pos= 0) קבועמשהו מלבד;
סוג_גודל מצא_ראשון_לא(קבועתרשים*ש,גודל_סוג pos,סוג_גודל n) קבוע;
סוג_גודל מצא_ראשון_לא(קבועתרשים*ש,גודל_סוג pos= 0) קבוע;
סוג_גודל מצא_ראשון_לא(charT ג,גודל_סוג pos= 0) קבוע;
סוג_גודל_מצא_אחרון_לא(קבועמחרוזת בסיסית&עמ,גודל_סוג pos=npos) קבועמשהו מלבד;
סוג_גודל_מצא_אחרון_לא(קבועתרשים*ש,גודל_סוג pos,סוג_גודל n) קבוע;
סוג_גודל_מצא_אחרון_לא(קבועתרשים*ש,גודל_סוג pos=npos) קבוע;
סוג_גודל_מצא_אחרון_לא(charT ג,גודל_סוג pos=npos) קבוע;
סיכום
ל- C ++ יש מילולי מחרוזות ואובייקטים של מחרוזות. לאובייקט המחרוזת יש אוסף של תווים ברצף, בדומה למערך של תווים ברצף. ההבדל בין אוסף המיתרים למערך, הוא שאוסף המיתרים יכול לגדול באורך או להתכווץ באורך. אובייקט מחרוזת מופעל מיידית (בנוי) ממחלקת מחרוזות. אובייקט מחרוזת הוא מבנה נתונים עם פונקציות חבר. ניתן לסווג את פונקציות החברים תחת הכותרות של בניית אובייקטים, גישה לרכיבים, קיבולת מחרוזת, פונקציות של מחרוזת עם ארגומנטים של איטרציה וסוגי החזרה ומשני מחרוזות. קיימים גם שוויוני מיתרים ומפעילים יחסיים.