>> [השמעת מוסיקה]
>> דאג LLOYD: היי, אז בואו מדבר על מפעילים בג
אז, כבר ראו אחד, למעשה, שווה מפעיל המשימה.
זה מאפשר לנו רק לשים ערך לתוך משתנה.
זה המשימה מפעיל, סימן שוויון אחת.
על מנת לתפעל ועבודה עם ערכים ומשתנים ב- C,
יש לנו מספר המפעילים עומד לרשותנו שאנחנו יכולים להשתמש.
בואו נסתכל חלק הנפוצים אלה
מתחיל עם מפעילי חשבון.
כפי שאפשר לצפות, שאנחנו יכולים לעשות פעולות מתמטיות בסיסיות למדי בג
אנחנו יכולים להוסיף, לחסר, להכפיל, ו מספרי הפרד באמצעות תוספת, מינוס, כוכב,
ולקצץ, בהתאמה.
הנה כמה שורות של קוד שבו אנחנו עושים את זה.
אז, יש לנו int x שווה y בתוספת 1.
הבה נניח כי איפשהו למעלה הקו הזה של קוד
אנחנו אמרתי y int שווה 10.
מה הערך של x אחרי ש לבצע שורה הראשונה של קוד?
אתה אומר 11?
אתה צודק 'd.
למה?
ובכן, y היה 10.
כמה int אני אומר x שווה 10 פלוס 1.
10 בתוספת 1 הוא 11.
אז, הערך 11 מקבל מאוחסן בx משתנה.
לא רע, נכון?
>> מה דעתך על הקו הבא של קוד? x שווה פעמים X 5.
ובכן, לפני שהוצאנו להורג הקו הזה של קוד, x היה 11.
אז, מהו הערך של x אחרי הקו הזה של קוד?
קח שני.
אז, x שווה פעמים X 5.
x היה 11.
אז, x שווה 11 פעמים 5.
או 55.
אז אם אתה אמר 55, אתה רוצה להיות צודק.
>> עכשיו, זה יכול להיות קצת מבלבל, אבל עם דרך המשימה שעובדת בC
הוא הערך על הזכות מקבל שהוקצה לערך משמאל.
אז, ראשון אנו מעריכים פעמים X 5.
אז, 11 פעמים 5 היא 55.
ואז אנו מאחסנים ערך שבx.
11 שהיו שם לפני כעת יוחלף.
אז הערך של x הוא כעת 55.
אני מקווה שזה פשוט למדי.
>> יש מפעיל אחר שיש לך כנראה לא שמע בהכרח
בשם זה, אבל יש לך בהחלט עבד איתם בעבר
אם אתה זוכר את הימים שלך ארוך דרך החלוקה בחזרה בבית הספר יסודי.
זה נקרא מפעיל מודול.
מה מודולוס עושה זה נותן לך את השארית
כאשר אתה מחלק את שני מספרים יחד.
לכן, אם אני אומר 13 חלקי 4, מה השארית?
וערך שיחושב על ידי מפעיל מודול.
>> אז, יש לי קו של קוד כאן, מ 'int שווה 13 mod 4.
ואני אומר כאן בתגובה הערך של מטר שהוא כעת 1.
למה אני אומר את זה?
ובכן, לעשות את החילוק הארוך בך ראש, אם אתה לשאת איתי לרגע.
אז, יש לי 4 חלקי 13.
4 נכנס 13 שלוש פעמים עם שארית של 1.
אז, בעצם, את כל מפעיל מודולוס עושה
זה אומר לך כשאתה פער, אתה מקבל את השארית.
אתה חושב שאולי זה בעצם לא דבר שימושי מאוד,
אבל אתה רוצה להיות מופתע, למעשה, על ידי תדירות מודולוס ש
מפעיל יכול להיות שימושי.
>> יש כמה בעיות אנחנו נעשה CS50 שיתמודד עם זה.
זה גם טוב לעושה דברים כמו מספר אקראי.
כך, למשל, אם יש לך אי פעם שמע על מחולל מספרים אקראי,
זה הולך לתת לך מספר מ -0 עד כמה מספר עצום.
אבל אולי אתה באמת רק צריך מספר 0-20.
אם אתה משתמש במפעיל מודולוס שבמספר הענק ש
מקבל שנוצר על ידי מחולל מספרים אקראי,
אתה הולך לקחת את כל מה ערך עצום זה, לחלק אותו ב -20,
ולקבל את היתרה.
היתרה יכולה רק להיות ערך 0-19.
אז, אתה משתמש מפעיל מודולוס לקחת מספר עצום זה
ולגלף אותו למשהו קצת יותר משמעותי.
אני די בטוח שאתה תהיה תוכל להשתמש בשני אלה
בשלב מסוים בעתיד בCS50.
>> אז, C גם נותן לנו דרך ליישם חשבון
מפעיל משתנה אחד בדרך קצרנות יותר קטנה.
אז, בשקופית הקודמת, ראינו x שווה פעמים X 5.
זה עבד.
x 5 פעמים ואז מקבל מאוחסנים בחזרה בx.
יש דרך קצרה יותר לעשות את זה, מחשבה, וזה הפעמים x התחביר שווה 5.
זה אותו דבר כמו מדויק x אומר שווה פעמים X 5.
זה רק מעט דרך קצרה יותר לעשות את זה.
וכשאתה רואה כמה קוד הפצה או
לראות כמה דוגמאות קוד ש עושה דברים כאלה,
רק להיות מוכר עם מה פירוש התחביר.
אתה בהחלט לא צריך כדי להשתמש בו, אבל אם אתה עושה,
זה יכול להפוך את הקוד שלך נראה קצת מעיל גשם.
ולדעת שאתה גם יכול להשתמש בכל המפעילים השונים יש לנו כבר
ראה לפני במקום פעמים.
אפשר לומר בתוספת x שווה 5, מינוס שווה 5, פעמים, הפרד, וmod.
כל עבודה אלה.
>> יש גם משהו שכל כך נפוץ בC
שאנחנו כבר החלטנו לחדד שעוד יותר.
להגדיל כל זמן משתנה על ידי 1 או decrementing משתנה על ידי 1
הוא thing-- כזה נפוץ במיוחד כאשר אנו מדברים על לולאות קצת יותר מאוחר
on-- שהחלטנו במקום אומר משהו כמו תוספת x שווה 1,
או x שווה X ועוד 1, יש לנו גם קצר נמסר כי לx פלוס פלוס.
אז, x שווה X ועוד 1, x בתוספת שווה 1, וx בתוספת בתוספת כל לעשות את אותו הדבר.
הם כל x התוספת של 1.
אבל זה הגדלה וdecrementing על ידי 1
הוא כל כך נפוצה שיש לנו בתוספת מינוס פלוס ומינוס
שתאפשר לנו קצרנות שעוד יותר.
>> אז, בואו להחליף הילוכים לשנייה ולדבר על ביטויים בוליאנית.
כל שהם סוג של גם ליפול ל הקטגוריה הכללית של מפעילים.
אבל ביטויים בוליאנית, בניגוד למפעילי חשבון,
משמשים להשוואת ערכים.
אז, שוב, את כל הביטויים בוליאניים בC להעריך לאחד משני ערכים אפשריים,
זוכר.
אמת או שקר.
זה שני הערכים היחידים ש משתנה בוליאני יכול לקחת על.
אנחנו יכולים להשתמש בתוצאות של ביטוי בוליאני
בהרבה דרכים בתכנות.
למעשה, אתה תהיה עושה די הרבה זה.
>> לדוגמא, אנו עשויים להחליט, טוב, אם כמה מצב נכון,
אולי אני אקח את זה סניף למטה הקוד שלי.
מותנה, כביכול.
נלמד על אלה מוקדם מדי.
או אולי, כל עוד זה נכון, אני רוצה
להמשיך לעשות את זה שוב ושוב ושוב.
לולאה.
בשני המקרים, יודע שאנו משתמשים ביטוי בוליאני, אמת או שקר,
להחליט אם או לא אתחיל בדרך מסוימת.
לפעמים כשאנחנו עובדים עם ביטויים בוליאנית,
אנו נשתמש משתנים מסוג בול.
ייתכן שהכרזת בול הקליד משתנים,
ואתה משתמש בשלך ביטוי בוליאני.
אבל אתה לא תמיד צריך לעשות.
כפי שמתברר, ב- C, כל שאינם 0 ערך הוא אותו הדבר כמו אומר אמיתי.
אם אתה הכריז משתנה מסוג בוליאני,
והוקצה לו את הערך אמיתי, זה אותו הדבר כמו שהכריז שלם
והקצאתו הערך 1, 2, 3, או בעצם כל ערך
היא אחרת מאשר 0.
כי בC, כל שאינם 0 ערך נכון.
0, מצד שני, הוא שקר.
זה עלול לבוא ב מאוחר יותר שימושי כדי לדעת,
אבל רק משהו שכדאי לזכור.
לא תמיד יש לנו להשתמש משתני סוג בוליאני כאשר אנו
עובדים עם ביטויים בוליאנית.
>> ישנם שני סוגים עיקריים של וליאנית ביטויים שאנחנו עובדים איתם.
אופרטורים לוגיים ו מפעילים יחסיים.
השפה יש לא נורא חשוב.
זה באמת רק איך אני קיבוצם.
ואתה בהחלט, אני חושב, במהירות להבין מה הוא מפעיל יחסי,
על סמך מה הם כשאנחנו לדבר עליהם בשנייה.
אבל אל תדאגו בהכרח לשנן את המפעיל ההגיוני הטווח
או מפעיל יחסי.
אני רק משתמש בו לקבוצה שלהם בצורה הגיונית.
>> אז, בואו נסתכל על שלושה מפעילים הגיוניים
שנראה די קצת בתכנות בCS50
ובתכנות באופן כללי יותר.
הגיוני ונכון, אם ו רק אם שני האופרנדים הם אמיתיים.
אחרת שקר.
איפה זה אומר?
אז, בואו נגיד שאני ב להצביע בקוד שלי שבו אני צריך
שני משתנים, x ו- y.
ואני רוצה להחליט אם לעשות משהו בקוד שלי
המבוסס על אם x הוא אמיתי וy הוא נכון.
אני רק רוצה לעשות את זה אם שניהם נכונים,
אחרת אני לא רוצה לרדת ש דרך כי זה לא הולך לעזור לי.
מה שאני יכול לומר הוא שאם x & y &.
שיהיה בוליאנית הגיונית x השוואת הביטוי וy
ולוקח בדרך מסוימת על סמך מה הם הערכים שלהם.
לכן, אם x הוא אמיתי וy נכון בהתבסס על השולחן את האמת הזאת כאן,
רק אז תוכל ללכת בדרך ש.
אם x, y & &.
זה רק true-- ורק נכון, אם x הוא אמיתי וy הוא נכון.
אם אחד מהם הוא שקר, כפי שאנו רואים את טבלת האמת,
אז גם x ו- y הם לא נכון.
וכך, y x & & הוא שקר.
>> הגיוני או נכון אם ורק אם האופרנד לפחות אחד הוא נכון.
אחרת שקר.
אז הגיוני ונדרש שני X ו- Y להיות אמיתיים.
הגיוני או דורש x להיות אמיתי או y להיות אמיתי או שניהם X ו- Y להיות אמיתיים.
אז, שוב, אנו מוצאים סוג של את עצמנו במצב
לאן אנחנו הולכים לקוד שלנו, והגענו לפרשת הדרכים.
ואנחנו רוצים לרדת נתיב מסוים אם x הוא אמיתי
או y הוא אמיתי, אבל לא בהכרח אם שניהם נכונים.
אבל אולי אם שניהם נכונים.
אז אם x הוא אמיתי וy הוא נכון, אנחנו נלך במסלול הזה.
x הוא אמיתי.
אחד מהם הוא אמיתי, נכון?
אם x הוא אמיתי וy הוא נכון.
אם x הוא אמיתי, ו- y הוא כוזב, אחד מהם הוא עדיין נכון.
אז, X או Y הוא עדיין נכון.
אם x הוא כוזב, ו- y הוא אמיתי, אחד מהם הוא עדיין נכון, נכון?
y הוא נכון, במקרה זה.
אז, זה נכון שx או y הוא אמיתי.
רק אם x הוא כוזב ו- y הוא שקר אנחנו לא נלך בכיוון הזה,
כי לא x ולא y הוא אמיתי.
עכשיו, אם אתה מחפש במסך עכשיו
ותוהה מה ש סמל הוא ללוגי או,
זה נקרא הקו האנכי.
ואם אתה מסתכל על המקלדת שלך לרגע, כמו שאני עושה עכשיו,
זה בדרך כלל רק מעל מקש Enter, ברוב המקלדות,
על אותו מקש שהלוכסן.
זה גם בדרך כלל תקין בסמוך לסוגריים המרובע.
אז, זה יכול להיות מפתח ש לא הוקלד מאוד בעבר.
אבל, אם אתה אי פעם לעשות השוואות הגיוניות,
כפי שאנו הולכים לעשות הרבה בקורס, זה
הולך להיות שימושי ל למצוא את המפתח ושלהשתמש בו.
אז, זה בדרך כלל על אותו המקש כקו נטוי מעל Enter.
>> המפעיל ההגיוני הסופי אינו.
ולא די פשוט.
זה הופך את הערך של האופרנד.
אם x הוא אמיתי, אז לא x הוא שקר.
אם x הוא שקר, אז לא x הוא אמיתי.
לפעמים אתה שומע את הסמל הזה מבוטא כמו מפץ או קריאה
או לא.
זה פחות או יותר כולם אותו הדבר.
במקרה שאתה שומע שמדבר ו אתה לא בטוח מה זה אומר,
זה רק הקריאה נקודה, אבל לפעמים זה
בשם כמה דברים שונים.
בסדר, כך שלוקח אכפת לי של אופרטורים לוגיים.
אז, בואו נדבר על מפעילים יחסיים.
שוב, אם אתה מכיר את זה חשבון בחזרה בבית הספר יסודי,
אתה בטח מכיר עם איך העבודה הבאות כבר.
אלה מתנהגים בדיוק כפי שהיית מצפים.
אז פחות מזה נכון, בזה למשל, אם x הוא פחות מ y.
לכן, אם x הוא 4 ו- y הוא 6, x הוא פחות מ y.
זה נכון.
פחות או שווה ל עובד די דומה.
אם x הוא 4, ו- y הוא 4, אז x הוא פחות או שווה ל- y.
גדול מ. x גדול מ- y.
וגדול או שווה ל, x הוא גדול או שווה ל- y.
אם זה נכון, אז אתה לעבור ביטוי ש,
ואתה יורד נתיב שעל הכביש.
אם יש לך אם x גדול מ y, וX הוא, למעשה, הוא גדול יותר מאשר y,
אתה תעשה מה שהוא בכפוף לתנאי זה.
>> שימו לב שאין לנו תו בודד בפחות מ
או שווה ל, כפי שאתה יכול להיות מכיר מספרי לימוד במתמטיקה.
אז, יש לנו פחות מסמל, אחרי סימן שוויון.
ככה אנחנו מייצגים פחות או שווה ל.
ובאופן דומה, אנחנו עושים את זה לגדול או שווה ל.
>> שני היחסי הסופי מפעילים חשובים
בודקים לשוויון ואי-שוויון.
לכן, אם x שווה שווה y, הוא אמיתי אם ערך x ו- y של אותו.
אם x הוא 10, ו- y הוא 10, אז x שווה שווה y הוא אמיתי.
אם x הוא 10 ו- y הוא 11, x שווה שווה y הוא לא נכון.
אנחנו יכולים גם לבדוק לאי-שוויון באמצעות סימן קריאה או מפץ או לא,
שוב.
אם x אינו שווה ל- y, אם זה המבחן בו אנו משתמשים כאן,
נהיה טוב ללכת.
לכן, אם x הוא לא שווה ל y, נלך במורד שביל ש.
>> להיות זהיר מאוד כאן.
זה mistake-- באמת משותף ו אחד די הרבה אני בהחלט עשיתי כאשר
אני מקבל started-- לטעות טעות
מפעיל המשימה, שווים אחת, למפעיל השוואת שוויון,
שווה כפול.
זה יהיה להוביל כמה מוזר התנהגות בקוד שלך,
ובדרך כלל המהדר להזהיר אותך על זה כאשר אתה מנסה
ולקמפל הקוד שלך, אבל לפעמים ייתכן שתוכל להתגנב על ידי.
זה לא בהכרח דבר טוב שאתה להתגנב על ידי, אם כי.
רק כך שאם אתה עושה בדיקה אי-שוויון,
אם אתה בודק אם שני יש משתנים שונים את אותו ערך
בתוכם, הקפד להשתמש ב שווה שווה, ושווים לא יחידים.
וכי התכנית שלך תהיה הדרך יש התנהגות שאתה מתכוון.
אני דאג לויד וזה CS50.