ויקיספר

שפת C/פלט וקלט: הבדלים בין גרסאות בדף

עיון אינטראקטיבי בהיסטוריה
→ העריכה הקודמתהעריכה הבאה ←
תוכן שנמחק תוכן שנוסף
חזותיקוד ויקי
נו באמת
מאין תקציר עריכה
תגית: אמוג'י
שורה 271:
 
[[קטגוריה:שפת C (ספר)|פלט וקלט]]
 
 
[[פלט וקלט מאת LTG Liam YT]]
 
ת
הערות כלליות, ומושגים
Namespace - מרחב שמות
אוסף של מחלקות שקובצו יחד וקיבלו שם משותף. אפשר לחשוב על המחלקות הלו כתוכניות
הנותנות שירותים שונים למתכנת מבלי שהוא יצטרך לכתוב את הקוד בעצמו. על מנת להשתמש
במחלקות הנמצאות ב-מרחב שמות כלשהו, נצטרך הוסיף בתחילת התוכנית שורה – ; "שם
מרחב השמות" using
מרחב השמות System כולל מחלקה מיוחדת Console המספקת שרותי קלט פלט – נרחיב
בהמשך.
אצלנו מרחב השמות נקבע כרצוננו, בד"כ לפי שם הפרויקט בו אנו כותבים את התוכנית.
הצהרה על class
#C בהיותה שפה מוכוונת עצמים משתמשת במחלקות (class (על מנת להגדיר עצמים
(אובייקטים), תוכנית שלנו הינה אובייקט ועל מנת לייצור אותו צריך ליצור מחלקה המגדירה
אותו.
אצלנו שם המחלקה יכול להקבע כרצוננו לפי משמעות המחלקה שאנו כותבים.
()Main void static – כותרת (מצומצמת) של הפעולה הראשית.
התוכנית בשפת #C - מתחילה תמיד מהפעולה הראשית Main.
המילה Main היא מילה שמורה, מתחילה תמיד (חובה) באות גדולה.
פעולה הינה קטע קוד שנועד לבצע משימה מוגדרת.
בהמשך הלימודים נרחיב בנושא – פעולות, ומחלקות בהקשרים רחבים של שפה מוכוונת
עצמים.
סוגרים מסולסלים {} -
קובעים בלוק (קטע תכנית), גבולות שבתוכן מוגדרות הוראות השפה (הגדרות, הפעולות וכד')
בהתאם להקשר שבו הם מופיעים. בדוגמא שלנו:
יש {} עבור גבולות מרחב השמות, ויש {} עבור המחלקה כולה, וגם {} עבור הפעולה Main.
תיעוד הערות
על מנת שתוכנית תהיה ברורה לקורא התוכנית, היא חייבת להיות מוסברת (מתועדת) היטב.
תיעוד התוכנית מסייע למתכנת להבין את הרעיון שעומד מאחורי הקוד שנכתב, מה היה קו
המחשבה במהלך פיתוח התוכנית, כך שבעתיד קל יותר יהיה לתחזק אותה או לשדרגה.
ההערות הינן כלי תחבירי של השפה באמצעותו ירשם התיעוד בתוכנית אבל הן אינן הוראות
לביצוע ולכן המהדר מתעלם מהן.
סוגי הערות המוכרים:
 הערת קטע: הערה היכולה להשתרע על פני מספר שורות.
הערת קטע תחומה (משמאל לימין), בין סימן */ (הפותח את ההערה) והסימן /* (הסוגר אותה).
דוגמא: /* גוף ההערה */
 הערת שורה: הערה מסוג זה מתחילה בסימן // ומסתיימת בסוף השורה
שימו ♥ לפי דרישת תכנית הלימודים, חובה לרשום תיעוד בראש כל תכנית.
מילים שמורות
בכל שפת תכנות קיימות מילים שמורות. מילה שמורה היא מילה שהשימוש בה והמובן שלה
שמורים
לשימוש בלעדי ע"י השפה ולא ניתן לשנות את משמעותה.
עיצוב כללי
 תוכנית לביצוע תהיה מורכבת מהוראות השפה ותיכתב בתוך הסוגריים המסולסלים תוך
שמירה על כללי כתיבה מקובלים כמו הזחות (indent (הקובעות את מיקום תחילת השורה -
ביחס לשורה שלפניה. חשוב להקפיד על הזחות ברורות הן תורמות לקריאוּת התוכנית.
 תווי רווח : (whitespace (תווי רווח הינם רווחים בין המילים, טאבים (tab (וירידת שורה  כל הוראה בשפת #C חייבת להסתיים בסימן נקודה פסיק – ( ; )
(מקש Enter ,(המהדר מתעלם מתווי רווח.
שימו ♥ עם זאת, המהדר אינו מתעלם מתווי רווח בתוך מחרוזת טקסט המופיעה בין גרשיים
 שפת #C הינה שפה תלוית ראשיות , (sensitive case (כלומר קיימת הבחנה בין אותיות
גדולות(case upper (ואותיות קטנות (case lower .(מילים Main ו main - נחשבות
למילים שונות בשפה. חובה להקפיד על גודל אות מתאים.
הכרזה על משתנים בתוכנית
הנחיות כלליות
• חובה להצהיר על כל משתני התוכנית.
• מספר שורות ההגדרה אינו מוגבל.
• נהוג להכריז על משתנים בעלי תפקידים דומים באותה שורה, ולספק תיאור של תפקיד
המשתנה כהערה בקצה השורה.
מבנה הגדרת משתנה • לכל משתנה יש טווח הכרה (scope ,(משתנה מוכר וקיים בתוך הבלוק שבו הוא נוצר.
הגדרת סוג משתנה (type data(
טווח ערכים
גודל
(מס' bit(
סוג
data type – טיפוס(
(
-27
<= X <= 27 sbyte 8 -1
-215 <= X <= 215 short 16 -1
-231 <= X <= 231 int 32 -1
-263 <= X <= 263 long 64 -1
±1.5 × 10-45 <= X <= ±3.4 × 1038 float 32
±5.0 × 10-324 <= X <= ±1.7 × 10308 double 64
char 16 Unicode characters (*)
bool 8 true or false (**)
0 <= X <= 28 byte 8 -1
0 <= X <= 216 ushort 16 -1
0 <= X <= 232 uint 32 -1
0 <= X <= 264 ulong 64 -1
מס' * 16 כמעט בלתי מוגבל
התווים
string
שימו ♥ אין לכלול משתנים מטיפוסים שונים באותה שורת הגדרה.
(*) טבלת Unicode
תקן (סטנדרט) ה- Unicode מורכב בין היתר, משיטת קידוד המספקת ערכים קבועים, לדוגמא
בטבלה להלן, לייצוג של תווים סטנדרטיים, עבור מרבית השפות בעולם. הערכים מאפשרים
להגדיר יחס (לקסיקוגרפי) בין שתי אותיות.
אין צורך ללמוד בע"פ את מיקום התווים בטבלה, מספיק לזכור את הסדר (העיקרי) :
151
4
148
8
12
2
0
7
9
0
6
5
5
7
4
המקום בטבלה 8
9 A ... Z a ... z א ... ת
..
.
0 התו
 אותיות ABC קודמות לאותיות abc
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~  כל אות מה-abc נמצאת במרחק 32 מהאות במקבילה לה ב-ABC
(**) משתנה מסוג bool
שאלה –
למה הגודל של משתנה בוליאני הוא - bit 8 = byte 1 ,ולא רק ביט אחד ?
תשובה
Byte - היחידה הקטנה ביותר, שניתן לגשת אליה בזיכרון.
מטעמי יעילות וביצועים. מה יעשו עם שאר ה-bits ? וגם אם כמה משתנים "ישתמשו" באותו
byte זה "לא שווה" את רמת הסיבוכיות שתעלה.
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
מתן שם למשתנה
ישנם מספר חוקים ומוסכמות למתן שמות למשתנים:
• לכל משתנה יש שם ייחודי לו. כלומר, לא ניתן להגדיר שני משתנים או יותר בעלי אותו השם.
• שם משתנה חוקי יכול להיות מורכב מסדרה של אותיות באנגלית, ספרות וקו תחתי _ .
• השם חייב להתחיל באות.
לא יכול להתחיל בספרה, אסור לכלול תווי רווח וסימנים אחרים.
מאד לא מקובל ששם משתנה יכיל אותיות בעברית, לכן אצלנו השם לא יכיל אותיות
עבריות.
• שפת #C היא שפה תלוית ראשיות (sensitive case ,(כלומר יש חשיבות לגודל אות. לכן :
 מקובל שאם שם המשתנה מורכב ממספר מילים, תתחיל כל מילה, החל מהמילה
השנייה, באות גדולה. לדוגמא: numberOfStudents , newNum, myNumber
 בגלל הרגישות לגודל אות, הרי שהשמות:
newnum , NewNum , newNum מתייחסים לשלושה משתנים שונים.
• שימו ♥ מילים שמורות אינן יכולות לשמש כשמות של משתנים.
משתנה שנקרא a או b או c לא אומר לנו שום דבר, מה משמעות התוכן שהוא מכיל ? • מעבר לכללים ולמוסכמות של השפה,
לעומת זאת אם למשתנה נקרא age) gil (או sum או , length ניתן יהיה להבין מהשם
את המשמעות של התוכן.
לכן, אצלנו שם של משתנה חייב להיות משמעותי, כך שמשמו ניתן יהיה להבין את
משמעותו.
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
מתן ערכים למשתנה – הוראת השמה
הוראת השמה משמשת להכנסת נתונים לתוך המשתנים.
השמה (הכנסה) של נתון למשתנה מוחקת את הערך שהיה שמור במשתנה, ושומרת את הערך
החדש בלבד (כלומר, המשתנה משנה את ערכו).
האופרטור לביצוע הפעולה הוא =
בניסוח אלגוריתם בפסאודו קוד, השמה תסומן על ידי כשכיוון החץ מצביע על המשתנה
המקבל .
לדוגמא: 100 dollar ,קרא 100 יושם במשתנה dollar.
שימו ♥
 טיפוס הערך המושם בתא חייב להיות תואם את טיפוס הנתונים של התא המקבל.
 משתנה מטיפוס ממשי (double (יכול לקבל (מ-קבוע או משתנה או תוצאת חישוב) :
 ערך ממשי או
 ערך שלם.
 משתנה מטיפוס שלם (int(
 יכול לקבל (מ-קבוע או משתנה או תוצאת חישוב) ערך שלם בלבד.
 ניסיון להשמת ערך ממשי (כלומר, המכיל נקודה עשרונית), יגרום להודעת
שגיאה.
 השמה (הכנסה) של נתון למשתנה מוחקת את הערך שהיה שמור במשתנה, ושומרת את
הערך החדש בלבד. על מנת להבהיר ולהסיר ספק – גם אם במשתנה המקבל היה ערך
כלשהו, ערך זה נמחק לאחר פעולת ההשמה. המחשב לא "זוכר" את הערך שהיה במשתנה
קודם לכן.
השמת קבוע
מבנה ההוראה: <קבוע> = <שם-משתנה-מקבל>
המשמעות, הכנס לתוך <שם-משתנה-מקבל> ערך קבוע.
דוגמא:
int a;
a = 5;
(*) אתחול
(**) הגדרת קבועים
השמת ערך ממשתנה אחר
מבנה ההוראה: <שם-משתנה-נותן> = <שם-משתנה-מקבל>
המשמעות, הכנס לתוך <שם-משתנה-מקבל> את הערך הנמצא ב- <שם-משתנה-נותן>
דוגמא:
int a , b ;
a = 5 ;
b = a ;
(***) המרות בין טיפוסי נתונים - casting
השמת ביטוי חשבוני
מבנה ההוראה: <ביטוי חשבוני> = <שם-משתנה-מקבל>
המשמעות, הכנס לתוך <שם-משתנה-מקבל> את הערך המחושב ב- <ביטוי חשבוני>
דוגמא:
int a , b ;
a = 5 ;
b = a * 8 ;
שימו ♥
 הביטוי יכול לכלול:
קבועים מספריים, משתנים, חישובים מתמטיים (+ - × ÷) וערך המוחזר מפונקציות
מתמטיות
 סדר הקדימויות של החישובים המתמטיים הוא סדר הקדימויות המתמטי:
 כפל וחילוק קודמים לחיבור וחיסור.
 סוגריים משנים את סדר החישוב.
סיכום  המשתנה לא יכיל את הביטוי החישובי אלא את תוצאת הפעולה, כלומר – ערך מספרי.
למשתנה יש סוג (type data - טיפוס), שם, ערך.
למה קוראים לו משתנה –
כי הערך שיש לו יכול להשתנת במהלך התוכנית.
זכרו - רק הערך יכול להשתנות (כלומר לא השם ולא הסוג).
המשך-להוראות-קלט-פלט
(*) אתחול נתונים
תזכורת - משתנה חייב להיות מוגדר לפני השימוש הראשוני בו. לכן, מקובל (נהוג) להגדיר את
משתני הפעולה בתחילת הפעולה לפני ההוראות לביצוע.
אתחול הינו השמה של ערך התחלתי למשתנה. ברוב המקרים האתחול יתבצע ע"י השמה של
קבוע למשתנה.
ניתן לתת למשתנים ערך התחלתי בשלב ההגדרה (הצהרה) שלהם או במהלך התוכנית.
דוגמא:
בשלב הגדרת המשתנים
int a = 5, b = 21;
double x = 7.32;
string str = "abc" ;
במהלך התוכנית
int a;
a = 5 ;
double x ;
x = 7.32 ;
string str ;
str = "abc";
(**) הגדרת קבועים חזור
מה מייצג הביטוי הבא ?
60 * 60
ומה מייצג הביטוי הבא?
NUM_OF_MINUTES * NUM_OF_SECONDS
מסקנה - עבודה עם קבועים הופכת את הנוסחאות ליותר קריאות
הכרזה על קבוע נעשית בחלק שבו מצהירים על המשתנים וכוללת את המילה השמורה
.const
ההכרזה קובעת ערך סופי למשתנה (הקבוע) ואין אפשרות לשנותו בהמשך התוכנית.
הקבוע יכול להיות מחרוזת, מספר שלם או מספר ממשי.
כדי להקל על זיהוי קבועים, נהוג לרשום (בשונה מהמוסכמות המקובלות) :
 שם הקבוע - באותיות גדולות (CASE UPPER.(
מבנה ההוראה: <ערך קבוע> = <שם-הקבוע> <טיפוס הנתונים> const  אם שם הקבוע מכיל יותר ממילה אחת, נשתמש בקו תחתי כמפריד בין המילים.
לדוגמא:
const int NUM_OF_MINUTES = 60;
const int NUM_OF_SECONDS = 60;
הרחבה של שימוש בקבועים נראה בפרק העוסק ב- לולאות.
חזור
(***) המרות בין טיפוסי נתונים - casting
היהפוך כושי עורו, ונמר חברבורותיו" (ירמיהו כ"ג) ?
בחיים אולי לא, אבל בעולם התכנות ניתן להמיר string ל-int ולהיפך, ניתן גם להמיר
doubleל-int או ל-float .לא רק שניתן, זה אפילו נחוץ ואף הכרחי בלא מעט מקרים.
אבל זהירות, זה גם יכול להיות מסוכן, לגרום לאובדן מידע במקרים מסוימים, ומזה אנחנו מאוד
רוצים להימנע.
קיימות שתי אפשרויות עיקריות לביצוע המרה מטיפוס אחד לטיפוס אחר:
● casting implicit - המרה מרומזת
 אין צורך לציין את ההמרה בכתיבת ה-casting .
 היא בטוחה ושום נתון לא יכול ללכת לאיבוד.
 מתבצעת אוטומטית ע“י המהדר, בשני מקרים עיקריים:
o המרה מטיפוס אחד (קטן) לטיפוס אחר (גדול) המסוגל להכיל בוודאות כל ערך
מהטיפוס הראשון.
לדוגמא:
double d ;
int i = 123 ;
d = i ;
o המרה מטיפוס של מחלקה נגזרת (Derived (לטיפוס של המחלקה ממנה הוא יורש
(Base .(לדוגמא, טיפוס מסוג מחלקת Employee יכול בצורה מרומזת להיות
מומר לטיפוס ממחלקת הבסיס Person ממנה הוא יורש (מכיוון שכל עובד הוא
בהכרח גם אדם).
● casting explicit - המרה מפורשת
 בה חובה לבצע את כתיבת ה-casting ,כלומר שימוש באופרטור ה-cast) <= type.(
כלומר, סוגריים עגולים שבתוכם סוג המשתנה שאליו רוצים לבצע את ההמרה.
 מידע יכול ללכת לאיבוד בזמן ההמרה או שההמרה יכולה להסתיים בכישלון מסיבות
שונות.
 מתבצעת ע“י המתכנת אשר מציין במפורש את סוג הטיפוס אליו הוא רוצה להמיר.
לדוגמא:
double d = 12.345
int i;
i = (int)d ;
שימו ♥
בדוגמא אנחנו נאבד חלק מהדיוק של המספר, מכיוון שטיפוס היעד – int אינו מאפשר
להכיל חלק עשרוני.
העשרה – בסוף הקובץ
חזור
הוראות קלט פלט בתוכנית
כדי ליצור אינטראקציה בין המשתמש (בתוכנית) והתוכנית עצמה משתמשים בהוראות קלט
ופלט.
הוראות הקלט משמשות – לקבלה והכנסה של נתונים מן המשתמש לתוך המשתנים,
הוראות הפלט נועדו –להציג את תוכן תאי הנתונים.
הוראות הקלט והפלט בשפת #C נעשות דרך המחלקה Console המציעה אוסף של פעולות
המטפלות
בקלט מידע מהמקלדת, ופלט לחלון ה- Console של מערכת ההפעלה, הלא הוא המסך.
הפעלת פעולה של מחלקה נעשית בדרך הבאה:
( )שם-הפעולה.שם-המחלקה
ClassName.MethodName ( )
נרחיב על נושא המחלקות בהמשך לימודי מדעי המחשב.
הוראות פלט
שליחת מידע לאמצעי הפלט הסטנדרטי (המסך), מבנה ההוראה:
; ( המידע שיוצג על המסך ) Write.Console
; ( המידע שיוצג על המסך ) WriteLine.Console
הוראת Write.Console מדפיסה את המידע ומשאירה את הסמן במקום בו הסתיימה
ההדפסה.
ההוראה WriteLine.Console מדפיסה את המידע ומעבירה את הסמן לתחילת השורה
הבאה.
דוגמא:
int myVar = 7 ;
Console.WriteLine("the number is " + myVar) ;
האופרטור + שראינו בפקודה מאפשר צירוף של מחרוזות ו-משתנים
צירוף של פרטי מידע נקרא שרשור.
(*) שליטה בצורת התצוגה – format
הוראות ההדפסה גורמות להדפסת הנתונים בצורה שנקבעה מראש.
#C מאפשרת להציג את הפלט תוך שימוש בסמנים (markers(
Console.WriteLine (" תוכן1: {0} תוכן2: {1} תוכן3: {2}", val0, val1, val2);
מבנה הפקודה:
מחרוזת (רכיב ראשון) הכוללת את הטקסט להדפסה (להצגה) ואת הסמנים המתאימים.
לאחר סגירת המחרוזת יש לרשום את תוכן המשתנים או הקבועים אותם (הערכים) יש להדפיס,
כך שכל משתנה או קבוע מתאים לסמן שלו, לפי סדר הופעתם במחרוזת.
סמנים (markers(
 הסמן יהיה מספר שלם, התחום בסוגרים מסולסלים.
 ערך הסמן הראשון יהיה תמיד {0.{
 ערכי כל סמן הבא אחר כך, יהיה עוקב לערך הסמן הקודם לו.
 דילוג בסדר המספור הרציף יגרום לשגיאה בתוכנית.
 הסמן { 0 {מוחלף על ידי הערך val0 ,הסמן {1 {על ידי הערך val1 ,הסמן {2 {על ידי
הערך val2.
 סדר הסמנים במחרוזת אינו חשוב, ובלבד שהוא יתאים לערך שיחליף אותו. דוגמא:
Console.WriteLine ("The sum of {2} and {1} is {0}" ,5+4 ,5 ,4 ) ;
 כל סמן יכול להופיע יותר מפעם אחת. דוגמא:
Console.WriteLine ("{0} is grater then {1}, {1} is grater then {2}. Therefore {0} is grater then {2}", a, b, c) ;
שימו ♥ פיצול הוראה לשתי שורות או יותר אינו משפיע על הביצוע.
הערכים יש לתת מופרדים בפסיקים.
פורמט הדפסה
 רוחב שדה הדפסה – מספר תווי המסך המוקצים לכל סמן, להדפסת הערך המחליף אותו.
המאפשר לשמור על מרווח אחיד בפלט.
 עבור מספר חיובי (לרוחב שדה ההדפסה) - היישור יהיה לצד ימין.
עבור מספר שלילי (לרוחב שדה ההדפסה) - היישור יהיה לצד שמאל.
 אם נקבע גודל רוחב הדפסה הקטן ממספר התווים במחרוזת או ממספר הספרות שבמספר,
תתעלם ההוראה מהגודל הניתן, והתוכן יוצג בשלמותו.
הדפסת טקסט (דוגמאות)
Console.WriteLine ("Your name is {0,7} {1,8}", "Burt", "Simpson" ); - עבור
_ _ _B u r t _S i m p s o n - יהיה והפלט
Console.WriteLine ("Your name is {0,-7} {1,-8}", "Burt", "Simpson" );- ועבור
B u r t _ _ _ S i m p s o n _ - יהיה הוא
(הסימן _ מציין תו אחד במסך)
הדפסת מספרים (דוגמאות)
 רוחב שדה הדפסה – בנוסף לאמור קודם
o למספרים ממשיים –
התייחסות לדיוק עשרוני, שימו לב - ההוראה אינה משפיעה על תוכן המשתנה אלא
על אופן התצוגה בלבד, כלומר שתצוגת המספר בלבד תעוגל לדיוק המבוקש.
ברירת המחדל אם לא צוינה סיפרה היא 2 ספרות עשרוניות.
o הנקודה העשרונית תופסת מקום אחד.
o למספרים ארוכים (גדולים) הפרדת פסיקים לאחר כל 3 ספרות.
double ddd = 3232.345;
Console.WriteLine("{0}", ddd);
3232.345
Console.WriteLine("{0,8:F}", ddd);
3232.35
Console.WriteLine("{0,-8:F1}", ddd);
3232.3
Console.WriteLine("{0,8:N3}", ddd);
3,232.345
הוראות קלט
ההוראה מאפשרת לתוכנית "לקרוא" מן המסך (באמצעות המחלקה Console (מידע שכתב
עליו המשתמש, באמצעות המקלדת.
ובמילים אחרות, בעזרת הוראה זו ניתן לקלוט, בזמן ריצת התוכנית, נתונים מן המשתמש
לכן הוראת קלט נחשבת בהרבה מקרים (והרבה מובנים) כחלק מהוראות ההשמה. ולשמור אותם (לבצע השמה שלהם) במשתנים שהחלטנו עליהם מראש.
קליטת מידע מאמצעי הקלט הסטנדרטי (המקלדת), מבנה ההוראה:
משתנה = Console.ReadLine () ;
קלט שהינו מחרוזת נומרית של תווים, על מנת להמיר אותה לערכים מספריים יש לבצע את
הפקודה במבנה הבא:
משתנה = data_type.Parse(Console.ReadLine ()) ;
data_type
לדוגמא :
עבור משתנה מסוג int הפקודה תראה ; (() ReadLine.Console(Parse.int = משתנה
(***) המרות בין טיפוסי נתונים - העשרה
כאן הזדמנות להרחיב מעט בהקשר של מחלקות / פעולות במחלקה, הקשורות למה שכבר
דיברנו.
בכל הטיפוסים (types data (הקיימים ומיושמים כמחלקות ב-#c ,מוגדרת פעולה (מתודה)
שנקראת ()ToString ,הפעולה הזו ממירה ערך כלשהו למחרוזת.
גם double , int הם בעצם מימוש של מחלקות בשפת #c .אבל מימוש מיוחד בגלל היותם
משתנים מאד פרימיטיביים כלומר בסיסיים (יסודיים), ולכן ההתייחסת אליהם קצת שונה.
יחד עם זאת גם להם מוגדרת (וממומשת) הפעולה ()ToString.
לדוגמא:
; ()ToString.int ממירה מספר (שלם) למחרוזת נומרית, 123" << 123."
."123.654" << 123.654 ,נומרית למחרוזת) ממשי (מספר ממירה double.ToString() ;
; ()ToString.char ממירה תו (בודד) למחרוזת בגודל תו בודד, 'x" << 'x."
בפקודת הדפסה ;() WriteLine.Console היינו צריכים להפעיל את הפעולה ()ToString
עבור משתנים הפרימיטיביים, אבל כחלק מההתייחסות המיוחדת למשתנים אלו, השפה מקלה
עלינו ועושה זאת עבורנו אוטומטית.
מאידך גיסא, כאשר אנחנו קולטים נתונים מהמשתמש באמצעות הפקודה ; ()
Console.ReadLine
נדרש לעשות את ההיפך, כלומר, להמיר מחרוזת נומרית למספר.
את פעולת ההמרה של מחרוזת נומרית למספר, נוכל לבצע באמצעות הפעולה (המתודה)
Parse אשר קיימת בכל הטיפוסים המספריים. הפעולה הזו מקבלת כפרמטר מחרוזת נומרית
(מכילה תווים חוקיים למספר) וממירה אותו למספר המתאים לסוג (type data (המפעיל את
הפעולה.
כך לדוגמא:
; ( מחרוזת נומרית )Parse.int ממירה מחרוזת נומרית למספר שלם.
; ( מחרוזת נומרית )Parse.double ממירה מחרוזת נומרית למספר ממשי.
; ( מחרוזת נומרית )Parse.char ממירה מחרוזת בעלת תו בודד לסוג של char .
זו הסיבה למה דיברנו על ערכים מספריים של Unicode ,
זוכרים ?
נראה – ולכן, כאשר אנחנו קולטים מהמשתמש ערכים מספריים (ובמרבית המקרים שלמים) בתוכנית
1 .הגדרה (הצהרה) - שם_משתנה int
= int.Parse(Console.ReadLine ()) ; - הקלט פקודת.2
שם_משתנה
והמשמעות: קרא מ"המסך" מחרוזת נומרית שמשתמש מקיש, המר אותה למספר שלם,
והשם את המספר (תוצאת ההמרה) לתוך משתנה.
אוחזר מתוך "https://he.wikibooks.org/wiki/שפת_C/פלט_וקלט"