2
00:00:00,000 --> 00:00:02,760
>> 1 SPEAKER: בואו לכתוב תכנית ש
מנחה את המשתמש לשמות ו

3
00:00:02,760 --> 00:00:04,700
בתיהם של שלושה תלמידים.

4
00:00:04,700 --> 00:00:08,840
עכשיו, כדי לאחסן אותם שמות ובתים
אנחנו יכולים להשתמש, מה, שישה משתנים.

5
00:00:08,840 --> 00:00:12,260
שלוש מחרוזות לשמות, ועוד
שלוש מחרוזות לבתים,

6
00:00:12,260 --> 00:00:16,560
אבל אנחנו כבר יודעים שאנחנו יכולים לנקות
קוד שעל ידי שימוש במערכים במקום,

7
00:00:16,560 --> 00:00:20,220
למשל מערך בגודל 3 עבור
שלושה שמות, ועוד מערך של

8
00:00:20,220 --> 00:00:22,110
גודל 3 לבתים.

9
00:00:22,110 --> 00:00:25,870
אבל מתברר שאנחנו יכולים לנקות את זה
עוד יותר, ולמעשה לשמור אותם

10
00:00:25,870 --> 00:00:30,520
שמות ובתים יחד, כך ש
שמו של התלמיד והבית שלו או שלה

11
00:00:30,520 --> 00:00:34,940
איכשהו במארז, ולכן כדי
לדבר, לתוך אותו משתנה.

12
00:00:34,940 --> 00:00:39,095
>> כדי לעשות זאת, אם כי, אנחנו צריכים להכריז
הסוג שלנו נתונים, הסוג שלנו ב-C,

13
00:00:39,095 --> 00:00:42,660
כי מחברי C לא עשו בהכרח
חושב על שנים.

14
00:00:42,660 --> 00:00:45,630
לשם כך אנחנו יכולים להשתמש במילת המפתח
typedef, יחד עם

15
00:00:45,630 --> 00:00:47,200
struct מילת מפתח אחר.

16
00:00:47,200 --> 00:00:48,160
בואו נסתכל.

17
00:00:48,160 --> 00:00:50,650
בתוך structs.h, יש לי כבר
קיבל נכתבו על ידי

18
00:00:50,650 --> 00:00:52,560
כולל ספריית CS50.

19
00:00:52,560 --> 00:00:57,640
אני הבא אני הולך להקליד struct typedef,
ולאחר מכן סד מתולתל.

20
00:00:57,640 --> 00:01:01,370
בתוך struct, אני הולך
תציין כי תלמיד יהיה

21
00:01:01,370 --> 00:01:04,960
מחרוזת קראה בשמה, ועוד
מחרוזת שנקראת בית.

22
00:01:04,960 --> 00:01:08,430
אני הולך לסגור אז הסוגריים המסולסלים שלי,
ולציין כי שמו של

23
00:01:08,430 --> 00:01:11,420
סוג הנתונים החדש יהיה סטודנטים.

24
00:01:11,420 --> 00:01:15,550
במילים אחרות, באמצעות תחביר זה יש לי
הכריז על סוג הנתונים חדש משלי

25
00:01:15,550 --> 00:01:19,910
שלא היה קיים לפני רגע, ו
בתוך סוג נתונים זה הם שני נתונים

26
00:01:19,910 --> 00:01:24,270
שדות או חברי נתונים, אחד בשם שם,
הבית התקשר לאחד, אשר שניהם

27
00:01:24,270 --> 00:01:25,630
הם מסוג מחרוזת.

28
00:01:25,630 --> 00:01:27,690
>> עכשיו בואו להשתמש בסוג זה
בתכנית בפועל.

29
00:01:27,690 --> 00:01:30,210

30
00:01:30,210 --> 00:01:34,090
בstructs0.c, קיבלתי באופן דומה
בעצמי כבר התחלתי עם כמה

31
00:01:34,090 --> 00:01:36,999
קוד מוכן מראש, ואני עכשיו
הולך להשתמש בנתונים אלה

32
00:01:36,999 --> 00:01:39,100
הקלד תלמיד, כמפורט להלן.

33
00:01:39,100 --> 00:01:42,450
אני הולך ראשון להכריז
מערך של סטודנטים סוג, אני

34
00:01:42,450 --> 00:01:43,920
קוראים לתלמידי מערך -

35
00:01:43,920 --> 00:01:44,630
בלשון רבים -

36
00:01:44,630 --> 00:01:49,360
ואני תציין שגודלה יהיה
שלוש, ש, הודעה מוקדמת, הוא הערך של

37
00:01:49,360 --> 00:01:50,880
התלמידים קבועים -

38
00:01:50,880 --> 00:01:51,890
בכל הבירות -

39
00:01:51,890 --> 00:01:54,930
כי אני כבר הכריז כאן,
מוקדם יותר באותו הקובץ.

40
00:01:54,930 --> 00:01:58,280
בואו עכשיו לחזר על שלושה אלה
תלמידים, ולבקש מהמשתמש

41
00:01:58,280 --> 00:02:00,050
שמותיהם ואת הבתים.

42
00:02:00,050 --> 00:02:05,422
>> עבור int אני מקבל 0, הוא שאני פחות
מזה קבוע, אני + +.

43
00:02:05,422 --> 00:02:08,600
ועכשיו בתוך הגוף של זה עבור
לולאה, אני הולך להדפיס משהו

