דאג LLOYD: ככל שתתחיל עבודה עם פונקציות,
דבר נוסף הוא הולך להיות באמת חשוב להבין,
שהוא מושג ההיקף משתנה.
אז היקף הוא אופייני של משתנה
שמגדיר ממנו הפונקציות ניתן לגשת משתנה ש.
>> ישנם שני טווחים עיקריים ב- C, משתנים מקומיים ומשתנים גלובלי.
עכשיו, משתנים מקומיים יכולים רק ניתן לגשת בפונקציות
שבו הם נוצרו.
הם לא ניתן להגיע על ידי כל אחרים פונקציה שקיים בתכנית שלך,
רק הפונקציה ב בה הוא נוצר.
משתנים גלובליים, על מצד שני, ניתן לגשת
על ידי פונקציה כלשהי בתכנית.
והסיבה לכך היא בגלל שהם לא נוצרו בתוך
של כל פונקציה מסוימת.
אנו מצהירים מחוץ ל כל הפונקציות, ש
משמעות הדבר היא שכל פונקציה יודעת איפה זה ויכול לגשת ולטפל בו.
>> עד כה בקורס יש לך די הרבה עובד באופן בלעדי
עם משתנים מקומיים.
הנה דוגמא של מאוד, מאוד פונקציה העיקרית פשוטה ומאוד פשוט
פונקציה נוספת שכתבנו.
במקרה זה, x, ש אני כבר בצבע ירוק רק
כדי להדגיש את היישוב או היקף משתנה ש,
הוא מקומי לפונקציה המשולשת.
עיקרי לא יכול להתייחס לx בכלל.
הוא לא יודע מה זה.
אין פונקציה אחרת, למעשה, אם אנחנו היו פונקציות נוספות בכאן,
יכול להתייחס לx.
>> כמו כן, תוצאות שיש לי צבע כחול, הוא מקומי בלבד לעיקרי.
רק עיקרי יודע מה התוצאה היא משתנה.
משולש לא יכול להשתמש בו.
>> עכשיו כפי שציינתי, משתנים גלובליים קיימים.
אם אתה מצהיר שמשתנה מחוץ לכל פונקציה,
כל הפונקציות ב תכנית יכולה להתייחס אליו.
אז במקרה הזה אני כבר הדגיש ב ירוק הצהרה משתנה גלובלית.
במקרה זה, יצור משתנה הכריז
נקרא גלובלי, רק כדי להיות מאוד ברור לגבי זה.
זה של לצוף סוג.
ואני להקצות לו את הערך .5050.
>> תוכל להבחין כי בעיקרי וב משולש, אני יכול להתייחס לגלובלי.
ולמעשה, אם אני עובר את התכנית כפי שצוין, שיחות הראשונות עיקריות משולשים,
מתרבה משולש הגלובלי על ידי 3, ש קובע הערך שלה לרמה של 1.5 משהו,
1.51 או משהו כזה, ו אז עיקרי גם מדפיס את הערך
של העולם.
אז ראשי לא להדפיס את .5050, זה ידפיס פעמים הגלובליות 3, 1.51.
אז יש לך להיות זהיר בעת אתה עובד עם משתנים גלובליים.
בעוד הם מאוד גמישים ב יכולת להעביר מידע
סביב כך שכל פונקציה יכולה להשתמש בו,
זה גם יכול להיות חלק השלכות מסוכנות
אם שינויי פונקציה אחת הערך של משתנה
לפני שאתה מצפה שזה ישתנה.
>> למה הבחנה זו חשובה?
למה אכפת לנו אם חלק ממשתנים הם מקומיים ואחרים הם גלובליים?
ובכן, על פי רוב, משתנים מקומיים ב- C הם מה שנקרא עבר ערך
כאשר אנו עושים קריאה לפונקציה.
מה הכוונה?
>> ובכן, כאשר משתנה הוא עבר על ידי ערך, callee, ש
היא דרך אחרת לומר את הפונקציה כי הוא מקבל את המשתנה ש
מקבל מועבר כקלט, זה באמת אינו מקבל משתנה שעצמו.
הוא מקבל משלו עותק ממנו לעבוד איתו.
זוהי הבחנה חשובה באמת.
ראינו רק לפני שנייה כי עם משתנים גלובליים,
אם אנחנו לתפעל העולמיים משתנה בפונקציה אחת, את ההשפעה
שבפונקציה אחת נושאת דרך לכל תפקיד אחר.
>> אבל עם משתנים מקומיים, זה לא נכון.
כל פונקציה כאשר מקבל כקלט משתנה
לקבל העתקים של משתנים אלו, לא משתנה בעצמם.
אז מה היא תופעת הלוואי של זה?
זה אומר שמשתנה ב המתקשר, הפונקציה ש
הוא מה שהופך את הקריאה לפונקציה, הוא ללא שינוי, אלא אם תחליף אותו.
>> לדוגמא, בקוד זה foo לא השתנה כלל.
foo int שווה 4, קורא משולש של foo, בתוך משולש,
היינו מצפה שהיית foo יוכפל 3 וחזרו,
אבל יש למעשה אין כל השפעה.
>> הנה כי, הבדל מאוד עדין.
זה עושה את האפקט שאנחנו רוצים.
האם אתה רואה למה?
אנחנו דריסת foo בעיקרי הפעם.
>> אז foo int שווה 4, foo שווה foo המשולש, כאשר אנו עושים שיחה ש,
משולש מקבל עותק משלו של foo, עותק של 4 משלו.
זה אומר לחזור 4 פעמים 3, או מה ש משתנה מקבל עבר בפעמים 3.
ואז אנחנו להקצות את התשואה ערך של משולש לfoo שוב.
אז זה בעצם היה להחליף foo.
זוהי הדרך היחידה לעשות זה עם משתנה מקומי.
אז עכשיו אם נוסיף עוד שורת קוד כאן
בסוף העיקרי ל להדפיס את הערך של foo,
זה היה למעשה להדפיס את 12.
>> היקף משתנה בדרך כלל לא יותר מדי של בעיה
אם אתה שם את כולך משתני דברים שונים.
אבל הוא יכול לקבל סוג של מגעיל אם באותו השם משתנה
מופיע בפונקציות מרובות, שיקרה הרבה.
אם אי פעם עובד ב העולם האמיתי שבו
אתה עובד על שיתוף פעולה תוכניות ואנשים בצוותים שונים
פועלים יחד כדי לכתוב אותו תכנית או אותה הקבוצה של תוכניות,
לעתים קרובות הם יעשו שימוש חוזר משתנים שמות, נפוצים במיוחד אלה
כמו x, y, i, j, וכן הלאה.
>> אבל יש לי כאשר משתנים באותו השם, בעיות היקף
יכול לקבל קצת יותר מסובך לנתח.
לדוגמא, אתה יודע מה יודפס
בסוף התכנית המסוימת הזה?
קח דקה.
להשהות את הווידאו ולקרוא באמצעות תכנית זו.
אתה יכול לראות שבחלק העליון יש לי הצהרת פונקציה
לפונקציה שנקראת תוספת.
הפונקציה שלוקחת אחת פרמטר, מספר שלם שאנו מכנים x.
וזה פלטי שלם.
זה סוג ההחזרה בתחילת.
>> אז יש לנו עיקרי, כמה שורות של קוד בעיקרי, האחרון שבן
היא הצהרת הדפסה.
וזכור, זה השאלה כאן.
מה בעצם הולך להיות מודפס בסוף הפונקציה זו?
ואז אנחנו בעצם יש לי הגדרה של תוספת בהמשך.
>> אז קח דקה, צעד דרך הקוד, לעקוב אחר דברים.
האם אתה יודע מה יודפס ב סוף התכנית המסוימת הזה?
>> בסדר.
יש לקוות, שצילמת כמה שניות כדי לנסות ולנתח את זה החוצה.
בואו נעשה את זה ביחד.
>> אז אני כבר מחקתי את התוספת של הכרזה בראש שם.
זה היה סוג של הסחת דעת.
זה לא משתנה משלו.
זה לא חייב היקפה.
זה רק פונקציה הכרזה, כך למטרות
בניסיון לנתח את מה קורה בתכנית זו,
אנחנו יכולים באותה מידה להימנע מכך.
>> עכשיו יש לנו במקרה זה, סיבת בעיה זו היא מסובכת
הוא כי יש לנו משתנים מקומיים ב שני עיקרי ותוספת, כל אחד מהם
הוא x נקרא.
וכמובן לגופו של עניין זה הוא מנסה מתרשם שמx מקבל השתנה
ואיך זה משתנה.
אז אני כבר צבעוני כל מקרה של x זה מקומי לאדום עיקרי.
ואני כבר בצבע על כל מקרה של x זה מקומי כדי להגדיל כחול.
>> שים לב שבשורה שלישית של עיקרי, y שווה תוספת
x, תוספת שלא להיות x עבר של עיקרי, או על ה- X האדום.
זה מקבל עבר עותק שלו.
וזה רק הולך לעבוד עם עותק זה של זה, x הכחול.
אם אתה מתמטי נוטה, אתה עלול
חשבתי במקום זה כמשנה x מ 'למשנה עיקרי וx i לתוספת.
אבל זה אותו הרעיון.
x מ 'משנה, או x של אדום בשקופית הקודמת,
הם משתנה שהם local-- הוא המופע של x ולא ש
הוא מקומי לעיקרי, ותת x i, או משתנים כחולים בשקופית הקודמת,
הם מקרים של x ש הם מקומיים כדי להגדיל.
>> אז, הייתם מסוגל להבין מה פונקציה זו נדפסה בסוף?
אני דאג לויד, וזה CS50.