1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [வாரம் 4]

2
00:00:03,000 --> 00:00:05,000
[டேவிட் ஜே Malan] [ஹார்வர்ட் பல்கலைக்கழகம்]

3
00:00:05,000 --> 00:00:08,000
[இந்த CS50 உள்ளது.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> சரி, இந்த CS50 தான், இந்த வாரம் 4 தொடக்கத்தில் இல்லை

5
00:00:12,000 --> 00:00:16,000
இந்த மெதுவான முடியும் வரிசையாக்க படிமுறைகள் ஒன்றாகும்.

6
00:00:16,000 --> 00:00:19,000
இது ஒரு நாங்கள் அங்கே பார்த்த அந்த அது?

7
00:00:19,000 --> 00:00:24,000
என்று, (n ^ 2) + கூட்டுத்தொகையாக பெரிய ஓ பொருட்டு, குமிழி வரிசையாக்கம் இருந்தது

8
00:00:24,000 --> 00:00:28,000
உண்மையில் நாம் என்று தெரிகிறது இந்த உலகில் மட்டுமே அல்ல

9
00:00:28,000 --> 00:00:30,000
என்ன குமிழி வரிசையாக்கம் அல்லது அதன் இயங்கும் நேரம்.

10
00:00:30,000 --> 00:00:33,000
உண்மையில், இந்த கூகிள் எரிக் ஸ்மித் பேட்டியில் அவர்

11
00:00:33,000 --> 00:00:45,000
முன்னாள் செனட்டர் பராக் ஒபாமா ஒரு சில ஆண்டுகளுக்கு முன்பு.

12
00:00:45,000 --> 00:00:48,000
>> இப்போது, செனட்டர், நீங்கள், Google இல் இருக்கிறோம்

13
00:00:48,000 --> 00:00:54,000
நான் ஒரு வேலை பேட்டியில் என ஜனாதிபதி என்று விரும்புகிறேன்.

14
00:00:54,000 --> 00:00:58,000
இப்போது, அது ஜனாதிபதியாக வேலை பெற கடினமாக உள்ளது, நீங்கள் இப்போது rigors மூலம் செல்கிறோம்.

15
00:00:58,000 --> 00:01:00,000
இது கூகிள் ஒரு வேலைக்கு கூட கடினம்.

16
00:01:00,000 --> 00:01:05,000
, நாம் கேள்விகள், மற்றும் நமது வேட்பாளர்கள் கேள்விகளை கேட்க

17
00:01:05,000 --> 00:01:10,000
இந்த ஒரு லாரி சுவிம்மர் இருந்து வருகிறது.

18
00:01:10,000 --> 00:01:14,000
உங்களுக்கு நான் விளையாடினேன் நான் நினைக்கிறேன்? அது இங்கு தான்.

19
00:01:14,000 --> 00:01:18,000
ஒரு மில்லியன் 32 பிட் முழு வரிசைப்படுத்த மிக சிறந்த வழி என்ன?

20
00:01:18,000 --> 00:01:21,000
[சிரிப்பு]

21
00:01:21,000 --> 00:01:24,000
நன்கு

22
00:01:24,000 --> 00:01:26,000
நான் வருந்துகிறேன். >> இல்லை, இல்லை, இல்லை, இல்லை.

23
00:01:26,000 --> 00:01:34,000
நான் குமிழி வரிசையாக்கம் செல்ல தவறான வழி என்று நான் நினைக்கிறேன்.

24
00:01:34,000 --> 00:01:39,000
>> அவரை இந்த யார் சொன்னது, வாருங்கள்!

25
00:01:39,000 --> 00:01:43,000
கடந்த வாரம், நாம் குறைந்த பட்சம் ஒரு நாள், குறியீடு இருந்து முறித்து கொண்டு நினைவுகூர

26
00:01:43,000 --> 00:01:46,000
மேலும் பொதுவாக தீர்க்கும் சில உயர் மட்ட கருத்துக்கள் மற்றும் சிக்கலை மையமாக தொடங்கியது

27
00:01:46,000 --> 00:01:49,000
தேடி மற்றும் வரிசையாக்க சூழலில்,

28
00:01:49,000 --> 00:01:53,000
நாம், நாம் கடந்த வாரம் இந்த பெயர் அடிப்பேன் என்று ஒன்று அறிமுகப்படுத்தப்பட்டது

29
00:01:53,000 --> 00:01:56,000
ஆனால் எந்த அறிகுறியும் குறியீடு, பிக் ஓ, பெரிய ஒமேகா,

30
00:01:56,000 --> 00:02:00,000
மற்றும் சில நேரங்களில் பெரிய தீட்டா குறியீடு, மற்றும் இந்த வெறுமனே வழிகள் இருந்தன

31
00:02:00,000 --> 00:02:02,000
படிமுறைகளின் இயங்கும் நேரம் விவரிக்கும்,

32
00:02:02,000 --> 00:02:05,000
அதை இயக்க ஒரு வழிமுறையை எடுத்து எவ்வளவு நேரம்.

33
00:02:05,000 --> 00:02:08,000
>> நீங்கள் அளவு அடிப்படையில் நீங்கள் இயங்கும் நேரம் பேசினார் என்பதை நினைவு இருக்கலாம்

34
00:02:08,000 --> 00:02:11,000
நாம் பொதுவாக பிரச்சனை இருக்கலாம் என்ன, n என்று எந்த உள்ளீடு, ஒரு,

35
00:02:11,000 --> 00:02:13,000
அங்கு n, அறையில் மக்கள் எண்ணிக்கை

36
00:02:13,000 --> 00:02:17,000
ஒரு தொலைபேசி புத்தகத்தில் பக்க எண், மற்றும் நாம் விஷயங்கள் எழுத தொடங்கியது

37
00:02:17,000 --> 00:02:21,000
ஓ போன்ற (n ^ 2) அல்லது O (n) அல்லது ஓ (n log n),

38
00:02:21,000 --> 00:02:24,000
மற்றும் கணித மிக மிக செய்தபின் வேலை செய்யவில்லை கூட

39
00:02:24,000 --> 00:02:28,000
அதை n என்று ² - n / 2 அல்லது அப்படி ஏதாவது

40
00:02:28,000 --> 00:02:31,000
நாம் பதிலாக, கீழ் வரிசை சொற்கள் சில எறியுங்கள் என்று

41
00:02:31,000 --> 00:02:34,000
மற்றும் ஊக்க நாம் உண்மையில் ஒரு வேண்டும் என்று உள்ளது

42
00:02:34,000 --> 00:02:37,000
மதிப்பிடும் நோக்கம் வழி வகை

43
00:02:37,000 --> 00:02:39,000
திட்டங்கள் செயல்பாடு அல்லது வழிமுறைகள் செயல்திறனை

44
00:02:39,000 --> 00:02:42,000
அந்த நாள் இறுதியில், உதாரணமாக, இல்லை

45
00:02:42,000 --> 00:02:45,000
உங்கள் கணினியின் வேகத்தை இன்று.

46
00:02:45,000 --> 00:02:47,000
>> உதாரணமாக, நீங்கள் குமிழி வரிசையாக்கம் செயல்படுத்த வேண்டும்,

47
00:02:47,000 --> 00:02:50,000
அல்லது நீங்கள், இன்று கணினியில் வகையான அல்லது தேர்வு வகையான ஒன்றாக்க செயல்படுத்த

48
00:02:50,000 --> 00:02:53,000
ஒரு 2 GHz கணினி, மற்றும் நீங்கள், அதை இயக்க

49
00:02:53,000 --> 00:02:56,000
இது ஒரு 3 GHz அங்கு அடுத்த ஆண்டு, நொடிகள் சில எண்ணை எடுக்கும்

50
00:02:56,000 --> 00:02:59,000
அல்லது 4 GHz கணினி, மற்றும் நீங்கள் அந்த "ஓ, என் வழிமுறையை கோர வேண்டும்

51
00:02:59,000 --> 00:03:03,000
உண்மையில் அந்த விஷயத்தில் தெளிவாக இல்லை போது ", இருமுறை வேகமாக உள்ளது.

52
00:03:03,000 --> 00:03:06,000
அது வன்பொருள் வேகமாக சென்றிருக்கிறது, ஆனால் உங்கள் கணினியில்

53
00:03:06,000 --> 00:03:10,000
, மற்றும் நாம் உண்மையில் போன்ற விஷயங்களை எறியுங்கள் விரும்பவில்லை

54
00:03:10,000 --> 00:03:13,000
2 மடங்குகள் அல்லது 3 மடங்குகள் அதை விளக்கும் போது

55
00:03:13,000 --> 00:03:17,000
எவ்வளவு வேகமாக அல்லது எப்படி மெதுவாக ஒரு வழிமுறையாகும் மற்றும் உண்மையில் நான் கவனம்

56
00:03:17,000 --> 00:03:20,000
n அல்லது அதன் சில காரணி, அன்று

57
00:03:20,000 --> 00:03:24,000
சில அதிகார அதின் கடந்த வாரம் இருந்து வகையான விஷயத்தில் போல்.

58
00:03:24,000 --> 00:03:27,000
மற்றும் ஒன்றிணைப்பு வகையான உதவியுடன் அந்த நினைவு

59
00:03:27,000 --> 00:03:31,000
நாம் குமிழி வரிசையாக்கம் மற்றும் தேர்வு வகையான விட மிகவும் சிறப்பாக செய்ய முடிந்தது

60
00:03:31,000 --> 00:03:33,000
மேலும் செருகும் வரிசையாக்கம்.

61
00:03:33,000 --> 00:03:36,000
>> நாங்கள், மீண்டும் n log n கீழே வைத்து, மற்றும்

62
00:03:36,000 --> 00:03:39,000
பதிவு n பொதுவாக வளரும் என்று ஒன்று குறிக்கிறது என்று நினைவு

63
00:03:39,000 --> 00:03:43,000
மெதுவாக பின்னர் n, அதனால் n log n இதுவரை நன்றாக இருந்தது

64
00:03:43,000 --> 00:03:45,000
அதை n ² விட குறைவாக தான்.

65
00:03:45,000 --> 00:03:47,000
ஆனால் ஒன்றிணைப்பு வகையான உடன் n அடைய n பதிவு

66
00:03:47,000 --> 00:03:51,000
நாம் அந்நிய என்று ஒரு யோசனை அடிப்படை கிருமி என்ன

67
00:03:51,000 --> 00:03:54,000
நாங்கள் வாரம் 0 மீண்டும் பயன்படுத்தியது என்று?

68
00:03:54,000 --> 00:03:58,000
எப்படி நாம் ஒன்றிணைப்பு வகையான கொண்டு புத்திசாலித்தனமாக வரிசையாக்க பிரச்சினை சமாளிக்க?

69
00:03:58,000 --> 00:04:04,000
ஒருவேளை, முக்கிய பார்வையை என்ன?

70
00:04:04,000 --> 00:04:07,000
யாரும்.

71
00:04:07,000 --> 00:04:09,000
சரி, பின் ஒரு முடிவை எடுக்க வேண்டும்.

72
00:04:09,000 --> 00:04:11,000
உங்கள் சொந்த வார்த்தைகளில் வகையான ஒன்றாக்க விவரிக்க.

73
00:04:11,000 --> 00:04:15,000
இது எப்படி வேலை?

74
00:04:15,000 --> 00:04:17,000
சரி, நாம் வாரம் 0 திரும்பி வரிசையை வேண்டும்.

75
00:04:17,000 --> 00:04:19,000
சரி, சரி.

76
00:04:19,000 --> 00:04:22,000
[செவிக்கு புலப்படாமல்-மாணவர்]

77
00:04:22,000 --> 00:04:26,000
நல்ல, சரி, நாங்கள் 2 துண்டுகளாக எண்கள் வரிசையில் பிரித்து.

78
00:04:26,000 --> 00:04:29,000
, நாம் அந்த துண்டுகள் ஒவ்வொரு வரிசைப்படுத்தப்பட்ட, மற்றும் நாம் இன்னும் இணைக்கப்பட்டது

79
00:04:29,000 --> 00:04:33,000
இந்த பெரிய என்று ஒரு பிரச்சனை எடுத்து முன் நாம் இந்த கருத்தை நான் பார்த்திருக்கிறேன்

80
00:04:33,000 --> 00:04:36,000
இந்த பெரிய அல்லது இந்த பெரிய என்று ஒரு பிரச்சனை அதை வரை நறுக்குவதில்.

81
00:04:36,000 --> 00:04:38,000
>> தொலைபேசி புத்தகம் எடுத்துக்காட்டாக நினைவு.

82
00:04:38,000 --> 00:04:42,000
, முன்பு வாரங்கள் சுய எண்ணும் வழிமுறை நினைவு

83
00:04:42,000 --> 00:04:45,000
எனவே ஒன்றாக்க வகையான இங்கே இந்த சூடோகுறியீடு சுருக்கமாக.

84
00:04:45,000 --> 00:04:48,000
நீங்கள் n உறுப்புகள் கொடுக்கப்பட்ட போது, முதலில் நல்லறிவு சோதனை இருந்தது.

85
00:04:48,000 --> 00:04:51,000
N <2 பின்னர் எதுவுமே செய்யவில்லை என்றால்

86
00:04:51,000 --> 00:04:55,000
n <2 பின்னர் n வெளிப்படையாக 0 அல்லது 1 என்று ஏனெனில்,

87
00:04:55,000 --> 00:04:57,000
அது ஒன்று தான் என்றாலும் அதனால் 0 அல்லது 1 வரிசைப்படுத்த ஒன்றுமில்லை.

88
00:04:57,000 --> 00:04:59,000
நீங்கள் முடித்துவிட்டீர்கள்.

89
00:04:59,000 --> 00:05:01,000
உங்கள் பட்டியலில் ஏற்கனவே எளிதில் பிரிக்கப்பட்டுள்ளது.

90
00:05:01,000 --> 00:05:04,000
ஆனால் நீங்கள் 2 அல்லது அதற்கு மேற்பட்ட கூறுகள் கிடைத்துவிட்டது மற்றபடி நீங்கள் போய் அவர்களை பிரித்து

91
00:05:04,000 --> 00:05:06,000
2 பகுதிகளாக, இடது மற்றும் வலது.

92
00:05:06,000 --> 00:05:09,000
அந்த பாதிகளுக்கு ஒவ்வொரு வரிசைப்படுத்த, பின்னர் வரிசையாக்கம் பாதிகளுக்கு ஒன்றாக்க.

93
00:05:09,000 --> 00:05:13,000
ஆனால் இங்கே பிரச்சினை நாம் punting போல முதல் பார்வையில் இந்த நினைக்கிறார் என்று.

94
00:05:13,000 --> 00:05:17,000
நான் இந்த n உறுப்புகள் வரிசைப்படுத்த நீங்கள் கேட்டுள்ளீர்கள் இந்த என்று ஒரு சுற்று வரையறை இல்லை

95
00:05:17,000 --> 00:05:22,000
நீங்கள் "சரி, சரி, நாம் அந்த n / 2 அந்த n / 2 உறுப்புகள் அடுக்க வேண்டும்" நீ என்னிடம் சொன்னாய்

96
00:05:22,000 --> 00:05:27,000
பிறகு என் அடுத்த கேள்வி போகிறது "எப்படி n / 2 உறுப்புகள் வரிசைப்படுத்துவது, சரியா?"

97
00:05:27,000 --> 00:05:30,000
>> ஆனால் இந்த திட்டம் அமைப்பு,

98
00:05:30,000 --> 00:05:33,000
இந்த தளத்தை வழக்கு உள்ளது, ஏனெனில், அதனால், பேச

99
00:05:33,000 --> 00:05:39,000
n உடனடியாக 2 மீண்டும் போன்ற சில நிலையான மதிப்பு <இருந்தால் சொல்வது இந்த சிறப்பு.

100
00:05:39,000 --> 00:05:42,000
அதே சுற்று பதில் உடன் பதில் இல்லை.

101
00:05:42,000 --> 00:05:46,000
இந்த செயல்முறை, இந்த cyclicity இறுதியில் முடிக்கும்.

102
00:05:46,000 --> 00:05:50,000
நான் "வரிசை இந்த n உறுப்புகள்," நீங்கள் கேட்கும் நீங்கள், சொன்னால் "சரி, இந்த n / 2 வரிசைப்படுத்த"

103
00:05:50,000 --> 00:05:53,000
நீங்கள் "சரி, அப்படி இந்த n / 4, n / 8, n/16,", என்று

104
00:05:53,000 --> 00:05:56,000
இறுதியில் நீங்கள் ஒரு பெரிய போதுமான எண்ணிக்கையில் பிரித்து விடுவேன்

105
00:05:56,000 --> 00:05:59,000
நீங்கள், நீங்கள் எந்த இடத்தில், வெறும் 1 உறுப்பு இடது வேண்டும் என்று

106
00:05:59,000 --> 00:06:02,000
"இதோ, இங்கே ஒரு வரிசைப்படுத்தப்பட்ட ஒற்றை உறுப்பு ஆகும்."

107
00:06:02,000 --> 00:06:06,000
இந்த வழிமுறையின் திறமை இங்கு உண்மையில் இருந்து பெற வேண்டும்

108
00:06:06,000 --> 00:06:09,000
அந்த முறை இந்த தனித்தனியாக பிரிக்கப்பட்டு பட்டியல்கள் அனைத்து வேண்டும்,

109
00:06:09,000 --> 00:06:12,000
தேவையில்லாத தெரிகிறது எந்த அளவு 1, இல்லாத அனைத்து,

110
00:06:12,000 --> 00:06:15,000
நீங்கள் அவர்களை இணைத்தல் மற்றும் இணைத்தல் துவக்க முறை

111
00:06:15,000 --> 00:06:19,000
ராப் வீடியோ ஒரு இறுதியாக வரிசையாக்கம் பட்டியலில் செய்தது போல் நீங்கள் இறுதியாக கட்டமைக்க.

112
00:06:19,000 --> 00:06:22,000
>> ஆனால் இந்த யோசனையை இதுவரை வரிசையாக்க அப்பால் நீண்டுள்ளது.

113
00:06:22,000 --> 00:06:26,000
மறுநிகழ்வு என்று அழைக்கப்படும் இந்த திட்டத்தில் பதிக்கப்பட்ட இந்த யோசனை, இல்லை

114
00:06:26,000 --> 00:06:29,000
நீங்கள் ஒரு திட்டம் ஆகும் அதன்படி யோசனை,

115
00:06:29,000 --> 00:06:32,000
மற்றும் நீங்கள் அழைக்க சில சிக்கலை தீர்க்க,

116
00:06:32,000 --> 00:06:36,000
அல்லது, நீங்கள் ஒரு செயல்பாடு இருக்கும் நிரலாக்க மொழிகளை சூழலில் வைத்து

117
00:06:36,000 --> 00:06:39,000
ஒரு பிரச்சினையை தீர்ப்பதற்கு பொருட்டு, நீங்கள் விழாவில் உங்களை அழைக்க

118
00:06:39,000 --> 00:06:42,000
மீண்டும் மீண்டும், மீண்டும், ஆனால் நீங்கள் செயல்பாடு

119
00:06:42,000 --> 00:06:44,000
உங்களை எண்ணற்ற பல முறை அழைக்க முடியாது.

120
00:06:44,000 --> 00:06:47,000
இறுதியாக நீங்கள், ஏன் பேச, கீழே அவுட் வேண்டும்

121
00:06:47,000 --> 00:06:49,000
மற்றும் நிதி சில விதமாகவோ அடிப்படை நிபந்தனை

122
00:06:49,000 --> 00:06:53,000
இந்த இடத்தில் மிகவும் உங்களை அழைத்து நிறுத்த என்று முழு செயல்முறை

123
00:06:53,000 --> 00:06:56,000
இறுதியாக உண்மையில் நிறுத்த.

124
00:06:56,000 --> 00:06:58,000
இந்த உண்மையில் தொடரை வேண்டும், என்ன அர்த்தம்?

125
00:06:58,000 --> 00:07:01,000
>> நாம், என்ன, ஒரு எளிய, சிறிய உதாரணம் செய்ய முடியும் என்றால், நாம் பார்ப்போம்

126
00:07:01,000 --> 00:07:03,000
இங்கு மேடையில் என்னுடன் 3 பேர், யாராவது வசதியான என்றால்.

127
00:07:03,000 --> 00:07:06,000
வரை, 2 மற்றும் 3 1, வரும்.

128
00:07:06,000 --> 00:07:09,000
நீங்கள் 3 இங்கே வர விரும்பினால்.

129
00:07:09,000 --> 00:07:12,000
நீங்கள் ஒரு வரியில் இங்கே என் பக்கத்தில் நிற்க வேண்டும் என்றால், ஒரு வேளை கையில் சிக்கல்

130
00:07:12,000 --> 00:07:15,000
மிக எளிதில் இங்கு இருக்கும் மக்கள் எண்ணிக்கையை.

131
00:07:15,000 --> 00:07:18,000
ஆனால் வெளிப்படையாக, நான் இந்த எண்ணிக்கை உதாரணங்கள் மிகவும் சோர்வாக இருக்கிறேன்.

132
00:07:18,000 --> 00:07:21,000
இந்த சில நேரம், 1, 2, மற்றும் டாட், டாட், டாட் நடக்கப்போகிறது.

133
00:07:21,000 --> 00:07:23,000
அது எப்போதும் எடுத்து நடக்கிறது.

134
00:07:23,000 --> 00:07:25,000
நான் உதவியுடன் முற்றிலும் பந்தயம் இந்த பிரச்சினை என்ன, உங்கள் பெயர்? மாறாக விட்டோம்

135
00:07:25,000 --> 00:07:27,000
சாரா. >> சாரா, சரி.

136
00:07:27,000 --> 00:07:29,000
கெல்லி. >> கெல்லி மற்றும்?

137
00:07:29,000 --> 00:07:31,000
>> வில்லி. >> வில்லி, சாரா, கெல்லி, மற்றும் வில்லி.

138
00:07:31,000 --> 00:07:34,000
இப்போது நான் யாரோ கேள்வி கேட்டார்

139
00:07:34,000 --> 00:07:37,000
எத்தனை பேர் இந்த மேடையில் வரை, மற்றும் எனக்கு எதுவும் தெரியாது.

140
00:07:37,000 --> 00:07:40,000
இந்த ஒரு நாள் நீண்ட பட்டியல் உள்ளது, எனவே அதற்கு பதிலாக நான் இந்த தந்திரம் செய்ய போகிறேன்.

141
00:07:40,000 --> 00:07:43,000
நான், வேலை மிக செய்ய எனக்கு அடுத்த நபர் ask போகிறேன்

142
00:07:43,000 --> 00:07:46,000
ஒருமுறை அவர் வேலை பெரும்பாலான செய்து செய்யப்படுகிறது

143
00:07:46,000 --> 00:07:49,000
நான் முடிந்தவரை வேலை குறைந்தது அளவு என்ன செய்ய போகிறாய் மற்றும் 1 சேர்க்க

144
00:07:49,000 --> 00:07:51,000
எனவே, இங்கே நாம் என்ன சொன்னாலும் அவர் பதில் வேண்டும்.

145
00:07:51,000 --> 00:07:54,000
நான் மேடையில் எப்படி பல மக்கள் கேட்டு.

146
00:07:54,000 --> 00:07:57,000
எத்தனை பேர் நீங்கள் இடது நிலையில் உள்ளன?

147
00:07:57,000 --> 00:08:00,000
சரி >>? எனக்கு இடது, ஆனால் ஏமாற்ற வேண்டாம்.

148
00:08:00,000 --> 00:08:04,000
அது சரியானது என்று, நல்லது, ஆனால் நாம் இந்த தர்க்கம் தொடர விரும்பினால்

149
00:08:04,000 --> 00:08:08,000
நீங்கள் இதேபோல் நீங்கள் இடது பந்தயம் இந்த சிக்கல் வேண்டும் என்று தான் நாம் கருதி கொள்வோம்,

150
00:08:08,000 --> 00:08:11,000
இதனால் பதில் விட நேரடியாக போய் வெறும் பக் அனுப்ப.

151
00:08:11,000 --> 00:08:14,000
ஓ, எனக்கு இடது எத்தனை பேர்?

152
00:08:14,000 --> 00:08:16,000
இடது எத்தனை பேர்?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[சிரிப்பு]

155
00:08:27,000 --> 00:08:30,000
சரி, இவ்வளவு 0, அதனால் என்ன இப்போது வில்லி செய்தது

156
00:08:30,000 --> 00:08:33,000
உங்கள் பதில் 0 என்று இந்த திசையில் திரும்பி வருகிறது.

157
00:08:33,000 --> 00:08:36,000
இப்போது, நீங்கள் என்ன செய்ய வேண்டும்? >> 1.

158
00:08:36,000 --> 00:08:39,000
சரி, நீங்கள் 1, நீ என்ன, "சரி, நான் 1 சேர்க்க போகிறேன்

159
00:08:39,000 --> 00:08:41,000
செய்ய என்ன வில்லி எண்ணிக்கை இருந்தது, "இவ்வளவு 1 + 0.

160
00:08:41,000 --> 00:08:43,000
சரி உங்கள் பதில் நீ இப்போது 1 நீங்கள் இப்போது

161
00:08:43,000 --> 00:08:45,000
1. >> மேலும் என்னுடைய 2 இருக்கும்.

162
00:08:45,000 --> 00:08:48,000
, நீ, 1 முந்தைய பதில் நல்ல எடுத்து

163
00:08:48,000 --> 00:08:51,000
நீ என்ன செய்ய வேண்டுமோ வேலை குறைந்த அளவு சேர்த்து, எந்த +1 ஆகும்.

164
00:08:51,000 --> 00:08:55,000
நீங்கள் இப்போது 2 வேண்டும், மற்றும் நீங்கள் என்னை எந்த மதிப்பு கொடு?

165
00:08:55,000 --> 00:08:57,000
3, நான், மன்னிக்கவும், 2 அர்த்தம்.

166
00:08:57,000 --> 00:08:59,000
நல்ல.

167
00:08:59,000 --> 00:09:02,000
>> சரி, நாம் இடது 0 இருந்தது.

168
00:09:02,000 --> 00:09:05,000
, நாம் 1 இருந்தது, மற்றும் நாம் 2 சேர்க்க

169
00:09:05,000 --> 00:09:07,000
இப்போது நீங்கள், என்னை எண் 2 ஒப்படைத்தார்

170
00:09:07,000 --> 00:09:10,000
அதனால் நான் 3, +1, சரி, சொல்கிறேன்.

171
00:09:10,000 --> 00:09:13,000
இந்த மேடையில் எனக்கு அடுத்த நின்று 3 பேர், உண்மையில் அங்கு

172
00:09:13,000 --> 00:09:16,000
அதனால் நாம் தெளிவாக, மிக நேர்க்கோட்டில் இதை செய்திருக்க முடியும்

173
00:09:16,000 --> 00:09:19,000
வெளிப்படையான முறையில் மிகவும், ஆனால் நாம் உண்மையில் என்ன செய்தாய்?

174
00:09:19,000 --> 00:09:21,000
நாம் ஆரம்பத்தில் அளவு 3 ஒரு பிரச்சினை நடந்தது.

175
00:09:21,000 --> 00:09:24,000
நாம், அளவு 2 ஒரு பிரச்சனை அதை முறிந்தன

176
00:09:24,000 --> 00:09:27,000
பின்னர் அளவு 1 ஒரு பிரச்சனை, மற்றும் அடிப்படை வழக்கில் இறுதியாக

177
00:09:27,000 --> 00:09:29,000
உண்மையில், ஓ, அங்கு யாரும், அங்கு

178
00:09:29,000 --> 00:09:33,000
அந்த சமயத்தில் வில்லி, ஒரு விதமாகவோ பதில் இரண்டு முறை திறம்பட திரும்பினார்

179
00:09:33,000 --> 00:09:36,000
இரண்டாவது ஒரு பின், மேல் குதுகலித்தது, வரை குதுகலித்தது, வரை குதுகலித்தது

180
00:09:36,000 --> 00:09:39,000
பின்னர் இந்த கூடுதல் 1 சேர்ப்பதன் மூலம்

181
00:09:39,000 --> 00:09:41,000
நாம் மறுநிகழ்வு இந்த அடிப்படை கருத்தை செயல்படுத்தப்படும்.

182
00:09:41,000 --> 00:09:44,000
>> இப்போது, இந்த வழக்கில் அது உண்மையில் ஒரு பிரச்சினை இல்லை

183
00:09:44,000 --> 00:09:46,000
இன்னும் திறமையுடன் நாம் இதுவரை பார்த்த.

184
00:09:46,000 --> 00:09:48,000
ஆனால் நாம் இதுவரை மேடையில் செய்துவிட்டேன் வழிமுறைகளை பற்றி நினைக்கிறேன்.

185
00:09:48,000 --> 00:09:51,000
நாம், சாக்போர்டு காகிதம் 8 துண்டுகள் இருந்தது

186
00:09:51,000 --> 00:09:55,000
வீடியோ சீன் எண் 7 தேடிக்கொண்டிருந்த, அவர் உண்மையில் என்ன இருக்கிறது?

187
00:09:55,000 --> 00:09:58,000
நன்றாக, அவர் பிளவை எந்த விதமான செய்ய வெற்றி பெறவில்லை.

188
00:09:58,000 --> 00:10:01,000
அவர் மறுநிகழ்வு எந்த விதமான செய்யவில்லை.

189
00:10:01,000 --> 00:10:03,000
மாறாக அவர் தான் இந்த நேரியல் வழிமுறை இல்லை.

190
00:10:03,000 --> 00:10:07,000
ஆனால் நாம் மேடையில் வரிசைப்படுத்தப்பட்ட எண்கள் யோசனை அறிமுகப்படுத்தப்பட்டது போது கடந்த வாரம் வாழ

191
00:10:07,000 --> 00:10:09,000
நாம், நடுத்தர செல்லும் இந்த உள்ளுணர்வு என்று

192
00:10:09,000 --> 00:10:13,000
எந்த புள்ளியில் நாம், அளவு 4 அல்லது அளவு 4 மற்றொரு பட்டியலில் ஒரு சிறிய பட்டியலில் இருந்தது

193
00:10:13,000 --> 00:10:17,000
மற்றும் நாம் சரியான அதே பிரச்சனை, நாம் திரும்ப திரும்ப, திரும்ப திரும்ப, திரும்ப திரும்ப.

194
00:10:17,000 --> 00:10:19,000
வேறுவிதமாக கூறினால், நாம் recursed.

195
00:10:19,000 --> 00:10:24,000
எங்களுடன் மறுநிகழ்வு ஆர்ப்பாட்டம் இங்கே நம் 3 தொண்டர்கள் மிகவும் நன்றி.

196
00:10:24,000 --> 00:10:28,000
>> நாம் இப்போது ஒரு சிறிய மேலும் கான்கிரீட் இந்த செய்ய முடியாது என்று பார்ப்போம்,

197
00:10:28,000 --> 00:10:30,000
மீண்டும் நாம் மிகவும் எளிதாக செய்ய முடியும் என்று ஒரு சிக்கலை தீர்ப்பதில்

198
00:10:30,000 --> 00:10:34,000
ஆனால் நாம் இந்த அடிப்படை கருத்தை செயல்படுத்த ஒரு படிக்கல்லாகும் அதை பயன்படுத்த வேண்டும்.

199
00:10:34,000 --> 00:10:37,000
நான், எண்கள் ஒரு கொத்து அளவில் கூட்டுத்தொகை கணக்கிட விரும்பினால்

200
00:10:37,000 --> 00:10:39,000
உதாரணமாக, நீங்கள் எண் 3 ல் வெற்றி என்றால்,

201
00:10:39,000 --> 00:10:42,000
நான், நீ சிக்மா 3 மதிப்பு கொடுக்க வேண்டும்

202
00:10:42,000 --> 00:10:46,000
அதனால் 3 தொகை + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
நான், பதில் 6 திரும்ப பெற வேண்டும்

204
00:10:48,000 --> 00:10:51,000
எனவே நாம் இந்த சிக்மா செயல்பாடு, இந்த கூட்டுத்தொகை செயல்பாட்டை செயல்படுத்த வேண்டும்

205
00:10:51,000 --> 00:10:54,000
என்று, மீண்டும், உள்ளீடு எடுத்து, பின்னர் கூட்டுத்தொகை கொடுக்கிறது

206
00:10:54,000 --> 00:10:57,000
கீழே 0 என்று பல வழி.

207
00:10:57,000 --> 00:10:59,000
நாம் சரியான, மிக எளிதாக செய்ய முடியும்?

208
00:10:59,000 --> 00:11:01,000
நாம், வளைவு அமைப்பு சில வகையான செய்யலாம்

209
00:11:01,000 --> 00:11:04,000
என்னை போய் இந்த துவங்கட்டும்.

210
00:11:04,000 --> 00:11:07,000
>> Stdio.h அடங்கும்.

211
00:11:07,000 --> 00:11:09,000
இங்கே வேலை என்னை முக்கிய மீண்டும் நானே எடுத்து விடுங்கள்.

212
00:11:09,000 --> 00:11:12,000
நாம் sigma.c இந்த சேமிக்க.

213
00:11:12,000 --> 00:11:14,000
நான் இங்கே போக போகிறேன், நான், ஒரு முழு எண்ணாக n அறிவிக்க போகிறேன்

214
00:11:14,000 --> 00:11:18,000
நான் பயனர் ஒத்துழைக்க இல்லை போது பின்வரும் செய்ய போகிறேன்.

215
00:11:18,000 --> 00:11:22,000
எனக்கு ஒரு நேர்மறையான எண் கொடுக்கப்பட்ட போது

216
00:11:22,000 --> 00:11:26,000
என்னை போய் n = GetInt அவர்கள் கேட்கும் விட,

217
00:11:26,000 --> 00:11:28,000
மேலும், எனக்கு இன்னும் என்ன செய்ய வேண்டும் என்று சில வழிமுறைகளை வழங்கட்டுமா

218
00:11:28,000 --> 00:11:33,000
எனவே printf ("நேர்மறை முழு தயவு செய்து").

219
00:11:33,000 --> 00:11:39,000
அந்த நேரத்தில் நாம் வரி 14 வெற்றி, அதனால் இந்த ஒப்பீட்டளவில் எளிமையான தான் ஏதாவது

220
00:11:39,000 --> 00:11:42,000
நாம் இப்போது n இல் மறைமுகமாக ஒரு நேர்மறை முழு எண்ணாக இருக்கிறது.

221
00:11:42,000 --> 00:11:44,000
>> இப்போது அது ஏதாவது செய்வோம்.

222
00:11:44,000 --> 00:11:50,000
என்னை போய் கூட்டுத்தொகை கணக்கிட விட, மிகவும் எண்ணாக கூட்டுத்தொகையாக = சிக்மா (n).

223
00:11:50,000 --> 00:11:54,000
சிக்மா ஒரு கூட்டுத்தொகை உள்ளது, அதனால் நான் ஆர்வலராக வழியில் அதை எழுதும்.

224
00:11:54,000 --> 00:11:56,000
நாம் அங்கு சிக்மா அழைக்கிறேன்.

225
00:11:56,000 --> 00:11:58,000
அந்த தொகை தான், இப்போது நான், இதன் விளைவாக அவுட் அச்சிட போகிறேன்

226
00:11:58,000 --> 00:12:08,000
printf (கூட்டுத்தொகையாக "கூட்டுத்தொகையாக ஈ, \ n% ஆகும்").

227
00:12:08,000 --> 00:12:11,000
பின்னர் நான் நல்ல நடவடிக்கை 0 தருகிறேன்.

228
00:12:11,000 --> 00:12:15,000
நாம், சுவாரஸ்யமான பகுதி தவிர இந்த திட்டம் தேவை என்று நான் செய்தேன்

229
00:12:15,000 --> 00:12:18,000
இது உண்மையில் சிக்மா செயல்பாட்டை செயல்படுத்த உள்ளது.

230
00:12:18,000 --> 00:12:22,000
>> என்னை கீழே இறங்கி போய், என்னை செயல்பாடு சிக்மா அறிவிக்க விட்டு.

231
00:12:22,000 --> 00:12:26,000
அது, வகை முழு தான் என்று ஒரு மாறி செல்ல இருக்கிறது

232
00:12:26,000 --> 00:12:30,000
என்ன தரவு வகை நான் சிக்மா இருந்து மறைமுகமாக திரும்ப வேண்டுமா?

233
00:12:30,000 --> 00:12:34,000
Int, நான் அதை வரி 15 என் எதிர்பார்ப்புகளை பொருத்த வேண்டும் என்பதால்.

234
00:12:34,000 --> 00:12:37,000
இங்கே என்னை போய் இந்த செயல்படுத்த அனுமதி

235
00:12:37,000 --> 00:12:41,000
ஒரு அழகான நேர்மையான வழியில்.

236
00:12:41,000 --> 00:12:45,000
>> தான் போய் எண்ணாக கூட்டுத்தொகையாக = 0 சொல்கிறேன்,

237
00:12:45,000 --> 00:12:47,000
இப்போது நான் இங்கே வளைய ஒரு சிறிய வேண்டும் போக போகிறேன்

238
00:12:47,000 --> 00:12:50,000
என்று, இப்படி ஏதாவது சொல்ல நடக்கிறது

239
00:12:50,000 --> 00:13:01,000
கூடுதல் + = நான் (! நான் <= எண் நான் + எண்ணாக நான் = 0).

240
00:13:01,000 --> 00:13:05,000
பின்னர் நான் தொகை திரும்ப போகிறேன்.

241
00:13:05,000 --> 00:13:07,000
நான் வழிகளில் எந்த எண்ணை இந்த செயல்படுத்தப்படும்.

242
00:13:07,000 --> 00:13:09,000
நான் ஒரு வளையம் பயன்படுத்தப்படுகிறது.

243
00:13:09,000 --> 00:13:11,000
நான், நான் உண்மையில் விரும்பினால் தொகை மாறி பயன்படுத்தி தவிர்க்கப்பட்டது

244
00:13:11,000 --> 00:13:15,000
ஆனால் குறுகிய, நாம் தான் நான் இல்லை என்றால் தவறு கூட்டுத்தொகையாக 0 அறிவிக்கிறது என்று ஒரு செயல்பாடு இருக்கும்.

245
00:13:15,000 --> 00:13:18,000
அது, எண் மூலமாக 0 இருந்து செயல்களை

246
00:13:18,000 --> 00:13:23,000
மற்றும் ஒவ்வொரு மறுசெய்கையும் அது கூட்டுத்தொகையாக என்று தற்போதைய மதிப்பை கூட்டுகிறது பின்னர் தொகையை கொடுக்கிறது.

247
00:13:23,000 --> 00:13:25,000
>> இப்போது, இங்கே ஒரு சிறிய தேர்வுமுறை உள்ளது.

248
00:13:25,000 --> 00:13:29,000
இது ஒரு வீணாகி படி, ஆனால் அது இருக்கும். இப்போது அது நல்லது.

249
00:13:29,000 --> 00:13:32,000
நாங்கள் குறைந்தது தான் முழுமையான இருப்பது மற்றும் 0 வழி நடக்கிறது.

250
00:13:32,000 --> 00:13:34,000
மிகவும் கடினமான மற்றும் மிகவும் நேரடியான இல்லை,

251
00:13:34,000 --> 00:13:37,000
ஆனால் அது சிக்மா செயல்பாடு நாம் ஒரே வாய்ப்பு உள்ளது என்று மாறும்

252
00:13:37,000 --> 00:13:39,000
நாம் மேடையில் இங்கே செய்தார்.

253
00:13:39,000 --> 00:13:42,000
மேடையில் நாம் தான், எனக்கு அடுத்த இருந்தன எத்தனை பேர் எண்ணி

254
00:13:42,000 --> 00:13:47,000
ஆனால் அதற்கு பதிலாக நாம் எண் 3 + 2 + 1 எண்ணி விரும்பினால்

255
00:13:47,000 --> 00:13:51,000
கீழே 0 நாம் ஒரு செயல்பாடு இதேபோல் பந்தயம் முடியும்

256
00:13:51,000 --> 00:13:55,000
நான் அதற்கு பதிலாக சுழல்நிலை என விவரிக்க வேண்டும் என்று.

257
00:13:55,000 --> 00:13:57,000
இங்கே ஒரு விரைவு நல்லறிவு சரிபார்த்து நான் தவறு செய்யவில்லை என்பதை உறுதி செய்வோம்.

258
00:13:57,000 --> 00:14:00,000
>> நான் தவறு செய்யவில்லை என்று இந்த திட்டத்தில் குறைந்தது ஒரு விஷயம் தெரியுமா.

259
00:14:00,000 --> 00:14:04,000
நான் நுழைய ஹிட் போது நான் என்னை திட்டுகிறாய் எந்த விதமான பெற போகிறேன்?

260
00:14:04,000 --> 00:14:06,000
நான் திட்டுவதற்கு வேண்டும் என்ன போகிறேன்?

261
00:14:06,000 --> 00:14:11,000
சரி, நான் முன்மாதிரி மறந்துவிட்டேன், நான் வரி 15 சிக்மா என்று ஒரு செயல்பாடு பயன்படுத்தி நான் மிகவும்

262
00:14:11,000 --> 00:14:16,000
ஆனால் அது வரி 22 வரை அறிவித்தார், நான் சிறந்த முன்னெச்சரிக்கையாக இங்கு போக

263
00:14:16,000 --> 00:14:22,000
மற்றும் ஒரு முன்மாதிரி என்று, நான் எண்ணாக சிக்மா (int எண்) சொல்கிறேன், அவ்வளவு தான்.

264
00:14:22,000 --> 00:14:24,000
அதை கீழே செயல்படுத்தப்படும்.

265
00:14:24,000 --> 00:14:27,000
>> அல்லது நான் இந்த தீர்க்க முடியும் மற்றொரு வழி,

266
00:14:27,000 --> 00:14:30,000
நான், எந்த கெட்ட அல்ல, அங்கு செயல்பாடு நகர்த்த முடியும்

267
00:14:30,000 --> 00:14:32,000
ஆனால் குறைந்த பட்சம் உங்கள் திட்டங்கள், வெளிப்படையாக, நீண்ட பெற தொடங்கும் போது

268
00:14:32,000 --> 00:14:35,000
நான் எப்போதும் மேலே முக்கிய கொண்ட சில மதிப்பு இருக்கிறது என்று நான் நினைக்கிறேன்

269
00:14:35,000 --> 00:14:38,000
நீங்கள் வாசகர் கோப்பை திறக்க மற்றும் பின்னர் உடனடியாக பார்க்க முடியும்

270
00:14:38,000 --> 00:14:40,000
நிரல் மூலம் தேட இல்லாமல் என்ன

271
00:14:40,000 --> 00:14:42,000
அந்த முக்கிய செயல்பாடு தேடும்.

272
00:14:42,000 --> 00:14:49,000
அது இங்கே என் முனைய சாளரத்தில் கீழே போகலாம்,, சிக்மா சிக்மா செய்ய உருவாக்கும் முயற்சி

273
00:14:49,000 --> 00:14:51,000
மற்றும் நான் இங்கு ஸ்க்ரீவ்டு.

274
00:14:51,000 --> 00:14:55,000
விழாவில் GetInt உள்ளார்ந்த அறிவிப்பு நான் என்ன வேறு செய்ய மறந்துவிட்டேன் என்று?

275
00:14:55,000 --> 00:14:57,000
[செவிக்கு புலப்படாமல்-மாணவர்]

276
00:14:57,000 --> 00:15:00,000
நல்ல, மிகவும் வெளிப்படையாக ஒரு பொதுவான தவறு, அதனால், தான் இங்கே இந்த போட அனுமதிக்க

277
00:15:00,000 --> 00:15:04,000
cs50.h, மற்றும் இப்போது என் முனைய சாளரத்தில் திரும்பி செல்லலாம்.

278
00:15:04,000 --> 00:15:08,000
>> நான் திரையில் தெளிவாக, நான் சிக்மா செய்ய மீண்டும் இயக்கவும் முடியும்.

279
00:15:08,000 --> 00:15:11,000
இது தொகுக்கப்பட்ட தெரிகிறது. எனக்கு இப்போது சிக்மா ஓடிப்போகட்டும்.

280
00:15:11,000 --> 00:15:15,000
, நான் எண்ணிக்கை 3 தட்டச்சு, நான் 6 கிடைத்தது, அதனால் ஒரு கடுமையான சோதனை

281
00:15:15,000 --> 00:15:18,000
ஆனால் குறைந்தது, இது முதல் பார்வையில் வேலை வேண்டும் தெரிகிறது, ஆனால் இப்போது நாம் அது தவிர கிழித்தெறிய

282
00:15:18,000 --> 00:15:21,000
மற்றும் நாம் உண்மையில், மீண்டும், மறுநிகழ்வு யோசனை அதிகப்படுத்தும்

283
00:15:21,000 --> 00:15:24,000
ஒரு மிக எளிய சூழலில், அதனால் ஒரு சில வாரங்களில் 'நேரத்தில்

284
00:15:24,000 --> 00:15:27,000
நாம் அணிகளை விட ஆர்வலராக தரவு கட்டமைப்புகள் ஆய்வு தொடங்கும் போது

285
00:15:27,000 --> 00:15:30,000
நாம் எந்த ஒரு கருவி மற்றொரு கருவி உள்ளது

286
00:15:30,000 --> 00:15:33,000
நாம் பார்க்கலாம் என அந்த தரவு கட்டமைப்புகள் கையாள.

287
00:15:33,000 --> 00:15:36,000
இந்த பங்கேற்பு அணுகுமுறை, சுழற்சி அடிப்படையிலான அணுகுமுறை ஆகும்.

288
00:15:36,000 --> 00:15:39,000
>> இப்போது இதை பதிலாக என்னை விட.

289
00:15:39,000 --> 00:15:44,000
அதற்கு பதிலாக சொல்ல என்னை அனுமதியுங்கள் என்று பல கூட்டுத்தொகை

290
00:15:44,000 --> 00:15:48,000
உண்மையில் அதே விஷயத்தை 0 கீழே உள்ளது

291
00:15:48,000 --> 00:15:53,000
எண்ணை + சிக்மா (எண் - 1).

292
00:15:53,000 --> 00:15:57,000
வேறு வார்த்தைகளில் கூறுவதானால், ஒரு மேடையில் போல் நான், எனக்கு அடுத்த மக்கள் ஒவ்வொரு punted

293
00:15:57,000 --> 00:16:00,000
அவர்கள் இதையொட்டி, நாம் இறுதியாக வில்லி வெளியே அடிப்பாகமுடைய வரை punting வைத்து

294
00:16:00,000 --> 00:16:03,000
யார் 0 போன்ற ஒரு விதமாகவோ பதில் திரும்ப வேண்டியதாயிற்று.

295
00:16:03,000 --> 00:16:07,000
இங்கே இப்போது நாம் இதேபோல் சிக்மா செய்ய punting

296
00:16:07,000 --> 00:16:10,000
அதே செயல்பாடு முதலில் என்று, ஆனால் முக்கிய பார்வையை இங்கே

297
00:16:10,000 --> 00:16:12,000
நாம் அடையாளங்களையே சிக்மா அழைப்பு இல்லை என்று.

298
00:16:12,000 --> 00:16:14,000
நாம் n கடந்து செல்லும்.

299
00:16:14,000 --> 00:16:17,000
நாம் தெளிவாக பல கடந்து - 1,

300
00:16:17,000 --> 00:16:20,000
எனவே சற்று சிறிய பிரச்சனை, சற்றே சிறிய பிரச்சினை.

301
00:16:20,000 --> 00:16:23,000
>> துரதிருஷ்டவசமாக, இந்த இன்னும் முற்றிலும் ஒரு தீர்வு அல்ல, நாம் சரி செய்ய முன்

302
00:16:23,000 --> 00:16:26,000
நீங்கள் சில வெளிப்படையான என என்ன குதித்து

303
00:16:26,000 --> 00:16:28,000
என்னை போய் செய்ய மீண்டும் இயக்கவும் நாம்.

304
00:16:28,000 --> 00:16:30,000
அது சரி, தொகுக்கலாம் தெரிகிறது.

305
00:16:30,000 --> 00:16:32,000
எனக்கு 6 சிக்மா மீண்டும் இயக்கவும் நாம்.

306
00:16:32,000 --> 00:16:37,000
அச்சச்சோ, என்னை 6 சிக்மா மீண்டும் இயக்கவும் நாம்.

307
00:16:37,000 --> 00:16:42,000
நாம் அதே தற்செயலாக கடந்த முறை என்றாலும், இந்த பார்த்திருக்கிறேன்.

308
00:16:42,000 --> 00:16:48,000
நான் ஏன் இந்த ரகசிய பிரிவு தவற்றை கிடைத்ததா? Yeah.

309
00:16:48,000 --> 00:16:50,000
[செவிக்கு புலப்படாமல்-மாணவர்]

310
00:16:50,000 --> 00:16:53,000
மேலும் குறிப்பாக எந்த அடிப்படை வழக்கு, மற்றும், என்ன ஒருவேளை நடந்தது?

311
00:16:53,000 --> 00:16:58,000
இந்த என்ன நடத்தையை ஒரு நோய் அறிகுறி?

312
00:16:58,000 --> 00:17:00,000
கொஞ்சம் உரக்க சொல்ல.

313
00:17:00,000 --> 00:17:02,000
[செவிக்கு புலப்படாமல்-மாணவர்]

314
00:17:02,000 --> 00:17:05,000
அதை திறம்பட ஒரு முடிவிலா சுழற்சியில், மற்றும் எல்லையற்ற கண்ணிக்கு பிரச்சினை

315
00:17:05,000 --> 00:17:08,000
அவர்கள் இந்த வழக்கில் மறுநிகழ்வு உள்ளடக்கியது போது, ஒரு செயல்பாடு, தன்னை அழைப்பு

316
00:17:08,000 --> 00:17:10,000
என்ன ஒரு செயல்பாடு என்று ஒவ்வொரு முறையும் நடக்கும்?

317
00:17:10,000 --> 00:17:13,000
சரி, நாம் ஒரு கணினியில் நினைவக தீட்டப்பட்டது எப்படி திரும்ப நினைக்கிறேன்.

318
00:17:13,000 --> 00:17:16,000
நாம், கீழே என்று ஸ்டேக் என்று நினைவகம் இந்த துண்டின் இல்லை என்று கூறினார்

319
00:17:16,000 --> 00:17:19,000
மற்றும் நீ இன்னும் சிறிது நினைவகம் ஒரு செயல்பாடு என்று ஒவ்வொரு முறையும் வைத்து

320
00:17:19,000 --> 00:17:24,000
அந்த விழாவில் உள்ளூர் மாறிகள் அல்லது அளவுருக்கள் கொண்ட இந்த பெயரளவிலான ஸ்டேக்கில்,

321
00:17:24,000 --> 00:17:27,000
சிக்மா சிக்மா அழைப்பு விடுக்கின்றது நீங்கள் சிக்மா சிக்மா அழைப்பு

322
00:17:27,000 --> 00:17:29,000
 சிக்மா அழைப்பு இந்த கதை முடிவில் என்ன?

323
00:17:29,000 --> 00:17:31,000
>> சரி, அது இறுதியில் நீட்டிப்புகளையும் மொத்த தொகை

324
00:17:31,000 --> 00:17:33,000
நீங்கள் உங்கள் கணினியில் கிடைக்கும் என்று நினைவகம்.

325
00:17:33,000 --> 00:17:37,000
நீங்கள் உள்ளே இருக்க வேண்டும் என்று பிரிவில், கைப்பற்றப்பட்ட

326
00:17:37,000 --> 00:17:40,000
இந்த அடுக்கு தவறு செய்து, அடிப்படை, டம்ப்

327
00:17:40,000 --> 00:17:43,000
மற்றும் டம்ப் என்ன அடிப்படை என்றால் நான் இப்போது கோர் என்று ஒரு கோப்பு உள்ளது என்று

328
00:17:43,000 --> 00:17:46,000
இது பூஜ்ஜியங்களும் ஒன்றுகளும் கொண்ட ஒரு கோப்பு

329
00:17:46,000 --> 00:17:49,000
என்று உண்மையில் எதிர்காலத்தில் நோயறிதலுக்கு பயனுள்ளதாக இருக்கும்.

330
00:17:49,000 --> 00:17:52,000
உங்கள் பிழை எங்கே அது உங்களுக்கு தெளிவாக இல்லை என்றால்

331
00:17:52,000 --> 00:17:54,000
நீங்கள் உண்மையில், அதனால் பேச, தடயவியல் ஆய்வு ஒரு பிட் செய்ய முடியும்

332
00:17:54,000 --> 00:17:58,000
இந்த அடிப்படை அடைக்கப்பட்டிருந்த கோப்புடன், இது, மீண்டும், ஒரு பூஜ்ஜியங்களும் ஒன்றுகளும் ஒரு மொத்தமாக உள்ளது

333
00:17:58,000 --> 00:18:02,000
அந்த அடிப்படையில் நினைவகத்தில் உங்கள் திட்டத்தை அரசு பிரதிநிதித்துவப்படுத்துகிறது

334
00:18:02,000 --> 00:18:05,000
தற்போது இந்த வழியில் செயலிழந்தது.

335
00:18:05,000 --> 00:18:11,000
>> இங்கே தீர்வை நாம் மட்டும் கண்மூடித்தனமாக, சிக்மா திரும்ப முடியாது என்று

336
00:18:11,000 --> 00:18:14,000
எண்ணை + சற்றே சிறிய பிரச்சினை சிக்மா.

337
00:18:14,000 --> 00:18:16,000
நாம், இங்கு அடிப்படை வழக்கில் சில வகையான வேண்டும்

338
00:18:16,000 --> 00:18:19,000
மற்றும் அடிப்படை வழக்கில் ஒருவேளை என்ன வேண்டும்?

339
00:18:19,000 --> 00:18:22,000
[செவிக்கு புலப்படாமல்-மாணவர்]

340
00:18:22,000 --> 00:18:25,000
சரி, இவ்வளவு காலமாக பல சாதகமான என்று நாம் உண்மையில், இந்த திரும்ப வேண்டும்

341
00:18:25,000 --> 00:18:29,000
அல்லது வேறு வழி வைத்து, எண் இருந்தால், என்ன, <= 0

342
00:18:29,000 --> 00:18:32,000
நீ, நான் மேலே போய் 0 தருகிறேன் என்ன, தெரியுமா

343
00:18:32,000 --> 00:18:36,000
வில்லி என்று மிகவும் போன்ற, மற்றும் வேறு, நான் போக போகிறேன்

344
00:18:36,000 --> 00:18:41,000
இந்த திருப்பி, அது அந்த மிகவும் குறுகிய இல்லை

345
00:18:41,000 --> 00:18:44,000
நாம் முதல் சுழற்சி ஒரு பயன்படுத்தி தட்டிவிட்டு என்று பங்கேற்பு பதிப்பு விட,

346
00:18:44,000 --> 00:18:48,000
ஆனால் அது நளினம் இந்த வகையான இல்லை என்று அறிவிப்பு.

347
00:18:48,000 --> 00:18:51,000
அதற்கு பதிலாக சில பல திரும்பிய மற்றும் அனைத்து இந்த கணித செயல்படுத்தலில்

348
00:18:51,000 --> 00:18:54,000
மற்றும் உள்ளூர் மாறிகள் பொருட்கள் சேர்த்து

349
00:18:54,000 --> 00:18:57,000
நீங்கள் பதிலாக சொல்கிறீர்கள் "சரி, இந்த ஒரு சூப்பர் எளிதாக பிரச்சனை என்றால்,

350
00:18:57,000 --> 00:19:01,000
எண் <0 போல, என்னை உடனடியாக 0 திரும்பி வரட்டும். "

351
00:19:01,000 --> 00:19:03,000
>> நாம், துணை எதிர்மறை எண்கள் தொந்தரவு போவதில்லை

352
00:19:03,000 --> 00:19:05,000
அதனால் நான் கடுமையாக குறியீடு 0 மதிப்பு செல்கிறேன்.

353
00:19:05,000 --> 00:19:08,000
ஆனால் மற்றபடி, கூட்டலாம் இந்த யோசனையை செயல்படுத்த

354
00:19:08,000 --> 00:19:11,000
இந்த எண்கள் அனைத்தும் ஒன்றாக நீங்கள் திறம்பட ஒரு சிறிய கடி எடுத்து கொள்ளலாம்

355
00:19:11,000 --> 00:19:14,000
பிரச்சனை வெளியே, மிகவும் போன்ற நாம், மேடையில் இங்கே இல்லை

356
00:19:14,000 --> 00:19:18,000
பின்னர் பந்தயம் அடுத்த நபர் பிரச்சினை மீதமுள்ள,

357
00:19:18,000 --> 00:19:20,000
ஆனால் இந்த வழக்கில் அடுத்த நபர் உங்களை உள்ளது.

358
00:19:20,000 --> 00:19:22,000
அது ஒரு அடையாளங்களையே என்ற விழா.

359
00:19:22,000 --> 00:19:25,000
அதை, ஒரு சிறிய மற்றும் சிறிய மற்றும் சிறிய பிரச்சனை ஒவ்வொரு முறை கடக்கும்

360
00:19:25,000 --> 00:19:28,000
நாம் இங்கே குறியீடு இல்லை மிகவும் முறைப்படுத்தப்பட்டது பொருட்கள் கூட

361
00:19:28,000 --> 00:19:33,000
இந்த தொலைபேசி புத்தகம் வாரம் 0 நடக்கிறது என்று சரியாக தான்.

362
00:19:33,000 --> 00:19:36,000
இந்த சீன் கடந்த வாரங்களில் நடக்கிறது சரியாக என்ன

363
00:19:36,000 --> 00:19:39,000
மற்றும் எண்கள் தேடி எங்கள் ஆர்ப்பாட்டங்கள் மூலம்.

364
00:19:39,000 --> 00:19:42,000
அது ஒரு பிரச்சினை எடுத்து மீண்டும் மீண்டும் பிளவு.

365
00:19:42,000 --> 00:19:44,000
>> வேறுவிதமாக கூறினால், மொழிபெயர்ப்பது இப்போது ஒரு வழி இருக்கிறது

366
00:19:44,000 --> 00:19:47,000
இந்த உண்மையான உலக கட்டமைப்பாகும், இந்த உயர் நிலை உருவாக்கப்பட்டது

367
00:19:47,000 --> 00:19:51,000
பிரித்து வெற்றி மீண்டும் மீண்டும் ஏதாவது செய்ய

368
00:19:51,000 --> 00:19:56,000
குறியீடு, இந்த நாங்கள் காலப்போக்கில் மீண்டும் பார்க்கலாம் ஒன்று.

369
00:19:56,000 --> 00:20:00,000
நீங்கள் மறுநிகழ்வு புதிய என்றால் இப்போது, ஒரு ஒதுக்கி, நீங்கள் குறைந்தது இப்போது புரிந்து

370
00:20:00,000 --> 00:20:02,000
ஏன் இந்த வேடிக்கையாக.

371
00:20:02,000 --> 00:20:05,000
நான், google.com க்கு போக போகிறேன்

372
00:20:05,000 --> 00:20:17,000
நான் மறுநிகழ்வு சில குறிப்புகள் மற்றும் தந்திரங்களை தேட போகிறேன், உள்ளிடவும்.

373
00:20:17,000 --> 00:20:21,000
அவர்கள் இப்போது சிரிக்கிறாய் என்று நீங்கள் அடுத்த நபர் சொல்ல.

374
00:20:21,000 --> 00:20:23,000
நீங்கள் மறுநிகழ்வு சொன்னீர்களா?

375
00:20:23,000 --> 00:20:25,000
நீங்கள் ஏன் அதாவது ஹா, அங்கு நாம்.

376
00:20:25,000 --> 00:20:28,000
சரி, இப்போது எல்லோர் ஓய்வு தான்.

377
00:20:28,000 --> 00:20:30,000
ஒரு சிறிய ஈஸ்டர் முட்டை Google இல் எங்கோ இருக்கிறது உட்பொதிக்கப்பட்ட.

378
00:20:30,000 --> 00:20:33,000
ஒரு ஒதுக்கி, நாம் நிச்சயமாக வலைத்தளத்தில் வைத்து இணைப்புகள் ஒருவராக

379
00:20:33,000 --> 00:20:36,000
இன்று பல்வேறு வரிசையாக்க படிமுறைகள் மட்டும் இந்த கட்டம் ஆகும்

380
00:20:36,000 --> 00:20:39,000
நாம் கடந்த வாரம் பார்த்தேன், ஆனால் இந்த காட்சி பற்றி நன்றாக அவற்றில் சில

381
00:20:39,000 --> 00:20:43,000
நீங்கள் நெறிமுறைகள் தொடர்பான பல்வேறு விஷயங்கள் சுற்றி உங்கள் மனதில் மடிக்க முயற்சி என

382
00:20:43,000 --> 00:20:46,000
நீங்கள் மிகவும் எளிதாக இப்போது உள்ளீடுகளின் பல்வேறு வகையான தொடங்க முடியும் என்று.

383
00:20:46,000 --> 00:20:50,000
உள்ளீடுகள் அனைத்து உள்ளீடுகளை சீரற்ற மற்றும் முன்னும் பின்னுமாக, உள்ளீடுகள் பெரும்பாலும் வரிசைப்படுத்தப்பட்ட, எதிர்மறையாக.

384
00:20:50,000 --> 00:20:53,000
நீங்கள் மீண்டும், முயற்சி, உங்கள் மனதில் இந்த விஷயங்களை வேறுபடுத்தி

385
00:20:53,000 --> 00:20:57,000
உணர்ந்து அந்த விரிவுரை பக்கத்தில் நிச்சயமாக வலைத்தளத்தில் இந்த URL

386
00:20:57,000 --> 00:21:00,000
அந்த சில வழியாக காரணம் உதவும்.

387
00:21:00,000 --> 00:21:05,000
>> இன்று நாம் இறுதியில், மீண்டும் ஒரு இருந்து இந்த பிரச்சனையை தீர்க்க வேண்டும்

388
00:21:05,000 --> 00:21:08,000
இது, இந்த இடமாற்று செயல்பாடு தான் வேலை செய்யவில்லை என்று

389
00:21:08,000 --> 00:21:12,000
மேலும், இந்த செயல்பாடு இடமாற்று உடன் அடிப்படை பிரச்சனை என்ன

390
00:21:12,000 --> 00:21:15,000
இங்கே மற்றும் இங்கே ஒரு மதிப்பு பரிமாறி, மீண்டும், அந்த இலக்கை அது

391
00:21:15,000 --> 00:21:17,000
இந்த நடக்கும் என்று?

392
00:21:17,000 --> 00:21:20,000
இந்த உண்மையில் வேலை செய்யவில்லை. ஏன்?

393
00:21:20,000 --> 00:21:22,000
Yeah.

394
00:21:22,000 --> 00:21:28,000
[செவிக்கு புலப்படாமல்-மாணவர்]

395
00:21:28,000 --> 00:21:31,000
இந்த bugginess இன்னும் சரியாக, விளக்கம்

396
00:21:31,000 --> 00:21:34,000
நீங்கள் சி செயல்பாடுகளை அழைப்பு காரணமாக எளிதாக இருந்தது

397
00:21:34,000 --> 00:21:38,000
அந்த பணிகள், ஒரு மற்றும் ப இங்கே போல, வாதங்கள் எடுத்து

398
00:21:38,000 --> 00:21:42,000
நீங்கள் அந்த செயல்பாடு வழங்கும் நீங்கள் என்ன மதிப்பு பிரதிகளை கடந்து செல்லும்.

399
00:21:42,000 --> 00:21:46,000
நீங்கள், உண்மையான மதிப்புகள் தங்களை வழங்கும்

400
00:21:46,000 --> 00:21:49,000
எனவே, buggyc சூழலில் இந்த பார்த்தேன்

401
00:21:49,000 --> 00:21:52,000
இந்த மாதிரி ஒரு சிறிய ஒன்று பார்த்து அதில் buggy3.c,.

402
00:21:52,000 --> 00:21:57,000
>> நாம் x மற்றும் y முறையே, 1 மற்றும் 2 துவக்கப்படும் என்று நினைவு.

403
00:21:57,000 --> 00:21:59,000
நாம் அவர்கள் என்ன அச்சு.

404
00:21:59,000 --> 00:22:03,000
நான் நான் x, y மற்றும் இடமாற்று அழைத்து அவர்களை மாற்ற என்று கூறினார்.

405
00:22:03,000 --> 00:22:06,000
ஆனால் பிரச்சனை, இடமாற்றத்திற்கு வேலை இருந்தது

406
00:22:06,000 --> 00:22:10,000
ஆனால் ஒரே இடமாற்று நோக்கம் தன்னை செயல்பட.

407
00:22:10,000 --> 00:22:13,000
நாம் வரி 40 அந்த பண்டமாற்று மதிப்புகள் வெற்றி விரைவில்

408
00:22:13,000 --> 00:22:16,000
தூர எறிந்து இருந்தது, அதனால் ஒன்றும்

409
00:22:16,000 --> 00:22:21,000
அசல் விழாவில் முக்கிய உண்மையில், அனைத்து மாற்றப்பட்டது

410
00:22:21,000 --> 00:22:26,000
இந்த நம் நினைவகம் அடிப்படையில் போல் என்ன என்று பின் என்று நீங்கள்

411
00:22:26,000 --> 00:22:29,000
குழுவின் இந்த இடது புறம் பிரதிபலிக்கிறது-என்றால்

412
00:22:29,000 --> 00:22:33,000
மற்றும் நான் பார்க்க அனைவருக்கும் என் சிறந்த செய்வேன் இந்த என்றால் குழுவின் இந்த இடப்புறம்

413
00:22:33,000 --> 00:22:37,000
குறிக்கிறது, உங்கள் RAM சொல்ல, மற்றும் ஸ்டாக், இந்த வழி வரை வளரும் போகிறது

414
00:22:37,000 --> 00:22:43,000
நாங்கள் முக்கிய போல ஒரு விழா அழைப்பு, மற்றும் முக்கிய 2 அக மாறிகள், x மற்றும் y உள்ளது

415
00:22:43,000 --> 00:22:48,000
அது இங்கே x என அந்த விவரிக்க விடுங்கள், மற்றும் நாம் இங்கே y இந்த விவரிக்க,

416
00:22:48,000 --> 00:22:55,000
மற்றும் மதிப்பு 1 மற்றும் 2 போட்டு விட்டு, இந்த இங்கே முக்கிய அதனால்

417
00:22:55,000 --> 00:22:58,000
மற்றும் முக்கிய இடமாற்று செயல்பாடு இயங்கு அழைத்தால்,

418
00:22:58,000 --> 00:23:02,000
, ஸ்டேக்கில் இடமாற்று செயல்பாடு நினைவக அதன் சொந்த பட்டையின் ஊடே கொடுக்கிறது

419
00:23:02,000 --> 00:23:04,000
ஸ்டாக் அதன் சொந்த சட்ட, அதனால் பேச.

420
00:23:04,000 --> 00:23:08,000
இது இந்த ints 32 பிட்கள் ஒதுக்கீடு.

421
00:23:08,000 --> 00:23:11,000
இது அவர்களுக்கு ஒரு மற்றும் ப அழைக்க நடக்கும், ஆனால் அந்த முற்றிலும் ஒருதலைப்பட்ச தான்.

422
00:23:11,000 --> 00:23:13,000
அது என்ன வேண்டுமானாலும் அழைத்து, ஆனால் போது முக்கிய என்ன நடக்கும்

423
00:23:13,000 --> 00:23:19,000
அழைப்புகளை இடமாற்று இது, இந்த 1 எடுக்கும் அங்கு ஒரு நகல் வைக்கிறது, அங்கு ஒரு நகல் வைக்கிறது உள்ளது.

424
00:23:19,000 --> 00:23:23,000
>> இடமாற்று 1 மற்ற உள்ளூர் மாறி இருக்கிறது, எனினும், என்ன என்று? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, எனவே, என்னை நானே இங்கே மற்றொரு 32 பிட்கள் வழங்கட்டுமா

426
00:23:27,000 --> 00:23:29,000
நான் இந்த விழாவில் என்ன செய்தாய்?

427
00:23:29,000 --> 00:23:34,000
நான் எண்ணாக tmp ஒரு, ஒரு 1 கொண்டுள்ளது பெறும் என்று, அதனால் நாம் கடைசி இந்த உதாரணம் விளையாடிய போது நான் செய்தேன்.

428
00:23:34,000 --> 00:23:39,000
பின்னர் ப பெறுகிறது, எனவே ப 2, எனவே இப்போது இந்த 2 ஆகிறது,

429
00:23:39,000 --> 00:23:42,000
இப்போது, ப திறக்க போகிறது, அதனால் திறக்க 1

430
00:23:42,000 --> 00:23:44,000
எனவே இப்போது ப இந்த ஆகிறது.

431
00:23:44,000 --> 00:23:46,000
அது மிகவும் நல்லது. அது வேலை.

432
00:23:46,000 --> 00:23:49,000
ஆனால் பின்னர் விரைவில் செயல்பாடு திரும்பக்கிடைக்கிறது

433
00:23:49,000 --> 00:23:52,000
இடமாற்று நினைவு திறம்பட அது மீண்டும் பயன்படுத்த முடியும் என்று மறைந்துவிடும்

434
00:23:52,000 --> 00:23:58,000
எதிர்காலத்தில் வேறு செயல்பாடு மூலம், மற்றும் முக்கிய வெளிப்படையாக முற்றிலும் மாறாமல் உள்ளது.

435
00:23:58,000 --> 00:24:00,000
நாம், அடிப்படையில் இந்த பிரச்சனையை தீர்க்கும் ஒரு வழி வேண்டும்

436
00:24:00,000 --> 00:24:03,000
இன்று நாம் இறுதியாக அதனால் இதை ஒரு வழி வேண்டும்

437
00:24:03,000 --> 00:24:06,000
நாம் ஒரு சுட்டிக்காட்டி என்று ஒன்று அறிமுகப்படுத்த முடியும்.

438
00:24:06,000 --> 00:24:09,000
நாம் இந்த பிரச்சனையை தீர்க்க முடியும் என்று மாறும்

439
00:24:09,000 --> 00:24:12,000
x மற்றும் y பிரதிகளை கடந்து செல்லும் மூலம்

440
00:24:12,000 --> 00:24:18,000
ஆனால் அதற்கு பதிலாக என்ன கடந்து செல்லும் மூலம், நீங்கள் இடமாற்று செயல்பாடு, நினைக்கிறீர்கள்?

441
00:24:18,000 --> 00:24:20,000
சரி, முகவரி பற்றி என்ன?

442
00:24:20,000 --> 00:24:22,000
நாம் உண்மையில், மிகவும் விரிவாக முகவரிகளை பற்றி பேசவே இல்லை

443
00:24:22,000 --> 00:24:25,000
ஆனால் இந்த blackboard என் கணினியின் நினைவகம் குறிக்கிறது என்றால்

444
00:24:25,000 --> 00:24:28,000
நாம் நிச்சயமாக என் RAM இல் பைட்டுகள் எண்ணிக்கையில் தொடங்க முடியும்

445
00:24:28,000 --> 00:24:31,000
இந்த பைட் # 1 என்று, இந்த பைட் # 3, # 2 பைட் ஆகும்

446
00:24:31,000 --> 00:24:35,000
பைட் # 4, பைட் # ... 2 பில்லியன் நான் ரேம் 2 ஜிகாபைட் இருந்தால்,

447
00:24:35,000 --> 00:24:38,000
எனவே நாம் நிச்சயமாக சில தன்னிச்சையான எண் திட்டம் கொண்டு வர முடியும்

448
00:24:38,000 --> 00:24:41,000
என் கணினியின் நினைவகம் உள்ள அனைத்து தனி பைட்டுகள் கிடைக்கும்.

449
00:24:41,000 --> 00:24:43,000
>> நான் இடமாற்று என்ன என்றால், அதற்கு பதிலாக அழைப்பு

450
00:24:43,000 --> 00:24:47,000
x மற்றும் y பிரதிகளை காட்டிலும் பாஸ்

451
00:24:47,000 --> 00:24:51,000
நான் ஏன் பதிலாக, இங்கே x முகவரி உள்ள அனுப்ப வேண்டாம்

452
00:24:51,000 --> 00:24:55,000
இங்கே y முகவரி, அடிப்படையில் அஞ்சல் முகவரி

453
00:24:55,000 --> 00:24:59,000
அவர் தகவல் இருந்தால் x மற்றும் y காரணமாக பின், இடமாற்றம்

454
00:24:59,000 --> 00:25:01,000
x மற்றும் y நினைவாக முகவரி,

455
00:25:01,000 --> 00:25:04,000
நாம் அவரை கொஞ்சம் பயிற்சி என்றால், இடமாற்றம்

456
00:25:04,000 --> 00:25:07,000
அவர் திறன், அதனால் பேச, அந்த முகவரிக்கு ஓட்ட முடியும்

457
00:25:07,000 --> 00:25:11,000
x, மற்றும் அங்கு பல மாற்ற, பின்னர், y முகவரி ஓட்டு

458
00:25:11,000 --> 00:25:16,000
உண்மையில் அந்த மதிப்புகள் தன்னை பிரதிகளை பெற்று கூட போது, அங்கு ஏராளமான மாற்ற,

459
00:25:16,000 --> 00:25:19,000
நாங்கள் முக்கிய நினைவகத்தில் இருப்பதால் இந்த பேசினார் கூட

460
00:25:19,000 --> 00:25:23,000
இந்த நிலையில் இருப்பது இடமாற்று நினைவு சக்திவாய்ந்த மற்றும் சி ஆபத்தான பகுதியாக

461
00:25:23,000 --> 00:25:28,000
எந்த செயல்பாடு, எங்கும் கணினியில் நினைவக தொடக்கூடாது என்று

462
00:25:28,000 --> 00:25:32,000
இந்த நீங்கள் சி கணினி நிரல்கள் மிக ஆடம்பரமான விஷயங்களை செய்ய முடியும் என்று சக்திவாய்ந்த உள்ளது

463
00:25:32,000 --> 00:25:36,000
நீங்கள் மிகவும் எளிதாக வரை திருகு ஏனெனில் இந்த ஆபத்தானது.

464
00:25:36,000 --> 00:25:39,000
உண்மையில், திட்டங்கள் மிகவும் பொதுவான வழிகளில் இந்த நாட்களில் ஒரு நாள் பயன்படுத்தி வேண்டும்

465
00:25:39,000 --> 00:25:42,000
ஒரு ப்ரோக்ராமர் உணர முடியவில்லை என்று உள்ளது

466
00:25:42,000 --> 00:25:45,000
அவர் ஒரு தரவு அனுமதிக்கிறது என்று

467
00:25:45,000 --> 00:25:49,000
நோக்கம் இல்லை என்று நினைவகத்தில் இடம் எழுதப்பட்ட வேண்டும்.

468
00:25:49,000 --> 00:25:51,000
>> உதாரணமாக, அவர் அளவு 10 அணிவரிசை அறிவிக்கிறது

469
00:25:51,000 --> 00:25:56,000
ஆனால் பின்னர் தற்செயலாக, நினைவகம் என்று வரிசையாக சென்று 11 பைட்டுகள் வைக்க முயற்சி

470
00:25:56,000 --> 00:25:59,000
நீங்கள் இனி செல்லாது என்று நினைவக பகுதிகள் தொட்டு தொடங்கும்.

471
00:25:59,000 --> 00:26:02,000
ஒரு சூழ்நிலை இந்த, நீங்கள் சில தெரியும் என்று

472
00:26:02,000 --> 00:26:06,000
மென்பொருள் பெரும்பாலும், தொடர் எண்கள் அல்லது பதிவு விசைகளை கேட்கும்

473
00:26:06,000 --> 00:26:08,000
ஃபோட்டோஷாப் மற்றும் வேர்ட் மற்றும் இதை போன்ற திட்டங்கள்.

474
00:26:08,000 --> 00:26:12,000
, நீங்கள் ஒரு சிறிய நிரலை ஆன்லைன் அங்கு, நீங்கள் சில தெரியும், பிளவுகள் இருக்கின்றன

475
00:26:12,000 --> 00:26:14,000
மற்றும் voila, ஒரு வரிசை எண் எந்த கோரிக்கை.

476
00:26:14,000 --> 00:26:16,000
என்று எப்படி வேலை செய்கிறது?

477
00:26:16,000 --> 00:26:21,000
பல சந்தர்ப்பங்களில் இந்த விஷயங்களை எளிமையாக கணினிகளில் கண்டுபிடிப்பதில்

478
00:26:21,000 --> 00:26:24,000
கணினியின் உண்மையான பூஜ்ஜியங்களும் ஒன்றுகளும் உரை பகுதிகளை

479
00:26:24,000 --> 00:26:28,000
வரிசை எண் கேட்டு அமைந்துள்ள அந்த விழாவில், எங்கே

480
00:26:28,000 --> 00:26:31,000
இயங்குவதாக போது, நீங்கள் அந்த இடத்தை மேலெழுதும், அல்லது

481
00:26:31,000 --> 00:26:33,000
முக்கிய சேமிக்கப்படும் அமைந்துள்ள நீங்கள் கண்டுபிடிக்க முடியாது

482
00:26:33,000 --> 00:26:37,000
ஏதோ பயன்படுத்தி ஒரு பிழை என்று, நீங்கள் மென்பொருள் என்று வழி வெடிக்க முடியும்.

483
00:26:37,000 --> 00:26:40,000
இந்த, இரு தினங்களில் இந்த எங்கள் நோக்கம் என்று அல்ல

484
00:26:40,000 --> 00:26:42,000
ஆனால் இது மிகவும் உண்மையான உலக கிளைகளை கொண்டுள்ளது.

485
00:26:42,000 --> 00:26:45,000
ஒரு, மென்பொருள் திருட்டு ஈடுபடுத்த நடக்கும் என்று

486
00:26:45,000 --> 00:26:47,000
ஆனால் முழு இயந்திரங்கள் சமரசம் கூட இல்லை.

487
00:26:47,000 --> 00:26:50,000
>> உண்மையில், அந்த இணையதளங்களில் இந்த நாட்களில் பயன்படுத்தி

488
00:26:50,000 --> 00:26:53,000
மற்றும் சமரசம் மற்றும் தரவு கசிந்த மற்றும் கடவுச்சொற்களை திருடப்பட்டிருக்கிறது

489
00:26:53,000 --> 00:26:58,000
இந்த மிக பெரும்பாலும் ஒரு நினைவக மோசமான நிர்வாகம் தொடர்புடையதாக,

490
00:26:58,000 --> 00:27:01,000
அல்லது, தரவுத்தளங்களை வழக்கில், தோல்வி எதிர்பார்க்க

491
00:27:01,000 --> 00:27:03,000
வரும் வாரங்களில் என்று மிகவும் அதிக adversarial உள்ளீடு,,

492
00:27:03,000 --> 00:27:07,000
ஆனால் இப்போது நீங்கள் என்ன செய்ய முடியும் என்று சேதம் மாதிரி ஒரு பதுக்கல் முன்னோட்டமாக

493
00:27:07,000 --> 00:27:11,000
மிகவும் விஷயங்கள் பேட்டை கீழ் வேலை எப்படி புரிந்து மூலம்.

494
00:27:11,000 --> 00:27:14,000
இந்த உடைந்தது ஏன் புரிந்து பற்றி செல்லலாம்

495
00:27:14,000 --> 00:27:17,000
ஒரு கருவி என்று இன்னும் பயனுள்ளதாக இருக்கும்

496
00:27:17,000 --> 00:27:19,000
நமது திட்டங்கள் இன்னும் சிக்கலான கிடைக்கும்.

497
00:27:19,000 --> 00:27:21,000
நீங்கள் உங்கள் திட்டத்தில் ஒரு பிழை என்று இதுவரை போது

498
00:27:21,000 --> 00:27:23,000
எப்படி அதை பிழைத்திருத்தம் பற்றி போயிருந்தாய்?

499
00:27:23,000 --> 00:27:25,000
என்ன உங்கள் நுட்பங்களை உங்கள் TF மூலம் கற்று என்பதை, இதுவரை இருந்திருக்கும்

500
00:27:25,000 --> 00:27:27,000
அல்லது சுய கற்று?

501
00:27:27,000 --> 00:27:29,000
[மாணவர்] Printf.

502
00:27:29,000 --> 00:27:31,000
நீங்கள் பார்க்க விரும்பினால் Printf, அதனால் printf ஒருவேளை அந்த உங்கள் நண்பர் வருகிறது

503
00:27:31,000 --> 00:27:33,000
உங்கள் திட்டத்தின் உள்ளே என்ன நடக்கிறது

504
00:27:33,000 --> 00:27:36,000
நீங்கள் printf இங்கே, printf இங்கே, printf இங்கே வைத்து.

505
00:27:36,000 --> 00:27:38,000
அதை இயக்க, மற்றும் நீங்கள் திரையில் பொருள் ஒரு மொத்தமாக கிடைக்கும்

506
00:27:38,000 --> 00:27:43,000
நீங்கள் உண்மையில் உங்கள் திட்டத்தில் தவறு என்ன ஊகிக்க பயன்படுத்த முடியும்.

507
00:27:43,000 --> 00:27:45,000
>> Printf, மிக சக்தி வாய்ந்த ஒன்று இருக்கிறது

508
00:27:45,000 --> 00:27:47,000
ஆனால் அது ஒரு மிக கையேடு செயல்முறை.

509
00:27:47,000 --> 00:27:49,000
நீங்கள், ஒரு printf இங்கே, இங்கே ஒரு printf போட வேண்டும்

510
00:27:49,000 --> 00:27:51,000
நீங்கள் ஒரு வட்டத்திற்கு உள்ளே வைத்து நீங்கள் 100 வரிகளை வந்துவிடும்

511
00:27:51,000 --> 00:27:53,000
நீங்கள் மூலம் பிரி வேண்டும் என்று வெளியீடு.

512
00:27:53,000 --> 00:27:58,000
இது, பிழைத்திருத்தம் திட்டங்கள் மிகவும் பயனர் நட்பு அல்லது செயல் அமைப்பு அல்ல

513
00:27:58,000 --> 00:28:00,000
ஆனால் அதிர்ஷ்டவசமாக மாற்று உள்ளது.

514
00:28:00,000 --> 00:28:03,000
GDB என உதாரணமாக ஒரு திட்டம்,,, குனு பிழைத்திருத்தி, அங்கு

515
00:28:03,000 --> 00:28:06,000
நீங்கள் அதை பயன்படுத்த எப்படி ஒரு சிறிய இரகசிய உள்ளது.

516
00:28:06,000 --> 00:28:08,000
இது, வெளிப்படையாக ஒரு சிறிய சிக்கல் இருந்தது, ஆனால்

517
00:28:08,000 --> 00:28:11,000
இந்த இந்த வாரம் வைத்து இருந்தால் அந்த விஷயங்கள் ஒரு மற்றும் அடுத்த

518
00:28:11,000 --> 00:28:14,000
GDB போன்ற ஒன்றை புரிந்து கொள்ள கூடுதல் மணி

519
00:28:14,000 --> 00:28:18,000
இது, நீண்ட நாட்களாக நீங்கள் மணி ஒருவேளை கணக்கான சேமிக்கும்

520
00:28:18,000 --> 00:28:21,000
அதனால் உடன், என்னை நீங்கள் இதை எவ்வாறு ஒரு டீஸர் கொடுக்கலாம்.

521
00:28:21,000 --> 00:28:23,000
>> நான் என் முனைய சாளரத்தில் இருக்கிறேன்.

522
00:28:23,000 --> 00:28:26,000
என்னை போய் இந்த திட்டம், buggy3 தொகுக்க வேண்டும்.

523
00:28:26,000 --> 00:28:28,000
அதை தேதி வரை ஏற்கனவே.

524
00:28:28,000 --> 00:28:31,000
நாம் ஒரு போதும் திரும்பி பார்த்து, உண்மையில், அது உடைந்து விட்டது போல எனக்கு இது ஓடிப்போகட்டும்.

525
00:28:31,000 --> 00:28:34,000
ஆனால் ஏன் இந்த? ஒருவேளை நான் இடமாற்று செயல்பாடு வரை ஸ்க்ரீவ்டு.

526
00:28:34,000 --> 00:28:37,000
ஒருவேளை அது ஒரு மற்றும் ப தான். நான் மிகவும் சரியாக அவர்களை சுற்றி நகரும்.

527
00:28:37,000 --> 00:28:39,000
என்னை போய் இதை செய்கிறேன்.

528
00:28:39,000 --> 00:28:43,000
மாறாக தான், என்னை பதிலாக இந்த திட்டம் GDB இயக்க அனுமதிக்க buggy3 ரன்

529
00:28:43,000 --> 00:28:48,000
மற்றும் நான், buggy3 இயக்க அதை சொல்ல போகிறேன்

530
00:28:48,000 --> 00:28:52,000
நான் ஒரு கட்டளை வரி வாதம், டுய், உள்ளிட்ட போகிறேன்

531
00:28:52,000 --> 00:28:55,000
நாம் ஞாபகப்படுத்த ஸ்பெக் எதிர்காலத்தில் பிரச்சினைகள் இந்த வைக்கிறேன்.

532
00:28:55,000 --> 00:28:57,000
இப்போது இந்த கருப்பு மற்றும் வெள்ளை இடைமுகம், மீண்டும், அந்த வெளிவர ஆரம்பித்தது

533
00:28:57,000 --> 00:28:59,000
இந்த உள்ளது, ஏனெனில் முதலில் ஒரு சிறிய பெரும் உள்ளது

534
00:28:59,000 --> 00:29:02,000
இங்கே கீழே உத்தரவாதத்தை தகவல், ஆனால் குறைந்தது பழக்கமான ஒன்று உள்ளது.

535
00:29:02,000 --> 00:29:04,000
சாளரத்தின் மேற்பகுதியில் உள்ள என் உண்மையான குறியீடு உள்ளது

536
00:29:04,000 --> 00:29:08,000
மற்றும் நான் இங்கே மேலே என்றால், எனக்கு என் கோப்பு மிகவும் மேலே உருட்டும் நாம்

537
00:29:08,000 --> 00:29:11,000
உண்மையில், இந்த சாளரத்தை கீழே buggy3.c, மற்றும் அறிவிப்பு இல்லை

538
00:29:11,000 --> 00:29:13,000
நான் இந்த GDB வரியில் உள்ளது.

539
00:29:13,000 --> 00:29:16,000
>> இந்த என் வழக்கமான ஜான் ஹார்வர்ட் வரியில் அதே அல்ல.

540
00:29:16,000 --> 00:29:19,000
இந்த என்னை GDB கட்டுப்படுத்த அனுமதிக்க நடக்கிறது என்று ஒரு வரியில் உள்ளது.

541
00:29:19,000 --> 00:29:21,000
GDB ஒரு பிழை உள்ளது.

542
00:29:21,000 --> 00:29:24,000
ஒரு பிழை நீ வழியாக நடக்க முடியும் என்று ஒரு திட்டம் உள்ளது

543
00:29:24,000 --> 00:29:27,000
வரி மூலம் வரி மூலம் உங்கள் நிரல் வரி நிறைவேற்றுவது,

544
00:29:27,000 --> 00:29:30,000
நீங்கள் நிரல் வேண்டும் எதையும் செய்து சேர்த்து,

545
00:29:30,000 --> 00:29:33,000
கூட, இன்னும் முக்கியமாக, செயல்பாடுகளை அழைப்பு, அல்லது looking

546
00:29:33,000 --> 00:29:35,000
பல்வேறு மாறி மதிப்பு உள்ள.

547
00:29:35,000 --> 00:29:37,000
தான் போய் இதை செய்கிறேன்.

548
00:29:37,000 --> 00:29:40,000
நான், மேலே சென்று GDB ஒரு வரியில் ரன் தட்டச்சு போகிறேன்

549
00:29:40,000 --> 00:29:43,000
நான் தட்டச்சு ரன் நான் திரையில் விட்டு கீழே பார்க்க,

550
00:29:43,000 --> 00:29:45,000
மற்றும் நான் நுழைய வெற்றி, மற்றும் அந்த என்ன செய்தாய்?

551
00:29:45,000 --> 00:29:50,000
அது உண்மையில் என் திட்டத்தை நடத்தியது, ஆனால் நான் உண்மையில் மிக இங்கே சென்று பார்க்க முடியவில்லை

552
00:29:50,000 --> 00:29:55,000
நான் உண்மையில் பிழை சொல்லவில்லை, ஏனெனில்

553
00:29:55,000 --> 00:29:57,000
நேரம் ஒரு குறிப்பிட்ட நேரத்தில் இடைநிறுத்தப்பட்டு.

554
00:29:57,000 --> 00:29:59,000
ஒரு ரன் தட்டச்சு நிரலை இயக்கும்.

555
00:29:59,000 --> 00:30:01,000
நான் உண்மையில் எனக்கு ஒன்றும் தெரியவில்லை. நான் அதை கையாள முடியாது.

556
00:30:01,000 --> 00:30:03,000
>> பதிலாக என்னை இந்த செய்வோம்.

557
00:30:03,000 --> 00:30:08,000
இந்த GDB வரியில் எனக்கு பதிலாக நுழைய, முறித்து தட்டச்சு செய்யலாம்.

558
00:30:08,000 --> 00:30:10,000
என்று நான் தட்டச்சு பொருள் என்ன இல்லை.

559
00:30:10,000 --> 00:30:13,000
முறித்து முக்கிய தட்டச்சு பதிலாக நாம்.

560
00:30:13,000 --> 00:30:15,000
வேறுவிதமாக கூறினால், நான் ஒரு இடைவேளைநேரத்தை என்று ஒன்று, அமைக்க வேண்டும்

561
00:30:15,000 --> 00:30:18,000
அதை உடைக்க அல்லது இடைநிறுத்தம் ஏனெனில் பொருத்தமாக பெயரிடப்பட்டது

562
00:30:18,000 --> 00:30:21,000
அந்த குறிப்பிட்ட இடத்தில் உங்கள் திட்டத்தை செயல்படுத்தும்.

563
00:30:21,000 --> 00:30:23,000
முக்கிய என் செயல்பாடு பெயர்.

564
00:30:23,000 --> 00:30:25,000
GDB கெட்டிக்காரி என்று பாருங்கள்.

565
00:30:25,000 --> 00:30:28,000
இது முக்கிய வரிசை 18 மணிக்கு சுமார் தொடங்க நடக்கும் என்று வந்தார்

566
00:30:28,000 --> 00:30:32,000
buggy3.c பற்றி, பின்னர் மேல் இடது இங்கே கவனிக்க

567
00:30:32,000 --> 00:30:34,000
ப + வரி 18 பக்கத்தில் தான்.

568
00:30:34,000 --> 00:30:38,000
என்று நான் வரி 18 அமைக்கப்படாத என்று எனக்கு நினைவு.

569
00:30:38,000 --> 00:30:42,000
இந்த நேரத்தில் நான் ரன் தட்டச்சு போது, நான் என் நிரலை இயக்க போகிறேன்

570
00:30:42,000 --> 00:30:45,000
மேலே வரை, அந்த இடைவேளைநேரத்தை பலி

571
00:30:45,000 --> 00:30:48,000
எனவே நிரல் வரி 18 மணிக்கு எனக்கு இடைநிறுத்தம் சாப்பிடுவேன்.

572
00:30:48,000 --> 00:30:50,000
இங்கே நாம் போய் ரன்.

573
00:30:50,000 --> 00:30:53,000
எதுவும் நடக்கவில்லை தெரிகிறது, ஆனால் கீழே அறிவிப்பு விட்டு

574
00:30:53,000 --> 00:30:58,000
தொடக்க நிகழ்ச்சியில், buggy3, buggy3.c வரி 18 பிரதான உள்ள இடைவேளைநேரத்தை 1.

575
00:30:58,000 --> 00:31:00,000
நான் இப்போது என்ன செய்ய முடியும்?

576
00:31:00,000 --> 00:31:03,000
>> கவனிக்க நான், அச்சு போன்ற விஷயங்களை தட்டச்சு செய்ய

577
00:31:03,000 --> 00:31:08,000
இல்லை printf, அச்சு x, இப்போது விசித்திரமாக இருக்கிறது.

578
00:31:08,000 --> 00:31:11,000
நாம் பார்க்கலாம் என $ 1, ஒரு ஆர்வத்தை உள்ளது

579
00:31:11,000 --> 00:31:14,000
நீங்கள் ஏதாவது அச்சிட ஒவ்வொரு முறையும் நீங்கள் ஒரு புதிய $ மதிப்பு கிடைக்கும்.

580
00:31:14,000 --> 00:31:18,000
என்று, நீ வழக்கில் முந்தைய மதிப்புகள் திரும்பி பார்க்கவும் முடியாது, அதனால் தான்

581
00:31:18,000 --> 00:31:21,000
ஆனால் இப்போது என்ன அச்சு என்னிடம் உள்ளது என்று கதை இந்த கட்டத்தில் x மதிப்பு

582
00:31:21,000 --> 00:31:26,000
வெளிப்படையாக 134514032 உள்ளது.

583
00:31:26,000 --> 00:31:29,000
என்ன? என்று கூட எங்கிருந்து வந்தது?

584
00:31:29,000 --> 00:31:31,000
[செவிக்கு புலப்படாமல்-மாணவர்]

585
00:31:31,000 --> 00:31:34,000
உண்மையில், இந்த ஒரு குப்பை மதிப்பு அழைக்கிறேன் என்ன, நாம், இன்னும் இது பற்றி பேசவில்லை நான்

586
00:31:34,000 --> 00:31:37,000
ஆனால் நீங்கள் மாறிகள் துவக்க என்று காரணம்

587
00:31:37,000 --> 00:31:40,000
நிச்சயமாக அவர்கள் அவற்றை வேண்டும் என்று சில மதிப்பு என்று.

588
00:31:40,000 --> 00:31:44,000
ஆனால் ப நீங்கள் மாறிகள் அறிவிக்க முடியும் என்று நினைவு

589
00:31:44,000 --> 00:31:46,000
நான் என் சிக்மா எடுத்துக்காட்டாக ஒரு கணம் முன்பு செய்தது போல

590
00:31:46,000 --> 00:31:48,000
உண்மையில் அவர்கள் ஒரு மதிப்பு கொடுக்காமல்.

591
00:31:48,000 --> 00:31:50,000
நான் சிக்மா உள்ள இங்கு என்ன நினைவு.

592
00:31:50,000 --> 00:31:52,000
நான் n அறிவித்தார், ஆனால் நான் என்ன மதிப்பு கொடுக்கலாம்?

593
00:31:52,000 --> 00:31:56,000
யாரும், நான் தெரியும் என்பதால் அடுத்த சில வரிகளில்

594
00:31:56,000 --> 00:31:59,000
GetInt n, உள்ளே ஒரு மதிப்பு வைத்து பிரச்சினையை கவனித்து கொள்கிறேன்.

595
00:31:59,000 --> 00:32:02,000
>> ஆனால் வரி 11 கதை இந்த புள்ளியில்

596
00:32:02,000 --> 00:32:05,000
மற்றும் வரி 12 மற்றும் வரி 13 மற்றும் வரி 14

597
00:32:05,000 --> 00:32:08,000
அந்த பல வரிகளை முழுவதும் n மதிப்பு என்ன?

598
00:32:08,000 --> 00:32:10,000
சி நீ தெரியாது.

599
00:32:10,000 --> 00:32:14,000
பொதுவாக சில குப்பை மதிப்பு, சில முற்றிலும் சீரற்ற எண்

600
00:32:14,000 --> 00:32:17,000
சில முந்தைய செயல்பாட்டை இருந்து அடிப்படையில் மேல் விட்டு அந்த

601
00:32:17,000 --> 00:32:21,000
உங்கள் நிரலை இயக்கும் இதனால், இயக்க

602
00:32:21,000 --> 00:32:24,000
விழாவில் செயல்பாடு, செயல்பாடு, செயல்பாடு கிடைக்குமா என்று நினைவு.

603
00:32:24,000 --> 00:32:27,000
இந்த சட்டங்கள், பின்னர் அந்த செயல்பாடுகளை மீண்டும் நினைவு மீது, மற்றும்

604
00:32:27,000 --> 00:32:31,000
மற்றும் போல் நான் அவர்களுடைய நினைவாற்றல் இறுதியில் பயன்படுத்தும் உள்ளது அழிப்பி கொண்டு கருத்து.

605
00:32:31,000 --> 00:32:37,000
சரி, அது தான் இந்த திட்டத்தில் இந்த மாறி x நடக்கிறது

606
00:32:37,000 --> 00:32:41,000
134514032 போன்ற சில குப்பை மதிப்பு கொண்டிருந்தது தெரிகிறது

607
00:32:41,000 --> 00:32:44,000
சில முந்தைய செயல்பாட்டை இருந்து, இல்லை நான் எழுதியது என்று.

608
00:32:44,000 --> 00:32:47,000
இது, இயக்க அமைப்பு சிறப்பாக வரும் என்று ஒன்று இருக்க முடியும்

609
00:32:47,000 --> 00:32:49,000
பேட்டை அடியில் சில செயல்பாடு.

610
00:32:49,000 --> 00:32:52,000
>> சரி, சரி, ஆனால் அடுத்த வரியில் முன்னெடுக்க இப்போது நாம்.

611
00:32:52,000 --> 00:32:55,000
நான் என் GDB வரியில் "அடுத்த" தட்டச்சு மற்றும் நான், உள்ளிடவும் வெற்றி

612
00:32:55,000 --> 00:32:58,000
கவனிக்க வேண்டும் என்று, வரி 19 நகர்வுகள் கீழே தனிப்படுத்தி

613
00:32:58,000 --> 00:33:01,000
ஆனால் தருக்க உட்குறிப்பு அந்த வரியை 18 ஆகும்

614
00:33:01,000 --> 00:33:06,000
இப்போது முடிந்ததும் நான் மீண்டும் தட்டச்சு நீங்கள், இயக்கும் "அச்சு x"

615
00:33:06,000 --> 00:33:10,000
நான் இப்போது 1 பார்க்க வேண்டும், உண்மையில், நான்.

616
00:33:10,000 --> 00:33:14,000
மீண்டும், $ பொருள் GDB நினைவுகூறுகீறேன் ஒரு வழி

617
00:33:14,000 --> 00:33:17,000
அச்சிட்டு வரலாற்றில் நீங்கள் செய்த என்ன.

618
00:33:17,000 --> 00:33:21,000
, இப்போது என்னை போக மற்றும் y அவுட் அச்சிட விட, உண்மையில், y மற்றும் சில வேடிக்கையான மதிப்பு

619
00:33:21,000 --> 00:33:24,000
ஆனால் பெரிய விஷயமல்ல வரி 19 இல் நாம் அதை ஒதுக்க இருப்பதால்

620
00:33:24,000 --> 00:33:27,000
மதிப்பு 2, என்னை மீண்டும் "அடுத்த" தட்டச்சு செய்யலாம்.

621
00:33:27,000 --> 00:33:29,000
இப்போது நாம் printf வரியில் இருக்கும்.

622
00:33:29,000 --> 00:33:31,000
என்னை அச்சு x செய்வோம்.

623
00:33:31,000 --> 00:33:34,000
என்னை அச்சு y செய்வோம். வெளிப்படையாக, நான் இந்த அச்சிடுதல் ஒரு கொஞ்சம் களைப்பாக இருக்கிறது.

624
00:33:34,000 --> 00:33:38,000
எனக்கு பதிலாக "காட்சி x" மற்றும் "காட்சி y," டைப் செய்யலாம்

625
00:33:38,000 --> 00:33:41,000
இப்போது ஒவ்வொரு முறையும் நான் எதிர்காலத்தில் ஒரு கட்டளையை தட்டச்சு

626
00:33:41,000 --> 00:33:45,000
நான் என்ன நினைவு என்ன x மற்றும் y, x மற்றும் y, x மற்றும் y என்ன.

627
00:33:45,000 --> 00:33:48,000
>> நான் கூட, ஒரு ஒதுக்கி, வகையாக "தகவல் உள்ளூர்."

628
00:33:48,000 --> 00:33:50,000
தகவல் ஒரு சிறப்பு கட்டளை.

629
00:33:50,000 --> 00:33:52,000
உள்ளூர் அது என்னை உள்ளூர் மாறிகள் காட்டுகிறது என்று பொருள்.

630
00:33:52,000 --> 00:33:55,000
நான் மறந்து அல்லது இந்த பைத்தியக்காரன், சிக்கலான செயல்பாடு என்பது தான் வழக்கு

631
00:33:55,000 --> 00:33:57,000
நான் அல்லது வேறு யாராவது தகவல் உள்ளூர் சொல்கிறேன் எழுதினார்

632
00:33:57,000 --> 00:34:00,000
இந்த உள்ளூர் செயல்பாடு உள்ளே அனைத்து உள்ளூர் மாறிகள் என்ன

633
00:34:00,000 --> 00:34:03,000
நீங்கள் சுற்றி குத்தியிருக்கும் விரும்பினால் பற்றி கவலைப்பட என்று.

634
00:34:03,000 --> 00:34:07,000
இப்போது, printf என்னை மேலே மற்றும் வகை செல்லலாம், இயக்க உள்ளது "அடுத்த."

635
00:34:07,000 --> 00:34:10,000
இந்த சூழலில் தான் நாம் உண்மையில் அதை பார்த்து

636
00:34:10,000 --> 00:34:14,000
இங்கே கீழே இயக்கவும், ஆனால் அது இங்கே ஒரு சிறிய mangled போகிறது கவனிக்க.

637
00:34:14,000 --> 00:34:17,000
ஆனால், அங்கு திரையில் overriding நோட்டீஸின்

638
00:34:17,000 --> 00:34:21,000
அதை இங்கே ஒரு சரியான திட்டம் இல்லை, ஆனால் நான் எப்போதும் சுற்றி குத்தியிருக்கும் ஏனெனில் அது பரவாயில்லை

639
00:34:21,000 --> 00:34:23,000
நான் விரும்பினால் அச்சு பயன்படுத்தி.

640
00:34:23,000 --> 00:34:26,000
>> என்னை அடுத்த மீண்டும் தட்டச்சு விட, இப்போது இங்கே சுவாரஸ்யமான பகுதி.

641
00:34:26,000 --> 00:34:29,000
கதை இந்த கட்டத்தில், y 2, மற்றும் x 1

642
00:34:29,000 --> 00:34:32,000
இங்கே கருத்து, மீண்டும், என

643
00:34:32,000 --> 00:34:35,000
நான் கட்டளையை பயன்படுத்தி இந்த தானாகவே இப்போது காண்பிக்கும் என்று காரணம்

644
00:34:35,000 --> 00:34:40,000
காட்சி x மற்றும் காட்சி y, நான் அடுத்த தட்டச்சு இவ்வளவு நேரம்

645
00:34:40,000 --> 00:34:43,000
கோட்பாடு x மற்றும் y உள்ள பண்டமாற்று வேண்டும்.

646
00:34:43,000 --> 00:34:45,000
இப்போது, நாம் ஏற்கனவே வழக்கு இருக்க போவதில்லை என்று எனக்கு தெரியும்,

647
00:34:45,000 --> 00:34:49,000
ஆனால் நாம் அந்த உண்மை ஏன் கண்டுபிடிக்க ஆழ்ந்த டைவ் எப்படி ஒரு நொடியில் பார்க்கலாம்.

648
00:34:49,000 --> 00:34:54,000
துரதிருஷ்டவசமாக அடுத்த, மற்றும், y இன்னும் 2 மற்றும் x இன்னும் 1, மற்றும் நான் எவ்வளவு உறுதிப்படுத்த முடியும்.

649
00:34:54,000 --> 00:34:56,000
அச்சு x, அச்சு y.

650
00:34:56,000 --> 00:34:59,000
உண்மையில், மாற்றம் இல்லை உண்மையில் நடந்தது, இந்த மேல் ஆரம்பிப்போம்.

651
00:34:59,000 --> 00:35:01,000
தெளிவாக இடமாற்று உடைந்துவிட்டது.

652
00:35:01,000 --> 00:35:04,000
அது பதிலாக மீண்டும் "ரன்" தட்டச்சு செய்யலாம்.

653
00:35:04,000 --> 00:35:07,000
எனக்கு சரி என்று நான், நான் ஆரம்பத்தில் இருந்து அதை மீண்டும் துவக்க வேண்டும், உள்ளிடவும்.

654
00:35:07,000 --> 00:35:09,000
>> இப்போது நான் மீண்டும் வரி 18 இருக்கிறேன்.

655
00:35:09,000 --> 00:35:11,000
இப்போது x மற்றும் y மீண்டும் குப்பை மதிப்புகள் கவனிக்க.

656
00:35:11,000 --> 00:35:15,000
, அடுத்த அடுத்த, அடுத்த, அடுத்த.

657
00:35:15,000 --> 00:35:17,000
நான் போர் அடிக்கிறது என்றால் நான் தான் அடுத்த n தட்டச்சு செய்யலாம்.

658
00:35:17,000 --> 00:35:21,000
நீங்கள் எழுத்துக்கள் குறைந்த சாத்தியம் வரிசையை அதை சுருக்கியது முடியும்.

659
00:35:21,000 --> 00:35:23,000
இடமாற்று இப்போது உடைந்துவிட்டது.

660
00:35:23,000 --> 00:35:25,000
அதற்கு பதிலாக அடுத்த தட்டச்சு அதனால், இன் முழுக்கு விட,

661
00:35:25,000 --> 00:35:30,000
நான் இந்த விழாவில் உள்ளே நுழைவதை நான் என்று இப்போது நான் படி தட்டச்சு போகிறேன்

662
00:35:30,000 --> 00:35:33,000
நான் அதை வழியாக நடக்க முடியும் என்று, நான் படி அடித்துவிட்டு பிறகு நுழைய வேண்டும்.

663
00:35:33,000 --> 00:35:37,000
கவனிக்க வரி 36 என் திட்டத்தில் சிறப்பித்த தாவல்கள் கீழே குறைந்த என்று.

664
00:35:37,000 --> 00:35:39,000
இப்போது உள்ளூர் மாறிகள் என்ன?

665
00:35:39,000 --> 00:35:41,000
தகவல் உள்ளூர்.

666
00:35:41,000 --> 00:35:43,000
நாம் அந்த வரியை போகவில்லையா ஏனென்றால் நான் இதுவரை எதுவும்,

667
00:35:43,000 --> 00:35:47,000
எனவே மேலே சென்று சொல்கிறேன் "அடுத்த."

668
00:35:47,000 --> 00:35:50,000
இப்போது நாம் tmp, அச்சு tmp தெரிகிறது.

669
00:35:50,000 --> 00:35:52,000
குப்பை மதிப்பு, சரியான? நான் அப்படி நினைக்கவில்லை.

670
00:35:52,000 --> 00:35:55,000
எப்படி ஒரு, அச்சு ப, 1 மற்றும் 2 அச்சிட?

671
00:35:55,000 --> 00:35:58,000
ஒரு நொடியில், விரைவில் நான் அடுத்த மீண்டும் தட்டச்சு

672
00:35:58,000 --> 00:36:02,000
tmp, வட்டம், 1 ஒரு மதிப்பை நடக்கப்போகிறது

673
00:36:02,000 --> 00:36:05,000
tmp ஒரு மதிப்பு ஒதுக்கப்படுகின்றன போகிறது என்பதால்.

674
00:36:05,000 --> 00:36:08,000
>> இப்போது ஒரு, அச்சு ப அச்சிட செய்வோம்,

675
00:36:08,000 --> 00:36:11,000
ஆனால் இப்போது tmp அச்சிட, அது உண்மையில் 1 தான்.

676
00:36:11,000 --> 00:36:14,000
என்னை அடுத்த செய்வோம். என்னை அடுத்த செய்வோம்.

677
00:36:14,000 --> 00:36:16,000
நான் இடமாற்று செயல்பாடு முடிச்சுட்டேன்.

678
00:36:16,000 --> 00:36:19,000
நான் வரி 40 இல் அது உள்ளே இன்னும் இருக்கிறேன், என்னை ஒரு அச்சிட விட,

679
00:36:19,000 --> 00:36:22,000
அச்சு ப, மற்றும் நான் tmp என்ன கவலை இல்லை.

680
00:36:22,000 --> 00:36:27,000
அது ஒரு மற்றும் ப மாற்றம் வரும் போது இடமாற்று சரியான போல தெரிகிறது.

681
00:36:27,000 --> 00:36:31,000
ஆனால் நான் இப்போது அடுத்த தட்டச்சு செய்தால், நான், வரி 25 மீண்டும் குதித்து

682
00:36:31,000 --> 00:36:34,000
மற்றும் நிச்சயமாக, x மற்றும் அச்சு y நான் வகை என்றால்

683
00:36:34,000 --> 00:36:38,000
அவர்கள் இன்னும் மாறாமல் இருக்கும், நாம் சிக்கல் சரி இல்லை.

684
00:36:38,000 --> 00:36:41,000
ஆனால் நோயறிதலுக்கு இப்போது ஒருவேளை இந்த GDB திட்டத்தின்

685
00:36:41,000 --> 00:36:44,000
நாம் குறைந்தபட்சம் புரிந்து கொள்ள ஒரு படி அருகில் வந்திருக்கிறேன்

686
00:36:44,000 --> 00:36:47,000
என்ன இங்கே ஒரு printf செலுத்துவதன் மூலம் குப்பை நமது குறியீடு இல்லாமல் தவறு நடக்கிறது,

687
00:36:47,000 --> 00:36:50,000
printf இங்கே, printf இங்கே மீண்டும் மீண்டும் இயங்கும்

688
00:36:50,000 --> 00:36:52,000
தவறு என்ன நடக்கிறது கண்டுபிடிக்க முயற்சி.

689
00:36:52,000 --> 00:36:55,000
>> நான் விட்டு ஒட்டுமொத்தமாக போய் இந்த வெளியே விட்டு போகிறேன்.

690
00:36:55,000 --> 00:36:57,000
அது என்ன நடக்கிறது, "எப்படியும் வெளியேறு?" ஆம்.

691
00:36:57,000 --> 00:37:00,000
இப்போது நான் என் வழக்கமான வரியில் திரும்பி இருக்கிறேன், மற்றும் நான் GDB பயன்படுத்தி செய்து வருகிறேன்.

692
00:37:00,000 --> 00:37:03,000
ஒரு ஒதுக்கி, நீங்கள் இந்த டுய் கொடி பயன்படுத்த தேவையில்லை.

693
00:37:03,000 --> 00:37:07,000
அதை தவிர்த்து விட்டால் உண்மையில், நீங்கள் அடிப்படையில் திரையின் கீழ் பாதி கிடைக்கும்.

694
00:37:07,000 --> 00:37:11,000
நான் ரன் பின்னர் முறித்து முக்கிய தட்டச்சு மற்றும் இருந்தால்

695
00:37:11,000 --> 00:37:15,000
நான் இன்னும் என் நிரலை இயக்க, ஆனால் என்ன செய்வேன் மேலும் உரையால் தான் முடியும்

696
00:37:15,000 --> 00:37:18,000
ஒரு நேரத்தில் என்னை தற்போதைய வரி ஒரு காட்டு.

697
00:37:18,000 --> 00:37:21,000
-டுய், உரை பயனர் இடைமுகம்,

698
00:37:21,000 --> 00:37:25,000
நீங்கள் ஒரு முறை, அநேகமாக ஒரு பிட் கருத்துருவில் எளிதாக இருக்கும் நிரலை இன்னும் காட்டுகிறது.

699
00:37:25,000 --> 00:37:27,000
ஆனால் உண்மையில், நான், அடுத்த அடுத்த, அடுத்த என்ன செய்ய முடியும்

700
00:37:27,000 --> 00:37:30,000
நான் ஒரு நேரத்தில் ஒரு வரியை பார்க்க போகிறேன், நான் உண்மையில் என்ன நடக்கிறது பார்க்க விரும்பினால்

701
00:37:30,000 --> 00:37:35,000
நான் பட்டியல் தட்டச்சு மற்றும் அண்டை வரிகளை ஒரு மொத்தமாக பார்க்க முடியும்.

702
00:37:35,000 --> 00:37:39,000
>> நாம் சிக்கல் 3 அமைக்கிறது நீங்கள் பார்க்கலாம் என்று கேட்டேன் என்று ஒரு வீடியோ உள்ளது

703
00:37:39,000 --> 00:37:43,000
இதில் நேட், GDB சிக்கல்களை சில மூடுகிறது

704
00:37:43,000 --> 00:37:46,000
இந்த, நேர்மையாக, அந்த பொருட்களை ஒன்றாக எங்கே நீங்கள் சில சாரமற்றதல்லாத சதவீதம்

705
00:37:46,000 --> 00:37:49,000
GDB தொடமாட்டேன், மற்றும் ஒரு கெட்ட விஷயம் இருக்க வேண்டும்

706
00:37:49,000 --> 00:37:53,000
உண்மையில் இந்த கல்வியாண்டிற்கு பிறகு அதிக நேரம் செலவழித்து இறுதியில் ஏனெனில்

707
00:37:53,000 --> 00:37:56,000
பிழைகள் கீழே துரத்துவதை பின்னர் நீங்கள் அந்த அரை மணி நேரம் / மணி வைக்க வேண்டும்

708
00:37:56,000 --> 00:38:00,000
இந்த வாரம் அடுத்த கற்றல் GDB வசதியாக பெற.

709
00:38:00,000 --> 00:38:02,000
Printf உங்கள் நண்பர் இருந்தார்.

710
00:38:02,000 --> 00:38:05,000
GDB இப்போது உங்கள் நண்பர் இருக்க வேண்டும்.

711
00:38:05,000 --> 00:38:08,000
>> GDB எந்த கேள்விகள்?

712
00:38:08,000 --> 00:38:12,000
இங்கு மிகவும் சக்திவாய்ந்த மற்றும் பயனுள்ள கட்டளைகளை சில விரைவான பட்டியல்.

713
00:38:12,000 --> 00:38:15,000
Yeah. >> நீங்கள் ஒரு சரம் அச்சிட முடியுமா?

714
00:38:15,000 --> 00:38:17,000
நீங்கள் ஒரு சரம் அச்சிட முடியுமா? முற்றிலும்.

715
00:38:17,000 --> 00:38:19,000
அது முழு இருக்க வேண்டும் இல்லை.

716
00:38:19,000 --> 00:38:22,000
ஒரு மாறி கள் அச்சு கள் தான் வகை ஒரு சரம் இருந்தால்.

717
00:38:22,000 --> 00:38:24,000
அது சரம் மாறி என்ன நீங்கள் காட்டும்.

718
00:38:24,000 --> 00:38:26,000
[செவிக்கு புலப்படாமல்-மாணவர்]

719
00:38:26,000 --> 00:38:28,000
அதை நீங்கள் முகவரி மற்றும் சரம் தன்னை கொடுக்கும்.

720
00:38:28,000 --> 00:38:32,000
நீங்கள் இருவரும் காண்பிக்கும்.

721
00:38:32,000 --> 00:38:34,000
மற்றும் ஒரு கடைசி விஷயம், தான் இந்த மிக எனக்கு நல்ல என்பதால்.

722
00:38:34,000 --> 00:38:37,000
Backtrace மற்றும் சட்ட, என்னை இந்த கடைசி நேரம் வரை டைவ் நாம்

723
00:38:37,000 --> 00:38:39,000
GDB அதே சரியான திட்டம்.

724
00:38:39,000 --> 00:38:44,000
என்னை போய் உரை பயனர் இடைமுகம் பதிப்பு ஓடிப்போகட்டும்,

725
00:38:44,000 --> 00:38:46,000
முக்கிய உடைத்து.

726
00:38:46,000 --> 00:38:49,000
என்னை போய் மீண்டும் இயக்க வேண்டும். இங்கே நான்.

727
00:38:49,000 --> 00:38:55,000
இப்போது எனக்கு, அடுத்த அடுத்த, அடுத்த, அடுத்த, அடுத்த செல்லலாம், படி, உள்ளிடவும்.

728
00:38:55,000 --> 00:39:00,000
>> இப்போது நான் வேண்டுமென்றே இடமாற்று இப்போது நான் நினைக்கிறேன், ஆனால் நான் அப்படி இல்லை "அடடா, x மதிப்பு என்ன?"

729
00:39:00,000 --> 00:39:02,000
நான் இனி x செய்ய முடியாது.

730
00:39:02,000 --> 00:39:05,000
அவர்கள் நோக்கம் இல்லை, ஏனெனில் நான் y செய்ய முடியாது.

731
00:39:05,000 --> 00:39:07,000
அவர்கள் பின்னணியில் தான், ஆனால் எந்த பிரச்சனையும் இல்லை.

732
00:39:07,000 --> 00:39:09,000
நான் backtrace தட்டச்சு செய்யலாம்.

733
00:39:09,000 --> 00:39:13,000
என்று என்னை நேரத்தில் இந்த புள்ளி வரை இயக்க வேண்டும் என்று செயல்பட்டு அனைத்து காட்டுகிறது.

734
00:39:13,000 --> 00:39:16,000
கவனிக்க பிரதான முக்கிய கீழே ஒரு, கோடுகள் வரை

735
00:39:16,000 --> 00:39:18,000
இங்கே எங்கள் படத்திற்கு கீழே இருப்பது.

736
00:39:18,000 --> 00:39:22,000
இடமாற்று இடமாற்று இங்கே நினைவகத்தில் அது மேலே இருப்பது வரை இது வரிகளை மேலே என்று உண்மையில்,

737
00:39:22,000 --> 00:39:26,000
மற்றும் நான் தற்காலிகமாக முக்கிய திரும்ப பெற விரும்பினால் நான் "ஃப்ரேம்." சொல்ல முடியாது

738
00:39:26,000 --> 00:39:30,000
என்ன எண்? முக்கிய சட்ட # 1 ஆகும்.

739
00:39:30,000 --> 00:39:32,000
நான் போய் சொல்ல போகிறேன் "ஃப்ரேம் 1."

740
00:39:32,000 --> 00:39:36,000
>> இப்போது நான் முக்கிய நான் திரும்ப, நான் x அச்சிட முடியாது, நான், y அச்சிட முடியாது

741
00:39:36,000 --> 00:39:40,000
ஆனால் நான் ஒரு அல்லது ப அச்சிட முடியாது.

742
00:39:40,000 --> 00:39:43,000
நான் சொன்னால் ஆனால் நான், "சரி, ஒரு நிமிடம். எங்கே இடமாற்று இருந்தது?" முடியும்

743
00:39:43,000 --> 00:39:46,000
என்னை போய் சொல்லட்டும் "ஃப்ரேம் 0."

744
00:39:46,000 --> 00:39:48,000
இப்போது நான், நான் இருக்க விரும்பவில்லை அங்கு திரும்பி இருக்கிறேன், மற்றும் ஒரு ஒதுக்கி போன்ற

745
00:39:48,000 --> 00:39:52,000
நீங்கள் உண்மையிலேயே சலித்து தட்டச்சு அடுத்த, அடுத்த, அடுத்த, அடுத்த பெறுகிறீர்கள் என்றால் மற்ற கட்டளைகள், மிக இல்லை

746
00:39:52,000 --> 00:39:56,000
நீங்கள் பொதுவாக ", அடுத்த 10" போன்ற விஷயங்களை சொல்ல முடியும் என்பதை அடுத்த 10 வரிசைகள் வழியாக செல்லும்.

747
00:39:56,000 --> 00:39:59,000
நீங்கள் உண்மையில் அது வழியாக நுழைவதை உடன் நொந்துப்போகிற போது "தொடர்ந்து" எழுத முடியும்.

748
00:39:59,000 --> 00:40:05,000
இது மற்றொரு இடைவேளைநேரத்தை எம் வரை தொடர்ந்து, இடையூறின்றி உங்கள் நிரலை

749
00:40:05,000 --> 00:40:07,000
ஒரு வட்டத்திற்கு அல்லது உங்கள் திட்டத்தில் கீழே குறையும்.

750
00:40:07,000 --> 00:40:11,000
>> இந்த வழக்கில் நாம் இறுதியில் தொடர்ந்து, மற்றும் நிரல் பொதுவாக வெளியேறிவிட்டது.

751
00:40:11,000 --> 00:40:13,000
இந்த ஒரு ஆடம்பரமான முறையில், தாழ்ந்த செயலாகும்.

752
00:40:13,000 --> 00:40:16,000
உங்கள் திட்டம் பொதுவாக வெளியேறிவிட்டது.

753
00:40:16,000 --> 00:40:24,000
வீடியோ மற்றும் வருவதற்கு அமர்வுகள் பிழைத்திருத்தம் என்று மேலும்.

754
00:40:24,000 --> 00:40:26,000
என்று நிறைய இருந்தது.

755
00:40:26,000 --> 00:40:35,000
நாம் இங்கே நம் 5 நிமிட இடைவேளை எடுத்து, மற்றும் நாம் structs மற்றும் கோப்புகள் தருகிறேன்.

756
00:40:35,000 --> 00:40:38,000
>> நீங்கள் ஏற்கனவே இந்த வாரம் pset கொண்டு dived இருந்தால்

757
00:40:38,000 --> 00:40:41,000
நீங்கள், நாங்கள் விநியோகம் குறியீடு பயன்படுத்த தெரியவரும்

758
00:40:41,000 --> 00:40:45,000
நாம் ஒரு தொடக்க புள்ளியாக, சில புதிய உத்திகள் உங்களுக்கு வழங்கும் மூல குறியீடு.

759
00:40:45,000 --> 00:40:50,000
குறிப்பாக, நாம், கட்டமைப்புக்கான, struct என்று இந்த புதிய சொல் அறிமுகம்

760
00:40:50,000 --> 00:40:53,000
அதனால் நாம் வகையான தனிப்பயனாக்கப்பட்ட மாறிகள் உருவாக்க முடியும்.

761
00:40:53,000 --> 00:40:57,000
நாங்கள், கோப்பு நான் / ஓ, கோப்பு உள்ளீடு மற்றும் வெளியீடு கருத்தை அறிமுகப்படுத்தப்பட்டது

762
00:40:57,000 --> 00:41:00,000
இந்த நாங்கள் மாநில சேமிக்க முடியும் என்று

763
00:41:00,000 --> 00:41:03,000
உங்கள் போராட்டம் குழுவின் வட்டில் ஒரு கோப்பு

764
00:41:03,000 --> 00:41:06,000
ஆசிரியர் கூட்டாளிகள் மற்றும் நான் புரிந்து கொள்ள முடியும் என்று

765
00:41:06,000 --> 00:41:09,000
என்ன கைமுறையாக விளையாட இல்லாமல் உங்கள் திட்டத்தின் உள்ளே நடக்கிறது

766
00:41:09,000 --> 00:41:11,000
போராட்டம் விளையாட்டுக்கள் டஜன் கணக்கான.

767
00:41:11,000 --> 00:41:13,000
நாம் இன்னும் automatedly இதை செய்ய முடியும்.

768
00:41:13,000 --> 00:41:18,000
>> ஒரு struct இந்த யோசனை மிகவும் கட்டாயமான சிக்கலை தீர்க்கிறான்.

769
00:41:18,000 --> 00:41:21,000
நாம் சில திட்டத்தை செயல்படுத்த வேண்டும் என்று நினைக்கிறேன்

770
00:41:21,000 --> 00:41:25,000
என்று எப்படியோ, மாணவர்கள் தகவல்களை கண்காணிக்கும்

771
00:41:25,000 --> 00:41:28,000
மற்றும் மாணவர்கள், உதாரணமாக, ஒரு பெயர் ஒரு ஐடி வேண்டும்

772
00:41:28,000 --> 00:41:31,000
மற்றும் ஹார்வர்ட் போன்ற ஒரு இடத்தில் ஒரு வீட்டில், அதனால் இந்த தகவல்களை 3 படுகின்றன

773
00:41:31,000 --> 00:41:34,000
நாங்கள் சுற்றி வைக்க வேண்டும், என்னை போய் இங்கே ஒரு சிறிய நிரல் எழுத ஆரம்பிக்கலாம்,

774
00:41:34,000 --> 00:41:38,000
stdio.h அடங்கும்.

775
00:41:38,000 --> 00:41:42,000
என்னை cs50.h. அடங்கும் செய்வோம்

776
00:41:42,000 --> 00:41:44,000
பின்னர் என் முக்கிய செயல்பாடு தொடங்கும்.

777
00:41:44,000 --> 00:41:46,000
நான், எந்த கட்டளை வரி அளவுருக்களை கொண்டு தொந்தரவு செய்யமாட்டேன்

778
00:41:46,000 --> 00:41:49,000
இங்கு நான் ஒரு மாணவர் வேண்டும், அதனால் நான் சொல்ல போகிறேன்

779
00:41:49,000 --> 00:41:54,000
ஒரு மாணவர் ஒரு பெயர் உண்டு, அதை நான் சொல்ல போகிறேன் "சரம் பெயர்."

780
00:41:54,000 --> 00:41:59,000
நான், ஒரு மாணவர் கூட, அதனால் எண்ணாக ஐடி அடையாள உள்ளது என்று போகிறேன்

781
00:41:59,000 --> 00:42:03,000
மற்றும் ஒரு மாணவர் ஒரு வீடு உள்ளது, அதனால் நான் சொல்ல போகிறேன் "சரம் வீடு."

782
00:42:03,000 --> 00:42:06,000
நான் இந்த மாதிரி இன்னும் தெளிவாக இந்த ஒரு சிறிய கூறலாம்.

783
00:42:06,000 --> 00:42:11,000
சரி, இப்போது நான், "ஒரு மாணவர்." இது ஒரு மாணவர் பிரதிநிதித்துவம் 3 மாறிகள் வேண்டும்

784
00:42:11,000 --> 00:42:15,000
>> இப்போது நான் இந்த மதிப்புகள் விரிவுப்படுத்த வேண்டும், என்னை போல் மேலே சென்று சொல்கிறேன்

785
00:42:15,000 --> 00:42:18,000
"Id = 123."

786
00:42:18,000 --> 00:42:21,000
பெயர் டேவிட் போகிறது.

787
00:42:21,000 --> 00:42:24,000
நாம் வீட்டில், மாதர் போகிறார் என்று சொல்ல

788
00:42:24,000 --> 00:42:31,000
மற்றும் நான் ("% கள், தன்னிச்சையாக printf போன்ற ஏதாவது செய்ய போகிறேன்

789
00:42:31,000 --> 00:42:37,000
யாருடைய அடையாள% d,% s இல் வாழ்கிறார்.

790
00:42:37,000 --> 00:42:41,000
இப்போது, நான், இங்கே உள்ள அடைப்பை மற்ற பின் ஒன்றாக என்ன வேண்டும்?

791
00:42:41,000 --> 00:42:47,000
பெயர், இனம், வீட்டின்; திரும்ப 0.

792
00:42:47,000 --> 00:42:50,000
சரி, வரை நான் எங்காவது இங்கு ஸ்க்ரீவ்டு

793
00:42:50,000 --> 00:42:54,000
நான் ஒரு மாணவர் சேமித்து ஒரு நல்ல திட்டம் இல்லை என்று.

794
00:42:54,000 --> 00:42:57,000
நிச்சயமாக, இந்த அனைத்து அந்த சுவாரஸ்யமான அல்ல. என்ன நான் 2 மாணவர்கள் வேண்டும் என்றால்?

795
00:42:57,000 --> 00:42:59,000
பெரிய விஷயமல்ல என்று. நான் 2 பேர் ஆதரவு முடியும்.

796
00:42:59,000 --> 00:43:03,000
என்னை போய் இந்த தேர்வு இங்கே கீழே போகலாம்,

797
00:43:03,000 --> 00:43:09,000
நான் கிர்க்லாண்ட் யார் ராப் போன்ற யாராவது "id = 456" சொல்ல முடியாது.

798
00:43:09,000 --> 00:43:12,000
>> சரி, காத்திருந்து, ஆனால் நான் இந்த அதையே அழைக்க முடியாது

799
00:43:12,000 --> 00:43:15,000
நான் இந்த நகலெடுக்க வேண்டும் போல் இருக்கிறது,

800
00:43:15,000 --> 00:43:19,000
என்னை இந்த டேவிட் மாறிகள் என்று சொல்கிறேன்,

801
00:43:19,000 --> 00:43:23,000
என்னை ராப் இந்த சில பிரதிகளை வைக்கலாம்.

802
00:43:23,000 --> 00:43:27,000
நாம் இந்த ராப் தான் அழைக்கிறேன் ஆனால் இந்த இப்போது வேலை செய்ய போவதில்லை

803
00:43:27,000 --> 00:43:33,000
நான் காத்திருக்க வேண்டும், ஏனெனில், அது NAME1 மற்றும் house1, id1 என்னை மாற்ற வேண்டும்.

804
00:43:33,000 --> 00:43:35,000
ராப், 2 2 இருக்கும்.

805
00:43:35,000 --> 00:43:42,000
நான் இங்கே, இங்கே, இங்கே, இங்கே, இங்கே, இங்கே இந்த மாற்ற வேண்டும்.

806
00:43:42,000 --> 00:43:45,000
காத்திருக்க, என்ன டாமி பற்றி? மீண்டும் இந்த செய்வோம்.

807
00:43:45,000 --> 00:43:49,000
நீங்கள் இன்னும் இந்த இதை ஒரு நல்ல வழி என்று வெளிப்படையாக இருந்தால், அது, இல்லை

808
00:43:49,000 --> 00:43:52,000
எனவே நகலெடுக்க / கெட்ட ஒட்டவும்.

809
00:43:52,000 --> 00:43:55,000
ஆனால் நாம் ஒரு வாரம் முன்பு இந்த தீர்த்தார்.

810
00:43:55,000 --> 00:43:59,000
>> நாம் அதே தரவு வகை பல நிகழ்வுகளை வைத்திருக்க விரும்பினேன் போது நம் தீர்வு என்ன?

811
00:43:59,000 --> 00:44:01,000
[மாணவர்கள்] ஒரு வரிசை.

812
00:44:01,000 --> 00:44:03,000
ஒரு வரிசை, என்னை இதை சுத்தம் செய்ய முயற்சி செய்வோம்.

813
00:44:03,000 --> 00:44:07,000
என்னை மேலே நானே சில அறை செய்ய, மற்றும் எனக்கு பதிலாக இங்கே இதை விட்டு.

814
00:44:07,000 --> 00:44:12,000
நாம் இந்த மக்கள் அழைக்கிறேன், மற்றும் அதற்கு பதிலாக நான் ", int ஐடிகள்" என்று போகிறேன்

815
00:44:12,000 --> 00:44:14,000
நான் இப்போது நம் 3 ஆதரவு போகிறேன்.

816
00:44:14,000 --> 00:44:18,000
நான், ", சரம் பெயர்கள்" என்று நான் நம் 3 ஆதரவாக இருப்பேன் செல்கிறேன்

817
00:44:18,000 --> 00:44:22,000
பின்னர் நான் ", சரம் வீடுகள்" என்று நான் நம் 3 ஆதரவு போகிறேன் செல்கிறேன்.

818
00:44:22,000 --> 00:44:26,000
இப்போது இங்கே பதிலாக டேவிட் தனது சொந்த உள்ளூர் மாறிகள் பெறுவதில் உள்ள

819
00:44:26,000 --> 00:44:28,000
நாம் அந்த விடுபட முடியும்.

820
00:44:28,000 --> 00:44:30,000
என்று நாம் இந்த சுத்தம் என்று நன்றாக.

821
00:44:30,000 --> 00:44:35,000
நான் டேவிட் [0] மற்றும் பெயர்கள் [0] இருக்கும் என்று சொல்லலாம்

822
00:44:35,000 --> 00:44:38,000
மற்றும் வீடுகள் [0].

823
00:44:38,000 --> 00:44:41,000
மற்றும் நாம் இதேபோல் இந்த சேமிக்க முடியும் ராப்.

824
00:44:41,000 --> 00:44:46,000
இந்த கீழே இங்கே வைக்கிறேன், அதனால் அவர் தன்னிச்சையாக ஐடிகள் [1] இருக்க போகிறது.

825
00:44:46,000 --> 00:44:50,000
அவர் பெயர்கள் இருக்க போகிறது [1],

826
00:44:50,000 --> 00:44:53,000
பின்னர் இறுதியாக, வீடுகள் [1].

827
00:44:53,000 --> 00:44:57,000
>> , இன்னும் கொஞ்சம் சிரமமான, இப்போது நான் இந்த கண்டுபிடிக்க வேண்டும்

828
00:44:57,000 --> 00:45:03,000
அப்படி நாம் "பெயர்கள் [0], அடையாள [0], வீடுகள் [0],

829
00:45:03,000 --> 00:45:06,000
மற்றும் இந்த pluralize நாம்.

830
00:45:06,000 --> 00:45:09,000
ஐடி, ஐடி, ஐடி.

831
00:45:09,000 --> 00:45:12,000
மீண்டும், நான் அதை செய்கிறேன், அதனால் மீண்டும், நான் ஏற்கனவே, மீண்டும் ஒட்டவும் / நகலெடுக்க ஈடுபடுகிறார்கள்

832
00:45:12,000 --> 00:45:14,000
எனவே முரண்பாடுகள் மற்றொரு தீர்வு இங்கு இருக்கிறாய்.

833
00:45:14,000 --> 00:45:18,000
நான் ஒருவேளை, அப்படி ஒரு சுழற்சி அல்லது ஏதாவது கொண்டு மேலும் இந்த சுத்தம் செய்யலாம்

834
00:45:18,000 --> 00:45:21,000
எனவே சுருக்கமாக, இது ஒரு சிறிய நல்லது ஆனால் இன்னமும் உணர்கிறார்

835
00:45:21,000 --> 00:45:24,000
, நான் ஒட்டவும் / நகலெடுக்க ஈடுபடுகிறார்கள், ஆனால், இந்த கூட, நான் கூறுவது

836
00:45:24,000 --> 00:45:27,000
உண்மையில் அடிப்படையில் சரியான தீர்வு அல்ல, ஏனெனில்

837
00:45:27,000 --> 00:45:29,000
சிறிது நாம் முடிவு செய்தால் நீங்கள் என்ன தெரியுமா?

838
00:45:29,000 --> 00:45:32,000
நாம் உண்மையில் டேவிட் மற்றும் ராப் மின்னஞ்சல் முகவரிகளை சேமித்து

839
00:45:32,000 --> 00:45:34,000
இந்த திட்டத்தில் அனைவரும்.

840
00:45:34,000 --> 00:45:36,000
நாங்கள் தொலைபேசி எண்கள் சேமிக்க வேண்டும்.

841
00:45:36,000 --> 00:45:39,000
நாங்கள் அவசரகால தொடர்பு எண்கள் சேமிக்க வேண்டும்.

842
00:45:39,000 --> 00:45:41,000
நாம், நாம் சேமிக்க வேண்டும் என்று தரவு இந்த துண்டுகளை வேண்டும்

843
00:45:41,000 --> 00:45:43,000
எனவே எப்படி என்று செய்து பற்றி போவேன்?

844
00:45:43,000 --> 00:45:46,000
>> நீங்கள் மேலே மற்றொரு அணி அறிவிக்க, மற்றும் நீங்கள் கைமுறையாக சேர்க்க

845
00:45:46,000 --> 00:45:49,000
ஒரு மின்னஞ்சல் முகவரியை [0], மின்னஞ்சல் முகவரியை [1]

846
00:45:49,000 --> 00:45:51,000
டேவிட் மற்றும் ராப் மற்றும் மிகவும் முன்னும் பின்னும்.

847
00:45:51,000 --> 00:45:56,000
ஆனால் இந்த வடிவமைப்பு அடித்தளத்தில் ஒரு அனுமானத்தின் உண்மையில் அங்கு

848
00:45:56,000 --> 00:45:59,000
நான் என்று கௌரவம் கணினியை பயன்படுத்தி என்று

849
00:45:59,000 --> 00:46:03,000
[நான்] பல வரிசைகள் ஒவ்வொரு

850
00:46:03,000 --> 00:46:06,000
அவ்வளவு தான், அதே நபர் பார்க்கவும் நடக்கிறது

851
00:46:06,000 --> 00:46:10,000
எனவே [0] ஐடிகள் உள்ள எண் 123, இல்லை

852
00:46:10,000 --> 00:46:13,000
நான் அந்த பெயர்களை கருதி போகிறேன் [0]

853
00:46:13,000 --> 00:46:16,000
அதே நபரின் பெயர் மற்றும் வீடுகள் [0]

854
00:46:16,000 --> 00:46:21,000
நான் உருவாக்க பல்வேறு அணிகளை அனைத்து அதே நபரின் வீடு மற்றும் முன்னும் பின்னுமாக இருக்கும்.

855
00:46:21,000 --> 00:46:24,000
ஆனால் அடிப்படை தொடர்பு இல்லை என்று அறிவிப்பு

856
00:46:24,000 --> 00:46:27,000
தகவல், ஐடி, பெயர் மற்றும் வீட்டின் அந்த 3 துண்டுகளாக மத்தியில்,

857
00:46:27,000 --> 00:46:32,000
நாம் இந்த திட்டத்தில் மாதிரி முயற்சிக்கும் நிறுவனம் வரிசைகள் அல்ல கூட.

858
00:46:32,000 --> 00:46:35,000
வரிசைகள் இதை இந்த வேலைத்திட்ட வழியாகும்.

859
00:46:35,000 --> 00:46:38,000
நாம் உண்மையில் நம் திட்டத்தில் மாடல் என்ன ஒரு நபர்

860
00:46:38,000 --> 00:46:41,000
டேவிட், இதில் உள்ளே ராப் போன்ற ஒரு நபர் போன்ற

861
00:46:41,000 --> 00:46:46,000
அல்லது பறைசாற்றுகின்றார் ஒரு பெயர் மற்றும் அடையாள ஒரு வீடு.

862
00:46:46,000 --> 00:46:49,000
>> நாம் எப்படியாவது கூட்டடைவு இந்த கருத்தை வெளிப்படுத்த முடியும்

863
00:46:49,000 --> 00:46:52,000
ஒரு நபர் ஒரு அடையாள, ஒரு பெயர் மற்றும் ஒரு வீடு உள்ளது மேற்கொள்கின்ற

864
00:46:52,000 --> 00:46:55,000
உண்மையில் இந்த ஹேக் நாட முடியாது ஆகையால் நாம் தான்

865
00:46:55,000 --> 00:46:58,000
அந்த அடைப்புக்குறி ஏதாவது நம்பிக்கை

866
00:46:58,000 --> 00:47:02,000
இந்த முற்றிலும் வேறான வரிசைகள் ஒவ்வொரு அதே மனித நிறுவனம் குறிக்கிறது?

867
00:47:02,000 --> 00:47:04,000
நாம் உண்மையில் இதை செய்ய முடியும்.

868
00:47:04,000 --> 00:47:08,000
எனக்கு இப்போது மேலே முக்கிய போய், என் சொந்த தரவு வகை உருவாக்க விட்டு

869
00:47:08,000 --> 00:47:10,000
முதல் முறையாக உண்மையில் இது.

870
00:47:10,000 --> 00:47:14,000
நாங்கள், போராட்டம், இந்த தொழில் நுட்பம் பயன்படுத்தப்படுகிறது

871
00:47:14,000 --> 00:47:17,000
ஆனால் இங்கே நான், மேலே சென்று ஒரு தரவு வகையை உருவாக்க போகிறேன்

872
00:47:17,000 --> 00:47:19,000
நீங்கள் என்ன, நான், அதை மாணவர் அல்லது அழைக்க போகிறேன்

873
00:47:19,000 --> 00:47:23,000
நான் ஒரு வகை வரையறை செய்ய typedef பயன்படுத்த போகிறேன்.

874
00:47:23,000 --> 00:47:25,000
நான், இந்த ஒரு அமைப்பு என்று போகிறேன்

875
00:47:25,000 --> 00:47:29,000
பின்னர் இந்த அமைப்பு, வகை மாணவர் இருக்க, நாம் சொல்ல வேண்டும் என்று

876
00:47:29,000 --> 00:47:31,000
அது எனக்கு இப்போது தேதியிட்ட ஒரு சிறிய விஷயம் கூட.

877
00:47:31,000 --> 00:47:33,000
நாம் "எண்ணாக ஐடி." சொல்கிறேன்

878
00:47:33,000 --> 00:47:35,000
நாம் "சரம் பெயர்." சொல்கிறேன்

879
00:47:35,000 --> 00:47:37,000
நாம் "சரம் வீட்டை," நான் கூறுவேன்

880
00:47:37,000 --> 00:47:40,000
எனவே இப்போது குறியீடு இந்த சில வரிகள் இறுதிக்குள்

881
00:47:40,000 --> 00:47:45,000
நான் அங்கு உள்ளது என்று கணகண வென்ற சப்தம் கற்று

882
00:47:45,000 --> 00:47:49,000
சரங்கள் தவிர ints தவிர ஒரு தரவு வகை,, தவிர மிதவைகள் தவிர, இரட்டையர்.

883
00:47:49,000 --> 00:47:54,000
>> நேரம் வரிசையில் 11 இந்த கணம் வரை, மாணவர்கள் என ஒரு புதிய தரவு வகை, இப்போது இல்லை

884
00:47:54,000 --> 00:47:58,000
இப்போது நான், எங்கேயும் நான் ஒரு மாணவர் மாறி அறிவிக்க முடியும்

885
00:47:58,000 --> 00:48:01,000
என்னை மக்கள் இங்கே கீழே பார்ப்போம்.

886
00:48:01,000 --> 00:48:05,000
, இப்போது நான் இந்த விடுபட முடியும், மற்றும் நான் இங்கே டேவிட் மீண்டும் கீழே போகலாம்

887
00:48:05,000 --> 00:48:10,000
மற்றும் டேவிட் நான் உண்மையில் அந்த டேவிட், சொல்ல முடியாது

888
00:48:10,000 --> 00:48:13,000
நாம் உண்மையில், நானே பிறகு மாறி பெயரிட முடியும்

889
00:48:13,000 --> 00:48:16,000
வகை மாணவர் இருக்க போகிறது.

890
00:48:16,000 --> 00:48:18,000
இந்த சற்றே இருக்கும், ஆனால் இந்த எல்லா என்று வேறு அல்ல

891
00:48:18,000 --> 00:48:22,000
ஒரு முழு எண்ணாக அல்லது ஒரு சரம் அல்லது ஒரு மிதவை போன்ற ஏதாவது அறிவித்தார் இருந்து.

892
00:48:22,000 --> 00:48:24,000
அது மிக, இப்போது மாணவர் என்று ஆகிவிட்டால்

893
00:48:24,000 --> 00:48:28,000
நான் இந்த அமைப்பு உள்ளே ஏதாவது செய்ய வேண்டும் என்றால்,

894
00:48:28,000 --> 00:48:31,000
, நான் இப்போது இலக்கணத்தை ஒரு புதிய துண்டு பயன்படுத்த வேண்டும், ஆனால் இது மிகவும் நேரடியான தான்

895
00:48:31,000 --> 00:48:39,000
david.id = 123, மூலதன டி உள்ள david.name = "டேவிட்",

896
00:48:39,000 --> 00:48:42,000
மற்றும் david.house = "மாதர்,"

897
00:48:42,000 --> 00:48:46,000
இப்போது நான் இங்கே இந்த பொருள் விடுபட முடியும்.

898
00:48:46,000 --> 00:48:51,000
நாம் இப்போது ஒரு மிக சிறந்த வழி எங்கள் திட்டம் வடிவமைக்கப்பட்டுள்ளது

899
00:48:51,000 --> 00:48:54,000
என்று இப்போது எங்கள் திட்டம், நிஜ உலகில் கண்ணாடிகள்.

900
00:48:54,000 --> 00:48:57,000
>> ஒரு நபர் அல்லது ஒரு மாணவர் ஒரு நிஜ உலக கருத்து இல்லை.

901
00:48:57,000 --> 00:49:02,000
இங்கே நாம் இப்போது ஒரு நபர் அல்லது இன்னும் குறிப்பாக ஒரு மாணவர் ஒரு சி பதிப்பு உள்ளது.

902
00:49:02,000 --> 00:49:05,000
அந்த நபர் உள்ளே இந்த தொடர்புடைய பண்புகள் உள்ளன

903
00:49:05,000 --> 00:49:10,000
ஐடி, பெயர் மற்றும் வீடு, அதனால் ராப் அடிப்படையில் கீழே இங்கே தான் ஆகிறது,

904
00:49:10,000 --> 00:49:14,000
, மாணவர் திருடு எனவே, இப்போது = 456 rob.id

905
00:49:14,000 --> 00:49:17,000
rob.name = "ராப்."

906
00:49:17,000 --> 00:49:20,000
மாறி ராப் அழைக்கப்படுகிறது என்ற அர்த்தமற்ற வகை.

907
00:49:20,000 --> 00:49:22,000
நாம் அது x அல்லது y அல்லது z என்று.

908
00:49:22,000 --> 00:49:25,000
நாம் தான், அதை சொற்பொருளியல் ரீதியாகவும் தொடர்ந்து இருக்கும் ராப் என்ற

909
00:49:25,000 --> 00:49:28,000
ஆனால் உண்மையில் பெயர், அந்த துறையில் தன்னை உள்ளே இருக்கும்

910
00:49:28,000 --> 00:49:30,000
எனவே இப்போது நான் இந்த வேண்டும்.

911
00:49:30,000 --> 00:49:33,000
இது நான் கடுமையாக டேவிட் குறியாக்கம் செய்த சிறந்த வடிவமைப்பு போல் இல்லை.

912
00:49:33,000 --> 00:49:35,000
நான் கடினமாக ராப் குறியிடப்படும்.

913
00:49:35,000 --> 00:49:39,000
நான் இன்னும் சில நகல் நாட மற்றும் நான் புதிய மாறிகள் வேண்டும் ஒவ்வொரு முறையும் ஒட்டவும் வேண்டும்.

914
00:49:39,000 --> 00:49:43,000
மேலும், நான், வெளிப்படையாக இந்த மாறிகள் ஒவ்வொரு ஒரு பெயர் கொடுக்க வேண்டும்

915
00:49:43,000 --> 00:49:46,000
நான் மிகவும் மாறாக இந்த மாறிகள் விவரிக்க என்று கூட

916
00:49:46,000 --> 00:49:48,000
 மேலும் பொதுவாக போன்ற மாணவர்கள்.

917
00:49:48,000 --> 00:49:52,000
>> இப்போது நாம் நன்கு வேலை என்று யோசனைகள் ஒன்றாக்க முடியும்

918
00:49:52,000 --> 00:49:56,000
அதற்கு பதிலாக, நீங்கள் என்னை ஒரு மாறி என மாணவர்கள் கொடுக்க என்ன, தெரியுமா ", என்று

919
00:49:56,000 --> 00:50:01,000
இப்போது நான் இந்த மேலும் துல்லியமாக்க முடியும் ", அது அளவு 3 இருக்க வேண்டும் என்று,

920
00:50:01,000 --> 00:50:04,000
, கைமுறையாக அறிவித்தார் டேவிட் விடுவித்தாக

921
00:50:04,000 --> 00:50:08,000
நான் அதற்கு பதிலாக [0] இங்கே மாணவர்கள் அப்படி சொல்லலாம்.

922
00:50:08,000 --> 00:50:11,000
நான், [0] இங்கே மாணவர்கள் சொல்ல முடியும்

923
00:50:11,000 --> 00:50:14,000
மாணவர்கள் இங்கே, அதனால் அடிக்கடி [0], மற்றும் நான் சுற்றி செல்ல முடியும்

924
00:50:14,000 --> 00:50:16,000
மற்றும் ராப் அந்த சுத்தம்.

925
00:50:16,000 --> 00:50:19,000
நான் கூட இப்போது ஒருவேளை ஒரு வட்டத்திற்கு சேர்த்து சுமார் செல்ல முடியும்

926
00:50:19,000 --> 00:50:23,000
உண்மையில் பயனர் இந்த மதிப்புகள் பெற GetString மற்றும் GetInt பயன்படுத்தி.

927
00:50:23,000 --> 00:50:27,000
இது பொதுவாக மோசமான நடைமுறையில் ஏனெனில் நான் ஒரு நிலையான சேர்த்து சுமார் செல்ல முடியும்

928
00:50:27,000 --> 00:50:29,000
இங்கு 3 போன்ற கடின குறியீடு சில தன்னிச்சையான எண்

929
00:50:29,000 --> 00:50:33,000
அதன் பின்னர் நீங்கள் எந்த இன்னும் 3 விட மாணவர்கள் வைத்து கொள்ள வேண்டும் என்று ஞாபகம்.

930
00:50:33,000 --> 00:50:36,000
இது அநேகமாக என் கோப்பின் மேல் வரையறை # பயன்படுத்த நன்றாக இருக்கும்

931
00:50:36,000 --> 00:50:40,000
மற்றும், எனவே உண்மையில், என்னை போய் இந்த பொதுமைப்படுத்த நாம் அந்த காரணி.

932
00:50:40,000 --> 00:50:43,000
>> எனக்கு இன்றைய மத்தியில் அது ஒரு உதாரணம் திறந்து விட

933
00:50:43,000 --> 00:50:46,000
முன்கூட்டியே உதாரணங்கள், structs1.

934
00:50:46,000 --> 00:50:49,000
இந்த # இங்கு வரையறுக்க பயன்படுத்தும் ஒரு முழுமையான நிரல்

935
00:50:49,000 --> 00:50:51,000
நாம் இயல்பாக 3 மாணவர்கள் போகிறது என்கிறார்.

936
00:50:51,000 --> 00:50:54,000
இங்கே நான், மாணவர்கள் ஒரு வர்க்கம் மதிப்புள்ள பிரகடனம்

937
00:50:54,000 --> 00:50:57,000
மாணவர்கள் ஒரு வகுப்பறையில் எனவே, இப்போது நான் ஒரு வட்டத்திற்கு பயன்படுத்தி வருகிறேன்

938
00:50:57,000 --> 00:51:00,000
வெறும் குறியீடு இன்னும் கொஞ்சம் நேர்த்தியான செய்ய, வர்க்கம் விரிவுப்படுத்த

939
00:51:00,000 --> 00:51:05,000
பயனர் உள்ளீடு, அதனால் 3 இது மாணவர்கள், நான் = 0 இல் இருந்து வரை கூறு.

940
00:51:05,000 --> 00:51:07,000
பின்னர் நான் இந்த பதிப்பில் பயனரை

941
00:51:07,000 --> 00:51:10,000
 என்ன மாணவர் அடையாள தான், நான் GetInt அது கிடைக்கும்.

942
00:51:10,000 --> 00:51:13,000
என்ன மாணவர் பெயர், மற்றும் நான் அதை GetString மூலம் கிடைக்கும்.

943
00:51:13,000 --> 00:51:15,000
மாணவர் வீட்டில் என்ன? நான் GetString அது கிடைக்கும்.

944
00:51:15,000 --> 00:51:19,000
பின்னர் இங்கே கீழே நான் மாற்ற முடிவு

945
00:51:19,000 --> 00:51:22,000
நான் இந்த அச்சிடுகிறது நான் உண்மையில் ஒரு சுழற்சி எவ்வாறு பயன்படுத்த வேண்டும் என்பதை,

946
00:51:22,000 --> 00:51:24,000
நான் யார் அச்சிடுதல்?

947
00:51:24,000 --> 00:51:27,000
கருத்து படி நான், மாதர் யாருக்கும் அச்சிடுதல்

948
00:51:27,000 --> 00:51:30,000
அந்த ராப் மற்றும் டாமி மிகவும் மற்றும் முன்னும் பின்னுமாக-உண்மையில் டாமி இன் மாதர் அது தான்.

949
00:51:30,000 --> 00:51:34,000
டாமி மற்றும் டேவிட் இந்த வழக்கில் அச்சிடப்பட்டு, ஆனால் எப்படி இந்த வேலை?

950
00:51:34,000 --> 00:51:40,000
நாம் இந்த விழாவில் காணப்படவில்லை, ஆனால் இந்த என்ன என்று ஒரு யூகம் எடுத்து இல்லை.

951
00:51:40,000 --> 00:51:42,000
சரங்களை ஒப்பிடுகிறது.

952
00:51:42,000 --> 00:51:45,000
>> அது மாறிவிடும் என்பதால் அதை சரங்களை ஒப்பிட்டு எப்படி ஒரு சிறிய அல்லாத கண்டிப்பாக

953
00:51:45,000 --> 00:51:49,000
அதை அதாவது 0 கொடுக்கிறது என்றால் சரங்களை சமமானவர்கள்.

954
00:51:49,000 --> 00:51:53,000
அது ஒரு -1 கொடுக்கிறது என்றால், அந்த ஒரு, மற்ற முன் அகர வரிசைப்படி வரும் பொருள்

955
00:51:53,000 --> 00:51:57,000
இது மற்ற வார்த்தைக்கு என்ன அர்த்தம் என்று +1 கொடுக்கிறது என்றால் மற்றும் அகர வரிசைப்படி வரும்

956
00:51:57,000 --> 00:52:00,000
மற்ற முன், மற்றும் நீங்கள் ஆன்லைன் அல்லது மனிதன் பக்கம் பார்க்க முடியும்

957
00:52:00,000 --> 00:52:04,000
சரியாக எந்த வழி எது பார்க்க, ஆனால் இதை எல்லாம் இப்போது செய்து அதை சொல்லி இருக்கிறாள்

958
00:52:04,000 --> 00:52:09,000
[நான்]. வீட்டில் "மாதர்" சமமாக இருந்தால்

959
00:52:09,000 --> 00:52:13,000
பின்னர் மேலே சென்று மிகவும் அவுட் அச்சிட மற்றும் மாதர் உள்ளது.

960
00:52:13,000 --> 00:52:16,000
ஆனால் இங்கே நாம் பார்த்ததே இல்லை விஷயம், நாம் இந்த வருகிறேன்.

961
00:52:16,000 --> 00:52:21,000
நான் எப்போதும் என் திட்டங்கள் எந்த இதை செய்ய கொண்ட நினைவு இல்லை.

962
00:52:21,000 --> 00:52:24,000
இலவச வெளிப்படையாக, நினைவாற்றல் பற்றி நினைவு பெறலாம்

963
00:52:24,000 --> 00:52:31,000
ஆனால் நான் வெளிப்படையாக இந்த திட்டத்தின் கீழ் இந்த வட்டத்திற்கு என்ன நினைவக பெறலாம்?

964
00:52:31,000 --> 00:52:34,000
நான் ஒரு நபரின் பெயர் பெறலாம் போல் தெரிகிறது

965
00:52:34,000 --> 00:52:37,000
மற்றும் ஒரு நபரின் வீடு, ஆனால் அது ஏன்?

966
00:52:37,000 --> 00:52:41,000
>> அதை நீங்கள் GetString பயன்படுத்தி வருகிறேன் என்று இந்த வாரம் நடக்கிறது

967
00:52:41,000 --> 00:52:45,000
நாம் வகையான உங்கள் திட்டங்கள் ஒவ்வொரு ஒரு பிழை அறிமுகம்.

968
00:52:45,000 --> 00:52:51,000
அதை நீங்கள் ஒரு சரம் திரும்ப முடியும் என்று வடிவமைப்பு தொண்டு நினைவக மூலம் GetString,

969
00:52:51,000 --> 00:52:55,000
போன்ற டேவிட், அல்லது ராப், மற்றும் நீ என்ன வேண்டுமானாலும் செய்யலாம்

970
00:52:55,000 --> 00:52:59,000
நாங்கள் உங்களுக்கு நினைவு முன்பதிவு செய்து உங்கள் திட்டம் என்று வாசகத்தில்.

971
00:52:59,000 --> 00:53:02,000
பிரச்சனை நீ GetString என்று ஒவ்வொரு முறையும் இந்த நேரம்

972
00:53:02,000 --> 00:53:05,000
நாம், GetString ஆசிரியர்கள், இயங்கு கேட்டு

973
00:53:05,000 --> 00:53:07,000
இந்த சரம் எங்களை ரேம் ஒரு பிட் கொடுக்க.

974
00:53:07,000 --> 00:53:09,000
இந்த அடுத்த சரம் எங்களை ரேம் ஒரு பிட் கொடுக்க.

975
00:53:09,000 --> 00:53:11,000
இந்த அடுத்த சரம் இன்னும் கொஞ்சம் ரேம் கொடுக்க.

976
00:53:11,000 --> 00:53:13,000
என்ன, ப்ரோக்ராமர், செய்து இல்லை

977
00:53:13,000 --> 00:53:15,000
, நம்மை நினைவு திரும்ப கொடுக்கும்

978
00:53:15,000 --> 00:53:17,000
எனவே இந்த பல வாரங்கள் திட்டங்கள் அனைத்து நீங்கள் எழுதிய

979
00:53:17,000 --> 00:53:20,000
அவர்கள் பயன்படுத்தி வைத்து கொள்ள ஒரு நினைவக பாய்ச்சல் என்று என்ன இருந்தது

980
00:53:20,000 --> 00:53:24,000
மேலும் நினைவக நீங்கள் GetString அழைப்பு, மற்றும் அது நல்லது ஒவ்வொரு முறையும்.

981
00:53:24,000 --> 00:53:27,000
அது சுவாரசியமாக இல்லை, ஏனெனில் நாங்கள் வேண்டுமென்றே முதல் வாரங்களில் செய்ய

982
00:53:27,000 --> 00:53:29,000
சரம் இருந்து வரும் அமைந்துள்ள பற்றி கவலைப்பட வேண்டும்.

983
00:53:29,000 --> 00:53:34,000
நீங்கள் விரும்பும் அனைத்து வார்த்தை போது பயனர் வகையான அது உள்ளே வர ராப் உள்ளது

984
00:53:34,000 --> 00:53:38,000
>> ஆனால் முன்னேற்றம் நாம் இப்போது இது பற்றி மேலும் அதிநவீன பெற்று தொடங்க வேண்டும்.

985
00:53:38,000 --> 00:53:42,000
நாம் நினைவகத்தை ஒதுக்க எந்த நேரமும் நாம் நல்ல இறுதியில் அதை திரும்ப ஒப்படைக்கிறேன்.

986
00:53:42,000 --> 00:53:45,000
மற்றபடி உங்கள் மேக் அல்லது கணினியில் உண்மையான உலகத்தில் நீங்கள் எப்போதாவது அனுபவம் வேண்டும்

987
00:53:45,000 --> 00:53:50,000
உங்கள் கணினி இறுதியில் ஒரு நிறுத்த சாணை அமைந்துள்ள அறிகுறிகள்

988
00:53:50,000 --> 00:53:54,000
அல்லது முட்டாள் சுழல் கடற்கரை பந்தை ஒரு கணினியின் ஆக்கிரமித்து

989
00:53:54,000 --> 00:53:56,000
முழு கவனம் மற்றும் நீங்கள் எல்லாம் செய்ய முடியாது.

990
00:53:56,000 --> 00:54:00,000
அந்த பிழைகள் எந்த எண் மூலம் விளக்கினார், ஆனால் அந்த வாய்ப்பு பிழைகள் மத்தியில்

991
00:54:00,000 --> 00:54:03,000
விஷயங்களை நினைவு கசிவுகள் அழைக்கப்படுகின்றன அதன்படி மென்பொருள் என்று துண்டு எழுதியது யார் யாரோ

992
00:54:03,000 --> 00:54:07,000
நீங்கள் இலவச நினைவக நினைவில் இல்லை பயன்படுத்தி

993
00:54:07,000 --> 00:54:10,000
அவர், இயக்க அமைப்பு கேட்டு என்று

994
00:54:10,000 --> 00:54:14,000
ஒரு CS50 விஷயம் என்பதால், GetString பயன்படுத்தி, ஆனால் இதே போன்ற செயல்பாடுகளை பயன்படுத்தி

995
00:54:14,000 --> 00:54:16,000
நினைவகத்தை இயக்க அமைப்பு கேட்கும்.

996
00:54:16,000 --> 00:54:19,000
நீங்கள் அல்லது அவர்கள் திருகு மற்றும் என்றால், உண்மையில் அந்த நினைவு திரும்பாது

997
00:54:19,000 --> 00:54:24,000
ஒரு திட்டத்தை தாமதப்படுத்தி தாமதப்படுத்தி கீழே குறைந்துவிடுகிறது என்று இருக்க முடியும் என்று ஒரு அறிகுறி

998
00:54:24,000 --> 00:54:26,000
நீங்கள் இலவச அழைக்க நினைவில் வரை.

999
00:54:26,000 --> 00:54:28,000
>> எப்போது, ஏன் இலவச அழைப்பு என்று நாம், திரும்பி வருவாள்

1000
00:54:28,000 --> 00:54:32,000
ஆனால் அது தான் நல்ல நடவடிக்கை இன்னும் மேலே போய் இந்த குறிப்பிட்ட இயங்குவதாக முயற்சி செய்வோம்.

1001
00:54:32,000 --> 00:54:35,000
இந்த structs1 என, உள்ளிடவும்.

1002
00:54:35,000 --> 00:54:40,000
டேவிட் மாதர், என்னை போய் structs1 ரன் 123 let,

1003
00:54:40,000 --> 00:54:47,000
456, ராப் கிர்க்லாண்ட், 789,

1004
00:54:47,000 --> 00:54:50,000
டாமி மாதர், மற்றும் நாம் மாதர் உள்ள டேவிட் பார்க்க, டாமி இன் மாதர் இல்.

1005
00:54:50,000 --> 00:54:53,000
இந்த திட்டம் வேலை என்று ஒரு சிறிய நல்லறிவு காசோலை.

1006
00:54:53,000 --> 00:54:56,000
இப்போது, துரதிருஷ்டவசமாக, இந்த திட்டம் என்று ஒரு சிறிய வெறுப்பாக இருக்கிறது

1007
00:54:56,000 --> 00:55:00,000
நான், நான் 9 வெவ்வேறு சரங்களை அனைத்து அந்த வேலையை தட்டச்சு செய்யவில்லை, உள்ளிடவும் வெற்றி

1008
00:55:00,000 --> 00:55:04,000
மாதர் இருந்த கூறினார், இன்னும் வெளிப்படையாக நான் அதை தட்டச்சு ஏனெனில் ஏற்கனவே மாதர் இருந்த தெரியும்.

1009
00:55:04,000 --> 00:55:07,000
இந்த திட்டம் இன்னும் ஒரு தரவுத்தள போல் இருந்தால் அது குறைந்த பட்சம் நன்றாக இருக்கும்

1010
00:55:07,000 --> 00:55:10,000
அது உண்மையில் நான் தட்டச்சு என்ன நினைத்துக்கொண்டு

1011
00:55:10,000 --> 00:55:12,000
எனவே நான் மீண்டும் உள்ளீடு இந்த மாணவர் பதிவுகள் வேண்டும் என்றும்.

1012
00:55:12,000 --> 00:55:15,000
ஒருவேளை அது ஒரு registrarial கணினி போல.

1013
00:55:15,000 --> 00:55:21,000
>> நாம், கோப்பு நான் / ஓ, கோப்பு உள்ளீடு மற்றும் வெளியீடு என அழைக்கப்படும் இந்த தொழில் நுட்பத்தை பயன்படுத்தி இதை செய்ய முடியும்

1014
00:55:21,000 --> 00:55:24,000
நீங்கள் கோப்புகளை படிக்க அல்லது கோப்புகளை எழுத வேண்டும் எந்த நேரம் என்று ஒரு மிகவும் பொதுவான வழி

1015
00:55:24,000 --> 00:55:26,000
நீங்கள் செயல்பாடுகளை ஒரு குறிப்பிட்ட அமைப்பு இந்த செய்ய முடியும்.

1016
00:55:26,000 --> 00:55:29,000
என்னை போய் இந்த உதாரணம் structs2.c திறக்க விட,

1017
00:55:29,000 --> 00:55:33,000
இது கிட்டத்தட்ட ஒன்றாக உள்ளது, ஆனால் அது இப்போது என்ன பார்க்க நாம்.

1018
00:55:33,000 --> 00:55:36,000
கோப்பு மேலே நான் மாணவர்கள் ஒரு வர்க்கம் என்று.

1019
00:55:36,000 --> 00:55:38,000
நான், பயனர் உள்ளீடு வர்க்கம் விரிவுப்படுத்த

1020
00:55:38,000 --> 00:55:41,000
எனவே குறியீடு அந்த வரிகளை சரியாக முன் மாதிரி.

1021
00:55:41,000 --> 00:55:45,000
மாதர் உள்ள அனைவருக்கும் தன்னிச்சையாக முன் மாதிரி நான் இங்கே கீழே என்றால் நான் அச்சிட,

1022
00:55:45,000 --> 00:55:47,000
ஆனால் இந்த ஒரு புதிய அம்சம்.

1023
00:55:47,000 --> 00:55:51,000
, குறியீடு இந்த வரிகளை புதிய, மற்றும் அவர்கள் இங்கே ஏதாவது அறிமுகம்

1024
00:55:51,000 --> 00:55:55,000
கோப்பு, அனைத்து தொப்பிகள், அது போல் இங்கே உள்ள * உள்ளது.

1025
00:55:55,000 --> 00:55:58,000
என்னை போல் இங்கு, இங்கு ஒரு * இந்த செல்லலாம்.

1026
00:55:58,000 --> 00:56:00,000
>> இந்த விழாவில் நாம் பார்த்ததே இல்லை, fopen,

1027
00:56:00,000 --> 00:56:03,000
ஆனால் இது திறந்த கோப்பு பொருள், எனவே இந்த வழியாக தான் ஆடையெடு விட,

1028
00:56:03,000 --> 00:56:05,000
இந்த, நாம் எதிர்காலத்தில் psets உள்ள திரும்பி வருவாள் ஒன்று

1029
00:56:05,000 --> 00:56:10,000
ஆனால் இங்கே இந்த வரி அடிப்படையில், தரவுத்தள என்று ஒரு கோப்பு திறக்கிறது

1030
00:56:10,000 --> 00:56:13,000
இது குறிப்பாக அது என்ன செய்ய முடியும் என்று ஒரு வழியில் அதை திறக்கும்?

1031
00:56:13,000 --> 00:56:15,000
[செவிக்கு புலப்படாமல்-மாணவர்]

1032
00:56:15,000 --> 00:56:19,000
சரி, அதனால் "w" அதை இயங்கு சொல்வது பொருள்

1033
00:56:19,000 --> 00:56:21,000
நான் அதை எழுத முடியும் வகையில் இந்த கோப்பை திறக்க.

1034
00:56:21,000 --> 00:56:23,000
நான் அதை படிக்க விரும்பவில்லை. நான் அதை பார்க்க விரும்பவில்லை.

1035
00:56:23,000 --> 00:56:26,000
நான், அதை மாற்ற மற்றும் சாத்தியமுள்ள விஷயங்களை சேர்க்க வேண்டும்

1036
00:56:26,000 --> 00:56:28,000
மற்றும் கோப்பு தரவுத்தள என்று போகிறது.

1037
00:56:28,000 --> 00:56:30,000
இந்த எதையும் என்று.

1038
00:56:30,000 --> 00:56:32,000
இந்த database.txt இருக்க முடியும். இந்த. Db இருக்க முடியும்.

1039
00:56:32,000 --> 00:56:37,000
இந்த foo போன்ற ஒரு வார்த்தை இருக்க முடியும், ஆனால் நான் தன்னிச்சையாக கோப்பு தரவுத்தள பெயரை தேர்வு.

1040
00:56:37,000 --> 00:56:42,000
இந்த, நாம் காலப்போக்கில் பெரும் விரிவாக திரும்பி வருவேன் என்று ஒரு சிறிய நல்லறிவு காசோலை

1041
00:56:42,000 --> 00:56:47,000
கைரேகை, கோப்பு சுட்டிக்காட்டி க்கு, சம NULL இல்லை என்று அனைத்து நன்றாக இருக்காது.

1042
00:56:47,000 --> 00:56:51,000
>> நீண்ட கதை குறுகிய, fopen போன்ற செயல்பாடுகளை சில நேரங்களில் தோல்வி.

1043
00:56:51,000 --> 00:56:53,000
ஒருவேளை கோப்பு இல்லை. ஒருவேளை நீங்கள் வட்டு இடம் போதவில்லை.

1044
00:56:53,000 --> 00:56:55,000
ஒருவேளை நீங்கள், அந்த கோப்புறையை அனுமதி இல்லை

1045
00:56:55,000 --> 00:56:58,000
fopen பூஜ்ய ஏதாவது கொடுக்கிறது மிகவும் மோசமான நடந்தது.

1046
00:56:58,000 --> 00:57:02,000
Fopen பூஜ்ய தராது மாறாக, அனைத்து நன்றாக உள்ளது

1047
00:57:02,000 --> 00:57:04,000
நான் இந்த கோப்பை எழுத தொடங்கலாம்.

1048
00:57:04,000 --> 00:57:06,000
இங்கே ஒரு புதிய தந்திரம் தான்.

1049
00:57:06,000 --> 00:57:08,000
இந்த, என் மாணவர்கள் ஒவ்வொரு தேடி என்று ஒரு சுழற்சி உள்ளது

1050
00:57:08,000 --> 00:57:10,000
இந்த, நாம் முன்னர் என்ன செய்தேன் என்பதை மிகவும் ஒத்த தெரிகிறது

1051
00:57:10,000 --> 00:57:15,000
ஆனால் இந்த செயல்பாடு, printf printf கோப்பு fprintf என்று ஒரு சகோதரர்

1052
00:57:15,000 --> 00:57:18,000
அது மட்டும் 2 வழிகளில் வேறு கவனிக்க.

1053
00:57:18,000 --> 00:57:20,000
ஒரு, இது, அதற்கு பதிலாக ப f தொடங்குகிறது

1054
00:57:20,000 --> 00:57:23,000
ஆனால் அதன் முதல் வாதத்தை வெளிப்படையாக என்ன?

1055
00:57:23,000 --> 00:57:25,000
[மாணவர்கள்] கோப்பு. >> இது ஒரு கோப்பு.

1056
00:57:25,000 --> 00:57:30,000
நாம் இறுதியில் ஒரு கோப்பு சுட்டிக்காட்டி என்ன தவிர கிண்டல் நான் எந்த ரேகை என்று இந்த விஷயம்,,

1057
00:57:30,000 --> 00:57:35,000
ஆனால் இப்போது கைரேகை வெறுமனே, நான் திறந்து என்று கோப்பை குறிக்கிறது

1058
00:57:35,000 --> 00:57:41,000
எனவே fprintf இங்கே, கோப்பு இந்த பயனர் அடையாள அச்சிட முடியாது திரைக்கு சொல்கிறார்கள்.

1059
00:57:41,000 --> 00:57:44,000
கோப்பு பயனர் பெயரை, இல்லை திரையில், அச்சிட

1060
00:57:44,000 --> 00:57:47,000
கோப்பு, இல்லை, வெளிப்படையாக, கீழே இங்கே பின் திரையில், மற்றும் வீடு

1061
00:57:47,000 --> 00:57:50,000
கோப்பு மூட, பின்னர் கீழே இங்கே நினைவு இலவச.

1062
00:57:50,000 --> 00:57:53,000
>> இந்த பதிப்பு 2 மற்றும் பதிப்பு 1 இடையில் மட்டுமே வேறுபாடு

1063
00:57:53,000 --> 00:57:58,000
fopen அறிமுகம் மற்றும் * இந்த கோப்பு

1064
00:57:58,000 --> 00:58:01,000
மற்றும் fprintf இந்த கருத்து, அதனால் முடிவு என்ன என்பது நாம் பார்ப்போம்.

1065
00:58:01,000 --> 00:58:03,000
என் முனைய சாளர செல்லலாம்.

1066
00:58:03,000 --> 00:58:06,000
உள்ளிட, என்னை structs2 ஓடிப்போகட்டும்.

1067
00:58:06,000 --> 00:58:09,000
அனைத்து நன்றாக தெரிகிறது. அது structs2 மீண்டும் இயக்கவும் நாம்.

1068
00:58:09,000 --> 00:58:15,000
123, டேவிட் மாதர், 456, ராப் கிர்க்லாண்ட்,

1069
00:58:15,000 --> 00:58:19,000
789, டாமி மாதர், உள்ளிடவும்.

1070
00:58:19,000 --> 00:58:23,000
அதே நடந்து போல, ஆனால் நான் இப்போது ls செய்தால்

1071
00:58:23,000 --> 00:58:28,000
என் குறியீடு மத்தியில் இங்கே என்ன கோப்பு கவனிக்க, தரவுத்தள,

1072
00:58:28,000 --> 00:58:32,000
எனவே அந்த அந்த, தரவுத்தளத்தின் gedit, மற்றும் பார் திறக்க அனுமதி.

1073
00:58:32,000 --> 00:58:34,000
இது கோப்பு வடிவங்களில் கவர்ச்சிகரமான இல்லை.

1074
00:58:34,000 --> 00:58:38,000
உண்மையில், வரிக்கு வரிக்கு தரவு வரி ஒரு துண்டு இருக்கிறது

1075
00:58:38,000 --> 00:58:42,000
ஆனால் எக்செல் அல்லது CSV கோப்புகளை பயன்படுத்த நீங்கள் அந்த, கமா, மதிப்புகள் பிரிக்கப்பட்ட

1076
00:58:42,000 --> 00:58:47,000
நான் நிச்சயமாக பதிலாக ஒருவேளை இந்த மாதிரி ஏதாவது செய்ய fprintf பயன்படுத்தப்படும்

1077
00:58:47,000 --> 00:58:50,000
நான் உண்மையில் ஒரு எக்சல் கோப்பை சமமான உருவாக்க முடியும் என்று

1078
00:58:50,000 --> 00:58:53,000
காற்புள்ளிகளை, தான் புதிய வரிகளை விஷயங்களை பிரிப்பதன் மூலம்.

1079
00:58:53,000 --> 00:58:56,000
>> இந்த வழக்கில் நான் பதிலாக காற்புள்ளிகளை பதிலாக புதிய வரிகளை பயன்படுத்தி இருந்தால்

1080
00:58:56,000 --> 00:59:01,000
நான் அதற்கு பதிலாக இது போன்ற செய்தால் நான் உண்மையில் எக்செல் இந்த தரவுத்தள கோப்பை திறக்க முடியவில்லை.

1081
00:59:01,000 --> 00:59:03,000
சுருக்கமாக, இப்போது நாம் கோப்புகளை எழுத சக்தி இருக்கிறது

1082
00:59:03,000 --> 00:59:07,000
நாம் இப்போது வட்டில் அதை சுற்றி வைத்து, தொடர்ச்சியான தரவு தொடங்க முடியாது

1083
00:59:07,000 --> 00:59:10,000
நாம் மீண்டும் மீண்டும் சுற்றி தகவல் வைத்திருக்க முடியும் என்று.

1084
00:59:10,000 --> 00:59:14,000
இப்போது சற்று தெரிந்திருந்தால் மற்ற விஷயங்களை ஒரு ஜோடி கவனிக்கவில்லை.

1085
00:59:14,000 --> 00:59:16,000
இந்த சி கோப்பு மேலே நாம் ஒரு typedef வேண்டும்

1086
00:59:16,000 --> 00:59:21,000
நாம் ஒரு சொல் குறிக்கிறது என்று ஒரு தரவு வகையை உருவாக்க வேண்டும், ஏனெனில்

1087
00:59:21,000 --> 00:59:25,000
இந்த வகை வார்த்தை அழைக்கப்படுகிறது எனவே, மற்றும் உள்ளே இந்த அமைப்பு

1088
00:59:25,000 --> 00:59:27,000
அது இப்போது ஒரு சிறிய ஆர்வலராக இருந்தது.

1089
00:59:27,000 --> 00:59:30,000
ஏன் ஒரு வார்த்தை வெளிப்படையாக ஒரு வரிசைக்கு ஆனது?

1090
00:59:30,000 --> 00:59:33,000
வெறும் உள்ளுணர்வாக ஒரு வார்த்தை என்ன?

1091
00:59:33,000 --> 00:59:35,000
>> அது கதாபாத்திரங்கள் ஒரு வரிசை தான்.

1092
00:59:35,000 --> 00:59:37,000
அதை மீண்டும் மீண்டும் மீண்டும் எழுத்துக்கள் ஒரு காட்சி.

1093
00:59:37,000 --> 00:59:41,000
அனைத்து தொப்பிகள் உள்ள எழுத்துக்களை நாம் தன்னிச்சையாக சொல்ல வேண்டும் நடக்கும் அதிகபட்ச நீளம்

1094
00:59:41,000 --> 00:59:44,000
நாம் போராட்டம் பற்றிய பயன்படுத்தி என்று அகராதியில் எந்த வார்த்தை.

1095
00:59:44,000 --> 00:59:46,000
நான் ஏன் ஒரு +1 இருக்கிறது?

1096
00:59:46,000 --> 00:59:48,000
வெற்று எழுத்து.

1097
00:59:48,000 --> 00:59:51,000
நாம் Bananagrams எடுத்துக்காட்டாக செய்த போது நாம் ஒரு சிறப்பு மதிப்பு தேவை நினைவுகூர

1098
00:59:51,000 --> 00:59:55,000
கண்காணிப்பதற்கு வார்த்தையின் முடிவில் பொருட்டு

1099
00:59:55,000 --> 00:59:59,000
பிரச்சனை தொகுப்பு விவரக்குறிப்பு சொல்வது வார்த்தைகள் உண்மையில் முடிவுக்கு எங்கு, மற்றும்

1100
00:59:59,000 --> 01:00:03,000
இங்கு நாம், ஒரு வார்த்தை, ஒரு பூலியன் மதிப்பை தொடர்புப்படுத்துகிறது

1101
01:00:03,000 --> 01:00:05,000
ஒரு கொடி, எனவே, உண்மை அல்லது பொய் பேச.

1102
01:00:05,000 --> 01:00:09,000
நாம் உணர ஏனெனில் நீங்கள் ஏற்கனவே இந்த வார்த்தை இல்லை

1103
01:00:09,000 --> 01:00:13,000
நாம் உண்மையில் நினைவில் ஒரு வழி தேவையில்லை மட்டுமே போராடும் ஒரு வார்த்தை என்ன

1104
01:00:13,000 --> 01:00:15,000
ஆனால் நீங்கள் இல்லாவிட்டாலும், மனித, அதை கண்டு

1105
01:00:15,000 --> 01:00:20,000
நீங்கள் கண்டறிய செய்தால் வார்த்தை "" நீங்கள் தட்டச்சு முடியாது, அதனால் நுழைய, நுழைய, நுழைய

1106
01:00:20,000 --> 01:00:23,000
மேலும் 3 புள்ளிகள், 3 புள்ளிகள், 3 புள்ளிகள், 3 புள்ளிகள் கிடைக்கும்.

1107
01:00:23,000 --> 01:00:26,000
நாம் ஒரு bool மூலம் அந்த வார்த்தை பிளாக்லிஸ்ட் முடியும் வேண்டும்

1108
01:00:26,000 --> 01:00:29,000
நீங்கள் ஏற்கனவே கிடைத்துவிட்டது என்றால் ஏன் உண்மை, மற்றும் அதனால் நாம் தான்

1109
01:00:29,000 --> 01:00:31,000
இந்த அமைப்பு இது மூடப்பட்டிருக்க.

1110
01:00:31,000 --> 01:00:35,000
>> இப்போது, கீழே இங்கே போராட்டம் உள்ள அகராதி என்று இந்த மற்ற struct உள்ளது.

1111
01:00:35,000 --> 01:00:39,000
இங்கே இல்லாமல் typedef வார்த்தை என்பதால் இந்த விஷயத்தில்

1112
01:00:39,000 --> 01:00:43,000
நாம், ஒரு அகராதியின் யோசனை கூட்டடைவு தேவை

1113
01:00:43,000 --> 01:00:46,000
ஒரு அகராதி, வார்த்தைகள் ஒரு மொத்தமாக கொண்டுள்ளது

1114
01:00:46,000 --> 01:00:49,000
இந்த வரிசை மூலம் மறைமுகமாக, எப்படி அந்த வார்த்தைகள் பல உள்ளன?

1115
01:00:49,000 --> 01:00:51,000
சரி, இந்த மாறி என்று அளவு கோல் என்ன.

1116
01:00:51,000 --> 01:00:53,000
ஆனால் நாம் ஒரு அகராதியை வேண்டும்.

1117
01:00:53,000 --> 01:00:55,000
நாம் அகராதியை என்று ஒரு தரவு வகையை தேவையில்லை.

1118
01:00:55,000 --> 01:00:58,000
நாம் தான் அவர்களை ஒரு தேவை, அது சி மாறிவிடும்

1119
01:00:58,000 --> 01:01:03,000
நீங்கள் typedef சொல்லவில்லை என்றால், நீங்கள் struct என்று அந்த, பின்னர் சுருள் ப்ரேஸ் உள்ளே

1120
01:01:03,000 --> 01:01:05,000
நீங்கள் பெயரை வைத்து பின், உங்கள் மாறிகள் வைத்து.

1121
01:01:05,000 --> 01:01:09,000
இந்த ஒரு மாறி என்று அகராதியில் பிரகடனம்

1122
01:01:09,000 --> 01:01:11,000
இந்த மாதிரி.

1123
01:01:11,000 --> 01:01:16,000
இதற்கு மாறாக, இந்த வரிகளை வார்த்தை என்று மீண்டும் பயன்படுத்தும் தரவு கட்டமைப்பை உருவாக்கும்

1124
01:01:16,000 --> 01:01:19,000
நாம் உருவாக்கிய போல் நீங்கள், பல பிரதிகளை உருவாக்க முடியும்

1125
01:01:19,000 --> 01:01:22,000
மாணவர்கள் பல பிரதிகள்.

1126
01:01:22,000 --> 01:01:24,000
>> இந்த இறுதியில் நாம் என்ன செய்ய வேண்டும் என்பதை அனுமதிக்கும்?

1127
01:01:24,000 --> 01:01:30,000
என்னை எளிய முறை, இது என்று ஒரு எளிய உதாரணம் விட, மீண்டும் செல்லலாம்,

1128
01:01:30,000 --> 01:01:34,000
மற்றும் compare1.c, தான் சொல்கிறேன், என்னை திறந்து விடுங்கள்.

1129
01:01:34,000 --> 01:01:38,000
கையில் இங்கே சிக்கல் உண்மையில் மீண்டும் தலாம் என்று

1130
01:01:38,000 --> 01:01:41,000
வரிசை அடுக்கு மற்றும் இந்த பயிற்சி சக்கரங்கள் ஆஃப் எடுத்து தொடங்க

1131
01:01:41,000 --> 01:01:44,000
அது ஒரு சரம் என்று இந்த நேரத்தில் மாறிவிடும் என்பதால்

1132
01:01:44,000 --> 01:01:47,000
நாம் உண்மையில் வாரம் 1 இல் ஒரு புனைப்பெயரை வாக்கு என்பது,

1133
01:01:47,000 --> 01:01:51,000
ஒரு பொருள் ஒரு சிறு ரகசிய தெரிகிறது என்று ஏதாவது CS50 நூலகம் இருந்து,

1134
01:01:51,000 --> 01:01:53,000
கரி *, மற்றும் நாம் முன்னர் இந்த நட்சத்திரம் பார்த்திருக்கிறேன்.

1135
01:01:53,000 --> 01:01:55,000
நாம் கோப்புகளை சூழலில் அதை பார்த்தேன்.

1136
01:01:55,000 --> 01:01:59,000
>> நாம் இப்போது சில நேரம் இந்த விவரம் மறைத்து வருகிறது ஏன் இப்போது பார்ப்போம்.

1137
01:01:59,000 --> 01:02:02,000
இங்கே compare1.c என்று ஒரு கோப்பு உள்ளது

1138
01:02:02,000 --> 01:02:07,000
அது வெளிப்படையாக, கள் மற்றும் t, 2 சரங்களை பயனரிடம்

1139
01:02:07,000 --> 01:02:11,000
பின்னர், வரி 26 இல் சமத்துவத்திற்கான அந்த சரங்களை ஒப்பிட்டு முயற்சி

1140
01:02:11,000 --> 01:02:14,000
அவர்கள் கூறும் சம என்றால், "நீங்கள், அதே விஷயத்தை தட்டச்சு"

1141
01:02:14,000 --> 01:02:17,000
அவர்கள் சம இல்லை என்றால் அது "நீங்கள் வேறு விஷயங்களை தட்டச்சு.", என்கிறார்

1142
01:02:17,000 --> 01:02:19,000
என்னை போய் இந்த நிரலை இயக்க அனுமதிக்க.

1143
01:02:19,000 --> 01:02:23,000
என் மூல அடைவில் செல்லலாம், ஒரு compare1 செய்ய. அது சரி, தொகுக்கப்பட்ட.

1144
01:02:23,000 --> 01:02:25,000
என்னை compare1 ஓடிப்போகட்டும்.

1145
01:02:25,000 --> 01:02:27,000
நான், பெரிதாக்க உள்ளிட வேண்டும்.

1146
01:02:27,000 --> 01:02:29,000
ஏதோ சொல்ல. வணக்கம்.

1147
01:02:29,000 --> 01:02:32,000
நான் மீண்டும் ஒன்று சொல்கிறேன். வணக்கம்.

1148
01:02:32,000 --> 01:02:34,000
நான் நிச்சயமாக வேறு விஷயங்களை தட்டச்சு செய்யவில்லை.

1149
01:02:34,000 --> 01:02:37,000
>> என்னை மீண்டும் இந்த முயற்சி செய்யலாம். பாய்.

1150
01:02:37,000 --> 01:02:40,000
நிச்சயமாக வேறு அல்ல, இங்கே என்ன நடக்கிறது என்று?

1151
01:02:40,000 --> 01:02:44,000
சரி, உண்மையில் வரி 26 என்ன ஒப்பிடுகையில்?

1152
01:02:44,000 --> 01:02:46,000
[செவிக்கு புலப்படாமல்-மாணவர்]

1153
01:02:46,000 --> 01:02:49,000
ஆம், அது ஒரு சரம், தரவு வகை, ஒரு வெள்ளை பொய் என்ன என்று கூறினார்.

1154
01:02:49,000 --> 01:02:53,000
ஒரு சரம் ஒரு எரிப்பதை *, ஆனால் ஒரு எரிப்பதை * என்ன?

1155
01:02:53,000 --> 01:02:56,000
ஒரு எரிப்பதை *, அவர்கள் கூறியது போல், ஒரு சுட்டிக்காட்டி உள்ளது

1156
01:02:56,000 --> 01:03:00,000
மற்றும் ஒரு சுட்டிக்காட்டி, இது ஒரு முகவரி

1157
01:03:00,000 --> 01:03:05,000
ஒரு தொகையை நினைவகத்தில் இடம், மற்றும் நீங்கள் வணக்கம் போன்ற ஒரு வார்த்தையை தட்டச்சு செய்து நேர்ந்தால்,

1158
01:03:05,000 --> 01:03:08,000
சரங்களின் கடந்த விவாதங்களில் இருந்து நினைவுகூர

1159
01:03:08,000 --> 01:03:16,000
இந்த வார்த்தை போன்ற ஹலோ உள்ளது.

1160
01:03:16,000 --> 01:03:19,000
ஹலோ போன்ற ஒரு வார்த்தை குறிப்பிடப்படுகின்றன முடியும் என்று நினைவில்

1161
01:03:19,000 --> 01:03:22,000
இந்த எழுத்துக்கள் அணிவரிசையாகும்

1162
01:03:22,000 --> 01:03:25,000
பின்னர் இறுதியில் ஒரு சிறப்பு தன்மை கொண்ட, வெற்று தன்மை என்று

1163
01:03:25,000 --> 01:03:27,000
\ குறிக்கிறது என்று.

1164
01:03:27,000 --> 01:03:29,000
ஒரு சரம் உண்மையில் என்ன?

1165
01:03:29,000 --> 01:03:32,000
இந்த நினைவகம் பல துண்டுகளாக்கி என்று அறிவிப்பு

1166
01:03:32,000 --> 01:03:36,000
நீங்கள் முழு சரம் வழியாக இருக்கும் முறை மற்றும் உண்மையில், அது இறுதியில் மட்டுமே அறியப்படுகிறது

1167
01:03:36,000 --> 01:03:38,000
சிறப்பு வெற்று தன்மையை தேடும்.

1168
01:03:38,000 --> 01:03:41,000
ஆனால் இந்த என் கணினியின் நினைவகம் இருந்து நினைவகம் ஒரு துண்டின் என்றால்,

1169
01:03:41,000 --> 01:03:44,000
நாம் தன்னிச்சையாக இந்த சரம், ஆதாயம், என்று

1170
01:03:44,000 --> 01:03:47,000
அது என் கணினியின் ரேம் ஆரம்பத்தில் வைக்கப்பட்டது.

1171
01:03:47,000 --> 01:03:54,000
இந்த பைட் 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> நான் GetString போன்ற ஏதாவது சொல்ல நான் சரம் கள் = GetString செய்யும் போது

1173
01:04:02,000 --> 01:04:04,000
உண்மையில் என்ன திரும்பினார்?

1174
01:04:04,000 --> 01:04:08,000
இந்த கடந்த பல வாரங்களாக, என்ன உண்மையில் கள் சேமிக்கப்படும்

1175
01:04:08,000 --> 01:04:13,000
தன்னிச்சையாக இந்த சரம் அல்ல, ஆனால் இந்த விஷயத்தில் என்ன சேமிக்கப்படும் என உள்ளது

1176
01:04:13,000 --> 01:04:18,000
GetString உண்மையில் என்ன காரணம் எண்ணை 0

1177
01:04:18,000 --> 01:04:20,000
இது உடல் ஒரு சரம் தராது.

1178
01:04:20,000 --> 01:04:22,000
என்று கூட உண்மையில் கருத்து பயன் இல்லை.

1179
01:04:22,000 --> 01:04:24,000
அது மீண்டும் ஒரு எண் என்ன.

1180
01:04:24,000 --> 01:04:28,000
அந்த எண், நினைவகத்தில் வணக்கம் முகவரி இல்லை

1181
01:04:28,000 --> 01:04:32,000
மற்றும் சரம் கள் பிறகு, நாம் மீண்டும் தலாம் இந்த அடுக்கு, சரம் உண்மையில் இல்லை என்றால்.

1182
01:04:32,000 --> 01:04:35,000
அது மட்டும் CS50 நூலகத்தில் ஒரு தெளிவுபடுத்தல் தான்.

1183
01:04:35,000 --> 01:04:38,000
>> இந்த உண்மையில் எரிப்பதை * என்று ஒன்று இருக்கிறது.

1184
01:04:38,000 --> 01:04:41,000
என்ன வணக்கம் போன்ற ஒரு வார்த்தை தான் சார் அர்த்தம்?

1185
01:04:41,000 --> 01:04:44,000
சரி, அதை எழுத்துகள் ஒரு தொடர், பாத்திரங்கள் ஒரு தொடர்.

1186
01:04:44,000 --> 01:04:47,000
கரி *, ஒரு பாத்திரம் முகவரி பொருள்

1187
01:04:47,000 --> 01:04:50,000
அதனால் என்ன, அது ஒரு சரம் திரும்ப அர்த்தம்?

1188
01:04:50,000 --> 01:04:53,000
ஒரு சரம் திரும்பி ஒரு நல்ல, எளிய வழி

1189
01:04:53,000 --> 01:04:57,000
இது தவிர, நான் 5 அல்லது 6 வெவ்வேறு பைட்டுகள் திரும்பி எப்படி கண்டுபிடிக்க முயற்சி

1190
01:04:57,000 --> 01:05:01,000
என்னை பைட் என்ற முகவரிக்கு திருப்பி விட?

1191
01:05:01,000 --> 01:05:03,000
முதல் ஒரு.

1192
01:05:03,000 --> 01:05:06,000
வேறுவிதமாக கூறினால், என்னை நீங்கள் நினைவு ஒரு பாத்திரம் முகவரி கொடுத்து விடுங்கள்.

1193
01:05:06,000 --> 01:05:10,000
என்று, கரி * பிரதிபலிக்கிறது என்ன நினைவகத்தில் ஒரு ஒற்றை தன்மை முகவரி.

1194
01:05:10,000 --> 01:05:12,000
என்று மாறி கள் அழைப்பு.

1195
01:05:12,000 --> 01:05:15,000
நான் தன்னிச்சையாக அவர் எந்த குறிப்பிட்ட முகவரி, 0 என்று கள் அங்காடியில்,

1196
01:05:15,000 --> 01:05:19,000
நான் விஷயங்களை எளிமையாக வைத்து, ஆனால் உண்மையில் இது பொதுவாக ஒரு பெரிய எண்.

1197
01:05:19,000 --> 01:05:21,000
>> ஒரு நிமிடம்.

1198
01:05:21,000 --> 01:05:23,000
நீங்கள் மட்டும் எனக்கு முதல் எழுத்து முகவரி கொடுத்து என்றால், எப்படி நான் முகவரி என்ன தெரியுமா

1199
01:05:23,000 --> 01:05:25,000
இரண்டாவது தன்மை, மூன்றாவது, நான்காவது மற்றும் ஐந்தாவது?

1200
01:05:25,000 --> 01:05:27,000
[செவிக்கு புலப்படாமல்-மாணவர்]

1201
01:05:27,000 --> 01:05:31,000
சரம் இறுதியில் இந்த எளிய தந்திரம் மூலம் எங்கே நீங்கள் மட்டுமே தெரியும்,

1202
01:05:31,000 --> 01:05:35,000
எனவே உங்களை போன்ற printf ஏதாவது பயன்படுத்த போது, என்ன printf மொழியில், அதன் வாதம் ஆகும்

1203
01:05:35,000 --> 01:05:39,000
இந்த% கள் ஒதுக்கிட பயன்படுத்தும் நினைவு, பின் நீங்கள் அனுப்ப

1204
01:05:39,000 --> 01:05:41,000
ஒரு சரம் சேமித்து என்று மாறி.

1205
01:05:41,000 --> 01:05:47,000
என்ன நீங்கள் உண்மையில் செல்லும் என்று சரம் முதல் தன்மை முகவரி.

1206
01:05:47,000 --> 01:05:50,000
Printf பின்னர், அந்த முகவரியை பெற்று மீது வளைய அல்லது ஒரு வட்டத்திற்கு ஒரு பயன்படுத்துகிறது

1207
01:05:50,000 --> 01:05:53,000
உதாரணமாக, 0, எனவே, என்னை இப்போது இந்த செய்வோம்

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n" கள்);

1209
01:06:02,000 --> 01:06:07,000
நான் அழைக்க போது printf ("% s \ n" கள்); என்ன நான் உடன் printf வழங்கும்

1210
01:06:07,000 --> 01:06:13,000
இந்த தன்னிச்சையான வழக்கில் எச் இது கள் முதல் பாத்திரம் முகவரி, இது

1211
01:06:13,000 --> 01:06:16,000
>> எப்படி printf திரையில் காண்பிக்க சரியாக என்ன தெரியும்?

1212
01:06:16,000 --> 01:06:19,000
நடைமுறைப்படுத்தப்படும் நபர் printf லூப் ஒரு வட்டத்திற்கு அல்லது செயல்படுத்தப்படவில்லை

1213
01:06:19,000 --> 01:06:23,000
இந்த பாத்திரம் சிறப்பு வெற்று தன்மையை சமமாக என்று?

1214
01:06:23,000 --> 01:06:25,000
இல்லை என்றால், அதை அச்சிட்டு. எப்படி இந்த ஒரு?

1215
01:06:25,000 --> 01:06:28,000
இது அச்சிட இல்லை என்றால், அதை அச்சிட்டு அதை அச்சிட்டு, அதை அச்சிட்டு.

1216
01:06:28,000 --> 01:06:32,000
ஓ, இந்த ஒரு சிறப்பு உள்ளது. அச்சிடுதல் நிறுத்த மற்றும் பயனர் திரும்ப.

1217
01:06:32,000 --> 01:06:35,000
மற்றும் அந்த மொழியில் பேட்டை அடியில் நடந்துகொண்டிருக்கிறது என்று எல்லாம்

1218
01:06:35,000 --> 01:06:38,000
என்று, ஒரு வர்க்கம் முதல் நாளில் ஜீரணிக்கமுடியுமா நிறைய

1219
01:06:38,000 --> 01:06:43,000
ஆனால் இப்போது அது உண்மையில் புரிந்து எல்லாம் கட்டுமான தொகுதி தான்

1220
01:06:43,000 --> 01:06:46,000
என்று, நம் கணினியின் நினைவகம் உள்ளே

1221
01:06:46,000 --> 01:06:49,000
இறுதியில் நாம் ஒரு சிறிய உதவியுடன் இந்த தவிர கிண்டலடிக்கிறேன்

1222
01:06:49,000 --> 01:06:51,000
ஸ்டான்போர்ட் எங்கள் நண்பர்கள் ஒன்று.

1223
01:06:51,000 --> 01:06:56,000
>> ஸ்டான்போர்ட் பேராசிரியர் நிக் Parlante இந்த அற்புதமான வீடியோ காட்சியில் செய்தது

1224
01:06:56,000 --> 01:06:58,000
அறிமுகப்படுத்தப்பட்டது என்று வெவ்வேறு மொழிகளில் அனைத்து வகையான இருந்து

1225
01:06:58,000 --> 01:07:00,000
இந்த சிறிய Claymation தன்மையை Binky.

1226
01:07:00,000 --> 01:07:03,000
நீங்கள் ஒரு சில இரண்டாவது பதுக்கல் முன்னோட்டமாக உள்ள கேட்க பற்றி நீங்கள் குரல்

1227
01:07:03,000 --> 01:07:05,000
ஒரு ஸ்டான்போர்ட் பேராசிரியராக என்று, நீ வருகிறோம்

1228
01:07:05,000 --> 01:07:07,000
இது சரியான மட்டுமே 5 அல்லது 6 வினாடிகள் இப்போது,

1229
01:07:07,000 --> 01:07:09,000
ஆனால் இந்த நாம் இன்று முடிக்க வேண்டும் என்ற குறிப்பு இல்லை

1230
01:07:09,000 --> 01:07:11,000
மற்றும் புதன்கிழமை தொடங்குகிறது.

1231
01:07:11,000 --> 01:07:15,000
நான் Binky, முன்னோட்ட உடன் சுட்டி வேடிக்கை கொடுக்க.

1232
01:07:15,000 --> 01:07:18,000
[♪ இசை ♪] [பேராசிரியர் Parlante] ஏய், Binky.

1233
01:07:18,000 --> 01:07:21,000
எழுந்திரு. அதை சுட்டிக்காட்டி வேடிக்கை நேரம்.

1234
01:07:21,000 --> 01:07:24,000
[Binky] என்று என்ன? சுட்டிகள் பற்றி அறிய?

1235
01:07:24,000 --> 01:07:26,000
ஓ, நல்லவன்!

1236
01:07:26,000 --> 01:07:29,000
>> நாம் புதன்கிழமை நீங்கள் பார்ப்போம்.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]