1
00:00:00,000 --> 00:00:04,664

2
00:00:04,664 --> 00:00:05,580
דאג LLOYD: בסדר.

3
00:00:05,580 --> 00:00:08,877
אז עכשיו בואו להתמודד
נושא ממש גדול, פונקציות.

4
00:00:08,877 --> 00:00:11,460
עד כה בקורס, כל
תוכניות שכבר כותבים

5
00:00:11,460 --> 00:00:12,969
נכתב בתוך עיקרי.

6
00:00:12,969 --> 00:00:14,260
הם תוכניות די פשוט.

7
00:00:14,260 --> 00:00:16,940
אתה לא צריך את כל אלה
סניפים ודברים קורה.

8
00:00:16,940 --> 00:00:18,773
אנחנו יכולים רק להתאים אותו כל
בתוך ראשי וזה

9
00:00:18,773 --> 00:00:20,407
לא מקבל מכריע מאוד.

10
00:00:20,407 --> 00:00:22,990
אבל כפי שכמובן הולך ו
כמו שאתה מתחיל לפתח תוכניות

11
00:00:22,990 --> 00:00:26,260
באופן עצמאי, הם כנראה הולכים
כדי להתחיל לקבל הרבה יותר מ -10

12
00:00:26,260 --> 00:00:27,200
או 15 שורות.

13
00:00:27,200 --> 00:00:31,400
אתה עלול לקבל מאות או אלפים
או עשרות אלפי שורות קוד.

14
00:00:31,400 --> 00:00:34,690
וזה ממש לא
כי משוגע מחשבה.

15
00:00:34,690 --> 00:00:39,720
ככזה, זה כנראה לא רעיון טוב
כדי לשמור על הכל בתוך עיקרי.

16
00:00:39,720 --> 00:00:43,240
זה יכול להיות קצת קשה למצוא
מה שאתה מחפש אם אתה עושה את זה.

17
00:00:43,240 --> 00:00:47,040
>> למרבה המזל, אף C, ופחות או יותר
כל שפת תכנות אחרת ש

18
00:00:47,040 --> 00:00:50,386
אולי לעבוד איתו, מאפשר לי
שלנו לכתוב פונקציות.

19
00:00:50,386 --> 00:00:52,260
ואני רק הולך ל
לקחת מהיר הצידה כאן

20
00:00:52,260 --> 00:00:54,971
להזכיר כי פונקציות היא
אזור של מדעי מחשב אחד.

21
00:00:54,971 --> 00:00:57,970
ואתה תראה הרבה יותר מהם ב
נקודות שונות לאורך הקורס

22
00:00:57,970 --> 00:00:59,290
ואם תמשיך ב.

23
00:00:59,290 --> 00:01:02,280
איפה יש הרבה
מילים נרדפות לאותה המילה.

24
00:01:02,280 --> 00:01:03,390
אז אנחנו קוראים לפונקציות.

25
00:01:03,390 --> 00:01:05,980
אבל אתה יכול גם לשמוע אותם
מכונה נהלים,

26
00:01:05,980 --> 00:01:09,570
או שיטות, במיוחד, אם יש לך אי פעם
עשה כל תכנות מונחה עצמים

27
00:01:09,570 --> 00:01:11,950
before-- ואל תדאגו
אם יש לך לא, לא

28
00:01:11,950 --> 00:01:14,280
deal-- גדול אבל ב
שפות ביקורת אוריינטציה

29
00:01:14,280 --> 00:01:16,129
שיטות מתקשרות לעתים תכופות.

30
00:01:16,129 --> 00:01:17,670
לפעמים הם נקראים גרות.

31
00:01:17,670 --> 00:01:20,690
אבל הם באמת כל מתייחסים
לאותו רעיון בסיסי.

32
00:01:20,690 --> 00:01:22,480
>> בואו לראות מה הוא הרעיון ש.

33
00:01:22,480 --> 00:01:23,310
מה היא פונקציה?

34
00:01:23,310 --> 00:01:26,470
ובכן פונקציה היא באמת
לא יותר מאשר קופסא שחורה.

35
00:01:26,470 --> 00:01:31,430
קופסא שחורה שיש לו קבוצה של אפס
או יותר תשומות ופלט יחיד.

36
00:01:31,430 --> 00:01:33,420
כך למשל, זה
יכול להיות פונקציה.

37
00:01:33,420 --> 00:01:35,510
זוהי פונקציה שנקראת func.

38
00:01:35,510 --> 00:01:39,330
וזה לוקח שלוש כניסות, B, C.

39
00:01:39,330 --> 00:01:42,580
ובתוך שהקופסה שחורה, ש
לא יודע בדיוק מה היא עושה,

40
00:01:42,580 --> 00:01:45,100
אבל זה מעבד את התשומות
בדרך כלשהי ואז זה

41
00:01:45,100 --> 00:01:48,680
נותן תפוקה אחת, במקרה זה, z.

42
00:01:48,680 --> 00:01:50,504
עכשיו כדי לעשות את זה קצת
פחות מופשט, ש

43
00:01:50,504 --> 00:01:52,420
אפשר לומר שאולי
יש פונקציה שנקראת

44
00:01:52,420 --> 00:01:58,750
תוסיף, כי לוקח שלוש כניסות, ב, ו
ג ומעבד את הפלט בדרך כלשהי

45
00:01:58,750 --> 00:02:01,010
בתוך הקופסה השחורה ל
לייצר פלט יחיד.

46
00:02:01,010 --> 00:02:05,190
אז במקרה הזה, אם
להוסיף לוקח 3, 6, ו -7.

47
00:02:05,190 --> 00:02:07,020
אי שם בתוך
להוסיף פונקציה, שהיינו

48
00:02:07,020 --> 00:02:09,750
מצפה מהם יתווספו יחד
כדי לייצר את הפלט, ש

49
00:02:09,750 --> 00:02:13,220
הוא 3 ועוד 6 ועוד 7 או 16.

50
00:02:13,220 --> 00:02:17,940
>> כמו כן, יש לך פונקציה שנקראת
mult שלוקח שתי כניסות, ו- B,

51
00:02:17,940 --> 00:02:21,070
מעבד אותם בדרך כלשהי, כגון
שהפלט של הפונקציה

52
00:02:21,070 --> 00:02:22,920
הוא התוצר של שתי כניסות.

53
00:02:22,920 --> 00:02:25,080
שתי כניסות כפול יחד.

54
00:02:25,080 --> 00:02:29,150
4 ו -5 שעברו לmult,
משהו קורה, התפוקה אנו מצפים

55
00:02:29,150 --> 00:02:31,090
הוא 20.

