דוגמה 1:
קובצי הכותרת 'אופציונלי' ו-'iostream' מיובאים בקוד זה. עלינו לייבא את קבצי הכותרות הללו כדי שנוכל לגשת בקלות לפונקציות המוגדרות בהם. לאחר מכן, אנו כוללים את 'מרחב השמות std' כך שלא נצטרך להקליד אותו עם פונקציות בנפרד כמו 'std::optional' ו-'std::cout'. אנו משתמשים כאן ב-'Namespace std'. אז, כעת, אנו מניחים את ה'אופציונלי' או 'cout' מבלי להקליד איתם 'std'.
לאחר מכן, אנו מפעילים את main() וממקמים את 'אופציונלי' ומגדירים אותו ל'int' ומצהירים על 'myNum'. זהו התחביר להכרזה על המשתנה 'std::optional'. לאחר מכן, אנו מאתחלים משתנה נוסף בשם 'value' ומקצים ערך למשתנה 'myNum' על ידי שימוש בפונקציה value_or(). אנו מעבירים את '99' בפונקציה הזו, אז היא מקצה את ה-'99' הזה למשתנה 'muNum' אם אין ערך נוכח ומאחסנת אותו במשתנה 'ערך'. לאחר מכן, אנו מניחים 'cout' מתחת לזה, מה שמסייע בהצגת הערך שהקצנו למשתנה שמעליו.
קוד 1:
#include <אופציונלי>#include
באמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
אופציונאלי < int > myNum ;
int ערך = myNum. ערך_או ( 99 ) ;
cout << 'הערך של myNum הוא:' << ערך << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, אנו יכולים להבחין כי '99' מוצג, כלומר הערך לא היה קיים למעלה והערך שהוספנו מוקצה למשתנה זה.
דוגמה 2:
אנו כוללים תחילה את קבצי הכותרת וממקמים את 'מרחב השמות std'. כעת, מתחת לזה, אנו מכריזים על הפונקציה 'std::optional' שהיא ה-'divideFunc()'. ה'דיבידנד' וה'מחלק' הם שני הפרמטרים של פונקציה זו. לאחר מכן אנו משתמשים ב'אם' מתחתיו, כאשר אנו מוסיפים תנאי שאומר 'מחלק != 0'. אם זה מסופק, זה מחזיר את התשובה של החלוקה הזו כשאנחנו מוסיפים 'תמורה' בתוך זה. אחרת, הוא מחזיר 'nullopt' כלומר אין ערך מסוג בטוח. כעת, אנו מפעילים את ה-main(). כדי להסיק ל-'std::optional', נמקם את 'divideFunc()' ונוסיף בו '27, 3' ונקצה את התוצאה למשתנה 'מנה'.
כאן אנו משתמשים במילת המפתח 'אוטומטית' כך שהיא מתאימה אוטומטית את סוג הנתונים שלה. לאחר מכן, אנו מוסיפים את ה'אם' שבו אנו משתמשים ב-'יש-ערך' שקובע אם ערך-טיפוס מתקבל. לאחר מכן, אנו מניחים את ה-'cout' שמציג את התוצאה המאוחסנת במשתנה 'המנה', והחלק 'else' מכיל משפט שמראה שהמחלק הוא אפס.
קוד 2:
#include#include <אופציונלי>
באמצעות מרחב שמות std ;
אופציונאלי < int > divideFunc ( int דיבידנד , int מחיצה ) {
אם ( מחיצה != 0 ) {
לַחֲזוֹר דיבידנד / מחיצה ;
}
לַחֲזוֹר nullopt ;
}
int רָאשִׁי ( ) {
אוטומטי מָנָה = divideFunc ( 27 , 3 ) ;
אם ( מָנָה. יש_ערך ( ) ) {
cout << 'המנה היא:' << מָנָה. ערך ( ) << endl ;
} אַחֵר {
cout << 'המחלק כאן אפס' << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הפלט מציג את התוצאה לאחר החלוקה כלומר המחלק אינו אפס. במקרה זה, 'std::optional' משמש כדי לקבוע אם קיים ערך או לא בצורה בטוחה.
דוגמה 3:
כאן, אנו מצהירים על המשתנה 'std::optional' שהוא ה'מספר' בתוך ה-main(). לאחר מכן, אנו משתמשים ב-'if' שבו אנו ממקמים את הפונקציה has_value() עם משתנה 'number' זה. זה בודק אם יש ערך או לא במשתנה 'מספר' זה. אם המשתנה 'מספר' מכיל ערך, הוא מציג את ההצהרה שהוספנו אחרי 'אם'. אחרת, הוא מציג את ההצהרה שהצבנו אחרי 'אחר'.
כעת, אנו מאתחלים את ה-'number' עם '92' ומשתמשים ב-'if' שוב מתחת לזה, כאשר הפונקציה has_value() מתווספת עם המשתנה 'number' ב-'if כתנאי'. זה קובע אם למשתנה 'מספר' יש ערך או לא. המשפט שנוסיף אחרי 'אם' מוצג אם למשתנה 'מספר' יש ערך. אם לא, ההצהרה שאנו מציבים אחרי 'אחר' תוצג.
קוד 3:
#include#include <אופציונלי>
int רָאשִׁי ( ) {
סטד :: אופציונאלי < int > מספר ;
אם ( מספר. יש_ערך ( ) ) {
סטד :: cout << 'המספר קיים:' << מספר. ערך ( ) << סטד :: endl ;
} אַחֵר {
סטד :: cout << 'המספר אינו קיים.' << סטד :: endl ;
}
מספר = 92 ;
אם ( מספר. יש_ערך ( ) ) {
סטד :: cout << 'המספר קיים:' << מספר. ערך ( ) << סטד :: endl ;
} אַחֵר {
סטד :: cout << 'המספר אינו קיים.' << סטד :: endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
זה מעבד את החלק 'אחר' תחילה מכיוון שאנו לא מקצים שום ערך למשתנה 'std::optionional'. לאחר מכן, אנו מקצים ערך למשתנה זה כדי להציג ערך זה בשורה הבאה.
דוגמה 4:
כעת, אנו מכריזים על שלושה משתנים 'std::אופציונליים' שהם 'n1', 'n2' ו-'n3'. אנו גם מקצים את הערכים למשתנים 'n2' ו-'n3 שהם '29' ו-'45', בהתאמה. המשתנה 'n1' של המחלקה 'std::optional' ריק כאן. כעת, אנו משתמשים ב-'boolalpha' המסייע בהחזרת ההחזר בצורה 'אמיתית' או 'שקר' במקום '1' ו-'0'.
לאחר מכן, אנו מנצלים את האופרטורים היחסים בין משתני ה'std::אופציונליים' אלה וממקמים כל משפט בתוך ה-'cout' כך שהוא גם יציג את התוצאה של ההשוואה שהוספנו. ראשית, הוא בודק ש'n3 > n2', ואז 'n3 < n2', 'n1 < n2', 'n1 == std::nullopt '. כאן, 'nullopt' משמש להשוואת הערך ללא סוג בטוח או null. לאחר מכן, אנו בודקים את 'n2 == 49' ו-'n3 == 88' בתוך המשפט 'cout' בנפרד.
קוד 4:
#include <אופציונלי>#include
int רָאשִׁי ( )
{
סטד :: אופציונאלי < int > n1 ;
סטד :: אופציונאלי < int > n2 ( 29 ) ;
סטד :: אופציונאלי < int > n3 ( ארבע חמש ) ;
סטד :: cout << סטד :: אותיות ומספרים ;
סטד :: cout << 'ה-n3 > n2' << ( n3 > n2 ) << סטד :: endl ;
סטד :: cout << 'ה-n3 < n2' << ( n3 < n2 ) << סטד :: endl ;
סטד :: cout << 'ה-n1 < n2' << ( n1 < n2 ) << סטד :: endl ;
סטד :: cout << 'ה-n1 == null' << ( n1 == סטד :: nullopt ) << סטד :: endl ;
סטד :: cout << 'ה-n2 == 49 ' << ( n2 == 29 ) << סטד :: endl ;
סטד :: cout << 'ה-n3 == 88' << ( n3 == 88 ) << סטד :: endl ;
}
תְפוּקָה:
תוכנית C++ שהזכרנו קודם לכן משווה ערכי משתנים שונים מהסוג 'std::optional' תוך הדפסה במקביל של התוצאה לפלט.
דוגמה 5:
קובצי הכותרות הכלולים בקוד זה הם 'iostream', 'fstream', 'אופציונלי' ו'מחרוזת'. ה-'fstream' מכיל את ההגדרה של שתי הפונקציות שהן 'ofstream' ו-'ifstream' שאנו צריכים בקוד הזה. כעת, אנו כוללים את 'מרחב השמות std', כך שלא נמקם אותו בנפרד עם כל פונקציה. לאחר מכן, אנו משתמשים ב-'std:optional' ומצהירים על פונקציה בשם 'ReadFileFunc' שבה נעביר את 'const string& f_Name' כארגומנט.
לאחר מכן, יש לנו 'ifstream' שעוזר לקרוא את הקובץ ששמו יתווסף למשתנה 'f_name'. לאחר מכן, אנו משתמשים ב-'if' שבו אנו כוללים את התנאי שאומר שאם הקובץ לא נפתח, הוא מחזיר 'nullopt' כפי שהוספנו אותו מתחת למשפט 'if'. לאחר מכן, אנו יוצרים פונקציה נוספת שהיא 'fileContent' המסייעת בכתיבת התוכן לקובץ אם הקובץ נפתח. כאן, אנו מניחים שוב את ה-'return fileContent' שמחזיר גם את התוכן שהוספנו לקובץ לאחר הפתיחה.
כעת, אנו קוראים ל-'main()' כאן, בו אנו מאתחלים את המשתנה 'f_Name' עם שם הקובץ 'Sample.txt' שברצוננו לפתוח. לאחר מכן, אנו קוראים ל-'ReadFileFunc()' כאן ומעבירים את המשתנה 'f_Name' בפונקציה הזו שמנסה לקרוא את הקובץ ומאחסנת את התוכן שלו במשתנה 'f_content'. מתחת לזה, אנו משתמשים ב-'has_value()' עם המשתנה 'f_content' ב-'if'. אם המשתנה הזה מכיל ערך, הוא גם מציג אותו כפי שהוספנו את ה-'cout' מתחת ל-'if' שבו גם מיקמנו את ה-'f_content'. אחרת, זה מראה את השגיאה שהוספנו אחרי 'אחר'.
קוד 5:
#include#include
#include <אופציונלי>
#include
באמצעות מרחב שמות std ;
אופציונאלי < חוּט > ReadFileFunc ( const חוּט & f_Name ) {
ifstream myFile ( f_Name ) ;
אם ( ! המסמך שלי. פתוח ( ) ) {
לַחֲזוֹר nullopt ;
}
string fileContent ( ( isstreambuf_iterator < לְהַשְׁחִיר > ( המסמך שלי ) ) , isstreambuf_iterator < לְהַשְׁחִיר > ( ) ) ;
לַחֲזוֹר fileContent ;
}
int רָאשִׁי ( ) {
const מחרוזת f_Name = 'Sample.txt' ;
אוטומטי f_content = ReadFileFunc ( f_Name ) ;
אם ( f_content. יש_ערך ( ) ) {
cout << 'תוכן הקובץ הוא: \n ' << f_content. ערך ( ) << endl ;
} אַחֵר {
cerr << 'שגיאה: הקובץ לא נפתח כאן' << f_Name << endl ;
}
לַחֲזוֹר 0 ;
}
תְפוּקָה:
כאן, הוא מציג את הצהרת השגיאה שהוספנו בחלק 'אחר' כתוצאה של הקוד הנתון.
סיכום
במדריך זה, חקרנו את התכונה החזקה של C++ שהיא 'std::optional' והסברנו שהיא מציעה שיטה סטנדרטית לייצוג הערכים האופציונליים, תוך ביטול הדרישה להפניות אפס ומשפרת את הבהירות ובטיחות הקוד. למדנו שזה גם משפר את היכולת להסביר את הנושאים המסובכים ולהתמודד עם טעויות בחן.