2
00:00:00,000 --> 00:00:02,760
>> காண்க: 1 ஒரு நிரல் எழுத அனுமதி என்று
பெயர்கள் பயனர் மற்றும் துவங்குகிறது

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
>> இதை செய்ய, எனினும், நாம் அறிவிக்க வேண்டும்
நமது சொந்த தரவு வகை, சி எங்கள் சொந்த வகை,

13
00:00:39,095 --> 00:00:42,660
சி ஆசிரியர்கள் அவசியம் இல்லை என்று
ஆண்டுகளுக்கு முன்பு நான் நினைக்கிறேன்.

14
00:00:42,660 --> 00:00:45,630
இதை செய்ய நாம் முக்கிய பயன்படுத்த முடியும்
typedef, இணைந்து

15
00:00:45,630 --> 00:00:47,200
மற்ற முக்கிய காலியானதே.

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
நான் அடுத்த, typedef struct தட்டச்சு செய்ய போகிறேன்
பின்னர் ஒரு சுருள் பிரேஸ்.

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
>> நான் 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
முழு எண்ணாக நான் 0, மீண்டும் நான் விட குறைவாக உள்ளது
மாணவர்கள், நான் + அச்சிட "% s% 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
நான் 0 பெற முழு எண்ணாக, நான் விட குறைவாக உள்ளது
மாணவர்கள், நான் + +, மற்றும் உடல் உள்ளே

66
00:03:42,610 --> 00:03:48,670
இந்த சுழற்சி, நான் வெறுமனே போகிறேன்
இலவச மாணவர்கள் அடைப்புக்குறி நான். பெயர் வழங்க,

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
மாதர் மாளிகையில், மாணவர் பெயர், நாம்
லாரன் சொல்ல, அவர் Leverett வாழ வேண்டும்

78
00:04:31,580 --> 00:04:36,590
ஹவுஸ், மாணவர் பெயர், ராப், அவர் நீடூழி
கிர்க்லாண்ட் மாளிகையில் வாழ.

79
00:04:36,590 --> 00:04:39,440
உண்மையில், டேவிட், மாதர் உள்ளது
லாரன், Leverett உள்ளது

80
00:04:39,440 --> 00:04:40,810
மற்றும் ராப் கிர்க்லாண்ட் உள்ளது.

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