כיצד להמיר סוגי נתונים ב-C++
ב-C++, יש שתי דרכים לשנות סוגי נתונים:
המרת סוג מרומז
על פי הכללים שהוגדרו מראש על ידי מהדר הקוד C++, המרת סוג מרומז היא המרת הסוג שמתבצעת על ידי המהדר באופן אוטומטי ללא דרישה לטריגר חיצוני כלשהו מהמשתמש. סוג המרה זה מתרחש בדרך כלל בתוכנית כאשר יש יותר מסוג נתונים אחד, וסוג הנתונים של הביטוי אינו תואם לסוג הנתונים של המשתנה המעורב בביטוי זה.
כדי למנוע אובדן נתונים במהלך ההמרה, המהדר משנה כברירת מחדל את סוג הנתונים המדויק הנמוך עם סוג הנתונים בעל דיוק גבוה יותר. לדוגמה, זה ימיר מספר שלם לצף במקום לשנות את הצף למספר שלם כדי למנוע אובדן נתונים. זה נקרא קידום. להלן דיאגרמת העדיפות עבור סוגי הנתונים השונים.
הזמנה להמרת סוג
הסדר הנכון להמרת סוג ניתן כ:
בול -- > char -- > קצר אינט -- > int -- > אינט לא חתום -- > ארוך -- > לא חתום ארוך -- > ארוך ארוך -- > לצוף -- > כפול -- > כפול ארוך
המשתנה מסוג דיוק נמוך מומר לסוג הנתונים ברמת דיוק גבוהה כדי למנוע אובדן נתונים.
דוגמה 1
בדוגמה זו, הוספה מתבצעת על המשתנה של סוגי נתונים שונים באמצעות המרת הסוג המרומז.
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
int מספר = 100 ;
לְהַשְׁחִיר אופי = 'ג' ;
cout << '100 + 'C' = ' << מספר + אופי << endl ;
לָצוּף val = מספר + 'ג' ;
cout << 'float val(100 + 'c') = ' << val << endl ;
int היה = 7890 ;
ארוך לא היה = היה ;
cout << 'var_int = ' << לא היה ;
לַחֲזוֹר 0 ;
}
כאן מוסיפים מספר שלם ותו מטבלת ASCII, ומספר צף והתו 'c'. המספר השלם נשמר בקטע השלישי כסוג נתונים ארוך וסוגי הנתונים משתנים על ידי המהדר עצמו בהתבסס על הכללים המוגדרים מראש שלו.
הסכום של 100 ו-'C' מחזיר 167 כשה-'C' שווה ל-67 במספרים ו-100+'c' מחזיר 199 כ-'c' הקטנה משווה ל-99. משתנה int מאוחסן בסוג נתונים ארוך.
דוגמה 2
בדוגמה זו, התו D מומר לצוף לביצוע פעולת החלוקה.
#includeבאמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
לְהַשְׁחִיר איקס = 'ד' ;
לָצוּף float_var ;
float_var = לָצוּף ( איקס ) / 'ג' ;
// המרה מפורשת של int ל-float.
cout << 'הערך של float_var הוא: ' << float_var << endl ;
לַחֲזוֹר 0 ;
}
ערך הקלט הוא בצורת תו D אשר מאוחסן ב-float data type ומחולק עוד יותר על ידי תו C. תווים אלו משתנים לערכים מספריים ומבצעים עליהם פעולת חלוקה, המחזירה את הערך ב-float.
המרת סוג מפורש
המשתמש חייב לשנות באופן ידני את סוג הנתונים עם המרת הסוג המפורש של C++, המכונה לעתים קרובות casting. סוג זה של ליהוק נעשה כדי להימנע מהמרת הסוג המרומז. ישנן שתי שיטות לבצע יציקת סוג מפורש ב-C++:
- המרה באמצעות ה-Assignment Operator
- המרה באמצעות ה-Cast Operator
הקלד המרה באמצעות ה-Assignment Operator ב-C++
המרת סוג באמצעות ה-Assignment Operator מתבצעת בכוח, כלומר, סוג נתונים אחד מומר באופן ידני לאחר. זה מושג באמצעות אופרטור ההקצאה '=', המקצה את הערך של האופרנד הימני למשתנה בצדו השמאלי.
דוגמא
תוכנית זו מחשבת את שטח המעגל באמצעות יציקת סוג.
#include
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
int רַדִיוּס ;
cout <> רַדִיוּס ;
לָצוּף אֵזוֹר = M_PI * רַדִיוּס * רַדִיוּס ;
cout << 'שטח מעגל עם רדיוס' << רַדִיוּס << ' = ' << אֵזוֹר ;
}
אופרטור ההקצאה משמש להקצאת הערך הצף לאזור, המורכב מערך הרדיוס בסוג הנתונים של מספר שלם.
שטח המעגל מוחזר בסוג נתונים צף, בעוד שהרדיוס מוקלט בסוג נתונים שלם. לפיכך, סוג הנתונים של המשתנה משתנה באמצעות יציקת סוג באמצעות אופרטור ההקצאה.
הקלד המרה באמצעות אופרטור Cast ב-C++
המרת סוג מתבצעת באמצעות אופרטור cast, אשר מאלץ סוג נתונים אחד לעבור לסוג אחר בהתאם לצרכי התוכנית.
ישנם ארבעה מפעילי שחקנים שונים:
- static_cast
- const_cast
- cast_dynamic
- לפרש_קאסט מחדש
1: static_cast
ה-static_cast הוא אופרטור הליהוק המשמש להמרת מצופים ותווים במפורש למספרים שלמים וכן הלאה. זהו מפעיל השחקנים הבסיסי ביותר. הוא יכול להעביר סוגי נתונים דומים באופיים. זה יכול להמיר מצביעים מצורה אחת לאחרת, כך שהוא יכול לשמש גם לניהול זיכרון.
תחביר
static_cast ( ביטוי ) דוגמא
תוכנית זו בנויה להמיר משתנה כפול לסוג נתונים int באמצעות static_cast. זה ינתק כל חלק עשרוני בפלט.
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
// להכריז על משתנה
לְהַכפִּיל ע ;
ע = 2,905 * 1,235 * 24,675 ;
לָצוּף תוֹצָאָה ;
cout << 'לפני השימוש בגבס הסטטי:' << endl ;
cout << ' הערך של p = ' << ע << endl ;
// השתמש ב-static_cast כדי להמיר את סוג הנתונים
תוֹצָאָה = static_cast ( ע ) ;
cout << 'לאחר שימוש בקאסט הסטטי:' << endl ;
cout << 'ערך התוצאה = ' << תוֹצָאָה << endl ;
לַחֲזוֹר 0 ;
}
בתחילה, משתנה כפול p נטען בערכים המוכפלים זה בזה ומאוחסנים בתוצאה. התוצאה מכילה את התוצאה לפני ואחרי האופרטור static_cast:
לפני השימוש באופרטור static_cast, התוצאה מוצגת בנקודות עשרוניות, בעוד שלאחר שימוש באופרטור זה היא מוצגת בסוג נתונים שלמים.
2: const_cast
האופרטור const_cast משמש להמרת ערך קבוע של אובייקט לסוג שאינו קבוע. הוא משמש במקום שבו מוצהר אובייקט קבוע, ואנחנו צריכים לשנות את ערכו מדי פעם.
תחביר
const_cast ( ביטוי ) דוגמא
בדוגמה זו, האופרטור const_cast משמש להסרת ה-Qualifier הקבוע באופן זמני ומאפשר לבצע שינויים במשתנה בהתאם לצורך:
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( ) {
const int איקס = 70 ;
const int * ו = & איקס ;
cout << 'הערך הישן הוא' << * ו << ' \n ' ;
int * עם = const_cast ( ו ) ;
* עם = 90 ;
cout << 'ערך חדש הוא' << * ו ;
לַחֲזוֹר 0 ;
}
המוקד הקבוע מוקצה למשתנה int x מה שאומר שלא ניתן לשנות את המשתנה הזה ישירות. אחרי זה נעשה שימוש ב-int *y שהוא מצביע כדי לגשת ל-x, אבל עדיין לא ניתן לשנות אותו, והערך המקורי שלו מוצג באמצעות cout. באמצעות האופרטור const_cast, נוצר מצביע z שאינו קבוע, הוא משמש כדי לגשת לערך של x מה שהופך אותו לאפשר לעריכה. זה משנה את הערך שהוקצה ל-z עם 90 שמשנה בעקיפין את הערך ב-x.
בתחילה, הערך של המשתנה הקבוע x הוא 70 אשר משתנה באמצעות האופרטור const_cast, מה שהופך אותו ל-90.
3: cast_dynamic
עם ההיררכיה של הירושה, המכונה גם למטה בטוח מסוג. השלכת מטה היא תהליך המרת הפניה או מצביע למחלקה נגזרת מהפניה או מצביע של מחלקה בסיסית.
תחביר
cast_dynamic ( ביטוי ) דוגמא
בדוגמה זו, האופרטור dynamic_cast משמש כדי לבדוק את סוג המחלקה הפולימורפית, והוא מאפשר גישה גם לחברי מחלקה בסיס וגם נגזרים.
#include <חריגה>
באמצעות מרחב שמות סטד ;
מעמד TBase
{
פּוּמְבֵּי :
לָצוּף base_g = 9.81 ;
וירטואלי בָּטֵל דֶמֶה ( )
{
} ;
} ;
מעמד נגזר : פּוּמְבֵּי TBase
{
פּוּמְבֵּי :
int local_g = 9.78 ;
} ;
int רָאשִׁי ( )
{
TBase * בסיס = חָדָשׁ נגזר ;
נגזר * נִגזָר ;
נִגזָר = cast_dynamic ( בסיס ) ;
cout < base_g << endl ;
cout < local_g << endl ;
getchar ( ) ;
לַחֲזוֹר 0 ;
}
שתי מחלקות מוגדרות כמחלקות בסיס ומחלקות נגזרות. בסיס מצביע מסוג TBase* נוצר ומוקצה לאובייקט שהוקצה באופן דינמי מסוג TDerived. ניתן להקצות אובייקט מחלקה נגזר למצביע מחלקה בסיס במקרה זה של פולימורפיזם. ה-dynamic_cast בודק אם המצביע ניגש לאובייקט התקף של TDerived, אם ה-cast מקבל תוצאה מוצלחת המחלקה הנגזרת תקבל תוצאה חוקית אחרת היא תחזיר ערך null.
4: reinterpret_cast
ה-reinterpret_cast הופך מצביע מסוג נתונים אחד למצביע מסוג אחר. זה לא בודק אם סוגי הנתונים של המצביעים זהים או לא. יש להשתמש במפעיל יציקה זה ולטפל בזהירות.
דוגמא
באיור זה, המצביע של סוג נתונים אחד מתפרש מחדש למצביע מסוג נתונים אחר באמצעות ה-reinterpret_cast:
באמצעות מרחב שמות סטד ;
int רָאשִׁי ( )
{
int * ש = חָדָשׁ int ( 70 ) ;
לְהַשְׁחִיר * ch = לפרש_קאסט מחדש ( ש ) ;
cout << * ש << endl ;
cout << * ch << endl ;
cout << ש << endl ;
cout << ch << endl ;
לַחֲזוֹר 0 ;
}
בתחילה, מוקצה מספר שלם עם הערך 70. המצביע q מצביע על מספר שלם זה המוקצה באופן דינמי. ה-reinterpret_cast משמש כדי לפרש מחדש את המצביע q כמצביע תו ch, מה שאומר שהזיכרון שהוקצה במקור ל-q מטופל כעת כאילו הוא תו. באמצעות הפקודה cout, הוא מדפיס את הערך שהוקצה ל-q ול-ch. מכיוון ש-ch מטופל כאל מצביע תו, הוא יחזיר ערך תו.
הוא מדפיס את הערך שהצביע על ch באמצעות *ch. עם זאת, מכיוון ש-ch מטופל כאל מצביע תו, שורה זו תפרש את הזיכרון כתו. הוא מדפיס את כתובת הזיכרון המאוחסנת במצביע ch באמצעות ch. זוהי אותה כתובת זיכרון כמו q כי היא רק פרשנות מחדש של אותו זיכרון.
בתחילה, המספר השלם מאחסן 70. מאוחר יותר, זה עובר מניפולציה בין המצביע q לבין המצביע ch. יציאות 2 ו-4 זהות מכיוון שהערך השני מתפרש מחדש באמצעות reinterpret_cast.
הערה : מומלץ לא להשתמש באופרטור הליהוק הזה עד וללא צורך רב מכיוון שהוא הופך את האובייקט למוצר לא נייד
סיכום
התהליך של שינוי סוג הנתונים של משתנה אחד למשנהו ידוע כהמרת סוג או יציקת סוג ב-C++. זה נעשה כדי לבצע פעולות מתמטיות על המשתנים של סוגי נתונים שונים, על ידי הפיכת סוגי הנתונים שלהם לתואמים זה לזה. המרת סוג מייעלת את הקוד. ישנן המרות מסוג מרומז ומפורש ב-C++. המרת סוג מרומז מבוצעת על ידי המהדר עצמו באמצעות מערכת חוקים מוגדרת מראש, בעוד שהמרת סוג מפורש מתבצעת על ידי המתכנת באמצעות אופרטורים של הקצאה ואופרטורים של cast.