56
00:02:31,090 --> 00:02:32,507
למה אנחנו קוראים לזה קופסא שחורה?

57
00:02:32,507 --> 00:02:34,840
ובכן, אם אנחנו לא כותבים
מתפקד את עצמנו, ש

58
00:02:34,840 --> 00:02:36,869
שעשינו לא מעט עד כה cs50.

59
00:02:36,869 --> 00:02:39,910
ראינו F הדפסה, למשל, ש
היא פונקציה שלא לכתוב

60
00:02:39,910 --> 00:02:42,305
את עצמנו, אבל אנחנו משתמשים כל הזמן.

61
00:02:42,305 --> 00:02:44,180
אם אנחנו לא כותבים
הפונקציות את עצמנו,

62
00:02:44,180 --> 00:02:48,450
אנחנו לא באמת צריכים לדעת איך זה
מיושם למעשה מתחת למכסת המנוע.

63
00:02:48,450 --> 00:02:51,710
>> כך למשל אני קופסא השחורה
רק הראיתי לך לכפל,

64
00:02:51,710 --> 00:02:53,740
mult, ב יכול להיות
defined-- וזו רק

65
00:02:53,740 --> 00:02:57,902
כמה pseudocode-- יכול להיות
מוגדר כפלט פעמים ב.

66
00:02:57,902 --> 00:02:58,860
זה הגיוני, נכון.

67
00:02:58,860 --> 00:03:01,370
אם יש לנו פונקציה שנקראת
mult שלוקח שתי כניסות.

68
00:03:01,370 --> 00:03:04,750
היינו מצפה שהתפוקה היית
להיות שתי הכניסות מוכפלות יחד,

69
00:03:04,750 --> 00:03:06,240
פעמים ב.

70
00:03:06,240 --> 00:03:09,170
אבל mult גם יכול להיות
מיושם כמו זה,

71
00:03:09,170 --> 00:03:13,150
יש לנו משתנים בניגוד ל
לקבל להגדיר בתוך mult ל0.

72
00:03:13,150 --> 00:03:18,000
ואז אנו חוזרים על תהליך זה
ב פעמים להוסיף לדלפק.

73
00:03:18,000 --> 00:03:24,270
לדוגמא, אם נכפיל 3a על ידי
5b, נוכל לומר שנקבע בניגוד ל0,

74
00:03:24,270 --> 00:03:27,700
לחזור חמש פעמים, להוסיף 3 לדלפק.

75
00:03:27,700 --> 00:03:34,490
אז אנחנו מתחילים ב 0 ואז אנחנו עושים
חמש פעמים זה 3, 6, 9, 12, 15.

76
00:03:34,490 --> 00:03:37,500
זה את אותה התוצאה. אנחנו
עדיין מקבל 3 פעמים 5 רק

77
00:03:37,500 --> 00:03:39,500
היישום הוא שונה.

78
00:03:39,500 --> 00:03:41,490
>> זה מה שאנחנו אומר
כאשר אנו אומרים קופסא שחורה.

79
00:03:41,490 --> 00:03:44,406
זה רק אומר שבאמת לא אכפת לנו
איך זה מיושם מתחת למכסת המנוע

80
00:03:44,406 --> 00:03:46,170
כל עוד את הפלט הוא מה שאנחנו מצפים.

81
00:03:46,170 --> 00:03:49,045
למעשה, זה חלק מהחוזה
של שימוש בפונקציות, במיוחד

82
00:03:49,045 --> 00:03:50,630
פונקציות שאחרים כותבים.

83
00:03:50,630 --> 00:03:53,980
ההתנהגות תמיד הולכת
להיות טיפוסי, בלתי צפוי

84
00:03:53,980 --> 00:03:55,420
המבוסס על השם של הפונקציה.

85
00:03:55,420 --> 00:03:57,500
וזה למה זה באמת
חשוב כשאתה כותב פונקציות

86
00:03:57,500 --> 00:04:00,020
או כאשר אנשים אחרים לכתוב
פונקציות שאתה עשוי להשתמש,

87
00:04:00,020 --> 00:04:03,590
כי יש פונקציות אלה
שמות ברורים, יחסית ברורים,

88
00:04:03,590 --> 00:04:04,990
ומתועדים היטב.

89
00:04:04,990 --> 00:04:08,560
וזה בהחלט המקרה
לפונקציה כמו F הדפסה.

90
00:04:08,560 --> 00:04:09,860
>> אז למה אנחנו משתמשים בפונקציות?

91
00:04:09,860 --> 00:04:14,220
ובכן כמו שאמרתי קודם, אם אנחנו כותבים
כל הקוד שלנו בתוך הדברים עיקריים

92
00:04:14,220 --> 00:04:17,120
יכול לקבל באמת מסורבל
ומסובך באמת.

93
00:04:17,120 --> 00:04:19,980
פונקציות מאפשרות לנו את היכולת
לארגן דברים ולשבור את

94
00:04:19,980 --> 00:04:24,540
בעיה מסובכת מאוד ל
הרבה חלקי משנה יותר לניהול.

95
00:04:24,540 --> 00:04:28,130
פונקציות גם יאפשרו לנו
לפשט את תהליך הקידוד.

96
00:04:28,130 --> 00:04:33,080
זה הרבה יותר קל לאתר באגים 10
פונקצית קו לעומת קו 100

97
00:04:33,080 --> 00:04:35,890
פונקציה או פונקצית 1,000 קו.

98
00:04:35,890 --> 00:04:38,400
אם יש לנו רק לבאגים
חתיכות קטנות בכל פעם,

99
00:04:38,400 --> 00:04:42,110
או לכתוב חתיכות קטנות בזמן,
זה עושה שניסיון בתכנות

100
00:04:42,110 --> 00:04:43,070
הרבה יותר טוב.

101
00:04:43,070 --> 00:04:44,910
תאמין לי על זה.

102
00:04:44,910 --> 00:04:48,400
>> לבסוף, אם אנחנו כותבים הפונקציות
ניתן לעשות שימוש חוזר באותם חלקים שונים.

103
00:04:48,400 --> 00:04:49,880
ניתן למחזר פונקציות.

104
00:04:49,880 --> 00:04:51,880
הם יכולים לשמש ב
תכנית זו או אחר.

105
00:04:51,880 --> 00:04:53,713
אתה כבר כתבת
הפונקציה, כל מה שאתה

106
00:04:53,713 --> 00:04:56,530
צריך לעשות הוא לספר לי תכנית ש
איפה למצוא את הפונקציה ש.

107
00:04:56,530 --> 00:04:59,680
אנחנו כבר מחזור ושימוש
להדפיס ו במשך 40 שנים.

