>> [השמעת מוסיקה]
דובר: בסדר.
אז בואו נדבר על עוד דבר זה סוג של ייחודי ל- C,
אשר הוא סוגי הנתונים ומשתנים.
כשאני אומר ייחודי ל- C, אני באמת אומר רק בהקשר של,
אם אתה כבר מתכנת במשך זמן ממש ארוך,
יש לך כנראה לא עבד עם סוגי נתונים
אם השתמשת מודרני שפות תכנות.
שפות מודרניות כמו PHP ו- JavaScript,
שאנחנו גם תראו קצת בשלב מאוחר יותר בקורס,
אתה באמת לא צריך לציין סוג נתונים של משתנה
כאשר אתה משתמש בו.
>> אתה פשוט להכריז עליו ולהתחיל להשתמש בו.
אם זה מספר שלם, זה יודע שזה מספר שלם.
אם זה אופי, זה יודע שזה אופי.
אם זה מילה, הוא יודע זה מחרוזת, מה שנקרא.
>> אבל בC, שהוא שפה מבוגרת, אנחנו צריכים
כדי לציין את הנתונים סוג של כל משתנה
שאנו יוצרים בפעם הראשונה שאנו משתמשים בי משתנים ש.
אז C מגיע עם כמה מובנה בסוגי נתונים.
ובואו להכיר עם כמה מאלה.
ואחר כך אנחנו גם מדברים קצת על כמה מסוגי נתונים
שכתבנו לך, כך שאתה יכול להשתמש בם בCS50.
>> הראשון הוא int.
סוג נתוני int משמש למשתנים שיהיה לאחסן ערכים שלמים.
אז 1, 2, 3, שלילי 1, 2, 3, וכן הלאה.
מספרים שלמים, וזה משהו שאתה צריך לזכור לחידון,
תמיד לקחת את ארבעה בתים של זיכרון, שהוא 32 סיביות.
יש שמונה סיביות בבתים.
>> אז זה אומר שהטווח של ערכים ששלמים יכול לאחסן
מוגבל על ידי מה שיכול להתאים בתוך 32 הסיביות בשווי של מידע.
עכשיו כפי שמתברר, זה ארוך הוחלט לפני
שהיינו להתפצל מגוון זה של 32 סיביות
למספרים שלמים שליליים ושלם וחיוביים,
כל מחצית מקבלת מהמגוון.
אז את טווח ערכים שאנו מייצגים עם מגוון שלם מ2 שליליים
לכח 31 2 ל הכח 31 מינוס 1,
לגרום לך גם צריכים מקום ל0.
>> אז בעצם מחצית מהערכים האפשריים אתה יכול להתאים בint הם שליליים,
ומחציתם חיוביות.
ובערך כאן, זה על שלילי 2 מליארד לכ -2 מיליארדים חיוביים.
לתת או לקחת כמה מאה מ'.
אז זה מה שאתה יכול להתאים במשתנה שלם.
עכשיו יש לנו גם משהו בשם שלם חתום.
עכשיו ints חתום אינו סוג נפרד של משתנה.
במקום זאת, היא חתום מה שנקרא במוקדמות.
זה משנה את הנתונים סוג של מספר שלם מעט.
>> ובמקרה זה, שאינו חתום מה means-- וגם אתה יכול
להשתמש בסוגי נתונים אחרים שאינם חתומים, שלם לא רק אחד.
מה זה ביעילות עושה הוא זוגות הטווח החיובי של ערכים
שמספר שלם יכול לקחת על ב חשבון כבר לא מאפשר
לך לקחת על ערכים שליליים.
אז אם יש לך מספרים שאתה יודע יקבל גבוה יותר מ -2 מיליארדים אבל פחות
מ -4 מיליארדים, לexample-- אשר 2 לה -32 power--
אולי כדאי לך להשתמש ב int חתום אם אתה
יודע את הערך שלך אף פעם לא יהיה שלילי.
>> מדי פעם תצטרך משמש למשתנים שאינם חתומים
בCS50, וזו הסיבה שאני מזכיר אותו כאן.
אבל שוב, את טווח ערכים ש יכול לייצג עם שלם חתום
ככדי לא שלם רגיל, הם 0 2 לכוח ה -32 מינוס 1,
או כ 0-4000000000.
אז אתה כבר הוכפל ביעילות טווח חיובי שאתה יכול להתאים,
אבל שנתת את כל הערכים השליליים.
>> עכשיו במאמר מוסגר, שאינו חתום לא רק במוקדמות
שאנו עלולים לראות ב סוגי מידע משתנים.
יש גם דברים שנקראו קצר וארוך וconst.
Const נראה קצת קצת מאוחר יותר בקורס.
, אנחנו כנראה לא יהיו קצרים וארוכים.
>> אבל רק יודע שיש הם מוקדמות אחרים.
לא חתום הוא לא היחיד.
אבל זה רק אחד אנחנו הולך לדבר על עכשיו.
אז בסדר.
אז אנחנו כבר כיסינו מספרים שלמים.
מה הלאה?
>> תווים.
אז תווים המשמשים למשתנים שיהיה לאחסן תווים בודדים.
תו הוא קיצור של אופי.
ולפעמים אתה יכול לשמוע אנשים לבטא את זה כמו מכונית.
>> אז דמויות תמיד לקחת את אחד בתים של זיכרון, שהוא רק 8 סיביות.
אז זה אומר שהם רק יכולים להתאים ערכים בטווח של 2 שליליים
לכח השביעי, או שלילי 128, 2 לכח 7 מינוס 1, או 127.
>> תודה לASCII, זה היה עוד החליט דרך לפני
למפות מספרים חיוביים אלה מ 0-127 לדמויות שונות
שכל קיימים במקלדת שלנו.
אז כפי שאנו רואים בהמשך כמובן, ואתה בטח
באנו לשנן בכמה נקודה, הון, לexample--
הון האופי זה-- מפות למספר 65.
והסיבה לכך היא כי זה מה שזה
הוקצה על ידי תקן ASCII.
>> אותיות קטנות הוא 97.
הדמות 0 לעת למעשה הקלד את האופי, לא
המייצגים את המספר אפס, הוא 48.
אתה תלמד זוג של אלה כמו שאתה הולך.
ואתה בהחלט מגיע לצריכה שלהם קצת מאוחר יותר בCS50.
>> סוג נתונים הגדול הבא הוא מספרי נקודה צפה.
אז מספרי נקודה צופים הידוע גם במספרים ממשיים.
הם בעצם מספרים ש יש נקודה עשרונית בהם.
ערכי נקודה צפה כמו מספרים שלמים גם
בתוך 4 בתים של זיכרון.
עכשיו אין תרשים כאן.
אין קו מספר, כי המתאר את הטווח של מצוף
לא בדיוק ברור או אינטואיטיבי.
>> די אם אומר לך יש 32 ביטים לעבוד איתו.
ואם יש לך מספר כמו פאי, שבו יש
חלק שלם 3, וצף חלק נקודה, או חלק עשרוני .14159,
וכן הלאה, אתה צריך להיות תוכל לייצג את כל it--
חלק השלם וחלק העשרוני.
>> אז מה אתה חושב שאולי זה אומר?
דבר אחד הוא שאם העשרוני חלק מקבל עוד ועוד,
אם יש לי גדול מאוד חלק שלם, אולי לא אני
תוכל להיות מדויק כ עם החלק העשרוני.
וזה באמת הגבלה של מצוף.
>> יש לי צף בעיה דיוק.
יש לנו רק 32 ביטים ל לעבוד איתו, כך שרק אנחנו יכולים
להיות כל כך מדויק עם החלק העשרוני שלנו.
לא יכול יש לנו בהכרח עשרוני חלק מדויק עד 100 או 200 ספרות,
כי יש לנו רק 32 סיביות לעבוד איתו.
אז זה הגבלה של מצוף.
>> עכשיו, למרבה המזל יש סוג נתונים אחר הנקרא
כפול, אשר במידה מסוימת עוסק בבעיה זו.
זוגות, כמו צף, משמש גם ל לאחסן אמיתיים מספרים, או נקודה צפה
ערכים.
ההבדל הוא ש זוגות הם בדיוק כפולים.
הם יכולים להתאים 64 סיביות של נתונים, או שמונה בתים.
מה הכוונה?
ובכן, זה אומר שאנחנו יכולים להיות הרבה יותר מדויק עם הנקודה העשרונית.
במקום שיש pi לשבע מקומות אולי, עם מצוף,
אנחנו יכולים אולי יש לו 30 מקומות.
אם זה חשוב, ייתכן שתרצה להשתמש כפול במקום לצוף.
בעיקרון, אם אתה עובד על משהו בי
יש מקום עשרוני באמת ארוך והרבה דיוק הוא חשוב,
אתה כנראה רוצה להשתמש overfloat כפול.
עכשיו עבור רוב העבודה שלך ב CS50, לצוף צריך להספיק.
אבל יודע שזוגות להתקיים כ דרך להתמודד עם קצת הדיוק
בעיה על ידי מתן תוספת 32 ביטים לעבוד עם המספרים שלך.
>> עכשיו זה לא סוג הנתונים.
זהו סוג.
וזה נקרא חלל.
על זה ואני מדבר כאן כי יש לנו כנראה
ראה את זה כבר כמה פעמים בCS50.
וייתכן שאתה תוהה מה זה כל עניין.
>> אז חלל הוא סוג.
זה קיים.
אבל זה לא סוג הנתונים.
>> אנחנו לא יכולים ליצור משתנים מסוג לבטל ולהקצות לו ערך.
אבל פונקציות, למשל, יכול להיות סוג החזר מבוטל.
בעיקרון, אם אתה רואה פונקציה שיש לו סוג החזרת חלל,
זה אומר שזה לא מחזיר ערך.
האם אתה יכול לחשוב על נפוץ פונקציה שהשתמשנו עד כה
בCS50 שלא מחזיר ערך?
>> Printf הוא אחד.
Printf לא ממש לחזור לך משהו.
היא מדפיסה משהו מסך, וזה בעצם
תופעת לוואי של מה printf עושה.
אבל זה לא נותן לך ערך בחזרה.
אתה לא ללכוד את התוצאה וחנות זה בכמה משתנה כדי להשתמש בו בהמשך.
זה פשוט מדפיס משהו המסך וסיימתם.
>> אז אנחנו אומרים שprintf היא פונקציה מבוטלת.
זה מחזיר שום דבר.
>> רשימת ההיקף של פונקציה יכולה להיות גם חלל.
ואתה ראית גם ש לא מעט בCS50 מדי.
החלל מרכזי Int.
האם זה מצלצל מוכר?
בעיקרון מה שזה אומר הוא ש עיקרי לא לוקח את כל פרמטרים.
אין ויכוח ש מועברים לעיקרי.
עכשיו בשלב מאוחר יותר נוכל לראות כי קיים דרך לעבור את הטיעונים לעיקריים,
אך עד כה מה שיש לנו ראיתי בטל עיקרי int.
ראשי פשוט לא לקחת שום טענות.
וכך אנו לציין כי באומרו הריק.
אנחנו רק להיות מאוד מפורש על כך
שזה לא ייקח כל טענות.
>> אז לעת עתה, די אם אומר שבעצם חלל
רק צריך לשמש כמציין מיקום בשבילך כמו לחשוב על שום דבר.
זה לא באמת עושה שום דבר.
אין ערך החזרה כאן.
אין פרמטרים כאן.
זה מבוטל.
זה יותר מורכב קצת יותר מזה.
אבל זה צריך להספיק ל את החלק טוב של הקורס.
ואני מקווה שעכשיו יש לך קצת קצת יותר מושג מה הוא החלל.
>> אז אלה הם חמישה הסוגים תמצאו מפגש שמובנה לג
אבל בCS50 יש לנו גם ספרייה.
CS50.h, שבו אתה יכול לכלול.
ושיספק לך עם שני סוגים נוספים
כי אתה בטח תוכל להשתמש במשימות שלך,
או סתם עובד בדרך כלל תכנות.
>> הראשון שבם הוא בול.
אז את סוג הנתונים בוליאנית, בול, משמש למשתנים
שיאחסן ערך בוליאני.
אם אי פעם שמעו מונח זה לפני, אתה
אולי יודע כי בוליאנית הערך הוא מסוגל רק
מחזיק שני ערכים שונים שונים.
אמת ושקר.
עכשיו זה נראה די בסיסי, נכון?
זה סוג של הפתעה שזה לא קיים ב- C כפי שהוא מובנה.
ובשפות רבות מודרניות, כמובן, Booleans
הם סוג נתוני ברירת מחדל סטנדרטי.
אבל בC, הם בעצם לא.
אבל יצרנו את זה בשבילך.
אז אם אי פעם אתה צריך ליצור משתנה מסוגה בול,
רק כדי להיות בטוח #include CS50.h בתחילת התכנית שלך,
ואתה תהיה מסוגל ליצור משתנים מהסוג בול.
>> אם שכחת #include CS50.h, ו אתה מתחיל שימוש במשתנים בוליאנית-סוג,
אתה עשוי להיתקל כמה בעיות כשאתה קומפילציה התכנית שלך.
כל כך פשוט להיות על המשמר מפני ש.
ואולי אתה יכול פשוט לתקן בעיות בלירה כולל CS50.h.
>> סוג נתונים הגדול האחר ש לספק לך בספריית CS50
הוא מחרוזת.
אז מה היא מחרוזת?
מחרוזות הן באמת רק מילות.
הם אוספים של דמויות.
הם מילות.
הם משפטים.
הם סעיפים.
יכול להיות כל ספרים, אפילו.
>> מאוד קצר לארוך מאוד סדרה של דמויות.
אם אתה צריך להשתמש במחרוזות, לדוגמא, כדי לאחסן מילה,
רק כדי להיות בטוח כולל CS50.h בתחילת התכנית שלך
כך שאתה יכול להשתמש בסוג המחרוזת.
ואז אתה יכול ליצור משתנים סוג הנתונים שלו הוא מחרוזת.
עכשיו בשלב מאוחר יותר בקורס, אנחנו גם תראו שזה
לא את כל הסיפור, או.
אנו נתקלים דברים מבנים שנקראו,
אשר מאפשרת לך קבוצה מה שעשוי להיות מספר שלם ומחרוזת ליחידה אחת.
ואנחנו יכולים להשתמש בזה ל איזו מטרה, שאולי
שימושי בהמשך הקורס.
>> ואנחנו גם תלמדו על סוגים מוגדרים,
אשר יאפשר לך ליצור סוגי נתונים שלך.
אנחנו לא צריכים לדאוג על זה לעת עתה.
אבל רק יודע שזה משהו באופק,
כי יש הרבה יותר לכל זה דבר סוג ממה שאני אומר לך רק
עכשיו.
אז עכשיו שאנחנו כבר למדנו קצת על הנתונים הבסיסיים
סוגים וסוגי נתונים CS50, בואו לדבר על איך לעבוד עם משתנים
וליצור אותם באמצעות אלה סוגי נתונים בתוכניות שלנו.
אם אתה רוצה ליצור משתנה, כל מה שאתה צריך לעשות הוא שני דברים.
>> ראשית, אתה צריך לתת לו סוג.
הדבר השני שאתה צריך לעשות הוא לתת לו שם.
ברגע שעשית את זה וסטרתי פסיק בסוף השורה ש,
שיצרת משתנה.
>> אז הנה שתי דוגמאות.
מספר int; מכתב char ;.
מה עשיתי כאן?
יצרתי שני משתנים.
>> הראשון, משתנה של שם הוא מספר.
ומספר הוא מסוגל להחזיק מספר שלם הקלד ערכים, בגלל סוגה הוא int.
מכתב הוא משתנה אחרת שיכול להכיל תווים
בגלל סוג הנתונים שלה הוא char.
>> די פשוט, נכון?
אם אתה מוצא את עצמך במצב שבו
אתה צריך ליצור מספר רב של משתנים מאותו הסוג,
אתה רק צריך לציין שם הסוג פעם.
אז פשוט רשימת משתנים רבים מהסוג שכמו שאתה צריך.
>> אז אני יכול למשל, כאן בשורה שלישית זה של קוד,
אומר גובה int ;, קו חדש.
רוחב Int ;.
וזה יעבוד גם.
הייתי עדיין לקבל שני משתנים הנקראים גובה ורוחב, כל אחד מהם
הוא מספר שלם.
אבל מותר לי, דברים לתחביר C, אחד אותה בשורה אחת.
גובה int, רוחב; זה אותו הדבר.
יצרתי שני משתנים, אחד בשם נקרא רוחב גובה אחד, אשר שניהם
הם מסוגלים להחזיק ערכי סוג מספר שלם.
>> כמו כן כאן, אני יכול ליצור שלוש ערכי נקודה צפה ובעונה אחת.
אני יכול אולי ליצור משתנה נקרא שורש הריבועי של 2--
שכנראה סופו של דבר להחזיק point-- הצף
ייצוג זה של הכיכר שורש של 2-- שורש הריבועי של 3, וpi.
אני יכול לעשות את זה על שלושה קווים נפרדים.
לצוף, שורש ריבועים 2; לצוף שורש הריבועי 3; לצוף pi; וזה יעבוד גם.
>> אבל שוב, אני יכול רק לגבש זה לשורה אחת של קוד.
עושה את דברים קצת קצר יותר, לא מגושם כ.
>> עכשיו באופן כללי, זה עיצוב טוב רק להצהיר על משתנה כאשר אתה צריך את זה.
ונדבר קצת קצת יותר על ש
בשלב מאוחר יותר בקורס כאשר אנו דנים היקף.
אז לא בהכרח צריך ליצור את כל המשתנים שלך
בתחילת התכנית, ש יש אנשים שאולי עשו בעבר,
או היה בהחלט נפוץ מאוד לפני שנים רבות בפועל קידוד
כאשר עובדים עם ג אתה פשוט יכול רוצה ליצור תקין משתנה כאשר
אתה צריך את זה.
בסדר.
אז יצרנו משתנים.
איך להשתמש בם?
אחרי שנכריז משתנה, אנחנו לא צריכים
כדי לציין את סוג הנתונים של משתנה זה יותר.
למעשה, אם אתה עושה זאת, אתה עלול בסופו של דבר עם כמה תוצאות מוזרות
שאנחנו סוג שלך לחפות על לעת עתה.
אבל די אם נאמר, דברים מוזרים הולכים
כדי להתחיל קורה אם בטעות מחדש להכריז משתנים בעלי אותו שם
שוב ושוב.
>> אז הנה יש לי ארבע שורות של קוד.
ויש לי כמה הערות יש רק מצביעות
מה שקורה ב כל שורה רק כדי לעזור
אתה מקבל ממוקם במה שקורה.
מספר אז int ;.
אתה ראית שקודם לכן.
זה הצהרה משתנה.
>> עכשיו אני כבר יצרתי משתנה מספר זה נקרא
מסוגלים להחזיק ערכים שלמים-סוג.
אני כבר הכריז עליה.
>> השורה הבאה אני הקצאה ערך למספר.
המספר שווה 17.
מה קורה שם?
אני שם את המספר 17 בתוך משתנה ש.
>> אז אם אני אי פעם אז להדפיס את מה ש התוכן של מספר הוא בשלב מאוחר יותר,
הם יגידו לי שזה 17.
אז אני כבר הצהיר משתנה, ואז אני כבר הוקצה זה.
>> אנחנו יכולים לחזור על התהליך שוב עם מכתב char ;.
זה הצהרה.
מכתב שווה הון ח זה משימה.
די פשוט, יותר מדי.
>> עכשיו אולי תהליך זה נראה סוג של מטופש.
למה אנחנו עושים את זה בשתי שורות של קוד?
האם יש דרך טובה יותר לעשות את זה?
למעשה, יש.
לפעמים אתה עשוי לראות זה נקרא אתחול.
זה כאשר אתה מצהיר על משתנה ולהקצות ערך באותו הזמן.
זהו למעשה די דבר שכיח לעשות.
כאשר אתה יוצר משתנה, אתה בדרך כלל רוצה שיהיה לו ערך כלשהו בסיסי.
גם אם זה 0 או משהו.
אתה פשוט אתה נותן לו ערך.
>> אתה יכול לאתחל משתנה.
Int מספר שווה 17 זהה שתי השורות הראשונות של קוד למעלה.
מכתב תו שווה h זהה קווים שלישיים והרביעי של קוד לעיל.
אוכל מוכן החשוב ביותר כאן כאשר אנו מכריזים והקצאה
משתנים הוא אחרי ש הכריז עליה, הודעה
אני לא משתמש בסוג הנתונים שוב.
אני לא אומר שמספר int שווה 17 ב הקו השני של קוד, לדוגמא.
אני רק אומר שמספר שווה 17.
>> שוב, מחדש הכרזה משתנה לאחר שכבר הכריז שהוא יכול להוביל
לחלק תוצאה מוזרה.
כל כך פשוט להיות זהיר של זה.
>> אני דאג לויד.
וזה CS50.