מהו השימוש במחרוזת C++ Constexpr?
שימוש ב-constexpr יכול להוביל לקבצי הפעלה קומפקטיים יותר ומוטבים יותר. מכיוון שהערכים נקבעים מראש על ידי המהדר, הקבצים הבינאריים המתקבלים יכולים להיות קטנים יותר בגודלם, ולממש שימוש חסכוני יותר במשאבי מערכת אשר בתורו יכול לשפר את ביצועי התוכנה בפלטפורמות שונות. יתרון משמעותי אחד של תכונה זו הוא ההפחתה שהיא מביאה לחישובי זמן הריצה. מכיוון שערכים מחושבים במהלך תהליך ההידור בכל עת שניתן, הערכת זמן הריצה הופכת פחות נחוצה. הגברת היעילות הזו לא רק מאיצה את הביצוע אלא גם מייעלת את פעולות התוכנית הכוללות.
דוגמה 1: שימוש ב-Constexpr ב-C++ עבור חישוב גורמים
בדוגמה זו, נשתמש ב-constexpr המאפשר לבצע את החישובים בזמן הידור ולא בזמן ריצה. בהקשר של חישוב גורמים גורמים, ניתן למנף פעולה מתמטית נפוצה, שהיא constexpr, לחישוב ערכי פקטורי במהלך ההידור. הבה נבחן ונסקור את הקוד הבא ולאחר מכן נסתכל על ההסבר של הקוד:
#include
constexpr int פקטורי ( int נ ) {
לַחֲזוֹר נ <= 1 ? 1 : ( נ * פקטורי ( נ - 1 ) ) ;
}
int רָאשִׁי ( ) {
int על אחד = 5 ;
סטד :: cout << 'גורם של' << על אחד << ' = ' << פקטורי ( על אחד ) << סטד :: endl ;
}
דוגמא הקוד הנתונה מדגימה את השימוש ב-constexpr לחישוב הפקטוריאלי של מספר בצורה רקורסיבית. המהדר מסוגל להעריך את הביטוי הפקטוריאלי בזמן ההידור בדוגמה זו מכיוון שהפונקציה הפקטוראלית מוצהרת ומוגדרת עם מפרט constexpr. באמצעות constexpr בתוכנית C++, המהדר מעריך את הביטוי הפקטוריאלי של 5 בזמן ההידור, ומבטל את הצורך בחישוב זמן ריצה.
כעת, תן לנו לראות את הפירוט המפורט של הקוד עם פרטים והסברים ספציפיים.
ראשית, אנו משתמשים ב-#include
לאחר מכן, נעבור לפונקציה הפקטוריאלית() (רקורסיבית) שהיא 'constexpr int factorial(int n)'. הפונקציה הפקטוראלית () זו מגדירה פונקציה רקורסיבית המחשבת את הפקטוראלי של מספר שלם 'n'. Constexpr מרמז שאופטימיזציות של ביצועים יכולות לנבוע מהערכת הפונקציה במהלך ההידור.
ההחזר n <= 1 ? 1 : (n * פקטורי(n – 1)) קו משתמש בביטוי מותנה לרקורסיה הקובע שאם 'n' קטן או שווה ל-1, הוא מחזיר 1 (מקרה בסיס). אם לא, היא מבצעת את החישוב הפקטוריאלי (n! = n * (n-1)!), שהיא הנוסחה הכללית לחישוב הפקטוריאלי, על ידי קורא לעצמו שוב ושוב עם 'n - 1' ואז מכפיל את התוצאה ב- 'n '. קווים אלה פועלים כמו שומר סף לחישוב פקטורי. הוא בודק אם המספר נמצא ברמת הבסיס ומחזיר 1 אם כן. אם לא, זה מפעיל תגובת שרשרת של קריאות פונקציה, שכל אחת מהן עובדת על מספרים קטנים יותר עד שמגיעים למקרה הבסיסי. לאחר מכן, התוצאות מוכפלות בסדר הפוך. להלן הפלט של הקוד לעיונך:
דוגמה 2: ספירת האותיות הקטנות הדגמת מחרוזת C++ Constexpr
כאן, נלמד כיצד לספור את מספר האותיות הקטנות באמצעות מחרוזת countexpr. בדוגמה זו, המטרה היא לספור את מספר האותיות הקטנות במחרוזת נתונה באמצעות התכונה constexpr כדי לצמצם את חישוב זמן הריצה. הפונקציה countLowercase(), המוצהרת כ-constexpr, לוקחת מחרוזת 'string_view' כפרמטר שלה וחוזרת דרך כל תו של המחרוזת הנתונה כקלט. עבור כל אות קטנה שאנו נתקלים בה, הספירה גדלה. לאחר מכן התוצאה מתקבלת בזמן ההידור כאשר הפונקציה פועלת על ביטויים קבועים, ומציגה את היעילות והיתרונות של הערכת זמן ההידור. ראשית, בדוק את הקוד הבא. לאחר מכן, עברו להסבר המפורט:
#include#include
באמצעות מרחב שמות std ;
constexpr size_t ספירה באותיות קטנות ( string_view s ) {
size_t לספור = 0 ;
ל ( לְהַשְׁחִיר ג : ס ) {
אם ( נמוך יותר ( ג ) ) {
לספור ++;
}
}
לַחֲזוֹר לספור ;
}
int רָאשִׁי ( ) {
cout << 'סה'כ אותיות קטנות ב' אותיות קטנות 'הם ='
<< ספירה באותיות קטנות ( 'אותיות קטנות' ) << endl ;
}
להלן פירוט מפורט של הקוד עם הסבר על כל שורה:
ה-#include
בפונקציה countLowercase(), הפונקציה 'constexpr size_t countlower(string_view s)', סופרת את האותיות הקטנות בתצוגת מחרוזת נתונה. ה-int main() הוא נקודת הכניסה של התוכנית שמדפיסה הודעה המציינת את מספר האותיות הקטנות ב-'Lower Case Letters' וקוראת לפונקציה countLowercase() עם 'Lower Case Letters' כקלט ומדפיס את התוצאה. עיין בפלט הבא של התוכנית:
דוגמה 3: הדגמת מערך על ידי שימוש ב-C++ Constexpr
הדגמת מערך מראה כיצד המערכים שהם אוספים מובנים של אלמנטים מאותו סוג נתונים נוצרים, נגישים ומתפעלים בתוך שפת תכנות. בהמשך, נסביר באמצעות דוגמה לקידוד שבה התוכנית מספקת דוגמה פשוטה לאתחול ומניפולציה של מערך בזמן קומפילציה.
הדגמת מערך ממחישה את הרעיון של מערכים - אוסף מובנה של אלמנטים החולקים את אותו סוג נתונים - וכיצד ניתן ליצור אותם, לגשת אליהם ולתפעל אותם באמצעות שפת תכנות. בדוגמא הקידוד הבאה, נדגים כיצד לאתחל מערך בזמן ההידור, לחשב את גודלו ולהדפיס את האלמנטים של המערך הנתון. ראה את הקוד הבא והמשך להסבר:
#includeבאמצעות מרחב שמות std ;
int רָאשִׁי ( ) {
constexpr int מערך [ 9 ] = { 5 , 55 , 555 , 5555 , 55555 } ;
constexpr int size_array = מידה של מערך / מידה של ( int ) ;
cout << 'אורך המערך הוא = ' << size_array << endl ;
cout << 'האלמנטים במערך הם = ' ;
ל ( int אני = 0 ; אני < size_array ; ++ אני ) {
cout << מערך [ אני ] << '' ;
}
}
תוכנית זו מאתחלת מערך constexpr, מחשבת את אורכו בזמן ההידור, ולאחר מכן מדפיסה את אורך המערך והאלמנטים למסוף. Constexpr מבטיח שהמערך והמאפיינים שלו נקבעים בזמן ההידור. בואו נשבור את הקוד ונסביר את הפרטים הספציפיים אחד אחד:
כדי לכלול את ספריית זרם הקלט-פלט הסטנדרטית, המאפשרת שימוש בפונקציות כמו 'cout' עבור פלט, נקרא #include
לולאת 'for' חוזרת דרך האלמנטים של מערך 'arrayint[]', והערכים מודפסים למסוף. הבה נראה את הפלט הבא של הקוד הנתון:
סיכום
ההקדמה וההתפתחות של מילת המפתח constexpr ב-C++ חוללו מהפכה באופן הטיפול בביטויים ובערכים קבועים. מאמר זה חקר שלוש דוגמאות מעשיות, שהציגו את הכוח של constexpr במחשוב פקטוריאליים, ספירת האותיות הקטנות, ואתחול המערכים בזמן הקומפילציה. היתרונות העיקריים כוללים ביצועים משופרים, חישובי זמן ריצה מופחתים ויעילות זיכרון משופרת. Constexpr הוא נכס בעל ערך ליצירת ישויות אמינות וקבועות בתוך בסיס קוד, הבטחת אי-שינוי ותרומה לתוכניות יעילות ויעילות יותר.