108
00:04:59,680 --> 00:05:02,150
אבל זה נכתב רק פעם אחת.

109
00:05:02,150 --> 00:05:04,270
די שימושי, נכון.

110
00:05:04,270 --> 00:05:04,830
בסדר.

111
00:05:04,830 --> 00:05:06,040
אז פונקציות נהדרות.

112
00:05:06,040 --> 00:05:06,860
אנחנו יודעים את זה.

113
00:05:06,860 --> 00:05:08,700
עכשיו בואו נתחיל לכתוב אותם.

114
00:05:08,700 --> 00:05:10,830
בואו נתחיל מקבלים
אותם לתוכניות שלנו.

115
00:05:10,830 --> 00:05:13,869
כדי לעשות את זה, הראשון
דבר שאנחנו עושים הוא להכריז על הפונקציה.

116
00:05:13,869 --> 00:05:16,160
כאשר אתה מצהיר על פונקציה
מה שאתה עושה בעצם

117
00:05:16,160 --> 00:05:18,900
הוא אומר לי מהדר,
היי, רק שתדע,

118
00:05:18,900 --> 00:05:20,850
אני הולך להיות כתיבה
פונקציה בשלב מאוחר יותר

119
00:05:20,850 --> 00:05:22,987
והנה מה שזה הולך להיראות.

120
00:05:22,987 --> 00:05:24,820
הסיבה לכך היא
כי מהדרים יכולים

121
00:05:24,820 --> 00:05:27,900
לעשות כמה דברים מוזרים אם
הם רואים קבוצה של סימנים

122
00:05:27,900 --> 00:05:29,560
כי הם לא מכירים.

123
00:05:29,560 --> 00:05:33,000
אז אנחנו פשוט לתת מהדר
ראש בראש, אני יוצר פונקציה

124
00:05:33,000 --> 00:05:35,492
וזה הולך לעשות את זה.

125
00:05:35,492 --> 00:05:38,450
הצהרות פונקציה בדרך כלל אם
אתה מארגן את הקוד שלך בדרך

126
00:05:38,450 --> 00:05:41,872
שאחרים יוכלו
להבין ולעשות שימוש,

127
00:05:41,872 --> 00:05:44,330
אתה בדרך כלל רוצה לשים את כל
הצהרות הפונקציה שלך

128
00:05:44,330 --> 00:05:48,220
בחלקו העליון של הקוד שלך, נכון
לפני שאתם מתחילים בכתיבה העיקרית אפילו.

129
00:05:48,220 --> 00:05:50,770
ובנוחות, יש
טופס סטנדרטי מאוד

130
00:05:50,770 --> 00:05:53,500
שכל הכרזת פונקציה כדלקמן.

131
00:05:53,500 --> 00:05:56,090
כולם פחות או יותר נראים כמו זה.

132
00:05:56,090 --> 00:06:01,440
ישנם שלושה חלקים לפונקציה
הצהרה, סוג תמורה, שם,

133
00:06:01,440 --> 00:06:03,420
ורשימת טיעון.

134
00:06:03,420 --> 00:06:07,180
>> עכשיו סוג ההחזרה הוא איזה סוג של
משתנה פלט פונקציה.

135
00:06:07,180 --> 00:06:10,710
כך למשל, אם אנחנו חושבים חזרה
דקות לפני להכפלת שני

136
00:06:10,710 --> 00:06:15,690
פונקצית מספרים, מה אנחנו מצפים אם
נכפיל מספר שלם על ידי שלם

137
00:06:15,690 --> 00:06:18,502
הפלט יהיה
כנראה שלם, תקין.

138
00:06:18,502 --> 00:06:20,710
שני מספרים שלמים כפול
יחד, אתה מקבל מספר שלם.

139
00:06:20,710 --> 00:06:24,167
אז הסוג של התמורה ש
פונקציה תהיה int.

140
00:06:24,167 --> 00:06:26,000
שם זה מה שאתה רוצה
לקרוא הפונקציה שלך.

141
00:06:26,000 --> 00:06:29,330
זה כנראה הכי פחות חשוב
חלק מהצהרת הפונקציה,

142
00:06:29,330 --> 00:06:30,827
במונחים של פונקציונליות.

143
00:06:30,827 --> 00:06:33,160
אך הוא למעשה כנראה אחד
החלקים החשובים ביותר

144
00:06:33,160 --> 00:06:36,243
הכרזת הפונקציה במונחים
לדעת מה הפונקציה למעשה

145
00:06:36,243 --> 00:06:37,120
עושה.

146
00:06:37,120 --> 00:06:40,474
אם אתה שם את פונקצית f או g שלך או
h או תעלומה או משהו כזה,

147
00:06:40,474 --> 00:06:42,765
אתה כנראה הולך לקבל
קצת הכשיל את הניסיון

148
00:06:42,765 --> 00:06:44,650
לזכור מה פונקציות אלה לעשות.

149
00:06:44,650 --> 00:06:47,880
לכן חשוב לנותנך
שמות בעלי המשמעות של הפונקציה.

150
00:06:47,880 --> 00:06:51,030
>> לבסוף, רשימת טיעון היא
הרשימה מופרדת בפסיקים

151
00:06:51,030 --> 00:06:55,260
של כל התשומות לפונקציה שלך,
כל אחד מהם יש לו סוג ושם.

152
00:06:55,260 --> 00:06:57,840
אז לא רק שאתה צריך
לציין איזה סוג של משתנה

153
00:06:57,840 --> 00:07:00,760
פלט פונקציה,
גם אתה רוצה לציין

154
00:07:00,760 --> 00:07:07,694
איזה סוג וסוגים של משתנים
פונקציה תהיה לקבל כתשומות.

155
00:07:07,694 --> 00:07:08,860
אז בואו נעשה דוגמא כאן.

156
00:07:08,860 --> 00:07:10,220
בואו רק נסתכל
באחד קונקרטי יותר.

157
00:07:10,220 --> 00:07:13,130
אז הנה דוגמא של פונקציה
הכרזה לפונקציה ש

158
00:07:13,130 --> 00:07:14,925
תוסיף שני מספרים שלמים ביחד.

159
00:07:14,925 --> 00:07:17,800
הסכום של שני מספרים שלמים הולך
להיות שלם, כמו גם, כפי שאנו פשוט

160
00:07:17,800 --> 00:07:18,450
דן.

161
00:07:18,450 --> 00:07:21,610
וכך סוג התמורה,
כאן בירוק, יהיה int.

162
00:07:21,610 --> 00:07:25,190
זה רק אומר לנו שיוסיף שני ints
הוא הולך, בסופו של היום,

163
00:07:25,190 --> 00:07:28,799
פלט, או לירוק אותו בחזרה
אלינו, מספר שלם.

