מחרוזות ב-C++: יסודות std::string, מתודות ומלכודות

std::string: טקסט שמנהל את עצמו

בעמוד הקודם ראיתם איך מצביעים חכמים מאפשרים לאובייקט להחזיק במשאב ולנקות אותו אוטומטית. std::string הוא אותו רעיון שמיושם על טקסט: הוא מחזיק חוצץ של תווים, מגדיל אותו כשמוסיפים, ומשחרר אותו כשהמחרוזת יוצאת מהטווח. לעולם לא קוראים ל-new, לא סופרים בתים ולא דואגים לתו null מסיים שחסר.

כדי להשתמש בו, כללו את <string>. המחלקה נמצאת במרחב השמות std.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name = "Ada";
    string greeting = "Hello, " + name + "!";

    cout << greeting << "\n";          // Hello, Ada!
    cout << "Length: " << name.size() << "\n";  // 3
    return 0;
}

האופרטור + הזה עושה עבודה של ממש: הוא מקצה חוצץ חדש שגדול מספיק לשני החלקים ומעתיק אותם לתוכו. עם char* גולמי, מצביע פשוט לתוך חוצץ תווים, הייתם משתמשים ב-strcpy וב-strcat ומקווים שהחוצץ שלכם גדול מספיק. std::string מעלים את כל סוג הטעויות הזה.

בנייה וחיבור של מחרוזות

אפשר לשרשר עם +, אבל סוס העבודה להגדלת מחרוזת במקומה הוא +=. הוא מוסיף לחוצץ הקיים במקום לייצר מחרוזת חדשה לגמרי בכל פעם, וזה חשוב בתוך לולאות.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string sentence;                  // מתחילה ריקה
    string words[] = {"the", "quick", "brown", "fox"};

    for (const string& w : words) {
        sentence += w;
        sentence += " ";
    }

    cout << sentence << "\n";         // the quick brown fox
    return 0;
}

הפתעה נפוצה: + צריך שלפחות אחד האופרנדים כבר יהיה std::string. שני ליטרלים של מחרוזת הם בסך הכול const char*, ולכן "a" + "b" לא מתקמפל: אין operator+ לשני מצביעים גולמיים. הפכו קודם אחד מהם למחרוזת:

string s = "a" + "b";              // error: can't add two const char*
string s = string("a") + "b";      // fine - left side is a std::string
string s = "a"s + "b";             // fine in C++14+, the "s" literal suffix

שימו לב שהצורה האחרונה משתמשת בסיומת s מ-<string> (using namespace std::string_literals;), שהופכת ליטרל ישירות ל-std::string.

גישה לתוך מחרוזת

std::string מתנהג כמו מכולה של char, ולכן אפשר לגשת אליו לפי אינדקס, לעבור עליו בלולאה ולבקש ממנו חלקים.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string word = "hello";

    cout << word[0] << "\n";          // h: גישה לפי אינדקס עם []
    cout << word.front() << " " << word.back() << "\n";  // h o
    cout << word.substr(1, 3) << "\n"; // ell: 3 תווים החל מאינדקס 1

    for (char c : word) {
        cout << c << '-';             // h-e-l-l-o-
    }
    cout << "\n";
    return 0;
}

substr(pos, len) מחזיר מחרוזת חדשה לגמרי שמועתקת מהמקורית, והוא לא משנה את המקור. שימו לב לגבולות: word[10] על מחרוזת בת 5 תווים הוא התנהגות לא מוגדרת: הוא לא יזרוק חריגה, הוא פשוט יקרא זבל. אם רוצים גישה עם בדיקה שזורקת std::out_of_range, השתמשו ב-word.at(10) במקום ב-word[10].

מלכודת קלאסית נוספת: .size() מחזיר טיפוס ללא סימן (size_t). לולאה לאחור כמו for (size_t i = word.size() - 1; i >= 0; --i) לעולם לא מסתיימת, כי i ללא סימן אף פעם לא יכול לרדת מתחת לאפס: הוא מתגלגל למספר עצום. השתמשו באינדקס עם סימן או בנו מחדש את התנאי כשצריך לעבור על מחרוזת בסדר הפוך.

חיפוש והחלפה

find מאתר תת-מחרוזת או תו ומחזיר את אינדקס ההתחלה. כשהיעד לא קיים, הוא מחזיר את הקבוע המיוחד std::string::npos: השוו תמיד מולו, במקום להניח ש-find מחזיר -1.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string path = "report.final.pdf";

    size_t dot = path.find('.');               // 6: הנקודה הראשונה
    size_t lastDot = path.rfind('.');          // 12: הנקודה האחרונה

    if (lastDot != string::npos) {
        cout << "Extension: " << path.substr(lastDot + 1) << "\n"; // pdf
        cout << "Base: " << path.substr(0, lastDot) << "\n";       // report.final
    }
    return 0;
}

כדי לשנות טקסט במקומו, replace(pos, len, text) מחליף קטע בתוכן חדש (שיכול להיות באורך שונה), ו-insert/erase מוסיפים או מסירים חלקים:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string msg = "I like cats";

    msg.replace(7, 4, "dogs");   // מחליפים 4 תווים באינדקס 7
    cout << msg << "\n";          // I like dogs

    msg.insert(0, "Honestly, "); // מוסיפים בהתחלה
    cout << msg << "\n";          // Honestly, I like dogs

    msg.erase(0, 10);            // מסירים את 10 התווים הראשונים
    cout << msg << "\n";          // I like dogs
    return 0;
}

מחרוזות ומספרים

טקסט ומספרים לא מומרים מעצמם: "42" הוא שלושה תווים, לא המספר השלם 42. הספרייה הסטנדרטית נותנת לכם פונקציות המרה לשני הכיוונים. השתמשו ב-stoi, ב-stod ובחבריהם כדי לפענח טקסט למספרים, וב-to_string לכיוון ההפוך.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string countText = "42";
    int count = stoi(countText) + 8;     // 50

    double price = 3.99;
    string label = "Price: $" + to_string(price);

    cout << count << "\n";               // 50
    cout << label << "\n";               // Price: $3.990000
    return 0;
}

שתי מלכודות כאן. הראשונה: stoi("abc") זורק std::invalid_argument, ולכן הגנו על קלט לא אמין עם בלוק try/catch. השנייה: to_string(3.99) נותן את 3.990000 המלא: אם צריך שליטה על דיוק ועיצוב, זו עבודה ל-string streams, ולשם בדיוק אנחנו ממשיכים.

try {
    int n = std::stoi(userInput);
} catch (const std::invalid_argument&) {
    std::cout << "That wasn't a number.\n";
}

הבא בתור: קלט ופלט

כל הזמן הדפסתם מחרוזות עם cout, אבל לקריאה שלהן בחזרה מהמשתמש יש הפתעות משלה: cin >> name עוצר ברווח הראשון, ולכן שורה מלאה כמו "Ada Lovelace" צריכה במקום זאת את std::getline. העמוד הבא מסביר כמו שצריך קלט ופלט ב-C++: אופרטורי stream, קריאת שורות שלמות, ושילוב >> עם getline בלי למעוד על שורות חדשות שנשארו.