1
00:00:07,010 --> 00:00:09,640
[Powered by Google Translate] פונקציות הן קטעי הקוד בשימוש בתוך תכנית גדולה יותר

2
00:00:09,640 --> 00:00:11,430
לביצוע משימה מסוימת.

3
00:00:11,430 --> 00:00:15,060
הם ידועים גם כנהלים, שגרות, וsubprograms,

4
00:00:15,060 --> 00:00:18,320
מאז שהם באמת רק תוכניות מינים בתוך תוכניות.

5
00:00:18,320 --> 00:00:20,340
למרות שאתה אולי לא שמת לב,

6
00:00:20,340 --> 00:00:24,090
אתה בהחלט השתמשת פונקציות כבר אם לתכנת ב C.

7
00:00:24,090 --> 00:00:26,770
כשאתה כותב את דברים על המסך באמצעות printf,

8
00:00:26,770 --> 00:00:29,380
אתה בעצם משתמש בפונקציה בשם printf.

9
00:00:29,380 --> 00:00:33,760
כמו כן, GetInt וGetString הם פונקציות שCS50 מספקת עבורך.

10
00:00:33,760 --> 00:00:37,750
כמתכנתים, אנחנו משתמשים בפונקציות של מספר סיבות.

11
00:00:37,750 --> 00:00:41,240
>> בעלי פונקציות לבצע משימות נפוצות כמו לכתוב על המסך

12
00:00:41,240 --> 00:00:44,480
ולשאול את המשתמש עבור קלט חוסך לנו זמן, כאשר תכנות.

13
00:00:44,480 --> 00:00:47,510
זה לא הכרחי לכתוב קוד כדי לעשות את אותם דברים

14
00:00:47,510 --> 00:00:49,520
מאז הם כבר עשו בשבילנו.

15
00:00:49,520 --> 00:00:54,580
זה אפילו לא נחוץ לנו להבין בדיוק איך הפונקציות האלה עובדות באופן פנימי.

16
00:00:54,580 --> 00:00:58,880
במקום זאת, אנחנו רק צריכים לדעת איך להשתמש בו או לקרוא להם בתוכניות שלנו.

17
00:00:58,880 --> 00:01:02,040
היא גם עוזרת לכתוב פונקציות בתוכניות גדולות יותר

18
00:01:02,040 --> 00:01:04,330
גם אם אתה לא מתכנן על שאחרים להשתמש בם,

19
00:01:04,330 --> 00:01:06,830
רק כדי לחלק את המשימה הגדולה יותר בהישג יד.

20
00:01:06,830 --> 00:01:11,910
בדרך זו, אתה נותן למבנה לקוד שלך הרבה כמוך הייתי נותן למבנה מאמר,

21
00:01:11,910 --> 00:01:15,180
ועם פרויקטים גדולים באמת לאפשר לאנשים מרובים

22
00:01:15,180 --> 00:01:16,730
לעבוד על חלקים שונים באותו הזמן

23
00:01:16,730 --> 00:01:20,480
מכיוון שזה ברור שבו עבודתו של האדם אחד מסתיימת והשני מתחיל.

24
00:01:20,480 --> 00:01:26,530
>> פונקציות בדרך כלל פועלות על 1 או יותר תשומות, הידועים כטיעונים או פרמטרים,

25
00:01:26,530 --> 00:01:30,520
הפיכת תשומות לאלה ערך תפוקה אז שהוא חזר.

26
00:01:30,520 --> 00:01:34,950
עם זאת, ייתכן גם שיש פונקציות שאינם משתמשים בכל טיעון קלט

27
00:01:34,950 --> 00:01:36,400
ואל תחזרו פלט.

28
00:01:36,400 --> 00:01:38,790
טוב, מספיק עם החומר הרך.

29
00:01:38,790 --> 00:01:41,790
בואו נסתכל על כמה פונקציות אמיתיות בג

30
00:01:41,790 --> 00:01:45,570
>> כאן יש לנו פונקציה שנקראת כיכר ש, תאמינו או לא,

31
00:01:45,570 --> 00:01:47,570
מחשב את הריבוע של הקלט.

32
00:01:47,570 --> 00:01:49,490
בואו לנתח את התחביר שלו.

33
00:01:49,490 --> 00:01:51,860
המילה הראשונה שאתה רואה בפונקציה, int,

34
00:01:51,860 --> 00:01:57,460
מציין את סוג ההחזרה של הפונקציה, כלומר, סוג C של הפלט של הפונקציה.

35
00:01:57,460 --> 00:02:00,370
פונקציה זו תהיה פלט ערך עם הסוג int.

36
00:02:00,370 --> 00:02:04,100
המילה הבאה שאתה רואה זה את השם של הפונקציה, הכיכר במקרה זה.

37
00:02:04,100 --> 00:02:07,390
שמות פונקציות מתאימות חשוב במיוחד

38
00:02:07,390 --> 00:02:11,260
מאז זה כנראה התיעוד הגלוי ביותר של מה הפונקציה עושה.

39
00:02:11,260 --> 00:02:14,880
זה יכול להיות מגניב לשם התפקיד Shazam זה או booyah,