164
00:07:28,799 --> 00:07:31,590
בהתחשב במה שאנחנו עושה בפונקציה זו
רוצה לתת לה שם משמעותי.

165
00:07:31,590 --> 00:07:33,630
להוסיף שני ints נראה
מתאים, בהתחשב ב

166
00:07:33,630 --> 00:07:37,574
אנחנו לוקחים שני מספרים שלמים כתשומות
ולהוסיף אותם בתקווה יחד.

167
00:07:37,574 --> 00:07:40,240
זה יכול להיות קצת מסורבל
שם ולמען האמת בפונקציה זו

168
00:07:40,240 --> 00:07:42,430
הוא כנראה לא הכרחי
מאז יש לנו בנוסף

169
00:07:42,430 --> 00:07:46,310
מפעיל, אם אתה זוכר משלנו
דיון של מפעילים, בעבר.

170
00:07:46,310 --> 00:07:49,650
אבל בואו נגיד לשם
טענה שהפונקציה זו שימושית

171
00:07:49,650 --> 00:07:52,860
וכך אנחנו קוראים לזה להוסיף שני ints.

172
00:07:52,860 --> 00:07:55,230
לבסוף, פונקציה זו לוקחת שתי כניסות.

173
00:07:55,230 --> 00:07:56,960
כל אחד מהם הוא מספר שלם.

174
00:07:56,960 --> 00:07:59,900
אז יש לנו פסיק זה
רשימה מופרדת תשומות.

175
00:07:59,900 --> 00:08:02,830
עכשיו אנחנו בדרך כלל רוצים
לתת שם לכל אחד מהם

176
00:08:02,830 --> 00:08:05,070
כך שהם יכולים לשמש
בתוך הפונקציה.

177
00:08:05,070 --> 00:08:07,180
השמות לא נורא חשובים.

178
00:08:07,180 --> 00:08:11,400
>> במקרה זה, אנחנו לא בהכרח
יש כל משמעות המצורפת אליהם.

179
00:08:11,400 --> 00:08:13,140
אז אנחנו יכולים רק לקרוא להם וב.

180
00:08:13,140 --> 00:08:14,257
זה לגמרי בסדר.

181
00:08:14,257 --> 00:08:16,090
אם לעומת זאת, אתה מוצא
עצמך במצב

182
00:08:16,090 --> 00:08:19,497
שבו השמות של המשתנים
באמת עשוי להיות חשוב,

183
00:08:19,497 --> 00:08:21,830
אולי כדאי לך לקרוא אותם
משהו אחר מאשר A ו- B

184
00:08:21,830 --> 00:08:24,701
לתת להם משהו יותר
משמעות סמלית.

185
00:08:24,701 --> 00:08:27,700
אבל במקרה הזה, אנחנו לא באמת
יודע משהו על הפונקציה אחרת.

186
00:08:27,700 --> 00:08:29,320
אנחנו רק רוצים להוסיף שני מספרים שלמים.

187
00:08:29,320 --> 00:08:32,429
אז אנחנו פשוט נתקשר
אלה מספרים שלמים וב.

188
00:08:32,429 --> 00:08:33,990
זו דוגמא אחת.

189
00:08:33,990 --> 00:08:36,287
>> למה אתה לא לוקח שני
לחשוב על זה,

190
00:08:36,287 --> 00:08:38,870
איך היית לכתוב פונקציה
הכרזה לפונקציה ש

191
00:08:38,870 --> 00:08:42,940
מכפיל שני מספרי נקודה צפו?

192
00:08:42,940 --> 00:08:45,910
אתה זוכר מה
מספר נקודה צפה הוא?

193
00:08:45,910 --> 00:08:48,120
מה היית עושה בפונקציה זו
הכרזה נראה?

194
00:08:48,120 --> 00:08:53,330
אני ממש ממליץ לך להשהות את הווידאו
כאן ולקחת כמה זמן שאתה צריך.

195
00:08:53,330 --> 00:08:55,521
תחשוב על מה זה
הצהרת פונקציה תהיה?

196
00:08:55,521 --> 00:08:56,770
מה היית סוג ההחזרה להיות?

197
00:08:56,770 --> 00:08:58,103
מה היית שם עם משמעות להיות?

198
00:08:58,103 --> 00:08:59,580
מה הייתם התשומות להיות?

199
00:08:59,580 --> 00:09:03,190
אז למה אתה לא להשהות את הווידאו כאן
ולכתוב-עד הכרזת פונקציה

200
00:09:03,190 --> 00:09:07,640
לפונקציה שהיה להכפיל
שני מספרי נקודה צפו יחד.

201
00:09:07,640 --> 00:09:09,330
אני מקווה שאתה עצר את הווידאו.

202
00:09:09,330 --> 00:09:12,950
>> אז בואו נסתכל על דוגמא
הצהרה אחת אפשרית.

203
00:09:12,950 --> 00:09:17,340
לצוף שני ריאל mult לצוף x, y לצוף.

204
00:09:17,340 --> 00:09:19,090
המוצר של שני
מספרי נקודה צפה,

205
00:09:19,090 --> 00:09:21,710
שזוכר הם איך אנחנו
מייצג מספרים אמיתיים

206
00:09:21,710 --> 00:09:26,770
או מספרים עם ערכים עשרוניים בג,
הולך להיות מספר נקודה צפה.

207
00:09:26,770 --> 00:09:28,570
כאשר אתה להכפיל
עשרוני ידי עשרוני,

208
00:09:28,570 --> 00:09:30,460
אתה כנראה הולך לקבל עשרוני.

209
00:09:30,460 --> 00:09:31,960
אתה רוצה לתת לה שם רלוונטי.

210
00:09:31,960 --> 00:09:33,810
להכפיל שני ריאל נראה בסדר.

211
00:09:33,810 --> 00:09:36,620
אבל אתה באמת יכול לקרוא לזה
שני צף mult, או צף mult.

212
00:09:36,620 --> 00:09:39,540
משהו כזה, כל עוד זה
נתן כמה משמעות אמיתית למה ש

213
00:09:39,540 --> 00:09:41,469
קופסא שחורה זה הולכת לעשות.

214
00:09:41,469 --> 00:09:44,260
ושוב, במקרה זה, אנחנו לא
נראה שיש משמעות המצורפת

215
00:09:44,260 --> 00:09:46,390
לשמות
משתנים שאנחנו עוברים ב,

216
00:09:46,390 --> 00:09:48,645
אז אנחנו פשוט קוראים להם X ו- Y.

217
00:09:48,645 --> 00:09:51,020
עכשיו, אם אתה קורא להם משהו
אחר, זה בסדר גמור.