44
00:02:08,600 --> 00:02:11,470
כמו שמו של התלמיד.

45
00:02:11,470 --> 00:02:14,890
אז אני הולך לקבל למעשה כי
שמו של הסטודנט על ידי ציון

46
00:02:14,890 --> 00:02:17,290
תלמידים סוגרים לי.

47
00:02:17,290 --> 00:02:21,550
במילים אחרות אני רוצה סטודנט i-ה
במערך הנקרא תלמידים, אבל עכשיו

48
00:02:21,550 --> 00:02:25,340
אני רוצה לקבל בשל תלמיד i-ה ש
שם, ולעשות את זה, אני הולך להשתמש

49
00:02:25,340 --> 00:02:30,160
. מפעיל, על מנת לקבל ב
בתוך תחום ספציפי של struct.

50
00:02:30,160 --> 00:02:37,100
אז אני מציין תלמידים סוגרים לי. שם
מקבל את ערך ההחזרה של GetString ().

51
00:02:37,100 --> 00:02:40,310
בינתיים, אני הולך להדפיס את
משהו דומה, באומרו של התלמיד

52
00:02:40,310 --> 00:02:45,410
בית, ועכשיו אני הולך לציין
כי שדה בית התלמידים i-ה

53
00:02:45,410 --> 00:02:49,480
יהיה לקבל את ערך ההחזרה של
שיחה נוספת לGetString ().

54
00:02:49,480 --> 00:02:52,350
>> עכשיו בואו נעשה משהו עם שלושה אלה
שמות של התלמידים ובתים,

55
00:02:52,350 --> 00:02:56,230
משהו פשוט כמו הדפסה
כל אחד בגזר דין.

56
00:02:56,230 --> 00:03:07,580
עבור int אני מקבל 0, שוב אני הוא פחות מ
תלמידים, אני + +,% s printf "הוא ב% s.

57
00:03:07,580 --> 00:03:12,600
n הלוכסן ההפוך ", ועכשיו תן לי חבר
הערכים של שני תחומים אלה,

58
00:03:12,600 --> 00:03:19,055
תלמידים סוגרים לי. שם, פסיק,
תלמידים סוגרים לי. בית, קרוב

59
00:03:19,055 --> 00:03:21,290
פארן, פסיק.

60
00:03:21,290 --> 00:03:23,020
>> ועכשיו אני צריך לעשות עוד דבר אחד.

61
00:03:23,020 --> 00:03:26,600
בחלק התחתון של קובץ זה, אני צריך
לשחרר את הזיכרון שהוקצה

62
00:03:26,600 --> 00:03:30,290
מאחורי הקלעים על ידי GetSring (), אשר
כמובן קורא malloc, על מנת

63
00:03:30,290 --> 00:03:32,500
להקצות זיכרון למחרוזות
סוגי המשתמשים.

64
00:03:32,500 --> 00:03:35,720
אבל לכך הוא פשוט.

65
00:03:35,720 --> 00:03:42,610
עבור int אני מקבל 0, הוא שאני פחות מ
תלמידים, אני + +, ובתוך הגוף של

66
00:03:42,610 --> 00:03:48,670
זה ללולאה, אני פשוט הולך
לספק לתלמידי סוגר חופשי i. שם,

67
00:03:48,670 --> 00:03:52,300
ולשחרר את תלמידים סוגרים לי. בית.

68
00:03:52,300 --> 00:03:55,620
>> עכשיו, אנחנו כבר השתמשנו בשלוש לולאות בצורה ברורה
בתכנית זו, כשבעצם

69
00:03:55,620 --> 00:03:58,800
יכול פשוט השתמשתי אחד, אבל זה
רק למען ההדגמה, כך ש

70
00:03:58,800 --> 00:04:02,850
אנו יכולים לציין בשלוש ברורים
צעדים מה בדיוק אנחנו עושים.

71
00:04:02,850 --> 00:04:06,120
אנחנו מקבלים שם ובית ראשון
לכל אחד מהתלמידים, אנחנו אז

72
00:04:06,120 --> 00:04:08,900
הדפסה את השם ואת הבית ל
כל אחד משלושה התלמידים, ו

73
00:04:08,900 --> 00:04:11,910
אז אנחנו הולכים לשחרר את הזיכרון
בשימוש על ידי כל אחד מהתלמידים.

74
00:04:11,910 --> 00:04:15,310
אבל אין ספק שאנחנו יכולים כבר לשלב את זה
לאחד גדול יותר ללולאה.

75
00:04:15,310 --> 00:04:18,650
>> בואו עכשיו להציל, לקמפל,
ולהפעיל את התכנית.

76
00:04:18,650 --> 00:04:26,850
structs לעשות 0. / structs 0, סטודנט
שם, בואו נספק דוד, הוא יחיה

77
00:04:26,850 --> 00:04:31,580
בבית מאת'ר, שמו של התלמיד, בוא
אומר לורן, היא מתגוררת בוורט

78
00:04:31,580 --> 00:04:36,590
בית, את שמו של התלמיד, רוב, הוא יהיה
לחיות בבית קירקלנד.

79
00:04:36,590 --> 00:04:39,440
ואכן, דוד הוא במאת'ר,
לורן הוא בוורט,

80
00:04:39,440 --> 00:04:40,810
ורוב הוא בקירקלנד.

81
00:04:40,810 --> 00:04:43,425