בשפת תכנות C, קצר int הוא סוג נתונים המשמש לאחסון ערכי מספרים שלמים. זהו משנה סוג שניתן להשתמש בו עם סוג נתונים int כדי ליצור משתנה מספר שלם קטן יותר, תוך שימוש בפחות זיכרון מאשר int רגיל.
ה קצר int סוג הנתונים תופס 2 בתים של זיכרון, שגודלו חצי מגודל רגיל סוג נתונים int , ויכול לייצג ערכי מספרים שלמים בטווח של -32,768 ל 32,767 .
תחביר של Short int
דוגמאות לקוד c#
התחביר להכרזה על משתנה int קצר הוא כדלקמן:
short int variable_name;
לדוגמה, הקוד הבא מצהיר ומאתחל את a קצר int משתנה בשם גיל:
short int age = 25;
משתני int הקצרים יכולים להוביל לשגיאות אם לא משתמשים בהם בזהירות. זה בגלל שיש להם טווח קטן יותר של ערכים מאשר משתני int ועלול לעלות על גדותיו אם יוקצה לו ערך מחוץ לטווח שלהם. מסיבה זו, חשוב לוודא שהערכים המוקצים למשתנה int קצר נמצאים בטווח שלו.
בנוסף, ניתן להשתמש במילת המפתח הקצרה במקום ה- קצר int להכריז על משתנה מסוג זה. לפיכך, שתי ההצהרות הבאות שוות ערך:
short int variable_name; short variable_name;
עוד כמה פרטים נוספים על סוג נתונים 'short int' הם כדלקמן:
כפי שהוזכר קודם, קצר int תופסת 2 בתים של זיכרון, שהוא חצי מהגודל של סוג נתונים אינט רגיל. הגודל של int קצר מוגדר למימוש, מה שאומר שהוא יכול להשתנות בהתאם לפלטפורמה ולקומפיילר בשימוש. עם זאת, זה תמיד מובטח להיות קטן יותר מאשר int רגיל.
מבחינת טווח הערכים, int קצר יכול לאחסן ערכי מספר שלמים בטווח של -32,768 ל 32,767 . ניתן לקבוע טווח זה באמצעות ה SHRT_MIN ו SHRT_MAX קבועים, המוגדרים ב- גבולות.ח קובץ הכותרת.
סוג הנתונים הקצר int משמש בדרך כלל כאשר שטח זיכרון מהווה דאגה, או כאשר טווח הערכים המאוחסן במשתנה הוא בטווח של int קצר. כמה דוגמאות למצבים שבהם ניתן להשתמש ב-int short כוללות:
- במערכות משובצות בהן הזיכרון מוגבל.
- בעת יצירת מערכים גדולים של מספרים שלמים שבהם יש צורך לייעל את השימוש בזיכרון.
- כאשר ידוע שטווח הערכים המאוחסן במשתנה נמצא בטווח של a קצר int , כגון אחסון גילו של אדם, אשר בדרך כלל אינו עולה על 100 שנים .
ה סוג נתונים קצר אינט הוא משנה סוג, מה שאומר שניתן להשתמש בו בשילוב עם סוגי נתונים אחרים ליצירת סוגי נתונים חדשים. לדוגמה, להלן הצהרות תקפות של משתנים:
short int x; short y; short int *ptr; short int arr[10];
בעת ביצוע פעולות אריתמטיות או השוואה בין משתנים מסוגי נתונים שונים, C עשויה לבצע המרות מרומזות כדי להבטיח שהפעולות מבוצעות כהלכה. בעת שימוש במשתני int קצרים, חשוב להיות מודעים להמרות אלו, מכיוון שהן עלולות לגרום להתנהגות בלתי צפויה. לדוגמה, שקול את הקוד הבא:
#include int main() { short int x = 300; short int y = 200; short int z = x + y; printf('%d
', z); return 0; } תְפוּקָה:
500
הֶסבֵּר:
בקוד זה, z i s הוקצה את הערך של 500 , שזו התוצאה הנכונה של הוספה איקס ו ו . עם זאת, אם ה printf ההצהרה משתנה ל printf('%hu ', z), הפלט יהיה 244 , שהיא תוצאה של המרה 500 לבלתי חתום קצר int . זה קורה בגלל ה %hu נעשה שימוש במפרט פורמט, המציין שהערך המודפס צריך להיות int קצר ללא חתימה.
בעת ביצוע פעולות בין משתנים מסוגי נתונים שונים, C עשויה לבצע קידום והורדה בדרגה כדי להבטיח שהפעולות מבוצעות כהלכה. קידום מתרחש כאשר משתנה מסוג נתונים קטן יותר מומר באופן מרומז למשתנה מסוג נתונים גדול יותר, בעוד שהורדה מתרחשת כאשר משתנה מסוג נתונים גדול יותר מומר באופן מרומז למשתנה מסוג נתונים קטן יותר. כאשר משתמשים במשתני int קצרים, חשוב להיות מודעים לקידום והורדות אלו, שכן הם יכולים להשפיע על תוצאות פעולות חשבון והשוואה.
עץ בינארי ג'אווה
אם משתנה int קצר מוכרז ללא אתחול, ערכו אינו מוגדר. במילים אחרות, הוא יכול להכיל כל ערך, כולל ערך שלילי או ערך מחוץ לטווח של קצר int . לכן, נוהג טוב תמיד לאתחל משתנים לערך ידוע כאשר הם מוצהרים.
יְצִיקָה הוא תהליך המרת משתנה מסוג נתונים אחד לאחר. בעת יציקת משתנה ל-a קצר int , הערך של המשתנה נחתך כך שיתאים לטווח של קצר int . לדוגמה, שקול את הקוד הבא:
int x = 500; short int y = (short int) x;
בקוד זה, הערך של איקס הוא 500 , שהוא מחוץ לטווח קצר int. עם זאת, מתי איקס יצוק ל-a קצר אינט, הערך נחתך כך שיתאים לטווח של קצר int , וכתוצאה מכך ו מיוחס לערך של -12 . לכן, בעת יציקת משתנים, חשוב לוודא שהערך המתקבל נמצא בטווח של סוג הנתונים הנוצק.
כברירת מחדל, קצר int הוא סוג נתונים חתום , מה שאומר שהוא יכול לייצג ערכים חיוביים ושליליים כאחד. עם זאת, אפשר גם להצהיר קצר int כסוג נתונים לא חתום, תוך שימוש ב- קצר אינט אוֹ מילת מפתח קצרה לא חתומה . int קצר ללא סימן יכול לייצג רק ערכים לא שליליים, אבל הטווח שלו מוכפל ל 0 ל 65,535 .
java הוא מופע של
מאז קצר int הוא סוג נתונים קטן יותר מאשר int , ניתן לקדם אותו באופן מרומז ל-int כאשר נעשה בו שימוש ב חֶשְׁבּוֹן או השוואת פעולות עם int. זה אומר שא קצר int ניתן להשתמש בכל מקום בו int צפוי, ללא צורך בקאסט מפורש.
הגודל של קצר int יכול להשתנות בהתאם לפלטפורמה ולמהדר בשימוש. כדי להבטיח ניידות של קוד על פני פלטפורמות שונות, מומלץ להשתמש ב- קובץ הכותרת stdint.h , המגדיר סוגי מספרים שלמים בגודל קבוע עם רוחב וסימנים ספציפיים. לדוגמה, ה סוג int16_t הוא סוג מספר שלם חתום ב-16 סיביות , שהוא שווה ערך ל קצר int ברוב הפלטפורמות.
כאשר מכריזים על מערך של ערכי int קצרים , כל רכיב של המערך נגיש באמצעות אינדקס. האינדקס יכול להיות מילולי של מספר שלם או משתנה מסוג int. עם זאת, אם האינדקס הוא משתנה מסוג קצר int , הוא יקודם אוטומטית ל-an int לפני השימוש לגישה למערך. לדוגמה:
short int arr[10]; short int i = 5; short int val = arr[i]; // i is promoted to int before being used as an index
קצר int יכול לשמש עבור פעולות מניפולציה של סיביות, כגון הסטה ו מִסוּך . בעת העברת א קצר int ערך, התוצאה היא ערך int קצר. עם זאת, בעת שימוש באופרטורים סיביים כמו & ו |, ערכי int קצרים מקודמים תחילה ל-int לפני ביצוע הפעולה.
במקרים מסוימים, שימוש קצר ב-int במקום ב-int יכול לשפר את הביצועים, במיוחד בפלטפורמות עם זיכרון מוגבל או כוח עיבוד מוגבל. עם זאת, זה תלוי ביישום הספציפי ובחומרה שבה נעשה שימוש, ויש לבדוק אותו על בסיס כל מקרה לגופו.
שפת C מספקת סיומת לאתחול משתנים עם סוג int קצר. הסיומת 's' אוֹ 'S' ניתן להשתמש עם ערך קבוע לציון קבוע int קצר במפורש. לדוגמה:
Short int x=10s;