שיטה 1: שימוש בפונקציה Empty() Member
גישה אחת פשוטה ומובנית ב-C++ כדי לקבוע אם מחרוזת ריקה כוללת שימוש בפונקציית האיבר 'empty()'. הפונקציה 'empty()' היא חלק ממחלקת המחרוזת הסטנדרטית C++ ומספקת דרך נוחה לבדוק אם למחרוזת אין תווים.
הנה דוגמה פשוטה שממחישה את השימוש בפונקציית empty():
#include
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
string emptyStr ;
אם ( emptyStr. ריק ( ) ) {
cout << 'המחרוזת ריקה.' << endl ;
} אַחֵר {
cout << 'המחרוזת לא ריקה.' << endl ;
}
לַחֲזוֹר 0 ;
}
בקטע קוד C++ זה, אנו מתחילים בהכללת קבצי הכותרת הדרושים, כגון
במקרה שלנו, אנו מפעילים את הפונקציה הזו במחרוזת 'emptyStr'. לאחר מכן, אנו משתמשים במשפט מותנה כדי להעריך את התוצאה הבוליאנית המוחזרת על ידי הפונקציה 'empty()'. אם המחרוזת אכן ריקה, התוכנית שלנו מוציאה הודעה שמציינת שהמחרוזת ריקה. מצד שני, אם המחרוזת מכילה תווים, התוכנה מוציאה הודעה המציינת שהמחרוזת אינה ריקה.
הפלט של קוד C++ שסופק הוא כדלקמן:
שיטה 2: שימוש בפונקציית Size() Member
גישה נוספת לזיהוי האם מחרוזת C++ ריקה כוללת שימוש בפונקציית האיברים 'size()' המסופקת על ידי המחלקה 'string'. בניגוד לפונקציה 'empty()' שמחזירה ישירות בוליאנית שמציינת ריקנות, 'size()' מחזירה את מספר התווים הקיימים במחרוזת. כדי לבדוק ריקנות, אנו משווים את התוצאה של 'size()' עם אפס מכיוון שלמחרוזת ריקה יש גודל אפס.
הנה דוגמה:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
מחרוזת myEmptyString ;
אם ( myEmptyString. גודל ( ) == 0 ) {
cout << 'המחרוזת שסופקה ריקה.' << endl ;
} אַחֵר {
cout << 'המחרוזת שסופקה אינה ריקה.' << endl ;
}
לַחֲזוֹר 0 ;
}
בדוגמה זו, אנו מתחילים בהכרזה על משתנה מחרוזת בשם 'myEmptyString' מבלי לאתחל אותו, ולהשאיר אותו ריק כברירת מחדל. בהמשך, אנו מפעילים את הפונקציה 'size()' כדי לקבוע את הגודל או את מספר התווים במחרוזת 'myEmptyString'. המשפט 'if' מעריך אם הגודל שווה לאפס, מה שמציין שהמחרוזת ריקה. אם תנאי זה מתקיים, אנו מוציאים הודעה למסוף המציינת שהמחרוזת שסופקה ריקה. לעומת זאת, אם הגודל אינו אפס, זרימת הבקרה עוברת לבלוק 'אחר' ומוצגת הודעה אחרת המאשרת שהמחרוזת שסופקה אינה ריקה.
שיטה 3: שימוש בהשוואה עם מילולית מחרוזת ריקה
טכניקה נוספת כדי לקבוע אם מחרוזת C++ ריקה כוללת השוואה ישירה עם מחרוזת ריקה מילולית. מחרוזת מילולית ריקה מיוצגת על ידי זוג מרכאות כפולות ללא תווים ביניהן כמו ''. אנו יכולים לוודא אם המחרוזת מכילה תו כלשהו על ידי השוואת מחרוזת נתונה למחרוזת הריקה הזו.
הנה דוגמה שממחישה את הגישה הזו:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
מחרוזת שם משתמש ;
cout <> שם משתמש ;
אם ( שם משתמש == '' )
{
cout << 'שגיאה: שם המשתמש לא יכול להיות ריק.' << endl ;
}
אַחֵר
{
cout << 'שלום, ' << שם משתמש << '! ברוכים הבאים לפלטפורמה שלנו.' << endl ;
}
לַחֲזוֹר 0 ;
}
במקרה זה, אנו מפעילים אפליקציה המבקשת מהמשתמש לספק את שם המשתמש שלו. התוכנית מתחילה בהכרזה על משתנה מחרוזת בשם 'שם משתמש' כדי לאחסן את הקלט של המשתמש. לאחר מכן, המשתמש מקבל את ההודעה 'הזן את שם המשתמש שלך:', והקלט שלו נקלט באמצעות זרם 'cin'. לאחר מכן, התוכנית משתמשת בהצהרה מותנית כדי לבדוק אם שם המשתמש שהוזן ריק, אשר מושגת על ידי השוואה ישירה שלו עם מחרוזת ריקה מילולית באמצעות אופרטור השוויון (==). אם שם המשתמש נמצא ריק, התוכנית מוציאה הודעת שגיאה האומרת, 'שגיאה: שם המשתמש לא יכול להיות ריק'. עם זאת, אם שם המשתמש אינו ריק, התוכנית מציגה הודעת קבלת פנים אישית המשלבת את שם המשתמש שהוזן עם הברכה 'שלום, [שם משתמש]! ברוך הבא לפלטפורמה שלנו'.
הנה הפלט שבו לא סיפקנו שום שם משתמש:
הפלט כאשר מסופק שם משתמש הוא כדלקמן:
שיטה 4: שימוש ב-Ternary Operator
האופרטור השלישוני מבטא בצורה תמציתית אמירה מותנית בשורה אחת מה שהופך את הקוד לקומפקט יותר. האופרטור השלישוני מחזיר אחד משני ערכים לאחר הערכת התנאי כדי לראות אם המחרוזת ריקה. במקרה זה, נוכל להשתמש בפונקציית האיברים 'empty()' כדי לבדוק אם יש ריקנות ולהעסיק את האופרטור השלישוני כדי להקצות הודעה מתאימה.
הנה דוגמה להמחשה:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
string sampleString = 'שלום עולם!' ;
cout << 'המחרוזת היא' << ( sampleString. ריק ( ) ? 'ריק.' : 'לא ריק.' ) << endl ;
לַחֲזוֹר 0 ;
}
לאחר מכן אנו מכריזים על משתנה מחרוזת בשם 'sampleString' ומאתחלים אותו עם ה-'Hello, World!' תוֹכֶן. אנו משתמשים באופרטור שליש בתוך הצהרת 'cout' כדי לקבוע אם המחרוזת ריקה. האופרטור השלישי מעריך את התנאי 'sampleString.empty()', בודק אם המחרוזת ריקה, ומדפיס את ההודעה המתאימה 'המחרוזת ריקה' אם התנאי הוא אמת, ו'המחרוזת לא ריקה' אם התנאי הוא שֶׁקֶר. התוכנית מסתיימת בהחזרת 0 המציין ריצה מוצלחת. ההפעלה של תוכנית זו מייצרת את הפלט הבא:
סיכום
זיהוי אם מחרוזת C++ ריקה הוא בסיסי למניפולציה ועיבוד של מחרוזות. במאמר זה בדקנו את מספר השיטות, שלכל אחת היתרונות שלה. פונקציית האיברים 'empty()' היא הפונקציה הישירה והנפוץ ביותר שמציינת בבירור את הריקנות של המחרוזת. השימוש ב-'size()' מציע גישה חלופית על ידי בדיקת אורך המחרוזת. השוואה עם מחרוזת ריקה מילולית היא פשוטה ואינטואיטיבית, בעוד אופרטורים שלישיים מספקים גמישות בשילוב הצ'ק בלוגיקה מורכבת יותר. יש לקחת בחשבון את הצרכים המיוחדים של התוכנית בעת בחירת הגישה הנכונה.