218
00:09:51,020 --> 00:09:53,310
למעשה, אם אתה עשית
הצהרה זו במקום

219
00:09:53,310 --> 00:09:55,450
באמצעות זוגות במקום
של צף, אם אתה זוכר

220
00:09:55,450 --> 00:09:59,100
שזוגות הם שונים
דרך למדויקת יותר

221
00:09:59,100 --> 00:10:02,330
לציין מספרים אמיתיים או
צפה משתני נקודה.

222
00:10:02,330 --> 00:10:03,620
זה לגמרי בסדר מדי.

223
00:10:03,620 --> 00:10:04,670
או אחד מאותם יהיה בסדר.

224
00:10:04,670 --> 00:10:06,711
למעשה, יש כמה
שילובים שונים

225
00:10:06,711 --> 00:10:08,410
דרכים להכריז בפונקציה זו.

226
00:10:08,410 --> 00:10:10,884
אבל אלה הם שני די טובים.

227
00:10:10,884 --> 00:10:12,550
אנחנו כבר הכריזו פונקציה, זה נהדר.

228
00:10:12,550 --> 00:10:15,700
אנחנו כבר אמרנו לי מהדר מה זה
הוא, מה שאנחנו הולכים לעשות.

229
00:10:15,700 --> 00:10:17,630
עכשיו בואו בעצם לכתוב פונקציה ש.

230
00:10:17,630 --> 00:10:20,750
בואו נותנים לו הגדרה,
כך שבתוך הקופסה השחורה

231
00:10:20,750 --> 00:10:22,840
התנהגות צפויה קורה.

232
00:10:22,840 --> 00:10:26,270
למעשה, אנחנו הכפלת שתי אמיתיים
מספרים יחד, או מספרי הוספה

233
00:10:26,270 --> 00:10:29,760
יחד, או עושה כל מה שהוא
ששאלנו את הפונקציה שלנו לעשות.

234
00:10:29,760 --> 00:10:32,780
>> כך שלמעשה, בואו ננסה להגדיר ו
להכפיל שני ריאל שאנחנו פשוט

235
00:10:32,780 --> 00:10:35,350
דיבר על לפני שנייה.

236
00:10:35,350 --> 00:10:38,560
עכשיו תחילת
הגדרת פונקציה

237
00:10:38,560 --> 00:10:41,720
נראה כמעט בדיוק אותו הדבר
כהצהרת פונקציה.

238
00:10:41,720 --> 00:10:43,170
יש לי את שניהם כאן.

239
00:10:43,170 --> 00:10:47,770
בחלק העליון היא הצהרת הפונקציה,
סוג, שם, טענה, מופרד בפסיקים

240
00:10:47,770 --> 00:10:49,410
רשימה, פסיק.

241
00:10:49,410 --> 00:10:53,800
פסיק מצביע על כך ש
כי הוא הצהרת פונקציה.

242
00:10:53,800 --> 00:10:57,060
תחילת הפונקציה
הגדרה נראית כמעט בדיוק

243
00:10:57,060 --> 00:11:03,790
אותו הדבר, הסוג, שם, מופרד בפסיקים
רשימת טיעון, לא פסיק,

244
00:11:03,790 --> 00:11:05,206
לפתוח סד מתולתל.

245
00:11:05,206 --> 00:11:07,580
הסד המתולתל הפתוח, בדיוק כפי ש
אנחנו כבר עושים עם עיקריים,

246
00:11:07,580 --> 00:11:09,540
משמעות הדבר היא כי אנו נמצאים כעת
מתחיל להגדיר

247
00:11:09,540 --> 00:11:14,567
מה שקורה בתוך הקופסה השחורה ש
החלטנו לקרוא לשני ריאל mult.

248
00:11:14,567 --> 00:11:15,900
הנה דרך אחת לביצועו.

249
00:11:15,900 --> 00:11:20,370
אנחנו יכולים לומר, שאנחנו יכולים להכריז חדשים
משתנה ממוצר לצוף נקרא סוג

250
00:11:20,370 --> 00:11:24,020
ולהקצות משתנה ש
לy הפעמים x הערך.

251
00:11:24,020 --> 00:11:27,306
ולאחר מכן להחזיר את המוצר.

252
00:11:27,306 --> 00:11:28,430
מה זה אומר לחזור לכאן.

253
00:11:28,430 --> 00:11:31,090
ובכן התמורה היא הדרך
אנו מצביעים על כך

254
00:11:31,090 --> 00:11:33,400
אנחנו עוברים את התפוקה לסגת.

255
00:11:33,400 --> 00:11:38,160
אז לחזור משהו, הוא אותו דבר כמו,
זה הפלט של הקופסה השחורה.

256
00:11:38,160 --> 00:11:40,732
אז ככה אתה עושה את זה.

257
00:11:40,732 --> 00:11:42,190
הנה דרך נוספת לביצועו.

258
00:11:42,190 --> 00:11:45,050
אנחנו יכולים רק לחזור פעמים x y.

259
00:11:45,050 --> 00:11:45,870
x הוא לצוף.

260
00:11:45,870 --> 00:11:46,660
y הוא לצוף.

261
00:11:46,660 --> 00:11:48,490
אז x y פעמים הוא גם לצוף.

262
00:11:48,490 --> 00:11:50,750
אנחנו אפילו לא צריכים
ליצור משתנים אחר.

263
00:11:50,750 --> 00:11:56,750
אז זה בדרך שונה
ליישם את אותה קופסא שחורה המדויקת.

264
00:11:56,750 --> 00:11:58,570
>> עכשיו קח רגע,
להשהות את הווידאו שוב,

265
00:11:58,570 --> 00:12:01,680
ולנסות ולהגדיר להוסיף שני ints,
אשר היא הפונקציה אחרת ש

266
00:12:01,680 --> 00:12:03,090
דיבר על לפני רגע.

267
00:12:03,090 --> 00:12:06,440
שוב כאן, שמו לי את הפונקציה
הכרזה, וכך פסיק,

268
00:12:06,440 --> 00:12:08,420
וסד מתולתל פתוח
ומתולתל סגור

269
00:12:08,420 --> 00:12:12,080
סד כדי לציין בו אנו אמלא
בתכנים של להוסיף שני ints,

270
00:12:12,080 --> 00:12:15,530
כך שאנו מגדירים מסוימים
התנהגות בתוך הקופסה השחורה.

271
00:12:15,530 --> 00:12:16,380
אז להשהות את הווידאו.

272
00:12:16,380 --> 00:12:18,790
ולקחת כמה שיותר זמן
אתה צריך לנסות ולהגדיר

