דאג LLOYD: בסדר.
אז עכשיו בואו להתמודד נושא ממש גדול, פונקציות.
עד כה בקורס, כל תוכניות שכבר כותבים
נכתב בתוך עיקרי.
הם תוכניות די פשוט.
אתה לא צריך את כל אלה סניפים ודברים קורה.
אנחנו יכולים רק להתאים אותו כל בתוך ראשי וזה
לא מקבל מכריע מאוד.
אבל כפי שכמובן הולך ו כמו שאתה מתחיל לפתח תוכניות
באופן עצמאי, הם כנראה הולכים כדי להתחיל לקבל הרבה יותר מ -10
או 15 שורות.
אתה עלול לקבל מאות או אלפים או עשרות אלפי שורות קוד.
וזה ממש לא כי משוגע מחשבה.
ככזה, זה כנראה לא רעיון טוב כדי לשמור על הכל בתוך עיקרי.
זה יכול להיות קצת קשה למצוא מה שאתה מחפש אם אתה עושה את זה.
>> למרבה המזל, אף C, ופחות או יותר כל שפת תכנות אחרת ש
אולי לעבוד איתו, מאפשר לי שלנו לכתוב פונקציות.
ואני רק הולך ל לקחת מהיר הצידה כאן
להזכיר כי פונקציות היא אזור של מדעי מחשב אחד.
ואתה תראה הרבה יותר מהם ב נקודות שונות לאורך הקורס
ואם תמשיך ב.
איפה יש הרבה מילים נרדפות לאותה המילה.
אז אנחנו קוראים לפונקציות.
אבל אתה יכול גם לשמוע אותם מכונה נהלים,
או שיטות, במיוחד, אם יש לך אי פעם עשה כל תכנות מונחה עצמים
before-- ואל תדאגו אם יש לך לא, לא
deal-- גדול אבל ב שפות ביקורת אוריינטציה
שיטות מתקשרות לעתים תכופות.
לפעמים הם נקראים גרות.
אבל הם באמת כל מתייחסים לאותו רעיון בסיסי.
>> בואו לראות מה הוא הרעיון ש.
מה היא פונקציה?
ובכן פונקציה היא באמת לא יותר מאשר קופסא שחורה.
קופסא שחורה שיש לו קבוצה של אפס או יותר תשומות ופלט יחיד.
כך למשל, זה יכול להיות פונקציה.
זוהי פונקציה שנקראת func.
וזה לוקח שלוש כניסות, B, C.
ובתוך שהקופסה שחורה, ש לא יודע בדיוק מה היא עושה,
אבל זה מעבד את התשומות בדרך כלשהי ואז זה
נותן תפוקה אחת, במקרה זה, z.
עכשיו כדי לעשות את זה קצת פחות מופשט, ש
אפשר לומר שאולי יש פונקציה שנקראת
תוסיף, כי לוקח שלוש כניסות, ב, ו ג ומעבד את הפלט בדרך כלשהי
בתוך הקופסה השחורה ל לייצר פלט יחיד.
אז במקרה הזה, אם להוסיף לוקח 3, 6, ו -7.
אי שם בתוך להוסיף פונקציה, שהיינו
מצפה מהם יתווספו יחד כדי לייצר את הפלט, ש
הוא 3 ועוד 6 ועוד 7 או 16.
>> כמו כן, יש לך פונקציה שנקראת mult שלוקח שתי כניסות, ו- B,
מעבד אותם בדרך כלשהי, כגון שהפלט של הפונקציה
הוא התוצר של שתי כניסות.
שתי כניסות כפול יחד.
4 ו -5 שעברו לmult, משהו קורה, התפוקה אנו מצפים
הוא 20.
למה אנחנו קוראים לזה קופסא שחורה?
ובכן, אם אנחנו לא כותבים מתפקד את עצמנו, ש
שעשינו לא מעט עד כה cs50.
ראינו F הדפסה, למשל, ש היא פונקציה שלא לכתוב
את עצמנו, אבל אנחנו משתמשים כל הזמן.
אם אנחנו לא כותבים הפונקציות את עצמנו,
אנחנו לא באמת צריכים לדעת איך זה מיושם למעשה מתחת למכסת המנוע.
>> כך למשל אני קופסא השחורה רק הראיתי לך לכפל,
mult, ב יכול להיות defined-- וזו רק
כמה pseudocode-- יכול להיות מוגדר כפלט פעמים ב.
זה הגיוני, נכון.
אם יש לנו פונקציה שנקראת mult שלוקח שתי כניסות.
היינו מצפה שהתפוקה היית להיות שתי הכניסות מוכפלות יחד,
פעמים ב.
אבל mult גם יכול להיות מיושם כמו זה,
יש לנו משתנים בניגוד ל לקבל להגדיר בתוך mult ל0.
ואז אנו חוזרים על תהליך זה ב פעמים להוסיף לדלפק.
לדוגמא, אם נכפיל 3a על ידי 5b, נוכל לומר שנקבע בניגוד ל0,
לחזור חמש פעמים, להוסיף 3 לדלפק.
אז אנחנו מתחילים ב 0 ואז אנחנו עושים חמש פעמים זה 3, 6, 9, 12, 15.
זה את אותה התוצאה. אנחנו עדיין מקבל 3 פעמים 5 רק
היישום הוא שונה.
>> זה מה שאנחנו אומר כאשר אנו אומרים קופסא שחורה.
זה רק אומר שבאמת לא אכפת לנו איך זה מיושם מתחת למכסת המנוע
כל עוד את הפלט הוא מה שאנחנו מצפים.
למעשה, זה חלק מהחוזה של שימוש בפונקציות, במיוחד
פונקציות שאחרים כותבים.
ההתנהגות תמיד הולכת להיות טיפוסי, בלתי צפוי
המבוסס על השם של הפונקציה.
וזה למה זה באמת חשוב כשאתה כותב פונקציות
או כאשר אנשים אחרים לכתוב פונקציות שאתה עשוי להשתמש,
כי יש פונקציות אלה שמות ברורים, יחסית ברורים,
ומתועדים היטב.
וזה בהחלט המקרה לפונקציה כמו F הדפסה.
>> אז למה אנחנו משתמשים בפונקציות?
ובכן כמו שאמרתי קודם, אם אנחנו כותבים כל הקוד שלנו בתוך הדברים עיקריים
יכול לקבל באמת מסורבל ומסובך באמת.
פונקציות מאפשרות לנו את היכולת לארגן דברים ולשבור את
בעיה מסובכת מאוד ל הרבה חלקי משנה יותר לניהול.
פונקציות גם יאפשרו לנו לפשט את תהליך הקידוד.
זה הרבה יותר קל לאתר באגים 10 פונקצית קו לעומת קו 100
פונקציה או פונקצית 1,000 קו.
אם יש לנו רק לבאגים חתיכות קטנות בכל פעם,
או לכתוב חתיכות קטנות בזמן, זה עושה שניסיון בתכנות
הרבה יותר טוב.
תאמין לי על זה.
>> לבסוף, אם אנחנו כותבים הפונקציות ניתן לעשות שימוש חוזר באותם חלקים שונים.
ניתן למחזר פונקציות.
הם יכולים לשמש ב תכנית זו או אחר.
אתה כבר כתבת הפונקציה, כל מה שאתה
צריך לעשות הוא לספר לי תכנית ש איפה למצוא את הפונקציה ש.
אנחנו כבר מחזור ושימוש להדפיס ו במשך 40 שנים.
אבל זה נכתב רק פעם אחת.
די שימושי, נכון.
בסדר.
אז פונקציות נהדרות.
אנחנו יודעים את זה.
עכשיו בואו נתחיל לכתוב אותם.
בואו נתחיל מקבלים אותם לתוכניות שלנו.
כדי לעשות את זה, הראשון דבר שאנחנו עושים הוא להכריז על הפונקציה.
כאשר אתה מצהיר על פונקציה מה שאתה עושה בעצם
הוא אומר לי מהדר, היי, רק שתדע,
אני הולך להיות כתיבה פונקציה בשלב מאוחר יותר
והנה מה שזה הולך להיראות.
הסיבה לכך היא כי מהדרים יכולים
לעשות כמה דברים מוזרים אם הם רואים קבוצה של סימנים
כי הם לא מכירים.
אז אנחנו פשוט לתת מהדר ראש בראש, אני יוצר פונקציה
וזה הולך לעשות את זה.
הצהרות פונקציה בדרך כלל אם אתה מארגן את הקוד שלך בדרך
שאחרים יוכלו להבין ולעשות שימוש,
אתה בדרך כלל רוצה לשים את כל הצהרות הפונקציה שלך
בחלקו העליון של הקוד שלך, נכון לפני שאתם מתחילים בכתיבה העיקרית אפילו.
ובנוחות, יש טופס סטנדרטי מאוד
שכל הכרזת פונקציה כדלקמן.
כולם פחות או יותר נראים כמו זה.
ישנם שלושה חלקים לפונקציה הצהרה, סוג תמורה, שם,
ורשימת טיעון.
>> עכשיו סוג ההחזרה הוא איזה סוג של משתנה פלט פונקציה.
כך למשל, אם אנחנו חושבים חזרה דקות לפני להכפלת שני
פונקצית מספרים, מה אנחנו מצפים אם נכפיל מספר שלם על ידי שלם
הפלט יהיה כנראה שלם, תקין.
שני מספרים שלמים כפול יחד, אתה מקבל מספר שלם.
אז הסוג של התמורה ש פונקציה תהיה int.
שם זה מה שאתה רוצה לקרוא הפונקציה שלך.
זה כנראה הכי פחות חשוב חלק מהצהרת הפונקציה,
במונחים של פונקציונליות.
אך הוא למעשה כנראה אחד החלקים החשובים ביותר
הכרזת הפונקציה במונחים לדעת מה הפונקציה למעשה
עושה.
אם אתה שם את פונקצית f או g שלך או h או תעלומה או משהו כזה,
אתה כנראה הולך לקבל קצת הכשיל את הניסיון
לזכור מה פונקציות אלה לעשות.
לכן חשוב לנותנך שמות בעלי המשמעות של הפונקציה.
>> לבסוף, רשימת טיעון היא הרשימה מופרדת בפסיקים
של כל התשומות לפונקציה שלך, כל אחד מהם יש לו סוג ושם.
אז לא רק שאתה צריך לציין איזה סוג של משתנה
פלט פונקציה, גם אתה רוצה לציין
איזה סוג וסוגים של משתנים פונקציה תהיה לקבל כתשומות.
אז בואו נעשה דוגמא כאן.
בואו רק נסתכל באחד קונקרטי יותר.
אז הנה דוגמא של פונקציה הכרזה לפונקציה ש
תוסיף שני מספרים שלמים ביחד.
הסכום של שני מספרים שלמים הולך להיות שלם, כמו גם, כפי שאנו פשוט
דן.
וכך סוג התמורה, כאן בירוק, יהיה int.
זה רק אומר לנו שיוסיף שני ints הוא הולך, בסופו של היום,
פלט, או לירוק אותו בחזרה אלינו, מספר שלם.
בהתחשב במה שאנחנו עושה בפונקציה זו רוצה לתת לה שם משמעותי.
להוסיף שני ints נראה מתאים, בהתחשב ב
אנחנו לוקחים שני מספרים שלמים כתשומות ולהוסיף אותם בתקווה יחד.
זה יכול להיות קצת מסורבל שם ולמען האמת בפונקציה זו
הוא כנראה לא הכרחי מאז יש לנו בנוסף
מפעיל, אם אתה זוכר משלנו דיון של מפעילים, בעבר.
אבל בואו נגיד לשם טענה שהפונקציה זו שימושית
וכך אנחנו קוראים לזה להוסיף שני ints.
לבסוף, פונקציה זו לוקחת שתי כניסות.
כל אחד מהם הוא מספר שלם.
אז יש לנו פסיק זה רשימה מופרדת תשומות.
עכשיו אנחנו בדרך כלל רוצים לתת שם לכל אחד מהם
כך שהם יכולים לשמש בתוך הפונקציה.
השמות לא נורא חשובים.
>> במקרה זה, אנחנו לא בהכרח יש כל משמעות המצורפת אליהם.
אז אנחנו יכולים רק לקרוא להם וב.
זה לגמרי בסדר.
אם לעומת זאת, אתה מוצא עצמך במצב
שבו השמות של המשתנים באמת עשוי להיות חשוב,
אולי כדאי לך לקרוא אותם משהו אחר מאשר A ו- B
לתת להם משהו יותר משמעות סמלית.
אבל במקרה הזה, אנחנו לא באמת יודע משהו על הפונקציה אחרת.
אנחנו רק רוצים להוסיף שני מספרים שלמים.
אז אנחנו פשוט נתקשר אלה מספרים שלמים וב.
זו דוגמא אחת.
>> למה אתה לא לוקח שני לחשוב על זה,
איך היית לכתוב פונקציה הכרזה לפונקציה ש
מכפיל שני מספרי נקודה צפו?
אתה זוכר מה מספר נקודה צפה הוא?
מה היית עושה בפונקציה זו הכרזה נראה?
אני ממש ממליץ לך להשהות את הווידאו כאן ולקחת כמה זמן שאתה צריך.
תחשוב על מה זה הצהרת פונקציה תהיה?
מה היית סוג ההחזרה להיות?
מה היית שם עם משמעות להיות?
מה הייתם התשומות להיות?
אז למה אתה לא להשהות את הווידאו כאן ולכתוב-עד הכרזת פונקציה
לפונקציה שהיה להכפיל שני מספרי נקודה צפו יחד.
אני מקווה שאתה עצר את הווידאו.
>> אז בואו נסתכל על דוגמא הצהרה אחת אפשרית.
לצוף שני ריאל mult לצוף x, y לצוף.
המוצר של שני מספרי נקודה צפה,
שזוכר הם איך אנחנו מייצג מספרים אמיתיים
או מספרים עם ערכים עשרוניים בג, הולך להיות מספר נקודה צפה.
כאשר אתה להכפיל עשרוני ידי עשרוני,
אתה כנראה הולך לקבל עשרוני.
אתה רוצה לתת לה שם רלוונטי.
להכפיל שני ריאל נראה בסדר.
אבל אתה באמת יכול לקרוא לזה שני צף mult, או צף mult.
משהו כזה, כל עוד זה נתן כמה משמעות אמיתית למה ש
קופסא שחורה זה הולכת לעשות.
ושוב, במקרה זה, אנחנו לא נראה שיש משמעות המצורפת
לשמות משתנים שאנחנו עוברים ב,
אז אנחנו פשוט קוראים להם X ו- Y.
עכשיו, אם אתה קורא להם משהו אחר, זה בסדר גמור.
למעשה, אם אתה עשית הצהרה זו במקום
באמצעות זוגות במקום של צף, אם אתה זוכר
שזוגות הם שונים דרך למדויקת יותר
לציין מספרים אמיתיים או צפה משתני נקודה.
זה לגמרי בסדר מדי.
או אחד מאותם יהיה בסדר.
למעשה, יש כמה שילובים שונים
דרכים להכריז בפונקציה זו.
אבל אלה הם שני די טובים.
אנחנו כבר הכריזו פונקציה, זה נהדר.
אנחנו כבר אמרנו לי מהדר מה זה הוא, מה שאנחנו הולכים לעשות.
עכשיו בואו בעצם לכתוב פונקציה ש.
בואו נותנים לו הגדרה, כך שבתוך הקופסה השחורה
התנהגות צפויה קורה.
למעשה, אנחנו הכפלת שתי אמיתיים מספרים יחד, או מספרי הוספה
יחד, או עושה כל מה שהוא ששאלנו את הפונקציה שלנו לעשות.
>> כך שלמעשה, בואו ננסה להגדיר ו להכפיל שני ריאל שאנחנו פשוט
דיבר על לפני שנייה.
עכשיו תחילת הגדרת פונקציה
נראה כמעט בדיוק אותו הדבר כהצהרת פונקציה.
יש לי את שניהם כאן.
בחלק העליון היא הצהרת הפונקציה, סוג, שם, טענה, מופרד בפסיקים
רשימה, פסיק.
פסיק מצביע על כך ש כי הוא הצהרת פונקציה.
תחילת הפונקציה הגדרה נראית כמעט בדיוק
אותו הדבר, הסוג, שם, מופרד בפסיקים רשימת טיעון, לא פסיק,
לפתוח סד מתולתל.
הסד המתולתל הפתוח, בדיוק כפי ש אנחנו כבר עושים עם עיקריים,
משמעות הדבר היא כי אנו נמצאים כעת מתחיל להגדיר
מה שקורה בתוך הקופסה השחורה ש החלטנו לקרוא לשני ריאל mult.
הנה דרך אחת לביצועו.
אנחנו יכולים לומר, שאנחנו יכולים להכריז חדשים משתנה ממוצר לצוף נקרא סוג
ולהקצות משתנה ש לy הפעמים x הערך.
ולאחר מכן להחזיר את המוצר.
מה זה אומר לחזור לכאן.
ובכן התמורה היא הדרך אנו מצביעים על כך
אנחנו עוברים את התפוקה לסגת.
אז לחזור משהו, הוא אותו דבר כמו, זה הפלט של הקופסה השחורה.
אז ככה אתה עושה את זה.
הנה דרך נוספת לביצועו.
אנחנו יכולים רק לחזור פעמים x y.
x הוא לצוף.
y הוא לצוף.
אז x y פעמים הוא גם לצוף.
אנחנו אפילו לא צריכים ליצור משתנים אחר.
אז זה בדרך שונה ליישם את אותה קופסא שחורה המדויקת.
>> עכשיו קח רגע, להשהות את הווידאו שוב,
ולנסות ולהגדיר להוסיף שני ints, אשר היא הפונקציה אחרת ש
דיבר על לפני רגע.
שוב כאן, שמו לי את הפונקציה הכרזה, וכך פסיק,
וסד מתולתל פתוח ומתולתל סגור
סד כדי לציין בו אנו אמלא בתכנים של להוסיף שני ints,
כך שאנו מגדירים מסוימים התנהגות בתוך הקופסה השחורה.
אז להשהות את הווידאו.
ולקחת כמה שיותר זמן אתה צריך לנסות ולהגדיר
יישום להוסיף שני ints, כגון כי כאשר פונקצית פלטי ערך,
היא עושה, למעשה, תמורה הסכום של שתי כניסות.
אז בדיוק כמו בדוגמא הקודמת, יש כמה דרכים שונות
שאתה יכול ליישם להוסיף שני ints.
הנה אחד.
כאן בתפוז יש לי פשוט הייתה כמה comments--
אני רק הוספתי כמה הערות כדי לציין
מה שקורה בכל שורת קוד.
אז אני מכריז על משתנה נקרא סכום של int הסוג.
אני אומר סכום שווה ב בתוספת.
זה מקום שבי אנחנו בעצם עושים עבודת הוספת A ו- B יחד.
ואני חוזר סכום.
וזה הגיוני, כי הסכום הוא משתנה int הסוג.
ומה סוג נתונים שזו פונקציה אומרת לי שזה הולך לפלט?
Int.
אז אני חוזר סכום, ש הוא מספר שלם משתנה.
וזה הגיוני בהתחשב במה שיש לנו מוצהר ומוגדר הפונקציה שלנו
לעשות.
>> עכשיו אתה גם יכול להגדיר הפונקציה זו דרך,
int סכום שווה בתוספת b-- לדלג ש הראשון step-- ולאחר מכן, לחזור סכום.
עכשיו אתה יכול להיות גם יישם אותו בדרך זו,
שאני מאוד לא ממליץ.
זהו סגנון רע אחד דבר ועיצוב ממש רע,
אבל זה, למעשה, עבודה.
אם אתה לוקח את הקוד הזה, שהוא int להוסיף ג נקודת האפעה רע, ולהשתמש בו.
זה בעצם עושה להוסיף שני מספרים שלמים ביחד.
זה יישום גרוע מאוד התנהגות המסוימת הזה.
אבל זה עובד.
זה פשוט כאן כדי להמחיש הנקודה שאנחנו עושים לא ממש
אכפת לי מה קורה בתוך הקופסה השחורה, כל עוד
שכן יש פלט שאנו מצפים.
זה הוא קופסא שחורה שלא תוכננה כראוי.
אבל בסוף היום, שהיא עושה פלט עדיין הסכום של ב בתוספת.
בסדר.
אז אנחנו כבר הכריזו פונקציות.
ואנחנו כבר מוגדרים פונקציה.
אז זה ממש טוב.
עכשיו בואו נתחיל להשתמש בפונקציות שאנחנו כבר הוכרזו ואנחנו כבר מוגדרים.
כדי לחייג לfunction-- זה בעצם די easy-- כל מה שאתה צריך לעשות
הוא להעביר אותו טיעונים מתאימים, טענות מסוג הנתונים
כי היא מצפה, ו לאחר מכן להקצות את התשואה
ערך של פונקציה ש וזה-- תירוץ me--
להקצות את ערך ההחזרה של פונקציה ש למשהו מהסוג הנכון.
>> אז בואו נעיף מבט ב בפועל זה בקובץ
נקרא נקודה ג האפעה 1, ש יש לי בIDE cs50.
אז הנה הוא האפעה 1 הנקודה ג.
בתחילת שאתה רואה יש לי שלי כולל, פאונד כולל,
הסטנדרטי IO, וh נקודת cs50.
ואז יש לי הצהרת הפונקציה שלי.
זה המקום שבי אני אומר לי מהדר אני
הולך להיות כתיבה פונקציה שנקראת להוסיף שני ints.
זה הולך פלט משתנה מסוג מספר שלם.
זה מה שהחלק הזה הוא ממש כאן.
ואז יש לי שתי כניסות אליו ו- B, כל אחד מהם הוא מספר שלם.
בתוך עיקרי, אני שואל את המשתמש ל קלט באומרו, לתת לי מספר שלם.
והם מתבקשים לשכוח int, שהיא פונקציה ש
כלול בספריית cs50.
ושמקבל מאוחסן ב x, משתנה שלם.
>> אז תבקש מהם למספר שלם אחר.
אנחנו מקבלים מספר שלם אחר ולאחסן כי בy.
ואז, כאן בקו 28, הוא שבו אנחנו עושים הקריאה לפונקציה שלנו.
אנחנו אומרים, שווים z int להוסיף 2 x ints פסיק y.
האם אתה רואה למה זה הגיוני?
x הוא משתנה מסוג מספר שלם ו y הוא משתנה מסוג מספר שלם.
אז זה טוב.
זה הגיוני עם מה הפונקציה שלנו הכרזה על קו 17 נראית כמו.
רשימת הקלט מופרד בפסיקים מצפה שני מספרים שלמים, וב.
במקרה זה, אנחנו יכולים לקרוא שלהם מה שאנחנו רוצים.
זה פשוט מצפה שני מספרים שלמים.
וx הוא מספר שלם ו- y הוא מספר שלם.
זה עובד.
>> ואנחנו יודעים שהוא הולך פונקציה לפלט מספרים שלמים גם כן.
וכך אנו מאחסנים פלט של הפונקציה,
להוסיף שני ints, בסוג שלם משתנה, שאנחנו קוראים z.
ואז אנו יכולים לומר, בסכום של אני אחוזים ואני אחוזים הוא אחוזים אני.
בהתאמה x, y ו- z מילוי באותם אחוזים אני של.
מהי ההגדרה של להוסיף שני ints נראה?
זה די פשוט.
זה אחד מאלה ש פשוט ראיתי לפני שנייה,
סכום int שווה סכום תמורה בתוספת ב.
זה עובד?
בואו לשמור את הקובץ.
וכאן למטה אז על המסוף שלי אני הולך לעשות האפעה 1,
ואני לנקות את המסך שלי.
אני הולך להתמקד בכי אני יודע זה קצת קשה לראות.
>> אז אנחנו לקמפל תכנית זו כאפעה 1.
אז אנחנו יכולים לעשות האפעה לוכסן נקודת 1.
תן לי מספר שלם, 10.
תן לי מספר שלם אחר, 20.
הסכום של 10 ו- 20 הוא 30.
אז עשינו קריאה לפונקציה מוצלחת.
אתה יכול להפעיל את הפונקציה שוב, שלילי 10, 17 סכום של 10 שליליים ו -17 הוא 7.
פונקציה זו פועלת.
יש לו את ההתנהגות כי אנו מצפים ל.
וכך שעשינו מוצלח פונקציה, הגדרה, הצהרה,
וקריאה לפונקציה מוצלחת.
שונה זוג נקודות על פונקציות
לפני שנסיים את החלק הזה.
נזכיר משלנו דיון של סוגי נתונים,
בעבר, שפונקציות לפעמים יכול לקחת שום תשומות.
אם זה המקרה, אנחנו להכריז על הפונקציה
כבעל רשימת טיעון מבוטל.
האם אתה זוכר מה רוב הפונקציה הנפוצה
שראינו עד כה שלוקח רשימת טיעון חלל היא?
זה עיקרי.
נזכיר גם פונקציה שלפעמים למעשה אין לי פלט.
במקרה זה, אנו מצהירים פונקציה כבעל סוג החזר מבוטל.
בואו נסיים את החלק הזה ב התמודדות עם בעיה בפועל.
>> אז הנה הבעיה ערוכה.
אני רוצה שתכתוב פונקציה נקרא משולש תקף.
מה פונקציה זו צריכה לעשות הוא ייקח את שלושה מספרים אמיתיים
המייצג את האורכים של שלוש צדדים של משולש כפרמטרים שלה,
או טענותיו, או שלה inputs-- קבוצה נוספת של מילים נרדפות
שאתה עשוי להיתקל.
פונקציה צריך זה או פלט אמת או שקר
תלוי אם שלושת אורכים אלה הם מסוגלים לעשות משולש.
האם אתה זוכר את סוג הנתונים ש אנחנו משמשים לציון אמת או שקר?
עכשיו איך אתה מיישם את זה?
ובכן יודע שיש כמה של כללים לגבי משולשים
כי הם למעשה שימושיים לדעת.
משולש יכול להיות רק צדדים עם אורך חיובי.
זה הגיוני.
אתה בטח אומר, דהה.
דבר נוסף שכדאי לציין אם כי, הוא שהסכום
של האורכים של כל שתי צלעות של המשולש
צריך להיות גדול יותר מ אורכו של הצד השלישי.
זה נכון בעצם.
אתה לא יכול להיות משולש של צדדים 1, 2 ו -4, לדוגמא, כי 1 בתוספת 2
אינו גדול מ -4.
אז אלה הם הכללים ש לקבוע אם או לא שלוש
תשומות יכולות להעלות על הדעת בצורה משולש.
אז לקחת כמה דקות ולהכריז ולאחר מכן להגדיר
פונקציה זו נקראת בתוקף משולש, כך שזה באמת
יש ההתנהגות שצוינה כאן.
>> זה יהיה פלט אמיתי אם שלושת צדדים אלה מסוגלים הכולל משולש,
ושקר אחר מוכן לראות איך עשה?
הנה יישום אחד משולש של תוקף.
זה לא רק אחד.
שלך עשויים להשתנות מעט.
אבל זה עושה, למעשה, יש לי ההתנהגות שאנו מצפים.
אנו מצהירים הפונקציה שלנו ב מאוד עליון, בול משולש תקפה
לצוף לצוף z y x לצוף.
אז שוב, פונקציה זו לוקח שלושה מספרים אמיתיים
כטיעוניו, צף משתני ערך נקודה,
ופלטי אמת או שקר ערך, שהוא בוליאנית, כזכור.
אז בגלל זה סוג ההחזרה הוא בול.
אז אנחנו מגדירים את הפונקציה.
הדבר ראשון שאנחנו עושים הוא לבדוק כדי לוודא שכל הצדדים חיוביים.
אם x הוא פחות או שווה 0, או אם y שווה ל- 0,
או אם z הוא פחות או שווה ל -0, שלא יכול להיות משולש.
אין להם צדדים חיוביים.
וכדי שנוכל לחזור שקר במצב זה.
בשלב הבא, אנחנו בודקים לוודא שכל זוג של תשומות
גדול מהשליש.
>> אז אם X ועוד Y הוא פחות או שווה ל Z,
או אם x בתוספת z הוא פחות או שווה ל y,
או אם y בתוספת z הוא פחות או שווה ל x, שגם לא יכול להיות משולש תקף.
אז אנחנו חוזרים שוב שקר.
בהנחה שעברנו את שתי הבדיקות אם כי, אז אנחנו יכולים לחזור אמיתיים.
בגלל שלושת צדדים אלה מסוגלים returning--
של יצירת משולש תקפה.
וזה הכל.
עכשיו אתה כבר הכריז ומוגדר.
וייתכן שתוכל לחברה להשתמש ולקרוא לפונקציה זו.
עבודה טובה.
אני דאג לויד.
זה cs50.