40
00:02:14,880 --> 00:02:18,340
אבל זה לא אומר לנו שום דבר על מה שהפונקציה עושה.

41
00:02:18,340 --> 00:02:23,470
>> בעקבות שם הפונקציה לבוא התשומות לפונקציה, את הטיעונים.

42
00:02:23,470 --> 00:02:26,380
הם מופיעים בתוך קבוצה של סוגריים

43
00:02:26,380 --> 00:02:30,160
עם שניהם סוג ושם לשימוש עבורם בתוך הגוף של הפונקציה.

44
00:02:30,160 --> 00:02:34,030
הכיכר לוקחת רק טיעון 1, int לכיכר,

45
00:02:34,030 --> 00:02:36,160
שהחלטתי לתת את השם x.

46
00:02:36,160 --> 00:02:40,760
זה מסיים את הכרזת פונקציה או אב טיפוס.

47
00:02:40,760 --> 00:02:43,320
הסוגריים המסולסלים מסביב שאר הפעולה

48
00:02:43,320 --> 00:02:45,870
תסמן את תחילתו וסופו של הגוף לתפקד,

49
00:02:45,870 --> 00:02:48,320
ההגדרה של הפונקציה עצם.

50
00:02:48,320 --> 00:02:50,300
כיכר היא פונקציה פשוטה למדי.

51
00:02:50,300 --> 00:02:54,100
יש בזה רק קו 1, שכן כל שעלינו לעשות הוא להכפיל את x על ידי עצמו.

52
00:02:54,100 --> 00:02:59,250
מילת התמורה מציינת את ערך התפוקה ומעוררת את סוף הפונקציה.

53
00:02:59,250 --> 00:03:03,430
כדי להשתמש בפונקציית הכיכר, אנחנו צריכים לספק את התשומות המתאימות

54
00:03:03,430 --> 00:03:05,310
ולאחר מכן ללכוד את הפלט.

55
00:03:05,310 --> 00:03:08,140
הנה, אתה רואה כמה דרכים לעשות את זה.

56
00:03:08,140 --> 00:03:13,600
אנחנו יכולים לעבור בint גלם, כמו 6, או שאנחנו יכולים לעבור במשתנה כמו.

57
00:03:13,600 --> 00:03:15,700
שימו לב שכל פעם שאנו מכנים כיכר,

58
00:03:15,700 --> 00:03:18,330
אנו ללכוד את הפלט במשתנה ולאחר מכן להדפיס אותו.

59
00:03:18,330 --> 00:03:22,690
עם זאת, אין לנו לאחסן את ערך ההחזרה במשתנה ואז להדפיס.

60
00:03:22,690 --> 00:03:27,090
אנחנו רק יכולים לשלוח אותו ישירות לprintf כפי שאנחנו עושים כאשר אנחנו מרובעים 10,

61
00:03:27,090 --> 00:03:30,580
אך אין זה אומר שאין לנו גישה לערך ההחזרה של כיכר 10

62
00:03:30,580 --> 00:03:32,230
במקום אחר בקוד.

63
00:03:32,230 --> 00:03:34,890
בואו נסתכל על דוגמה פשוטה אחרת.

64
00:03:34,890 --> 00:03:38,750
>> הפעם, אנו נסכם 2 צפנו יחד, כך שנוכל לראות מה פונקציה נראית כמו

65
00:03:38,750 --> 00:03:41,220
כאשר הוא קבל 2 כניסות רק במקום 1.

66
00:03:41,220 --> 00:03:43,950
כפי שאתה יכול לראות, זה לא שונה בהרבה.

67
00:03:43,950 --> 00:03:47,330
כל מה שאנחנו עושים הוא להוסיף בטענת 2, לצוף בשם B,

68
00:03:47,330 --> 00:03:51,820
לרשימת הארגומנטים באמצעות פסיק כדי להפריד אותו מהטענה הראשונה, לצוף.

69
00:03:51,820 --> 00:03:55,550
אז, הריבוע שלנו ופונקציות סכום הם די קלים להבין

70
00:03:55,550 --> 00:03:58,930
בגלל שהם שווים ערך לפונקציות שראיתם כבר פעם בשיעורי מתמטיקה.

71
00:03:58,930 --> 00:04:01,610
עכשיו, בואו נסתכל על פונקציה שהיא מעט שונה.

72
00:04:01,610 --> 00:04:04,620
במקום להחזיר ערך, הוא משנה מצב.

73
00:04:04,620 --> 00:04:07,260
תופעה זו ידועה כבעלת תופעת לוואי.

74
00:04:07,260 --> 00:04:10,750
בתכנית זו, פונקצית printf_fudd_style

75
00:04:10,750 --> 00:04:13,410
יש סוג החזר שלא ראו לפני כן, בטל ומבוטל.

76
00:04:13,410 --> 00:04:16,730
>> חלל הוא נהג לומר שפונקציה לא מחזירה שום דבר.

77
00:04:16,730 --> 00:04:19,410
אין משתנים של חלל סוג,