273
00:12:18,790 --> 00:12:25,040
יישום להוסיף שני ints, כגון
כי כאשר פונקצית פלטי ערך,

274
00:12:25,040 --> 00:12:29,209
היא עושה, למעשה, תמורה
הסכום של שתי כניסות.

275
00:12:29,209 --> 00:12:32,000
אז בדיוק כמו בדוגמא הקודמת,
יש כמה דרכים שונות

276
00:12:32,000 --> 00:12:34,210
שאתה יכול ליישם להוסיף שני ints.

277
00:12:34,210 --> 00:12:35,130
הנה אחד.

278
00:12:35,130 --> 00:12:37,172
כאן בתפוז יש לי
פשוט הייתה כמה comments--

279
00:12:37,172 --> 00:12:38,880
אני רק הוספתי כמה
הערות כדי לציין

280
00:12:38,880 --> 00:12:41,400
מה שקורה בכל שורת קוד.

281
00:12:41,400 --> 00:12:45,430
אז אני מכריז על משתנה
נקרא סכום של int הסוג.

282
00:12:45,430 --> 00:12:47,279
אני אומר סכום שווה ב בתוספת.

283
00:12:47,279 --> 00:12:50,070
זה מקום שבי אנחנו בעצם עושים
עבודת הוספת A ו- B יחד.

284
00:12:50,070 --> 00:12:51,850
ואני חוזר סכום.

285
00:12:51,850 --> 00:12:56,460
וזה הגיוני, כי
הסכום הוא משתנה int הסוג.

286
00:12:56,460 --> 00:13:00,180
ומה סוג נתונים שזו
פונקציה אומרת לי שזה הולך לפלט?

287
00:13:00,180 --> 00:13:00,680
Int.

288
00:13:00,680 --> 00:13:03,072
אז אני חוזר סכום, ש
הוא מספר שלם משתנה.

289
00:13:03,072 --> 00:13:06,030
וזה הגיוני בהתחשב במה שיש לנו
מוצהר ומוגדר הפונקציה שלנו

290
00:13:06,030 --> 00:13:07,320
לעשות.

291
00:13:07,320 --> 00:13:09,700
>> עכשיו אתה גם יכול להגדיר
הפונקציה זו דרך,

292
00:13:09,700 --> 00:13:15,260
int סכום שווה בתוספת b-- לדלג ש
הראשון step-- ולאחר מכן, לחזור סכום.

293
00:13:15,260 --> 00:13:17,760
עכשיו אתה יכול להיות גם
יישם אותו בדרך זו,

294
00:13:17,760 --> 00:13:19,180
שאני מאוד לא ממליץ.

295
00:13:19,180 --> 00:13:22,540
זהו סגנון רע אחד
דבר ועיצוב ממש רע,

296
00:13:22,540 --> 00:13:24,420
אבל זה, למעשה, עבודה.

297
00:13:24,420 --> 00:13:30,199
אם אתה לוקח את הקוד הזה, שהוא int
להוסיף ג נקודת האפעה רע, ולהשתמש בו.

298
00:13:30,199 --> 00:13:31,990
זה בעצם עושה להוסיף
שני מספרים שלמים ביחד.

299
00:13:31,990 --> 00:13:37,632
זה יישום גרוע מאוד
התנהגות המסוימת הזה.

300
00:13:37,632 --> 00:13:38,340
אבל זה עובד.

301
00:13:38,340 --> 00:13:41,200
זה פשוט כאן כדי להמחיש
הנקודה שאנחנו עושים לא ממש

302
00:13:41,200 --> 00:13:44,530
אכפת לי מה קורה בתוך
הקופסה השחורה, כל עוד

303
00:13:44,530 --> 00:13:46,510
שכן יש פלט שאנו מצפים.

304
00:13:46,510 --> 00:13:48,870
זה הוא קופסא שחורה שלא תוכננה כראוי.

305
00:13:48,870 --> 00:13:53,801
אבל בסוף היום, שהיא עושה
פלט עדיין הסכום של ב בתוספת.

306
00:13:53,801 --> 00:13:54,300
בסדר.

307
00:13:54,300 --> 00:13:56,320
אז אנחנו כבר הכריזו פונקציות.

308
00:13:56,320 --> 00:13:57,490
ואנחנו כבר מוגדרים פונקציה.

309
00:13:57,490 --> 00:13:58,540
אז זה ממש טוב.

310
00:13:58,540 --> 00:14:03,020
עכשיו בואו נתחיל להשתמש בפונקציות
שאנחנו כבר הוכרזו ואנחנו כבר מוגדרים.

311
00:14:03,020 --> 00:14:05,960
כדי לחייג לfunction-- זה בעצם
די easy-- כל מה שאתה צריך לעשות

312
00:14:05,960 --> 00:14:09,070
הוא להעביר אותו טיעונים מתאימים,
טענות מסוג הנתונים

313
00:14:09,070 --> 00:14:11,600
כי היא מצפה, ו
לאחר מכן להקצות את התשואה

314
00:14:11,600 --> 00:14:15,190
ערך של פונקציה ש
וזה-- תירוץ me--

315
00:14:15,190 --> 00:14:19,390
להקצות את ערך ההחזרה של פונקציה ש
למשהו מהסוג הנכון.

316
00:14:19,390 --> 00:14:22,410
>> אז בואו נעיף מבט ב
בפועל זה בקובץ

317
00:14:22,410 --> 00:14:27,730
נקרא נקודה ג האפעה 1, ש
יש לי בIDE cs50.

318
00:14:27,730 --> 00:14:31,042
אז הנה הוא האפעה 1 הנקודה ג.

319
00:14:31,042 --> 00:14:33,500
בתחילת שאתה רואה יש לי
שלי כולל, פאונד כולל,

320
00:14:33,500 --> 00:14:35,460
הסטנדרטי IO, וh נקודת cs50.

321
00:14:35,460 --> 00:14:37,700
ואז יש לי הצהרת הפונקציה שלי.

322
00:14:37,700 --> 00:14:39,570
זה המקום שבי אני
אומר לי מהדר אני

323
00:14:39,570 --> 00:14:42,850
הולך להיות כתיבה
פונקציה שנקראת להוסיף שני ints.

324
00:14:42,850 --> 00:14:45,780
זה הולך פלט
משתנה מסוג מספר שלם.

325
00:14:45,780 --> 00:14:47,360
זה מה שהחלק הזה הוא ממש כאן.

326
00:14:47,360 --> 00:14:51,950
ואז יש לי שתי כניסות אליו
ו- B, כל אחד מהם הוא מספר שלם.

327
00:14:51,950 --> 00:14:58,250
בתוך עיקרי, אני שואל את המשתמש ל
קלט באומרו, לתת לי מספר שלם.

