דוגמה 1:
קובצי כותרות שונים מיובאים לכאן שהם 'stddef.h', 'limits' ו-'iostream'. ניתן למצוא את ההגדרות של משתנים, סוגים ומצביעים בשימוש תכוף ב-'stddef.h' וקובץ הכותרת 'limits' משמש כקבועים המייצגים את הגבולות של טיפוסים אינטגרלים, כגון ערכי המינימום והמקסימום עבור סוגי נתונים שונים , אשר נגישים דרך קובץ הכותרות הזה. לאחר מכן, ה'iostream' מתווסף מכיוון שהפונקציות המשמשות לקלט/פלט של הנתונים מוגדרות בו.
לאחר מכן, מרחב השמות 'std' נוסף כאן. מתחת לזה, מופעלת שיטת 'main()'. בתוך זה, אנו מניחים את ה-'cout' המסייע בעיבוד הנתונים שנמקם כאן. ה-'numeric_limits::max()' מוקלד מכיוון שהוא מחזיר את הערך הסופי הגבוה ביותר שהסוג המספרי 'T' יכול לייצג. זה משמעותי עבור כל סוג מוגבל אבל זה לא יכול להיות שלילי.
קוד 1:
#include
#include
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
cout << 'הגודל המרבי של size_t הוא' << מספרי_מגבלות :: מקסימום ( ) << endl ;
}
תְפוּקָה:
אנו עשויים לשים לב שהגודל המקסימלי של סוג 'T' מוצג כעת, שהוא ערך גדול מאוד כפי שמוצג להלן:
דוגמה 2:
שני קבצי כותרות מיובאים לכאן כולל 'גבולות' ו-'iostream. מכיוון שהפונקציות הדרושות לקלט ופלט של הנתונים מוגדרות בו, מתווסף כאן 'iostream'. לאחר מכן, קובץ הכותרת 'מגבלות' משמש כדי לגשת לקבועים המתארים את הגבולות של טיפוסים אינטגרלים כגון ערכי המינימום והמקסימום עבור סוגי נתונים שונים.
לאחר מכן, מרחב השמות 'std' מוצג כאן ונקראת הפונקציה 'main()'. מתחת לזה, אנו משתמשים ב-'INT_MAX' בתוך ה-'cout' כדי להציג את הערך הגבוה ביותר של הגבול העליון של סוג הנתונים של מספר שלם בתכנות C++. לאחר מכן, בשורה הבאה, אנו משתמשים ב-'size_t' שנותן את הערך הגבוה ביותר.
קוד 2:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
cout << 'הערך השלם המקסימלי:' << INT_MAX << endl ;
cout << 'הגודל שהפונקציה size_t מכילה: ' << ( size_t ) 0 - 1 << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה :
הגודל המרבי של המספר השלם מוצג תחילה, אותו אנו מקבלים בעזרת 'INT_MAX'. לאחר מכן, הגודל המקסימלי ש-'size_t' מאחסן מוצג, אותו אנו מקבלים בעזרת 'size_t' בקוד זה.
דוגמה 3:
כאן מיובאים שני קובצי כותרות, 'climits' ו-'iostream'. ה-'iostream' נכלל כאן מכיוון שהפונקציות הנדרשות לקלט ופלט של הנתונים מוגדרות בו. לאחר מכן, ניתן לגשת לקבועים המתארים את הגבולות של טיפוסים אינטגרלים כגון ערכי המינימום והמקסימום עבור סוגי נתונים שונים באמצעות קובץ הכותרת 'climits'.
כאן, הפונקציה 'main()' מופעלת כעת ומרחב השמות 'std' מוצג לאחר מכן. מתחת לזה, אנו משתמשים ב-'INT_MAX' בתוך ה-'cout' כדי להוציא את הגבול העליון של הערך המרבי של סוג הנתונים של מספר שלם בתכנות C++. מתחת לזה, אנו משתמשים ב-'INT_MIN' שמחזיר את הערך הנמוך של סוג הנתונים 'int'. לאחר מכן, אנו משתמשים ב-'size_t' אשר מניב את הערך המרבי שהוא מאחסן בשורה הבאה:
קוד 3:
#include#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
cout << 'הערך השלם הגדול ביותר:' << INT_MAX << endl ;
cout << 'המספר השלם הקטן ביותר:' << INT_MIN << endl ;
cout << 'הגודל שהפונקציה size_t מכילה: ' << ( size_t ) 0 - 1 << endl ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
ראשית, מוצג הגודל המרבי של המספר השלם אותו אנו משיגים בעזרת ה-'INT_MAX'. שנית, מוצג הגודל המינימלי של המספר השלם שאנו משיגים בעזרת 'INT_MIN'. לאחר מכן, בעזרת 'size_t' בקוד זה, הגודל המקסימלי ש- 'size_t' מאחסן מוצג.
דוגמה 4:
קבצי הכותרת הכלולים בקוד זה הם 'cstddef', 'iostream', וכן 'מערך'. קובצי כותרות אלו כלולים כך שנוכל להשתמש בפונקציות שההגדרות שלהן מוגדרות בקבצי כותרות אלו. קובץ הכותרת 'מערך' מתווסף כאן מכיוון שעלינו לעבוד עם ה'מערכים' והפונקציות בקוד זה. אנו מכריזים על המשתנה 'my_sVar' כאן עם ה-'const size_t' ומאתחלים אותו עם הערך '1000' כדי להציג את הגודל שלו.
לאחר מכן, אנו מכריזים גם על מערך 'num[]' של סוג הנתונים 'int' ומעבירים את 'my_sVar' כגודלו. לאחר מכן, אנו משתמשים בפונקציה 'size_of()' שבה אנו מניחים את המשתנה 'num' כפרמטר ומאחסנים אותו במשתנה 'my_size' מסוג 'size_t'. לאחר מכן, אנו משתמשים ב-'cout' ומקלידים כאן 'SIZE_MAX' כך שהוא יציג את הגודל המרבי של המשתנה 'my_sVar'.
לאחר מכן, אנו מציגים את האלמנטים מסוג מערך במספרים קטנים יותר. אנו בוחרים בו רק כדי להציג 10 בתור 1000 שהוא יותר מדי מכדי להתאים בפלט. באמצעות הסוג 'size_t', אנו מתחילים באינדקס 0 כדי להראות כיצד ניתן להשתמש ב-'size_t' גם לאינדקס וגם לספירה. מכיוון שהמספרים יצטמצמו, המערך מוצג בסדר יורד כאשר מיקמנו '-a' בקוד.
קוד 4:
#include#include
#include <מערך>
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
const size_t my_sVar = 1000 ;
int על אחד [ my_sVar ] ;
size_t המידה שלי = מידה של ( על אחד ) ;
cout << 'הגודל המרבי של my_sVar = ' << SIZE_MAX << endl ;
cout << 'כאשר עובדים עם מערך של מספרים, סוג size_t הוא כדלקמן.' ;
מַעֲרָך < size_t , 10 > my_arr ;
ל ( size_t א = 0 ; א ! = my_arr. גודל ( ) ; ++ א )
my_arr [ א ] = א ;
ל ( size_t א = my_arr. גודל ( ) - 1 ; א < my_arr. גודל ( ) ; -- א )
cout << my_arr [ א ] << '' ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הוא מעבד את הגודל המקסימלי של המשתנה תחילה ולאחר מכן מעבד את המערך בסדר יורד.
דוגמה 5:
קוד זה כולל את קבצי הכותרת 'cstddef', 'iostream' ו-'מערך'. מכיוון שקוד זה מחייב אותנו לעבוד עם 'מערכים' ופונקציות, קובץ הכותרת 'מערך' ממוקם כאן. כדי להציג את הגודל של המשתנה 'var', אנו מצהירים עליו כאן עם הערך 'const size_t' ומאתחלים אותו עם '1000'. הגודל המקסימלי של המשתנה 'var' מוצג כאן כאשר השתמשנו בפונקציית 'cout' וציינו 'SIZE_MAX' בשדה זה.
לאחר מכן, אנו מנסים להציג את הפריטים מסוג המערך בכמויות קטנות יותר. עד כה, בחרנו להציג רק 20 כי 1000 ימלאו את הפלט. אנו מדגימים כיצד ניתן להשתמש ב-'size_t' הן לאינדקס והן לספירה תוך שימוש בסוג 'size_t' ומתחיל באינדקס 0. המערך מוצג אז בסדר יורד מכיוון שהמספרים יקטן כפי שמצוין על ידי המיקום של '–a' ב- הקוד הבא:
קוד 5:
#include#include
#include <מערך>
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
const size_t היה = 1000 ;
cout << 'גודל מקסימלי של var = ' << SIZE_MAX << endl ;
cout << 'סוג size_t המשמש עם מערך של מספרים ניתן כ' ;
מַעֲרָך < size_t , עשרים > array_num ;
ל ( size_t אני = 0 ; אני ! = array_num. גודל ( ) ; ++ אני )
array_num [ אני ] = אני ;
ל ( size_t אני = array_num. גודל ( ) - 1 ; אני < array_num. גודל ( ) ; -- אני )
cout << array_num [ אני ] << '' ;
לַחֲזוֹר 0 ;
}
תְפוּקָה :
הוא מעבד את המערך ברצף הולך ופוחת לאחר רינדור המשתנה לגודלו המרבי.
סיכום
סוג 'size_t' בתכנות C++ נחקר ביסודיות במאמר זה. הגדרנו שאנו משתמשים ב-'size_t' בקודי C++ שלנו מכיוון שהוא מאחסן את הערך הגדול ביותר שלו. הסברנו גם שזה סוג לא חתום והוא לא יכול להיות שלילי. הדגמנו את הקודים של תכנות C++ שבהם השתמשנו ב-'size_t' ולאחר מכן ביצענו את התוצאות שלהם במאמר זה.