78
00:04:19,410 --> 00:04:22,760
כך שאם אתה מנסה להחזיר משהו מפונקציה כמו printf_fudd_style,

79
00:04:22,760 --> 00:04:24,290
המהדר לצעוק עליך.

80
00:04:24,290 --> 00:04:29,390
בתוך printf_fudd_style, אנו רואים כי בעוד שהפונקציה עדיין מבצעת משימה,

81
00:04:29,390 --> 00:04:31,890
כלומר, מיתוג כל הרופים לב"ב,

82
00:04:31,890 --> 00:04:36,380
הנקודה של הפונקציה היא לשנות את המחרוזת ולאחר מכן להדפיס אותו על המסך,

83
00:04:36,380 --> 00:04:39,400
שינוי מצב התכנית במקום לחזור תוצאה.

84
00:04:39,400 --> 00:04:43,700
שימוש בפונקציה זו דומה מאוד לשימוש בריבוע שלנו ופונקציות סכום,

85
00:04:43,700 --> 00:04:46,950
אלא שאנו לא שומרים את התוצאה במשתנה או להעביר אותו לפונקציה אחרת

86
00:04:46,950 --> 00:04:49,520
מכיוון שאין לדבר על תוצאה.

87
00:04:49,520 --> 00:04:53,180
לכן, כאשר אנו לקמפל ולהריץ תכנית פאד אלמר,

88
00:04:53,180 --> 00:04:56,970
אתה רואה את זה "אתה ממזר ארנב!" מקבל הפך זכות

89
00:04:56,970 --> 00:04:58,730
"אתה wascally wabbit!"

90
00:04:58,730 --> 00:05:02,250
>> לבסוף, יש פונקציה 1 יותר ראוי לדיון

91
00:05:02,250 --> 00:05:06,810
מאחר שאתה כבר משתמש בה בכל תכנית C שאי פעם נכתב, עיקרי.

92
00:05:06,810 --> 00:05:09,450
העיקרי הוא פונקציה הרבה כמו כל האחרים.

93
00:05:09,450 --> 00:05:13,580
יש בזה סוג תמורה, שם, רשימה של טענות, וגוף.

94
00:05:13,580 --> 00:05:16,110
סוג ההחזרה של עיקרי הוא תמיד int,

95
00:05:16,110 --> 00:05:19,120
וint זה משמש לתקשורת את מעמדה של התכנית כאשר היא מסתיימת.

96
00:05:19,120 --> 00:05:23,360
>> האם זה יפעל בהצלחה, או שהוא יסתיים מוקדם בגלל טעות?

97
00:05:23,360 --> 00:05:26,390
חוזר לאפס מלמד לרוץ מוצלח,

98
00:05:26,390 --> 00:05:29,510
ומחזיר כל ערך שאינו אפס מציין שגיאה.

99
00:05:29,510 --> 00:05:31,950
בהתאם לסוג של תכנית שאתה כותב,

100
00:05:31,950 --> 00:05:34,960
חוזר קודים שונים לשגיאות שונות יכול להיות מועיל

101
00:05:34,960 --> 00:05:37,210
לאנשים שמשתמשים בתכנית שלך בהמשך.

102
00:05:37,210 --> 00:05:40,220
טיעוני חשמל הם קצת יותר מסובכים.

103
00:05:40,220 --> 00:05:42,150
>> רשימת הארגומנטים יכולה להיות ריקה,

104
00:05:42,150 --> 00:05:45,330
בו אנו מציינים על ידי הכתיבה בחלל ריק בין הסוגריים,

105
00:05:45,330 --> 00:05:50,220
או הרשימה יכולה להיות 2 טענות: int ומערך של char * s.

106
00:05:50,220 --> 00:05:52,820
אלה משמשים כאשר התכנית שלך מתכוונת להשתמש

107
00:05:52,820 --> 00:05:56,490
טיעונים עברו בשורת הפקודה כאשר התכנית מופעלת.

108
00:05:56,490 --> 00:05:59,690
טיעון int נקרא בדרך כלל argc,

109
00:05:59,690 --> 00:06:03,300
וזה שווה את אורכו של מערך char *, הידוע כargv.

110
00:06:03,300 --> 00:06:07,080
Argv מכיל את הארגומנטים בשורת פקודה שמועברים לפונקציה.

111
00:06:07,080 --> 00:06:11,440
במקרה אחר קצר, נדבר על אופן שימוש במשתנים הללו ביתר פירוט.

112
00:06:11,440 --> 00:06:15,220
לעת עתה, אתה יכול להרגיש חופשי להכריז עיקרי כאן או לכאן.

113
00:06:15,220 --> 00:06:19,410
אני בדרך כלל בוחר לכתוב את זה בדרך הקצרה, ללא ויכוחים, כאשר דבר אפשרי.

114
00:06:19,410 --> 00:06:22,230
>> עכשיו שאתה יודע איך לכתוב פונקציות,

115
00:06:22,230 --> 00:06:25,030
אתה גם על הדרך שלך לפיתוח תוכניות גדולות ומורכבות יותר.

116
00:06:25,030 --> 00:06:29,740
השם שלי הוא נייט Hardison. זה CS50.