328
00:14:58,250 --> 00:15:01,040
והם מתבקשים לשכוח
int, שהיא פונקציה ש

329
00:15:01,040 --> 00:15:03,240
כלול בספריית cs50.

330
00:15:03,240 --> 00:15:07,660
ושמקבל מאוחסן ב
x, משתנה שלם.

331
00:15:07,660 --> 00:15:09,886
>> אז תבקש מהם למספר שלם אחר.

332
00:15:09,886 --> 00:15:13,070
אנחנו מקבלים מספר שלם אחר
ולאחסן כי בy.

333
00:15:13,070 --> 00:15:17,990
ואז, כאן בקו 28, הוא
שבו אנחנו עושים הקריאה לפונקציה שלנו.

334
00:15:17,990 --> 00:15:23,770
אנחנו אומרים, שווים z int
להוסיף 2 x ints פסיק y.

335
00:15:23,770 --> 00:15:25,980
האם אתה רואה למה זה הגיוני?

336
00:15:25,980 --> 00:15:29,710
x הוא משתנה מסוג מספר שלם ו
y הוא משתנה מסוג מספר שלם.

337
00:15:29,710 --> 00:15:31,220
אז זה טוב.

338
00:15:31,220 --> 00:15:34,570
זה הגיוני עם מה הפונקציה שלנו
הכרזה על קו 17 נראית כמו.

339
00:15:34,570 --> 00:15:38,300
רשימת הקלט מופרד בפסיקים
מצפה שני מספרים שלמים, וב.

340
00:15:38,300 --> 00:15:40,300
במקרה זה, אנחנו יכולים לקרוא
שלהם מה שאנחנו רוצים.

341
00:15:40,300 --> 00:15:42,300
זה פשוט מצפה שני מספרים שלמים.

342
00:15:42,300 --> 00:15:44,930
וx הוא מספר שלם ו- y הוא מספר שלם.

343
00:15:44,930 --> 00:15:45,640
זה עובד.

344
00:15:45,640 --> 00:15:48,680
>> ואנחנו יודעים שהוא הולך פונקציה
לפלט מספרים שלמים גם כן.

345
00:15:48,680 --> 00:15:51,290
וכך אנו מאחסנים
פלט של הפונקציה,

346
00:15:51,290 --> 00:15:56,050
להוסיף שני ints, בסוג שלם
משתנה, שאנחנו קוראים z.

347
00:15:56,050 --> 00:16:01,980
ואז אנו יכולים לומר, בסכום של
אני אחוזים ואני אחוזים הוא אחוזים אני.

348
00:16:01,980 --> 00:16:06,210
בהתאמה x, y ו- z
מילוי באותם אחוזים אני של.

349
00:16:06,210 --> 00:16:08,334
מהי ההגדרה של
להוסיף שני ints נראה?

350
00:16:08,334 --> 00:16:09,125
זה די פשוט.

351
00:16:09,125 --> 00:16:11,270
זה אחד מאלה ש
פשוט ראיתי לפני שנייה,

352
00:16:11,270 --> 00:16:14,390
סכום int שווה סכום תמורה בתוספת ב.

353
00:16:14,390 --> 00:16:15,420
זה עובד?

354
00:16:15,420 --> 00:16:17,270
בואו לשמור את הקובץ.

355
00:16:17,270 --> 00:16:22,080
וכאן למטה אז על המסוף שלי
אני הולך לעשות האפעה 1,

356
00:16:22,080 --> 00:16:23,000
ואני לנקות את המסך שלי.

357
00:16:23,000 --> 00:16:25,791
אני הולך להתמקד בכי אני יודע
זה קצת קשה לראות.

358
00:16:25,791 --> 00:16:31,520

359
00:16:31,520 --> 00:16:33,770
>> אז אנחנו לקמפל תכנית זו כאפעה 1.

360
00:16:33,770 --> 00:16:37,910
אז אנחנו יכולים לעשות האפעה לוכסן נקודת 1.

361
00:16:37,910 --> 00:16:40,060
תן לי מספר שלם, 10.

362
00:16:40,060 --> 00:16:42,380
תן לי מספר שלם אחר, 20.

363
00:16:42,380 --> 00:16:45,200
הסכום של 10 ו- 20 הוא 30.

364
00:16:45,200 --> 00:16:47,615
אז עשינו קריאה לפונקציה מוצלחת.

365
00:16:47,615 --> 00:16:55,820
אתה יכול להפעיל את הפונקציה שוב, שלילי
10, 17 סכום של 10 שליליים ו -17 הוא 7.

366
00:16:55,820 --> 00:16:57,120
פונקציה זו פועלת.

367
00:16:57,120 --> 00:16:59,240
יש לו את ההתנהגות
כי אנו מצפים ל.

368
00:16:59,240 --> 00:17:03,610
וכך שעשינו מוצלח
פונקציה, הגדרה, הצהרה,

369
00:17:03,610 --> 00:17:07,288
וקריאה לפונקציה מוצלחת.

370
00:17:07,288 --> 00:17:09,079
שונה זוג
נקודות על פונקציות

371
00:17:09,079 --> 00:17:10,611
לפני שנסיים את החלק הזה.

372
00:17:10,611 --> 00:17:12,319
נזכיר משלנו
דיון של סוגי נתונים,

373
00:17:12,319 --> 00:17:16,109
בעבר, שפונקציות
לפעמים יכול לקחת שום תשומות.

374
00:17:16,109 --> 00:17:17,930
אם זה המקרה, אנחנו
להכריז על הפונקציה

375
00:17:17,930 --> 00:17:19,788
כבעל רשימת טיעון מבוטל.

376
00:17:19,788 --> 00:17:21,579
האם אתה זוכר מה
רוב הפונקציה הנפוצה

377
00:17:21,579 --> 00:17:25,036
שראינו עד כה שלוקח
רשימת טיעון חלל היא?

378
00:17:25,036 --> 00:17:27,300
זה עיקרי.

379
00:17:27,300 --> 00:17:30,850
נזכיר גם פונקציה שלפעמים
למעשה אין לי פלט.

380
00:17:30,850 --> 00:17:34,210
במקרה זה, אנו מצהירים פונקציה
כבעל סוג החזר מבוטל.

381
00:17:34,210 --> 00:17:37,880
בואו נסיים את החלק הזה ב
התמודדות עם בעיה בפועל.

382
00:17:37,880 --> 00:17:39,900
>> אז הנה הבעיה ערוכה.

383
00:17:39,900 --> 00:17:43,630
אני רוצה שתכתוב פונקציה
נקרא משולש תקף.

384
00:17:43,630 --> 00:17:47,410
מה פונקציה זו צריכה לעשות
הוא ייקח את שלושה מספרים אמיתיים

385
00:17:47,410 --> 00:17:51,930
המייצג את האורכים של שלוש
צדדים של משולש כפרמטרים שלה,

386
00:17:51,930 --> 00:17:54,550
או טענותיו, או שלה
inputs-- קבוצה נוספת של מילים נרדפות

387
00:17:54,550 --> 00:17:57,340
שאתה עשוי להיתקל.

388
00:17:57,340 --> 00:18:01,120
פונקציה צריך זה
או פלט אמת או שקר

389
00:18:01,120 --> 00:18:04,960
תלוי אם שלושת אורכים אלה
הם מסוגלים לעשות משולש.

390
00:18:04,960 --> 00:18:09,930
האם אתה זוכר את סוג הנתונים ש
אנחנו משמשים לציון אמת או שקר?

391
00:18:09,930 --> 00:18:11,436
עכשיו איך אתה מיישם את זה?

392
00:18:11,436 --> 00:18:13,810
ובכן יודע שיש כמה
של כללים לגבי משולשים

393
00:18:13,810 --> 00:18:15,480
כי הם למעשה שימושיים לדעת.

394
00:18:15,480 --> 00:18:18,292
משולש יכול להיות רק
צדדים עם אורך חיובי.

395
00:18:18,292 --> 00:18:19,000
זה הגיוני.

396
00:18:19,000 --> 00:18:21,432
אתה בטח אומר, דהה.

397
00:18:21,432 --> 00:18:23,390
דבר נוסף שכדאי לציין
אם כי, הוא שהסכום

398
00:18:23,390 --> 00:18:25,484
של האורכים של כל
שתי צלעות של המשולש

399
00:18:25,484 --> 00:18:27,650
צריך להיות גדול יותר מ
אורכו של הצד השלישי.

400
00:18:27,650 --> 00:18:28,690
זה נכון בעצם.

401
00:18:28,690 --> 00:18:34,150
אתה לא יכול להיות משולש של צדדים 1,
2 ו -4, לדוגמא, כי 1 בתוספת 2

402
00:18:34,150 --> 00:18:36,270
אינו גדול מ -4.

403
00:18:36,270 --> 00:18:38,870
אז אלה הם הכללים ש
לקבוע אם או לא שלוש

404
00:18:38,870 --> 00:18:42,740
תשומות יכולות להעלות על הדעת בצורה משולש.

405
00:18:42,740 --> 00:18:46,360
אז לקחת כמה דקות
ולהכריז ולאחר מכן להגדיר

406
00:18:46,360 --> 00:18:49,810
פונקציה זו נקראת בתוקף
משולש, כך שזה באמת

407
00:18:49,810 --> 00:18:51,650
יש ההתנהגות שצוינה כאן.

408
00:18:51,650 --> 00:18:57,030
>> זה יהיה פלט אמיתי אם שלושת צדדים אלה
מסוגלים הכולל משולש,

409
00:18:57,030 --> 00:19:01,950
ושקר אחר
מוכן לראות איך עשה?

410
00:19:01,950 --> 00:19:04,650
הנה יישום אחד
משולש של תוקף.

411
00:19:04,650 --> 00:19:05,770
זה לא רק אחד.

412
00:19:05,770 --> 00:19:07,770
שלך עשויים להשתנות מעט.

413
00:19:07,770 --> 00:19:11,040
אבל זה עושה, למעשה, יש לי
ההתנהגות שאנו מצפים.

414
00:19:11,040 --> 00:19:14,450
אנו מצהירים הפונקציה שלנו ב
מאוד עליון, בול משולש תקפה

415
00:19:14,450 --> 00:19:16,630
לצוף לצוף z y x לצוף.

416
00:19:16,630 --> 00:19:18,930
אז שוב, פונקציה זו
לוקח שלושה מספרים אמיתיים

417
00:19:18,930 --> 00:19:22,280
כטיעוניו, צף
משתני ערך נקודה,

418
00:19:22,280 --> 00:19:26,510
ופלטי אמת או שקר
ערך, שהוא בוליאנית, כזכור.

419
00:19:26,510 --> 00:19:28,660
אז בגלל זה סוג ההחזרה הוא בול.

420
00:19:28,660 --> 00:19:30,016
אז אנחנו מגדירים את הפונקציה.

421
00:19:30,016 --> 00:19:33,140
הדבר ראשון שאנחנו עושים הוא לבדוק כדי לוודא
שכל הצדדים חיוביים.

422
00:19:33,140 --> 00:19:37,010
אם x הוא פחות או שווה
0, או אם y שווה ל- 0,

423
00:19:37,010 --> 00:19:41,050
או אם z הוא פחות או שווה ל -0,
שלא יכול להיות משולש.

424
00:19:41,050 --> 00:19:42,380
אין להם צדדים חיוביים.

425
00:19:42,380 --> 00:19:45,790
וכדי שנוכל לחזור
שקר במצב זה.

426
00:19:45,790 --> 00:19:49,010
בשלב הבא, אנחנו בודקים לוודא
שכל זוג של תשומות

427
00:19:49,010 --> 00:19:51,830
גדול מהשליש.

428
00:19:51,830 --> 00:19:54,530
>> אז אם X ועוד Y הוא פחות
או שווה ל Z,

429
00:19:54,530 --> 00:19:57,060
או אם x בתוספת z הוא פחות
או שווה ל y,

430
00:19:57,060 --> 00:20:01,730
או אם y בתוספת z הוא פחות או שווה ל
x, שגם לא יכול להיות משולש תקף.

431
00:20:01,730 --> 00:20:03,800
אז אנחנו חוזרים שוב שקר.

432
00:20:03,800 --> 00:20:06,900
בהנחה שעברנו את שתי הבדיקות
אם כי, אז אנחנו יכולים לחזור אמיתיים.

433
00:20:06,900 --> 00:20:09,440
בגלל שלושת צדדים אלה
מסוגלים returning--

434
00:20:09,440 --> 00:20:11,647
של יצירת משולש תקפה.

435
00:20:11,647 --> 00:20:12,230
וזה הכל.

436
00:20:12,230 --> 00:20:13,830
עכשיו אתה כבר הכריז ומוגדר.

437
00:20:13,830 --> 00:20:17,330
וייתכן שתוכל לחברה
להשתמש ולקרוא לפונקציה זו.

438
00:20:17,330 --> 00:20:19,470
עבודה טובה.

439
00:20:19,470 --> 00:20:20,650
אני דאג לויד.

440
00:20:20,650 --> 00:20:22,820
זה cs50.

441
00:20:22,820 --> 00:20:24,340