1
00:00:00,000 --> 00:00:02,500
[Powered by Google Translate] [பகுதி 5 - மேலும் வசதியான]

2
00:00:02,500 --> 00:00:04,690
[ராப் Bowden - ஹார்வர்ட் பல்கலைக்கழகம்]

3
00:00:04,690 --> 00:00:07,250
[இந்த CS50 உள்ளது. - CS50.TV]

4
00:00:08,990 --> 00:00:14,250
>> நான் என் மின்னஞ்சல் கூறினார் போல், நீங்கள் பயன்படுத்தலாம் நிறைய விஷயங்கள் உள்ளன

5
00:00:14,250 --> 00:00:17,060
உண்மையில் பிரச்சினை செட் செய்ய சாதனம் வேறு.

6
00:00:17,060 --> 00:00:19,910
நாம் இன்னும் எளிதாக உங்களுக்கு உதவ முடியும் உன்னால் பயன்பாட்டிற்கான அதை செய்ய பரிந்துரை

7
00:00:19,910 --> 00:00:22,070
நாங்கள் எல்லாம் வேலை என்ன தெரியுமா.

8
00:00:22,070 --> 00:00:26,950
ஆனால் என்ன, நீங்கள் எல்லாம் செய்ய முடியும் ஒரு உதாரணமாக, நீங்கள் அணுக இல்லை

9
00:00:26,950 --> 00:00:31,570
ஒரு கருவியை அல்லது நீங்கள் அறிவியல் மையம் அடித்தள வேலை செய்ய வேண்டும் -

10
00:00:31,570 --> 00:00:33,090
இது உண்மையில் அவர்கள் மிகவும் பயன்பாட்டிற்கான வேண்டும் -

11
00:00:33,090 --> 00:00:35,150
நீங்கள் எங்கு வேலை விரும்பினால்.

12
00:00:35,150 --> 00:00:42,370
ஒரு எடுத்துக்காட்டாக நீங்கள் பார்த்து / SSH கேட்டுவிட்டேன்?

13
00:00:44,380 --> 00:00:47,780
SSH தான் ஏதாவது இணைக்க போன்ற அடிப்படையில்.

14
00:00:47,780 --> 00:00:51,340
உண்மையில், இப்போது நான் பயன்பாட்டிற்கான ஒரு SSHed.

15
00:00:51,340 --> 00:00:54,290
நான் பயன்பாட்டிற்கான நேரடியாக வேலை இல்லை.

16
00:00:55,930 --> 00:01:01,060
இங்கே பயன்பாடு, மற்றும் நீங்கள் இங்கு இருக்கும் நீங்கள் இந்த ஐபி முகவரியை பார்க்கவும்.

17
00:01:01,060 --> 00:01:03,650
நான் பயன்பாட்டிற்கான தன்னை வேலை இல்லை;

18
00:01:03,650 --> 00:01:08,840
நான் எப்போதும் ஒரு iTerm2 சாளரத்தில் / முனைய சாளரத்தில் வருவாள்.

19
00:01:08,840 --> 00:01:15,910
நீங்கள் ஐபி முகவரி, ssh jharvard@192.168.129.128 செய்ய SSH முடியும்.

20
00:01:15,910 --> 00:01:20,390
இது போன்ற ஒரு நல்ல முறை தான் நான் மிகவும் எளிதாக அந்த எண்ணை நினைவில்.

21
00:01:20,390 --> 00:01:24,920
ஆனால் அந்த என்னுடைய கடவுச்சொல்லை என்னை கேட்பார்கள், இப்போது நான் பயன்பாட்டிற்கான இருக்கிறேன்.

22
00:01:24,920 --> 00:01:33,060
அடிப்படையில், இந்த கட்டத்தில், நீங்கள், பயன்பாடு தன்னை உள்ளே ஒரு முனை திறந்து

23
00:01:33,060 --> 00:01:36,350
இந்த இடைமுகம், ஆனால் நீங்கள் அதை பயன்படுத்த முடியும், அதே தான்

24
00:01:36,350 --> 00:01:40,010
முகப்பு நான் இங்கு பயன்படுத்தி ஆனால் இப்போது நீங்கள் SSHed நீங்கள்.

25
00:01:42,240 --> 00:01:44,920
நீங்கள் பயன்பாட்டிற்கான ஒரு SSH இல்லை.

26
00:01:44,920 --> 00:01:52,360
நீங்கள் எப்படி SSH மற்றொரு இடத்தில் ஒரு எடுத்துக்காட்டாக நீங்கள் முன்னிருப்பாக இருக்கும் அழகான நிச்சயமாக இல்லை -

27
00:01:52,360 --> 00:01:55,020
ஓ. பெரிய.

28
00:01:55,020 --> 00:02:01,130
நீங்கள் அனைத்து எஃப்.ஏ. எஸ் சேவையகங்களில் முன்னிருப்பு எஃப்.ஏ. எஸ் கணக்குகள் மூலம் வேண்டும்.

29
00:02:01,130 --> 00:02:06,840
எனக்கு, நான் SSH rbowden@nice.fas.harvard.edu வேண்டும் என்று.

30
00:02:06,840 --> 00:02:11,610
அதை நீங்கள் தான் முதல் முறையாக 'to ask நடக்கிறது, நீங்கள் சம்மதிக்கிறேன்.

31
00:02:11,610 --> 00:02:15,840
என்னுடைய கடவுச்சொல்லை என் எஃப்.ஏ. எஸ் கடவுச்சொல்லை போகிறது.

32
00:02:15,840 --> 00:02:22,650
அதனால் இப்போது, நான் நல்ல சேவையகங்களுக்கு SSHed, மற்றும் நான் இங்கே எதை வேண்டுமானாலும் செய்ய முடியும்.

33
00:02:22,650 --> 00:02:28,560
நீங்கள் 124 போன்ற ஆகலாம் வகுப்புகள் நிறைய, நீங்கள் இங்கு பொருட்களை ஏற்ற வேண்டும் போகிறீர்கள்

34
00:02:28,560 --> 00:02:30,950
உண்மையில் உங்கள் பிரச்சினை செட் சமர்ப்பிக்க.

35
00:02:30,950 --> 00:02:34,100
ஆனால் நீங்கள் உங்கள் பயன்பாட்டிற்கான அணுகல் இல்லை என்று.

36
00:02:34,100 --> 00:02:37,910
பிறகு, விஷயங்களை செய்ய இங்கே இப்படி சொல்ல முடியும் -

37
00:02:37,910 --> 00:02:42,160
இந்த கேள்விகள் நம் பிரிவு.

38
00:02:42,160 --> 00:02:45,070
இது பயன்பாட்டிற்கான இந்த செய்ய நீங்கள் கேட்க வேண்டும்.

39
00:02:45,070 --> 00:02:47,790
அதற்கு பதிலாக நான் சர்வரில் அதை செய்கிறேன்.

40
00:02:47,790 --> 00:02:50,560
நான் அந்த zip கோப்பை திறக்க போகிறேன்.

41
00:02:50,560 --> 00:02:55,670
பிரச்சனை நீ gedit போல பயன்படுத்தி பயன்படுத்தப்படும் என்று போகிறது

42
00:02:55,670 --> 00:02:58,160
இரணத்தை அல்லது அதை உள்ளே.

43
00:02:58,160 --> 00:03:01,830
நீங்கள் எஃப்.ஏ. எஸ் சர்வரில் அந்த வேண்டும் போவதில்லை.

44
00:03:01,830 --> 00:03:04,110
அது அனைத்து இந்த உரை இடைமுகத்தை இருக்க போகிறது.

45
00:03:04,110 --> 00:03:09,180
அதனால், அவர்கள் இல்லை என்று ஒரு உரை ஆசிரியர் அறிய அல்லது ஒரு முயற்சி என்று.

46
00:03:09,180 --> 00:03:12,130
அவர்கள் நானோ வேண்டும்.

47
00:03:12,130 --> 00:03:14,990
நானோ பொதுவாக பயன்படுத்த அழகான எளிது.

48
00:03:14,990 --> 00:03:19,470
உங்கள் அம்புகள் பயன்படுத்தி பொதுவாக தட்டச்சு செய்யலாம்.

49
00:03:19,470 --> 00:03:21,250
அதனால் கடுமையாக இல்லை.

50
00:03:21,250 --> 00:03:24,720
நீங்கள் உண்மையில் ஆடம்பரமான பெற விரும்பினால் நீங்கள், Emacs பயன்படுத்தலாம்

51
00:03:24,720 --> 00:03:29,850
நான் கூட Emacs மூட எப்படி என்று தெரியவில்லை, ஏனெனில் இது நான் அநேகமாக திறந்து கூடாது.

52
00:03:29,850 --> 00:03:32,760
கட்டுப்பாடு எக்ஸ், கட்டுப்பாடு சி? Yeah.

53
00:03:32,760 --> 00:03:35,310
அல்லது உங்களுக்கு நான் பயன்படுத்த என்ன இது Vim, பயன்படுத்த முடியும்.

54
00:03:35,310 --> 00:03:37,800
அதனால் அந்த உங்கள் விருப்பங்கள்.

55
00:03:37,800 --> 00:03:43,830
நீங்கள் அதை செய்ய விரும்பவில்லை என்றால், நீங்கள் கூட, நீ பார் என்றால் manual.cs50.net -

56
00:03:43,830 --> 00:03:45,410
ஓ.

57
00:03:45,410 --> 00:03:49,920
ஒரு கணினியில், நீங்கள் SSH, புட்டி பயன்படுத்தி

58
00:03:49,920 --> 00:03:51,940
நீங்கள் தனியாக பதிவிறக்கி வேண்டும் போகிறோம் இது.

59
00:03:51,940 --> 00:03:55,460
ஒரு Mac இல், நீங்கள் இயல்புநிலை பயன்பாடு முனை அல்லது நீங்கள், iTerm2 பதிவிறக்க முடியும்

60
00:03:55,460 --> 00:03:58,490
இது ஒரு நல்ல, ஆடம்பரமான டெர்மினல் போல.

61
00:03:58,490 --> 00:04:03,780
நீங்கள் manual.cs50.net சென்று நீங்கள் Notepad இணைப்பை காண்பீர்கள் + +

62
00:04:03,780 --> 00:04:07,120
இது ஒரு கணினியில் பயன்படுத்த முடியும் என்று.

63
00:04:07,120 --> 00:04:13,340
இது Notepad இருந்து நீங்கள் SFTP உதவுகிறது + + எந்த அடிப்படையில் SSH உள்ளது.

64
00:04:13,340 --> 00:04:17,750
என்ன இந்த உங்களுக்கு உதவும், உள்நாட்டில் உங்கள் கோப்புகளை திருத்த உள்ளது

65
00:04:17,750 --> 00:04:20,670
பிறகு அவர்களை காப்பாற்ற வேண்டும் போதெல்லாம், அதை, nice.fas செய்ய சேமிக்கும்

66
00:04:20,670 --> 00:04:23,670
நீங்கள் அவற்றை இயக்க முடியும்.

67
00:04:23,670 --> 00:04:26,880
ஒரு மேக் மீது சமமான TextWrangler போகிறது.

68
00:04:26,880 --> 00:04:28,760
அதை நீங்கள் தான் செய்ய முடியும்.

69
00:04:28,760 --> 00:04:32,800
இது, நீங்கள் உங்கள் கணினியில் கோப்புகளை திருத்த மற்றும் nice.fas அவற்றை சேமிக்க உதவுகிறது

70
00:04:32,800 --> 00:04:35,730
நீங்கள் அவற்றை இயக்க முடியும்.

71
00:04:35,730 --> 00:04:40,400
நீங்கள் எப்போதாவது ஒரு கருவியை இல்லாமல் மாட்டிக்கொண்டிருக்கிறோம் என்றால், நீங்கள் இந்த விருப்பங்கள்

72
00:04:40,400 --> 00:04:44,230
உங்கள் பிரச்சினை செட் செய்ய இன்னும் வேண்டும்.

73
00:04:44,230 --> 00:04:48,250
ஒரு பிரச்சனை நீங்கள் CS50 நூலகம் வேண்டும் போவதில்லை என்று போகிறது

74
00:04:48,250 --> 00:04:51,580
nice.fas முன்னிருப்பாக என்று இல்லை, ஏனெனில்.

75
00:04:51,580 --> 00:04:55,970
நீங்கள் CS50 நூலகம் பதிவிறக்க முடியும் -

76
00:04:55,970 --> 00:04:58,470
நான் இந்த நேரத்தில் என்று நினைக்கவில்லை.

77
00:04:58,470 --> 00:05:03,270
நீங்கள், CS50 நூலகம் பதிவிறக்கி nice.fas அது தொடர்பாக நகலெடுக்க முடியும்

78
00:05:03,270 --> 00:05:07,450
அல்லது நான் இந்த இடத்தில் நாம் எப்படியும் இனி அதை பயன்படுத்த வேண்டாம் என்று.

79
00:05:07,450 --> 00:05:12,720
நாம் செய்தால் அல்லது, நீங்கள் முறையாக அதற்கு பதிலாக

80
00:05:12,720 --> 00:05:18,480
எப்படியும் CS50 நூலகத்தில் செயல்பாடுகளை செயலாக்கங்கள்.

81
00:05:18,480 --> 00:05:21,370
அதனால் ஒரு கட்டுப்பாடு அவ்வளவு கூடாது.

82
00:05:21,370 --> 00:05:23,710
அந்த என்று.

83
00:05:26,460 --> 00:05:29,820
>> நான் இப்போது பயன்பாட்டிற்கான செல்ல, நாம் உபயோகப்பொருள் எல்லாம் செய்வேன்.

84
00:05:29,820 --> 00:05:37,510
நான் என் மின்னஞ்சல் கூறினார் போல், ஆரம்பத்தில், கேள்விகள் நம் பிரிவை பார்த்து,

85
00:05:37,510 --> 00:05:43,620
நாங்கள் உன்னை பார்க்க வேண்டும் என்று குறுகிய பற்றி பேச வேண்டும்.

86
00:05:43,620 --> 00:05:51,980
நாங்கள் திருப்பி & பைப்புகள் மற்றும் இந்த மூன்று கேள்விகள்.

87
00:05:51,980 --> 00:05:56,070
>> எந்த ஓடை போன்ற செயல்பாடுகளை printf முன்னிருப்பாக எழுத?

88
00:05:56,070 --> 00:05:59,130
ஸ்ட்ரீம் எனவே. ஒரு ஓடை என்ன?

89
00:06:06,520 --> 00:06:15,100
அது சில போல் ஒரு ஸ்ட்ரீம் அடிப்படையில் -

90
00:06:15,100 --> 00:06:21,450
அது கூட 1 வி மற்றும் 0s ஆதாரமாக இல்லை.

91
00:06:21,450 --> 00:06:24,920
அதை இங்கே கேட்டு தான் ஸ்ட்ரீம் தரம் இல்லை.

92
00:06:24,920 --> 00:06:27,250
எனவே தரமான வெளியே ஒரு ஸ்ட்ரீம் நீங்கள், அதை எழுத போது

93
00:06:27,250 --> 00:06:30,940
அதை திரையில் தோன்றும்.

94
00:06:30,940 --> 00:06:36,860
நிலையான அவுட், ஸ்ட்ரீம் மூலம், நீங்கள் மட்டும், 1 வி மற்றும் அதை 0s எழுத பொருள்

95
00:06:36,860 --> 00:06:40,220
மற்றும் நிலையான அவுட் மற்ற இறுதியில் தான் அந்த ஸ்ட்ரீம் இருந்து படிக்கிறார்.

96
00:06:40,220 --> 00:06:43,540
இது 1 வி மற்றும் 0s ஒரு சரம் தான்.

97
00:06:43,540 --> 00:06:45,570
நீங்கள் நீரோடைகள் எழுத முடியும் அல்லது நீங்கள் நீரோடைகள் இருந்து படிக்க முடியும்

98
00:06:45,570 --> 00:06:47,950
ஸ்ட்ரீம் உண்மையில் என்ன பொறுத்து.

99
00:06:47,950 --> 00:06:52,800
மற்ற இரண்டு இயல்புநிலை நீரோடைகள் மற்றும் நிலையான பிழை தரமானதாக இருக்கும்.

100
00:06:52,800 --> 00:06:57,540
நீங்கள் GetString செய்ய போதெல்லாம் நிர்ணயமாக இருக்கிறது, அதை நீங்கள் உள்ளீடு பொருள் காத்திருக்கின்றனர்.

101
00:06:57,540 --> 00:07:01,570
அதனால் உனக்காக காத்திருக்கிறேன், அது உண்மையில், நிலையான மீது காத்துக்கொண்டிருக்கிறார்

102
00:07:01,570 --> 00:07:04,880
இதில் நீங்கள் விசைப்பலகை உள்ள தட்டச்சு போது நீங்கள் என்ன உண்மையில்.

103
00:07:04,880 --> 00:07:07,530
நீங்கள் தரமான முறையில் தட்டச்சு

104
00:07:07,530 --> 00:07:10,050
நிலையான பிழை, நிலையான வெளியே செல்ல அடிப்படையில் சமமாக

105
00:07:10,050 --> 00:07:13,280
நீங்கள் நிலையான பிழை அச்சிட போது ஆனால், அந்த சிறப்பு தான்

106
00:07:13,280 --> 00:07:16,770
நீங்கள் தான் பிழை செய்திகளை அச்சிட வேண்டும்

107
00:07:16,770 --> 00:07:20,200
எனவே நீங்கள் திரையில் அச்சிடப்பட்டு வழக்கமான செய்திகளை பாகுப்படுத்தி

108
00:07:20,200 --> 00:07:24,560
அவர்கள் தரமான அவுட் அல்லது நிலையான பிழை சென்றார் என்பதை பொறுத்து பிழை செய்திகளை எதிராக.

109
00:07:24,560 --> 00:07:28,660
மிகவும் கோப்புகள்.

110
00:07:28,660 --> 00:07:32,440
நிலையான அவுட், நிலையான மற்றும் நிலையான பிழை, ஒரு சிறப்பு போக்குகள்

111
00:07:32,440 --> 00:07:36,810
ஆனால் உண்மையில் எந்த கோப்பு, நீங்கள் ஒரு கோப்பை திறக்கும் போது, அது பைட்டுகள் ஒரு ஓடை ஆகிறது

112
00:07:36,810 --> 00:07:40,740
எங்கே அந்த ஸ்ட்ரீம் இருந்து படிக்க முடியும்.

113
00:07:40,740 --> 00:07:47,770
நீங்கள், பெரும்பாலான, வெறும் பைட்டுகள் ஒரு ஓடை போல் ஒரு கோப்பு நினைக்க முடிகிறது.

114
00:07:47,770 --> 00:07:51,190
அதனால் என்ன நீரோடைகள் அவர்கள் இயல்பாக எழுத வேண்டும்? நிலையான அவுட்.

115
00:07:51,190 --> 00:07:56,980
>> > மற்றும் >> என்ன வித்தியாசம்?

116
00:07:58,140 --> 00:08:03,710
யாராவது முன்பே வீடியோ பார்க்க? சரி.

117
00:08:03,710 --> 00:08:10,960
>, நீங்கள் கோப்புகளில் திருப்பி எப்படி இருக்க போகிறது

118
00:08:10,960 --> 00:08:15,240
மேலும் >> மேலும், கோப்புகளில் வெளியீடு திருப்பி போகிறது

119
00:08:15,240 --> 00:08:17,820
ஆனால் அதற்கு பதிலாக கோப்பில் சேர்க்க வேண்டும் நடக்கிறது.

120
00:08:17,820 --> 00:08:23,430
உதாரணமாக, நாம் நான், சரி இங்கே dict வேண்டும் நடக்கும் என்று

121
00:08:23,430 --> 00:08:27,020
மற்றும் dict உள்ளே மட்டுமே பொருட்களை பூனை, பூனை, நாய், மீன், நாய்.

122
00:08:27,020 --> 00:08:31,530
நீங்கள் கட்டளை வரியில் என்று ஒரு கட்டளை, பூனை,

123
00:08:31,530 --> 00:08:34,539
இது ஒரு கோப்பில் என்ன அச்சிட வேண்டும்.

124
00:08:34,539 --> 00:08:40,679
அதனால் நான் பூனை dict என்று சொல்லும் போது, அது பூனை, பூனை, நாய், மீன், நாய் அச்சிட நடக்கிறது. அனைத்து பூனை இல்லை தான்.

125
00:08:40,679 --> 00:08:46,280
அது பூனை, பூனை, நாய், மீன், நாய் வெளியே நிலையான அச்சிடப்பட்டு என்று பொருள்.

126
00:08:46,280 --> 00:08:53,240
நான் அதற்கு பதிலாக ஒரு கோப்பு என்று திருப்பி விரும்பினால், நான் பயன்படுத்த> மற்றும் கோப்பு என்ன அதை திருப்பி முடியும்.

127
00:08:53,240 --> 00:08:56,460
நான் கோப்பு கோப்பு அழைக்கிறேன்.

128
00:08:56,460 --> 00:09:00,320
நான் ls என்றால் இப்போது, நான் கோப்பை என்று அழைக்கப்படும் ஒரு புதிய கோப்பு வேண்டும் என்று பார்க்கிறேன்.

129
00:09:00,320 --> 00:09:05,700
நான் அதை திறந்து என்றால், அது பூனை கட்டளை வரியில் வைத்து சரியாக என்ன வேண்டும் நடக்கிறது.

130
00:09:05,700 --> 00:09:11,040
நான் மீண்டும் அந்த செய்தால் அதனால் இப்போது, அது, கோப்பில் வெளியீடு திருப்பிவிட நடக்கிறது

131
00:09:11,040 --> 00:09:13,930
நான் அதே சரியான விஷயம் தான் போகிறேன்.

132
00:09:13,930 --> 00:09:17,910
எனவே தொழில்நுட்ப, அது முற்றிலும் நாம் என்ன overrode.

133
00:09:17,910 --> 00:09:22,970
நான் dict மாற்ற நாம் பார்க்கலாம், நான் நாய் வெளியே எடுத்தார்.

134
00:09:22,970 --> 00:09:29,980
இப்போது மீண்டும் கோப்பில் நாம் பூனை dict என்றால், நாம் நாய் நீக்கப்பட்டு புதிய பதிப்பு போகிறது.

135
00:09:29,980 --> 00:09:32,400
அது முற்றிலும் இது மீறப்படும்.

136
00:09:32,400 --> 00:09:36,640
நாம் >> பயன்படுத்தினால், அதற்கு பதிலாக, அதை கோப்பு சேர்க்க வேண்டும் நடக்கிறது.

137
00:09:36,640 --> 00:09:40,860
இப்போது, கோப்பு திறந்து, நாம் இருமுறை அச்சிடப்படும் மட்டும் தான் இருக்கிறது

138
00:09:40,860 --> 00:09:44,920
இது ஒரு முறை இருந்தது ஏனெனில், நாம் உண்மையான இணைக்கப்படும்.

139
00:09:44,920 --> 00:09:48,130
எனவே என்ன> மற்றும் >> செய்ய.

140
00:09:48,130 --> 00:09:50,580
அடுத்த ஒரு ask - அது பற்றி கேட்க கூடாது.

141
00:09:50,580 --> 00:09:59,050
>> நாம் வேறு ஒரு நிலையான அவுட் வழிமாற்றுகளை <இருந்தால்,>, தான்

142
00:09:59,050 --> 00:10:01,970
<நிலையான உள்ளே திருப்பி போகிறது

143
00:10:01,970 --> 00:10:12,050
நாம் ஒரு உதாரணம் இருந்தால் பார்க்கலாம்.

144
00:10:14,750 --> 00:10:16,930
நான் ஒரு உண்மையான விரைவு எழுத முடியும்.

145
00:10:17,870 --> 00:10:25,700
அது எந்த கோப்பு, hello.c அழைத்து செல்லலாம்.

146
00:10:56,060 --> 00:10:59,070
நேரடியாக கோப்பு.

147
00:10:59,070 --> 00:11:03,570
நான் நான் உள்ளிட்ட சரம் தான் என்ன "வணக்கம்" அச்சிடும் பின்னர் ஒரு சரம் பெறுவது மற்றும்.

148
00:11:03,570 --> 00:11:07,990
அதனால் ஹலோ ஹலோ பின்னர் செய்ய. /.

149
00:11:07,990 --> 00:11:10,720
இப்போது அது, ஏதாவது நுழைய எனக்கு தூண்டுதல்

150
00:11:10,720 --> 00:11:15,070
அது உள்ளே நிலையான நுழைந்தது வேண்டும் விஷயங்களை காத்து பொருள்

151
00:11:15,070 --> 00:11:20,450
எனவே நாங்கள் ராப், வணக்கம் சொல்ல போகிறோம் உள்ளே நான் தரமான கொண்டு என்ன வேண்டுமானாலும் நுழைய!

152
00:11:20,450 --> 00:11:23,310
அது, வணக்கம் அவுட் தரத்தை ராப் அச்சிடும்!

153
00:11:23,310 --> 00:11:28,860
நான். / ஹலோ பின்னர் திருப்பி, செய்தால்

154
00:11:30,740 --> 00:11:34,310
இப்போது நீங்கள் மட்டுமே ஒரு கோப்பு இருந்து திருப்பி முடியும்.

155
00:11:34,310 --> 00:11:41,720
நான் சில கோப்பு, txt வைக்க, நான், ராப் வைத்து இருந்தால்

156
00:11:41,720 --> 00:11:52,300
நான் ஹலோ ரன் பின்னர் இந்த கோப்பு txt திருப்பிவிட வேண்டும். / ஹலோ, இது ராப், வணக்கம் சொல்ல நடக்கிறது! உடனடியாக.

157
00:11:52,300 --> 00:11:57,160
அது முதல் GetString கிடைத்தால் அது, நிலையான மீது காத்து போது

158
00:11:57,160 --> 00:12:01,730
நிலையான உள்ளிட்ட கொள்ள தரவு விசைப்பலகை காத்திருக்கின்றன இல்லை.

159
00:12:01,730 --> 00:12:05,980
அதற்கு பதிலாக, நாம் கோப்பு txt இருந்து வாசிக்க நிலையான திருப்பிவிடப்பட்டது.

160
00:12:05,980 --> 00:12:10,290
எனவே இது வெறும் வரி ராப் இது கோப்பு txt, இருந்து வாசிக்க நடக்கிறது

161
00:12:10,290 --> 00:12:13,380
பின்னர் அதை வணக்கம், ராப் அச்சிட நடக்கிறது!

162
00:12:13,380 --> 00:12:18,180
நான் விரும்பினால், நான் என்ன செய்ய முடியும். / ஹலோ <txt

163
00:12:18,180 --> 00:12:21,500
பின்னர் நிலையான என்று வணக்கம் இது அது அச்சிடுதல், ராப்!,

164
00:12:21,500 --> 00:12:24,700
நான் அதன் சொந்த கோப்பில் என்று திருப்பி முடியும்.

165
00:12:24,700 --> 00:12:29,790
நான் ஹலோ கோப்பு அழைக்கிறேன் - இல்லை, நான் மாட்டேன், என்று இயங்கக்கூடிய காரணம் - txt2.

166
00:12:29,790 --> 00:12:40,150
இப்போது, txt2 வணக்கம் போகிறது இது. / ஹலோ <txt, ராப் வெளியீடு போகிறாள்!

167
00:12:41,370 --> 00:12:43,520
>> கேள்விகள்?

168
00:12:45,900 --> 00:12:49,090
>> சரி. அப்படியென்றால், இங்கே நாம் குழாய் உள்ளது.

169
00:12:49,090 --> 00:12:53,510
குழாய்கள் திருப்பிவிட கடைசி அலகு ஆகும்.

170
00:12:53,510 --> 00:12:58,750
>> ஓ. நான் திருப்பிவிட இன்னும் ஒரு யூனிட் என்றால் பதிலாக நினைக்கிறேன்> நீங்கள் 2 செய்ய>,

171
00:12:58,750 --> 00:13:01,070
நிலையான பிழை திருப்பி.

172
00:13:01,070 --> 00:13:06,280
ஏதாவது நிலையான பிழை சென்று இருந்தால், அதை txt2 வந்தது.

173
00:13:06,280 --> 00:13:12,480
ஆனால் நான் 2> செய்தால் கவனிக்க, அது இன்னும் ராப், வணக்கம் அச்சிடும்! கட்டளை வரியில்

174
00:13:12,480 --> 00:13:18,600
நான் மட்டுமே நிலையான பிழை திருப்பி இருக்கிறது, ஏனென்றால், நான் தரமான அவுட் திருப்பி இல்லை.

175
00:13:18,600 --> 00:13:22,210
நிலையான பிழை மற்றும் நிலையான வெளியே உள்ளன.

176
00:13:24,210 --> 00:13:27,080
நீங்கள் உண்மையில் நிலையான பிழை எழுத வேண்டும், என்று

177
00:13:27,080 --> 00:13:35,080
நான் stderr செய்ய fprintf இந்த மாற்ற முடியும்.

178
00:13:35,080 --> 00:13:37,850
எனவே printf, முன்னிருப்பாக, நிலையான அவுட் செய்ய அச்சிடுகிறது.

179
00:13:37,850 --> 00:13:41,720
நான் கைமுறையாக நிலையான பிழை அச்சிட வேண்டும் என்றால், நான் fprintf பயன்படுத்த வேண்டும்

180
00:13:41,720 --> 00:13:45,010
மற்றும் நான் அச்சிட வேண்டும் என்று குறிப்பிடவும்.

181
00:13:45,010 --> 00:13:49,720
அதற்கு பதிலாக நான் fprintf stdout செய்தால், பின் அந்த printf செய்ய அடிப்படையில் சமமாக இருக்கும்.

182
00:13:49,720 --> 00:13:55,530
ஆனால் fprintf நிலையான பிழை.

183
00:13:57,790 --> 00:14:03,650
அதனால் இப்போது, நான் txt2 இந்த திருப்பிவிட என்றால், வணக்கம், ராப்! இன்னும் கட்டளை வரியில் அச்சிட

184
00:14:03,650 --> 00:14:08,270
அது நிலையான பிழை அச்சிடப்பட்டு மற்றும் நான் மட்டுமே நிலையான அவுட் திருப்பி நான் இருந்து.

185
00:14:08,270 --> 00:14:16,420
நான் இப்போது தரமான பிழை திருப்பி என்றால், இப்போது அதை அச்சிட்டு, மற்றும் txt2, வணக்கம் ராப் போகிறது!

186
00:14:16,420 --> 00:14:21,910
அதனால் இப்போது, நீங்கள் நிலையான பிழை உங்கள் உண்மையான பிழைகள் அச்சிட முடியாது

187
00:14:21,910 --> 00:14:24,720
மற்றும் நிலையான அவுட் உங்கள் வழக்கமான செய்திகளை அச்சிட.

188
00:14:24,720 --> 00:14:31,420
உங்கள் நிரலை எனவே போது, நீங்கள் 2 ஹலோ இந்த வகை அதை ரன். / முடியாது>

189
00:14:31,420 --> 00:14:33,800
உங்கள் திட்டம், பொதுவாக இயக்க போகிறார் என்று

190
00:14:33,800 --> 00:14:38,400
ஆனால் நீங்கள் எனக்கு எந்த பிழை செய்திகளை, உங்கள் பிழை பதிவு பின்னர் பார்க்கலாம்

191
00:14:38,400 --> 00:14:44,500
பிழைகள் மிகவும், பின்னர் பார்த்து உங்கள் பிழைகள் கோப்பு நடந்தது என்று எந்த பிழைகளை வேண்டும்.

192
00:14:45,200 --> 00:14:47,540
>> கேள்விகள்?

193
00:14:47,540 --> 00:14:58,070
>> கடந்த ஒரு ஒரு கட்டளை இருந்து நிலையான வெளியே எடுத்து என நினைக்க முடியும் குழாய், இல்லை

194
00:14:58,070 --> 00:15:01,210
அது அடுத்த கட்டளை நிலையான செய்யும்.

195
00:15:01,210 --> 00:15:05,570
ஒரு எடுத்துக்காட்டாக இங்கே எதிரொலி ஒரு கட்டளை வரி விஷயம்

196
00:15:05,570 --> 00:15:11,840
என்று தான் நான் அதன் வாதம் என்று வைத்து என்ன எதிரொலி போகிறது. நான் மேற்கோள் மாட்டான்.

197
00:15:11,840 --> 00:15:16,150
எதிரொலி அபத்தம், அபத்தம், அபத்தம் வெறும் அபத்தம், அபத்தம், அபத்தம் அச்சிட வேண்டும்.

198
00:15:16,150 --> 00:15:20,600
முன், நான் சொல்லும் போது நான் ஒரு txt கோப்பில் ராப் வைத்து இருந்தது

199
00:15:20,600 --> 00:15:28,830
நான் மட்டும் txt கோப்புகளை திருப்பி, அதற்கு பதிலாக ஏனெனில், / நான் ராப் எதிரொலி என்றால்

200
00:15:28,830 --> 00:15:35,520
பின்னர் குழாய் அது. / ஹலோ, அந்த விஷயத்தை அதே வகை செய்யும்.

201
00:15:35,520 --> 00:15:39,160
இந்த கட்டளையை வெளியீடு, எதிரொலி ராப், எடுக்கிறது

202
00:15:39,160 --> 00:15:43,610
மற்றும் உள்ளீடு அதை பயன்படுத்தி. / ஹலோ.

203
00:15:44,790 --> 00:15:49,560
நீங்கள் முதலில் ஒரு கோப்பில் எதிரொலி ராப் திருப்பி அதை நினைக்க முடிகிறது

204
00:15:49,560 --> 00:15:54,160
பின்னர். / ஹலோ என்று கோப்பில் உள்ளீடு தான் outputted என்று.

205
00:15:54,160 --> 00:15:57,850
ஆனால் அது படம் தற்காலிகமாக கோப்பினை எடுக்கும்.

206
00:16:01,890 --> 00:16:04,460
>> என்று கேள்விகள்?

207
00:16:04,460 --> 00:16:07,150
>> அடுத்த கேள்வி, இந்த ஈடுபடுத்த போகிறது.

208
00:16:07,150 --> 00:16:15,310
என்ன குழாய் நீங்கள் names.txt என்ற கோப்பில் தனிப்பட்ட பெயர்கள் எண்ணிக்கை கண்டறிய பயன்படுத்த முடியும்?

209
00:16:15,310 --> 00:16:24,160
நாம் இங்கே பயன்படுத்த வேண்டும் போகிறோம் கட்டளைகளை தனிப்பட்ட, அதனால் uniq, பின்னர் WC இருக்கும்.

210
00:16:24,160 --> 00:16:28,840
நீங்கள், உண்மையில் அந்த என்ன இருக்கும் மனிதன் uniq செய்ய முடியும்

211
00:16:28,840 --> 00:16:34,840
அது வெறும் உள்ளீடு இருந்து அருகில் பொருந்தும் வரிகளை வடிகட்ட நடக்கிறது.

212
00:16:34,840 --> 00:16:40,690
மற்றும் மனிதன் WC NEWLINE, வார்த்தை, மற்றும் ஒவ்வொரு கோப்பிலும் பைட் எண்ணிக்கை அச்சிட வேண்டும்.

213
00:16:40,690 --> 00:16:43,760
நாம் பயன்படுத்த வேண்டும் போகிறோம் கடந்த ஒரு மாதிரியான

214
00:16:43,760 --> 00:16:47,410
இது வெறும் txt கோப்பு இணைப்புகள் வரிசைப்படுத்த வேண்டும்.

215
00:16:47,410 --> 00:16:58,080
நான் சில txt கோப்பு, names.txt, மேலும் இது ராப், டாமி, ஜோசப், டாமி, ஜோசப், RJ, ராப், இருந்தால்

216
00:16:58,080 --> 00:17:03,910
என்ன நான் இங்கே செய்ய வேண்டும் இந்த கோப்பில் தனிப்பட்ட பெயர்கள் எண்ணிக்கை கண்டறிய வேண்டும்.

217
00:17:03,910 --> 00:17:08,750
அதனால் பதில் என்ன வேண்டும்? >> [மாணவர்] 4. >> சரி.

218
00:17:08,750 --> 00:17:13,780
இது ராப், டாமி, ஜோசப் முதல் 4 இருக்க வேண்டும், RJ இந்த கோப்பு மட்டுமே தனிப்பட்ட பெயர்கள்.

219
00:17:13,780 --> 00:17:20,180
முதல் கட்டமாக, நான் names.txt வார்த்தை எண்ணிக்கை செய்தால்,

220
00:17:20,180 --> 00:17:24,290
இந்த உண்மையில் எனக்கு எல்லாம் சொல்கிறார்.

221
00:17:24,290 --> 00:17:32,560
இந்த உண்மையில் அச்சிடும் உள்ளது - newlines, வார்த்தைகள், மற்றும் பைட் எண்ணிக்கை - மனிதன் WC, பார்க்கலாம்.

222
00:17:32,560 --> 00:17:38,270
நான் மட்டும் வரிகளை பற்றி கவலை என்றால், பிறகு நான் WC-l names.txt செய்ய முடியும்.

223
00:17:41,730 --> 00:17:44,300
அதனால் படி 1 தான்.

224
00:17:44,300 --> 00:17:50,510
Names.txt தான் அனைத்து பெயர்கள் உள்ளன ஏனெனில் ஆனால் நான், WC-l names.txt விரும்பவில்லை

225
00:17:50,510 --> 00:17:54,170
நான் எந்த அல்லாத தனிப்பட்ட ஒருவர் வெளியே வடிகட்ட வேண்டும்.

226
00:17:54,170 --> 00:18:01,200
நான் uniq names.txt செய்தால் அதனால், அந்த மிக எனக்கு என்ன வேண்டுமோ அதை கொடுக்க முடியாது

227
00:18:01,200 --> 00:18:03,760
நகல் பெயர்கள் இன்னும் இருப்பதால்.

228
00:18:03,760 --> 00:18:07,690
அது ஏன்? ஏன் uniq நான் என்ன செய்வது?

229
00:18:07,690 --> 00:18:10,500
[மாணவர்] நகல்களை இல்லை [செவிக்கு புலப்படாமல்] >> சரி.

230
00:18:10,500 --> 00:18:16,370
Uniq ஆண் பக்கம் நினைவில் வடிகட்டி அருகில் பொருத்தம் வரிகளை என்கிறார்.

231
00:18:16,370 --> 00:18:19,680
அவர்கள் அருகில் இல்லை, அதனால் அவர்கள் வடிகட்ட முடியாது.

232
00:18:19,680 --> 00:18:31,100
நான் அவர்களுக்கு முதல் வரிசைப்படுத்த என்றால், வகையான names.txt ஒன்றாக அனைத்து போலி கோடுகள் போட்டு வருகிறது.

233
00:18:31,100 --> 00:18:34,450
எனவே இப்போது வகையான names.txt என்று.

234
00:18:34,450 --> 00:18:40,550
Uniq | நான் எந்த uniq, உள்ளீடு என்று பயன்படுத்த வேண்டும் போகிறேன்.

235
00:18:40,550 --> 00:18:43,390
என்று என்னை ஜோசப், RJ, ராப், டாமி, கொடுக்கிறது

236
00:18:43,390 --> 00:18:49,260
மற்றும் நான், WC-l உள்ளீடு என்று பயன்படுத்த வேண்டும்

237
00:18:49,260 --> 00:18:52,740
இது எனக்கு 4 கொடுக்க போகிறார்.

238
00:18:52,740 --> 00:18:56,930
அதை இங்கே சொல்வது போல, நீ என்ன குழாய் பயன்படுத்த முடியும்?

239
00:18:56,930 --> 00:19:01,390
நீங்கள் கட்டளைகளை ஒரு தொடர் பயன்படுத்தி போன்ற நிறைய விஷயங்களை செய்ய முடியும்

240
00:19:01,390 --> 00:19:05,130
நீங்கள் அடுத்த கட்டளையை உள்ளீடு ஒரு கட்டளை இருந்து வெளியீடு பயன்படுத்தும்.

241
00:19:05,130 --> 00:19:08,780
நீங்கள் நிறைய விஷயங்களை, வீழ்வது நிறைய விஷயங்களை செய்ய முடியும்.

242
00:19:08,780 --> 00:19:11,440
>> கேள்விகள்?

243
00:19:12,910 --> 00:19:14,600
சரி.

244
00:19:14,600 --> 00:19:17,880
குழாய்கள் மற்றும் திருப்பிவிட அது தான்.

245
00:19:18,370 --> 00:19:24,090
>> இப்போது நாம் உண்மையான பொருள், குறியீட்டு பொருள் சென்று.

246
00:19:24,090 --> 00:19:29,100
இந்த PDF உள்ளே, நீ, இந்த கட்டளையை பார்க்கலாம்

247
00:19:29,100 --> 00:19:32,950
உங்கள் சாதனம் இந்த கட்டளையை இயக்க வேண்டும் என்று நான் நினைக்கிறேன்.

248
00:19:36,240 --> 00:19:42,250
wget, அடிப்படையில், இப்போது இணையத்தில் இருந்து ஏதாவது பெற கட்டளை

249
00:19:42,250 --> 00:19:45,180
எனவே wget இந்த URL ஐ.

250
00:19:45,180 --> 00:19:49,110
நீங்கள் உங்கள் உலாவியில் இந்த URL க்கு போனால், அது அந்த கோப்பை பதிவிறக்க வேண்டும்.

251
00:19:49,110 --> 00:19:52,510
நான் அதை கிளிக், அது எனக்கு கோப்பு பதிவிறக்கம்.

252
00:19:52,510 --> 00:19:55,650
ஆனால் முனையம் உள்ளே அந்த விஷயம் wget எழுதி

253
00:19:55,650 --> 00:19:58,620
உங்கள் முனையத்தில் பதிவிறக்கி போகிறது.

254
00:19:58,620 --> 00:20:02,750
, நான் section5.zip வேண்டும், மற்றும் நீங்கள் section5.zip zip கோப்பை திறக்க வேண்டும் என்று நான் நினைக்கிறேன்

255
00:20:02,750 --> 00:20:06,520
இது, நீங்கள் section5 என்று ஒரு கோப்புறையை கொடுக்க போகிறது

256
00:20:06,520 --> 00:20:11,550
நாம் அது உள்ளே இன்று பயன்படுத்தி கொள்ள போகிறோம் கோப்புகள் அனைத்தையும் சாப்பிட போகிறேன் இது.

257
00:20:33,380 --> 00:20:37,710
இந்த திட்டங்கள் 'கோப்பு பெயர்களை பரிந்துரைக்க என, அவர்கள் ஒரு பிட் தரமற்ற தான்,

258
00:20:37,710 --> 00:20:40,990
உங்கள் பணி gdb ஐ பயன்படுத்தி ஏன் கண்டுபிடிக்க வேண்டும்.

259
00:20:40,990 --> 00:20:44,560
அவர்கள் அனைவருக்கும் பதிவிறக்கம் / அவர்களை பதிவிறக்கம் பெற எப்படி தெரியும்

260
00:20:44,560 --> 00:20:47,480
அவற்றின் பயன்பாடு பற்றி? சரி.

261
00:20:47,480 --> 00:20:56,400
>> ./buggy1 இயங்கும், இது, அடுக்கு தவறு (கோர் டம்ப்) கூறுவேன்

262
00:20:56,400 --> 00:21:00,500
இதில் நீங்கள் ஒரு segfault கிடைக்கும் எந்த நேரத்தில், அது ஒரு கெட்ட விஷயம்.

263
00:21:00,500 --> 00:21:03,810
என்ன சூழ்நிலையில் நீங்கள் ஒரு segfault கிடைக்கும்?

264
00:21:03,810 --> 00:21:08,210
[மாணவர்] ஒரு பூஜ்ய சுட்டிக்காட்டி Dereferencing. >> சரி. அதனால் ஒரு உதாரணம் ஆகும்.

265
00:21:08,210 --> 00:21:11,580
நீங்கள் ஒரு segfault போகிறோம் ஒரு பூஜ்ய சுட்டிக்காட்டி Dereferencing.

266
00:21:11,580 --> 00:21:16,720
நீங்கள் நினைவு தொட்டு என்ன ஒரு வழிமுறையாக segfault நீங்கள் தொட்டு கூடாது.

267
00:21:16,720 --> 00:21:21,350
எனவே ஒரு பூஜ்ய சுட்டிக்காட்டி dereferencing, முகவரி 0 தொடும்

268
00:21:21,350 --> 00:21:28,060
மற்றும் அடிப்படையில், அனைத்து கணினிகள் இப்போதெல்லாம் முகவரியை 0 நீ தொட்டு கூடாது நினைவகம் என்று.

269
00:21:28,060 --> 00:21:31,920
ஒரு segfault ஒரு வெற்று சுட்டிக்காட்டி முடிவு dereferencing அதனால் தான்.

270
00:21:31,920 --> 00:21:37,210
நீங்கள் ஒரு சுட்டிக்காட்டி துவக்க முடியவில்லை நடக்கும் போது, அது, ஒரு குப்பை மதிப்பு உள்ளது

271
00:21:37,210 --> 00:21:41,520
அதனால் நீங்கள் dereference முயற்சி போது, அனைத்து வாய்ப்பினை நீங்கள் நினைவு தொடுதல்

272
00:21:41,520 --> 00:21:43,540
என்று எங்கும் மத்தியில் தான்.

273
00:21:43,540 --> 00:21:45,650
நீங்கள் அதிர்ஷ்டசாலி மற்றும் குப்பை மதிப்பு பெற நேர்ந்தால்

274
00:21:45,650 --> 00:21:48,440
ஸ்டாக் அல்லது ஏதாவது எங்காவது சுட்டி நடந்தது,

275
00:21:48,440 --> 00:21:50,820
பிறகு நீங்கள் சுட்டிக்காட்டி துவக்கப்படும் இல்லை என்று நீங்கள் dereference,

276
00:21:50,820 --> 00:21:52,730
எதுவும் தவறாக போம்.

277
00:21:52,730 --> 00:21:55,480
அதை சுட்டி காட்டும் போது ஆனால், எங்கோ ஸ்டேக் மற்றும் குவியல் இடையே, என்று

278
00:21:55,480 --> 00:21:59,850
அல்லது அது எங்கோ, இன்னும் உங்கள் நிரல் பயன்படுத்தப்படுகிறது இல்லை என்று சுட்டி காட்டும்

279
00:21:59,850 --> 00:22:02,240
நீ தொட்டு கூடாது நினைவக தொட்டு நீங்கள் segfault.

280
00:22:02,240 --> 00:22:06,370
நீங்கள் ஒரு சுழல்நிலை செயல்பாடு எழுதி அதை பல முறை recurses போது

281
00:22:06,370 --> 00:22:08,720
உங்கள் ஸ்டேக் விஷயங்களை மிக பெரிய மற்றும் ஸ்டாக் மோதுகிறது வளரும்

282
00:22:08,720 --> 00:22:12,270
நீ தொட்டு அது மோதி கூடாது என்று, நீங்கள் நினைவகத்தை தொட்டு நீங்கள்,

283
00:22:12,270 --> 00:22:14,810
எனவே நீங்கள் segfault.

284
00:22:14,810 --> 00:22:17,010
என்ன ஒரு segfault உள்ளது.

285
00:22:17,010 --> 00:22:21,810
>> அதே காரணம் என்று உங்களை போன்ற ஒரு சரம் இருந்தால் -

286
00:22:21,810 --> 00:22:23,930
முந்தைய திட்டத்தை திரும்ப செல்லலாம்.

287
00:22:23,930 --> 00:22:28,530
இந்த hello.c-I'm நான் வேறு ஏதாவது செய்ய.

288
00:22:28,530 --> 00:22:33,770
கரி * கள் = "ஹலோ உலகம்!";

289
00:22:33,770 --> 00:22:42,310
நான் பயன்படுத்தினால் * கள் = ஒன்று அல்லது கள் [0] = 'எக்ஸ்';

290
00:22:42,310 --> 00:22:47,290
அதனால் ஹலோ செய்ய,. / ஹலோ, ஏன் என்று segfault?

291
00:22:48,410 --> 00:22:51,250
ஏன் இந்த segfault?

292
00:22:55,660 --> 00:22:57,890
நீங்கள் என்ன எதிர்பார்க்கிறீர்கள்?

293
00:22:57,890 --> 00:23:06,640
நான் printf செய்தால் ("% s \ n", கள்); என்ன அச்சிடப்பட்டிருக்கும் எதிர்பார்க்க முடியும்?

294
00:23:06,640 --> 00:23:09,930
[மாணவர்] எக்ஸ் ஹலோ. >> சரி.

295
00:23:09,930 --> 00:23:15,140
பிரச்சனை, நீங்கள் இந்த மாதிரி ஒரு சரம் போது அறிவிக்க உள்ளது

296
00:23:15,140 --> 00:23:18,190
கள், ஸ்டாக் போக நடக்கிறது என்று ஒரு சுட்டி உள்ளது

297
00:23:18,190 --> 00:23:25,880
என்ன கள் குறிக்கும் என்பது வாசிப்பு மட்டும் நினைவகம் உள்ள இந்த சரம்.

298
00:23:25,880 --> 00:23:30,560
வெறும் பெயர், வாசிப்பு மட்டும் நினைவகம் மூலம், நீங்கள் யோசனை வேண்டும்

299
00:23:30,560 --> 00:23:33,010
என்று நீங்கள் வாசிப்பு மட்டும் நினைவக என்ன மாற்ற முயற்சி செய்தால்,

300
00:23:33,010 --> 00:23:36,670
நீங்கள் நினைவகம் செய்யவில்லை ஏதோ செய்கிறாய் நீ segfault.

301
00:23:36,670 --> 00:23:45,360
இந்த உண்மையில் எரிப்பதை * கள் மற்றும் கரி கள் [] இடையில் ஒரு பெரிய வித்தியாசம்.

302
00:23:45,360 --> 00:23:48,790
எனவே எரிப்பதை கள் [], இப்போது இந்த சரம் ஸ்டாக் வைக்க போகிறது,

303
00:23:48,790 --> 00:23:53,960
மற்றும் ஸ்டாக் இந்த செய்தபின் நன்றாக வேலை வேண்டும், அதாவது, படிக்க மட்டுமே அல்ல.

304
00:23:55,500 --> 00:23:57,370
மற்றும் அது.

305
00:23:57,370 --> 00:24:06,250
நினைவில் என்று நான் எரிப்பதை செய்யும் போது * கள் = "ஹலோ உலகம்!", கள் தன்னை ஸ்டாக் உள்ளது

306
00:24:06,250 --> 00:24:10,390
ஆனால் கள் வேறு புள்ளிகளை, மற்றும் வேறு எங்காவது படிக்க மட்டுமே இருக்க நடக்கிறது.

307
00:24:10,390 --> 00:24:15,640
ஆனால் எரிப்பதை கள் [] தான் ஸ்டேக்கில் ஒன்று.

308
00:24:17,560 --> 00:24:21,760
அதனால் ஒரு segfault நடந்து மற்றொரு எடுத்துக்காட்டு.

309
00:24:21,760 --> 00:24:27,820
>> நாம் ./buggy1 ஒரு segfault விளைவாக என்று பார்த்தேன்.

310
00:24:27,820 --> 00:24:31,810
கோட்பாடு, நீங்கள் உடனடியாக buggy1.c பார்க்க கூடாது.

311
00:24:31,810 --> 00:24:35,170
அதற்கு பதிலாக, நாம் gdb ஐ மூலம் அதை பார்க்க வேண்டும்.

312
00:24:35,170 --> 00:24:37,750
நீங்கள் அடுக்கு தவறு (கோர் டம்ப்) கிடைக்கும் போது கவனிக்க,

313
00:24:37,750 --> 00:24:40,850
நீங்கள் இங்கே என்று கோர் இந்த ஃபைலை.

314
00:24:40,850 --> 00:24:45,200
நாம் ls-l என்றால், நாம் அந்த அடிப்படை பொதுவாக ஒரு அழகான பெரிய கோப்பு பார்க்கிறேன்.

315
00:24:45,200 --> 00:24:51,580
இந்த கோப்பு பைட்டுகள் எண்ணிக்கை, அது 250-ஏதாவது கிலோபைட்டுகளை போல் தெரிகிறது.

316
00:24:51,580 --> 00:24:56,120
இந்த காரணம் கோர் டம்ப் உண்மையில் என்ன உள்ளது

317
00:24:56,120 --> 00:25:01,410
இருக்கும் போது, உங்கள் நிரல் செயலிழந்தால், உங்கள் திட்டம் நினைவக நிலை

318
00:25:01,410 --> 00:25:05,230
வெறும் நகல் மற்றும் இந்த கோப்பில் ஒட்டப்படும்.

319
00:25:05,230 --> 00:25:07,270
அந்த கோப்பில் கொட்டப்படுகின்றன.

320
00:25:07,270 --> 00:25:13,060
இந்த திட்டம், அது இயங்கும் போது, 250 சுற்றி கிலோபைட்டுகளை ஒரு நினைவக பயன்பாடு வேண்டும் நடந்தது

321
00:25:13,060 --> 00:25:17,040
எனவே இந்த கோப்பில் டம்ப் நடந்தது என்ன.

322
00:25:17,040 --> 00:25:23,630
நாம் gdb ஐ buggy1 முக்கிய செய்தால் இப்போது நீங்கள் அந்த கோப்பு பார்க்க முடியும்.

323
00:25:23,630 --> 00:25:30,130
நாங்கள் gdb ஐ buggy1 செய்ய முடியும், என்று மட்டும், தொடர்ந்து gdb ஐ தொடங்கும் என்று

324
00:25:30,130 --> 00:25:33,800
அதன் உள்ளீடு கோப்பு buggy1 பயன்படுத்தி.

325
00:25:33,800 --> 00:25:38,260
நீங்கள் gdb ஐ buggy1 முக்கிய செய்தால் ஆனால், அது குறிப்பாக gdb ஐ தொடங்கும் நடக்கிறது

326
00:25:38,260 --> 00:25:40,330
என்று கோர் கோப்பில் பார்த்து.

327
00:25:40,330 --> 00:25:45,560
நீங்கள் buggy1 வழிமுறையாக gdb ஐ கூறி அந்த கோர் கோப்பில் buggy1 திட்டம் வரும் என்று தெரிகிறது.

328
00:25:45,560 --> 00:25:49,580
எனவே gdb ஐ buggy1 முக்கிய உடனடியாக எங்களுக்கு கொண்டு போகிறது

329
00:25:49,580 --> 00:25:52,060
திட்டத்தை நிறுத்தி நடந்தது அங்கு என்று.

330
00:25:57,720 --> 00:26:02,340
நாம் திட்டம் சிக்னல் 11, பிரிவு தவற்றை முடிவு இங்கே பார்க்க.

331
00:26:02,340 --> 00:26:10,110
நாம் ஒருவேளை மிகவும் பயனுள்ளதாக இது சட்டமன்ற, ஒரு வரி பார்க்க நடந்தது.

332
00:26:10,110 --> 00:26:15,360
நீங்கள் BT அல்லது backtrace தட்டச்சு ஆனால், அந்த செயல்பாடு இருக்க போகிறது

333
00:26:15,360 --> 00:26:19,430
என்று எங்கள் தற்போதைய ஸ்டேக் பிரேம்கள் பட்டியலை கொடுக்கிறது.

334
00:26:19,430 --> 00:26:23,150
எனவே backtrace. நாம் இரண்டு அடுக்கு பிரேம்கள் வேண்டும் போல் இருக்கிறது.

335
00:26:23,150 --> 00:26:26,310
முதல், எங்கள் முக்கிய ஸ்டாக் சட்டகமானது உள்ளது

336
00:26:26,310 --> 00:26:29,810
இரண்டாவது, நாம் இருக்க நடக்கும் இந்த விழாவில் ஸ்டாக் சட்டகமானது உள்ளது

337
00:26:29,810 --> 00:26:34,440
நாம் மட்டும் சட்டசபை குறியீடு உள்ளது போன்ற எந்த தெரிகிறது.

338
00:26:34,440 --> 00:26:38,050
எனவே எங்கள் முக்கிய செயல்பாடு மீண்டும் செல்லலாம்,

339
00:26:38,050 --> 00:26:42,300
நாம் சட்ட 1 செய்ய முடியும் என்று, நான் நாங்கள் கீழே செய்ய முடியும் என்று,

340
00:26:42,300 --> 00:26:45,160
அல்லது - ஆனால் நான் கிட்டத்தட்ட கீழே செய்ய முடியாது. Yeah.

341
00:26:45,160 --> 00:26:50,710
மேலும் கீழும். மேலே நீங்கள் ஒரு ஸ்டாக் சட்டகமானது நீங்கள் கீழே கொண்டு கீழே, ஒரு ஸ்டாக் சட்டகமானது காட்டும்.

342
00:26:50,710 --> 00:26:53,240
நான் அந்த பயன்படுத்த முடியாது முனைகின்றன.

343
00:26:53,240 --> 00:26:59,120
நான் குறிப்பாக 1 பெயரிடப்பட்ட சட்ட சென்று இது சட்ட 1, என்று.

344
00:26:59,120 --> 00:27:01,750
சட்ட 1, முக்கிய ஸ்டாக் சட்டகமானது நோக்கி நம்மை அழைத்து செல்கிறது

345
00:27:01,750 --> 00:27:05,570
அது சரி, இங்கே நாம் இருக்க நடக்கும் குறியீடு வரி பணம்.

346
00:27:05,570 --> 00:27:07,950
நாம் குறியீடு ஒரு ஜோடி மேலும் வரிகளை விரும்பினால், நாங்கள், பட்டியலில் சொல்ல முடியும்

347
00:27:07,950 --> 00:27:11,280
என்று நம்மை சுற்றி குறியீடு அனைத்து வரிகளையும் கொடுக்க நடக்கிறது.

348
00:27:11,280 --> 00:27:13,360
நாம் மணிக்கு segfaulted வரி 6:

349
00:27:13,360 --> 00:27:17,360
நீங்கள் (strcmp ("CS50 பாறைகள்", argv [1]) == 0).

350
00:27:17,360 --> 00:27:24,130
அது இன்னும் தெளிவாக இல்லை என்றால், நீங்கள் அதை segfaulted ஏன் நினைத்து இங்கே இருந்து நேராக அதை பெற முடியும்.

351
00:27:24,130 --> 00:27:28,800
ஆனால் நாம் ஒரு படி மேலே எடுத்து சொல்ல, "ஏன் argv [1] segfault என்று?" முடியும்

352
00:27:28,800 --> 00:27:38,830
நாம் அச்சு argv [1], மற்றும் அது வெற்று சுட்டிக்காட்டி இது அது 0x0, தெரிகிறது.

353
00:27:38,830 --> 00:27:44,750
நாம் segfault போகிறது என்று CS50 பாறைகள் மற்றும் பூஜ்ய strcmping, மற்றும்.

354
00:27:44,750 --> 00:27:48,280
ஏன் என்று argv [1] பூஜ்ய?

355
00:27:48,640 --> 00:27:51,280
[மாணவர்] நாம் எந்த கட்டளை வரி அளவுருக்களை வழங்காததால்.

356
00:27:51,280 --> 00:27:53,390
Yeah. நாம் அது எந்த கட்டளை வரி அளவுருக்களை தரவில்லை.

357
00:27:53,390 --> 00:27:58,460
எனவே ./buggy1 மட்டுமே argv [0] ./buggy1 இருக்க வேண்டும் என்று.

358
00:27:58,460 --> 00:28:02,100
அது ஒரு argv [1] வேண்டும் போகவில்லை, segfault போகிறது என்று.

359
00:28:02,100 --> 00:28:07,450
அதற்கு பதிலாக, நான் CS50 செய்ய, ஆனால், அதை நீங்கள் ஒரு டி கிடைக்கும் என்று நடக்கிறது

360
00:28:07,450 --> 00:28:09,950
அது என்ன செய்யவேண்டும் என்ன காரணம்.

361
00:28:09,950 --> 00:28:15,240
Buggy1.c பார்த்து, அதை அச்சிட வேண்டும் என "நீங்கள் ஒரு டி கிடைக்கும்" -

362
00:28:15,240 --> 00:28:20,820
Argv [1] "CS50 பாறைகள்", வேறு, "நீ ஒரு டி கிடைக்கும்" என்றால் "நீங்கள் ஒரு ஒரு கிடைக்கும்!"

363
00:28:20,820 --> 00:28:25,660
நாம் ஒரு ஒரு தேவை இருந்தால், நாம், உண்மை என ஒப்பிட்டு இந்த வேண்டும்

364
00:28:25,660 --> 00:28:28,710
இது 0 ஒப்பிட்டு என்பதாகும்.

365
00:28:28,710 --> 00:28:31,100
எனவே argv [1] "CS50 பாறைகள்" இருக்க வேண்டும்.

366
00:28:31,100 --> 00:28:35,660
நீங்கள் கட்டளை வரியில் அதை செய்ய விரும்பினால், நீங்கள் வெளி தப்பிக்க \ பயன்படுத்த வேண்டும்.

367
00:28:35,660 --> 00:28:41,690
எனவே CS50 \ பாறைகள் மற்றும் ஒரு ஒரு கிடைக்கும்!

368
00:28:41,690 --> 00:28:44,060
நீங்கள் பின்சாய்வுக்கோடானது செய்யாவிட்டால், ஏன் இந்த வேலை இல்லை?

369
00:28:44,060 --> 00:28:47,190
[மாணவர்] இது இரண்டு வெவ்வேறு வாதங்கள் தான். >> சரி.

370
00:28:47,190 --> 00:28:52,540
Argv [1] CS50 போகிறது, மற்றும் argv [2] பாறைகள் இருக்கும். சரி.

371
00:28:52,540 --> 00:28:56,470
>> இப்போது ./buggy2 மீண்டும் segfault போகிறது.

372
00:28:56,470 --> 00:29:01,880
அதற்கு பதிலாக அதன் முக்கிய கோப்பு அதை திறந்து, நாம் தான், நேரடியாக buggy2 திறக்க வேண்டும்

373
00:29:01,880 --> 00:29:05,000
gdb ஐ buggy2 எனவே.

374
00:29:05,000 --> 00:29:09,590
நாம் நமது நிரலை இப்போது, அது, நிரல் சமிக்ஞை SIGSEGV பெற்றார் சொல்ல நடக்கிறது

375
00:29:09,590 --> 00:29:15,530
இது சமிக்ஞை segfault, இது நடக்கும் நடந்தது அங்கு இது.

376
00:29:15,530 --> 00:29:21,250
எங்கள் backtrace பார்த்து, நாம், நாம் செயல்பாடு oh_no இருந்தன என்று பார்க்க

377
00:29:21,250 --> 00:29:23,900
இதில், செயல்பாடு binky அழைப்பு எந்த செயல்பாடு dinky, அழைப்பு

378
00:29:23,900 --> 00:29:26,460
இதில் முக்கிய அழைத்தார்.

379
00:29:26,460 --> 00:29:31,680
நாம் இந்த செயல்பாடுகளை அளவுருக்களை பார்க்க முடியும்.

380
00:29:31,680 --> 00:29:34,680
dinky மற்றும் binky என்று வாதம் 1 இருந்தது.

381
00:29:34,680 --> 00:29:44,390
நாம் செயல்பாடு oh_no பட்டியலிட என்றால், நாம் oh_no மட்டும் எரிப்பதை ** கள் = NULL செய்து பார்க்க;

382
00:29:44,390 --> 00:29:47,410
* கள் = "Boom";

383
00:29:47,410 --> 00:29:50,330
ஏன் என்று தோல்வியடையும்?

384
00:29:54,330 --> 00:29:58,380
[மாணவர்] நீங்கள் dereference பூஜ்ய சுட்டிக்காட்டி முடியாது? >> சரி.

385
00:29:58,380 --> 00:30:06,090
ஒரு எரிப்பதை ** இருக்க நேர்ந்தால் இது, பொருட்படுத்தாமல், கள் சுழியாக சொல்கிறாள்

386
00:30:06,090 --> 00:30:12,070
நீங்கள் அதை புரிந்து எப்படி பொறுத்து, அது ஒரு சரம் ஒரு சுட்டிக்காட்டி ஒரு சுட்டிக்காட்டி இருக்கும் என்று,

387
00:30:12,070 --> 00:30:15,550
அல்லது சரங்களின் ஒரு வரிசை.

388
00:30:15,550 --> 00:30:21,430
இது கள் சுழியாக அதனால் * கள், ஒரு பூஜ்ய சுட்டிக்காட்டி dereferencing

389
00:30:21,430 --> 00:30:24,800
எனவே இந்த செயலிழக்க வேண்டும்.

390
00:30:24,800 --> 00:30:27,540
இந்த சாத்தியமான segfault முடியும் விரைவான வழிகளில் ஒன்றாகும்.

391
00:30:27,540 --> 00:30:31,300
அது ஒரு வெற்று சுட்டிக்காட்டி அறிவித்தார் உடனடியாக segfaulting.

392
00:30:31,300 --> 00:30:34,570
அந்த oh_no செய்கிறான்.

393
00:30:34,570 --> 00:30:43,400
நாம் ஒரு சட்டகம் வரை சென்றால், நாம் oh_no என்று அந்த செயல்பாடு பெற போகிறோம்.

394
00:30:43,400 --> 00:30:44,830
நான் கீழே அதை செய்ய வேண்டும்.

395
00:30:44,830 --> 00:30:48,610
நீங்கள் ஒரு கட்டளையை உள்ளிட்டு என்றால் நீங்கள், மீண்டும் Enter விசையை

396
00:30:48,610 --> 00:30:52,350
அது நீங்கள் ஓடி என்று முந்தைய கட்டளையை மீண்டும் நடக்கும்.

397
00:30:52,350 --> 00:30:56,610
நாம் சட்ட 1 உள்ளன.

398
00:30:56,610 --> 00:31:04,650
இந்த சட்ட பட்டியலிட்டு, நாம் இங்கே நமது செயல்பாடு பார்க்க.

399
00:31:04,650 --> 00:31:08,520
நீங்கள் மீண்டும் பட்டியல் அடிக்க முடியும், அல்லது நீங்கள் பட்டியலில் 20 செய்வது மற்றும் அதை இன்னும் பட்டியலிட முடியும்.

400
00:31:08,520 --> 00:31:13,640
விழாவில் dinky நான் 1 இருந்தால், பின், oh_no விழாவிற்கு போக சொல்வது

401
00:31:13,640 --> 00:31:15,960
வேறு ஸ்லிங்கி விழாவிற்கு போக.

402
00:31:15,960 --> 00:31:18,700
மற்றும் நாம் இங்கு பார்க்க நடக்க காரணம் 1 என்று

403
00:31:18,700 --> 00:31:22,560
அந்த dinky வாதம் 1 அழைக்கப்பட்டார்.

404
00:31:22,560 --> 00:31:27,560
அல்லது நீங்கள் தான் நான் அச்சிட மற்றும் அதை நான் 1 தான்.

405
00:31:27,560 --> 00:31:33,770
நாம் dinky தற்போது, நாம் மற்றொரு சட்ட வரை சென்றால், நாம் binky முடிவடைய வேண்டும் என்று.

406
00:31:33,770 --> 00:31:36,600
Up. இப்போது நாம் binky இருக்கிறோம்.

407
00:31:36,600 --> 00:31:41,340
அரை என்னை துண்டித்து முன் இருந்து பட்டியல் - - இந்த செயல்பாடு பட்டியலிடும்

408
00:31:41,340 --> 00:31:52,670
நான் 0 என்றால் அது தொடங்கியது, நாம் அதை oh_no அழைக்க போகிறோம், வேறு dinky அழைப்பு.

409
00:31:52,670 --> 00:31:57,000
நாம் என் 1 என்று எனக்கு தெரியும், அதனால் dinky என்று.

410
00:31:57,000 --> 00:32:05,030
இப்போது நாம் முக்கிய மீண்டும் நீங்கள், மற்றும் முக்கிய சில எண்ணாக நான் = ரேண்ட் ()% 3 போகிறது;

411
00:32:05,030 --> 00:32:08,790
என்று மட்டும் நீங்கள் 0, 1, அல்லது 2 என்று ஒரு சீரற்ற எண் கொடுக்க போகிறார்.

412
00:32:08,790 --> 00:32:12,780
அது பல binky அழைக்க நடக்கிறது, அதை 0 திரும்புவார்.

413
00:32:12,780 --> 00:32:16,700
இந்த பார்த்து,

414
00:32:16,700 --> 00:32:19,880
நான், உடனடியாக அது இயங்கும் இல்லாமல் கைமுறையாக திட்டத்தின் மூலம் நடைபயிற்சி

415
00:32:19,880 --> 00:32:25,400
நீங்கள் முக்கிய ஒரு பிரேக் பாயிண்ட் அமைக்க வேண்டும், அதில் நாம் நிரலை என்று அர்த்தம்

416
00:32:25,400 --> 00:32:31,020
இது ஒரு பிரேக் பாயிண்ட் எம் வரை உங்கள் நிரல் வரை இயங்கும்.

417
00:32:31,020 --> 00:32:35,450
இயங்குவதாக எனவே, அதை இயக்கும் மற்றும் அது முக்கிய செயல்பாடு வெற்றி இயங்கும் தடுக்க முடியும்.

418
00:32:35,450 --> 00:32:44,700
இப்போது நாம் முக்கிய உள்ளே இருக்கும், மற்றும் படி அல்லது அடுத்த குறியீடு அடுத்த வரியில் நம்மை கொண்டு செல்கிறது.

419
00:32:44,700 --> 00:32:47,050
நீங்கள் நடவடிக்கை அல்லது அடுத்த செய்ய முடியும்.

420
00:32:47,050 --> 00:32:51,800
அடுத்த தாக்கியதால், இப்போது நான் ரேண்ட் ()% 3, எனவே நான் மதிப்பு அச்சிட முடியாது, அமைக்கப்படுகிறது

421
00:32:51,800 --> 00:32:55,280
அதை நான் 1 தான்.

422
00:32:55,280 --> 00:32:58,110
இப்போது நாம் அடுத்த அல்லது படி பயன்படுத்த என்பதை விஷயம் இல்லை.

423
00:32:58,110 --> 00:33:01,000
நான் முந்தைய ஒரு முக்கியத்தும் நினைக்கிறேன், ஆனால் அடுத்த பயன்படுத்த வேண்டும்.

424
00:33:01,000 --> 00:33:06,000
நாம் படி பயன்படுத்தினால், நாம் செயல்பாடு அடியெடுத்து, இது உண்மையான விஷயம் பாருங்கள் பொருள்

425
00:33:06,000 --> 00:33:07,940
அந்த binky உள்ளே நடக்கிறது.

426
00:33:07,940 --> 00:33:10,510
நாம் அடுத்த பயன்படுத்தினால், அது செயல்பாடு மீது போக பொருள்

427
00:33:10,510 --> 00:33:14,070
மற்றும் எங்கள் பிரதான விழாவில் குறியீடு அடுத்த வரி போக.

428
00:33:14,070 --> 00:33:17,900
இங்கே இந்த வரிசையில், நான் அதை ரேண்ட் ()% 3 கூறினார் இருந்தது;

429
00:33:17,900 --> 00:33:21,320
நான் படி செய்தால், அதை ரேண்ட் செயல்படுத்த போக வேண்டும்

430
00:33:21,320 --> 00:33:25,110
அங்கு என்ன நடக்கிறது என்று பாருங்கள், நான் ரேண்ட் செயல்பாடு மூலம் விலக முடியும்.

431
00:33:25,110 --> 00:33:26,920
ஆனால் நான் ரேண்ட் செயல்பாடு பற்றி கவலை இல்லை.

432
00:33:26,920 --> 00:33:30,190
நான் பிரதான உள்ள குறியீடு அடுத்த வரி போக வேண்டும், நான் அடுத்த பயன்படுத்த.

433
00:33:30,190 --> 00:33:35,800
ஆனால் இப்போது நான் binky செயல்பாடு பற்றி கவலையில்லை, அதனால் நான் அந்த அடியெடுத்து வேண்டும்.

434
00:33:35,800 --> 00:33:37,730
இப்போது நான் binky இருக்கிறேன்.

435
00:33:37,730 --> 00:33:42,040
குறியீடு முதல் வரி (நான் == 0), நான் ஒரு முடிவை எடுக்க வேண்டும் சொல்ல போகிறார்,

436
00:33:42,040 --> 00:33:44,930
நாம் dinky மணிக்கு முடிவுக்கு பார்க்க.

437
00:33:44,930 --> 00:33:51,620
நாம் பட்டியல் விஷயங்களை, நாம் அதை சரி என்று பார்த்தால் நான் = 0 ஆகும்.

438
00:33:51,620 --> 00:33:55,470
, நான் 0 சமமாக இல்லை, அது வேறு நிலை சென்றார்

439
00:33:55,470 --> 00:33:59,540
இது dinky (நான்) அழைக்க போகிறார்.

440
00:33:59,540 --> 00:34:04,030
நீங்கள் குழப்பி.

441
00:34:04,030 --> 00:34:07,380
நீங்கள் நேரடியாக இந்த வரிகளை பார்த்தால், நீங்கள் நினைக்கலாம், (நான் == 0) என்றால்

442
00:34:07,380 --> 00:34:10,800
சரி, நான் ஒரு படி எடுத்து இப்போது நான் dinky (நான்) இருக்கிறேன்

443
00:34:10,800 --> 00:34:14,120
நீங்கள் என்று நான் = 0 அல்லது ஏதாவது அர்த்தம் வேண்டும் நினைக்கலாம்.

444
00:34:14,120 --> 00:34:18,980
இல்லை, இது வெறும் அது வரி dinky (நான்) நேரடியாக ஒட்டி கொள்ளலாம் தெரியும் என்று அர்த்தம்.

445
00:34:18,980 --> 00:34:23,300
நான் 0 முடியாது என்பதால், அடுத்த நடவடிக்கை வேறு மணிக்கு முடிவுக்கு போவதில்லை.

446
00:34:23,300 --> 00:34:26,239
வேறு அது நிறுத்த நடக்கிறது ஒரு வரி அல்ல.

447
00:34:26,239 --> 00:34:31,570
அது உண்மையில் இது (நான்) dinky இருக்கிறது, இயக்க முடியும் அடுத்த வரி போக நடக்கிறது.

448
00:34:31,570 --> 00:34:36,090
Dinky (நான்) நுழைவதற்கு, நாம் பார்க்க (நான் == 1) என்றால்.

449
00:34:36,090 --> 00:34:42,670
நாங்கள் விலக போது, நாம் oh_no முடிவடைய போகிறது என்று, நான் = 1 தெரிகிறோம்

450
00:34:42,670 --> 00:34:46,489
நான் = 1 நீங்கள் அடியெடுத்து கூடிய செயல்பாடு oh_no, அழைப்பு காரணமாக

451
00:34:46,489 --> 00:34:52,969
செய்ய போகிறார்கள் இதில் எரிப்பதை ** கள் = பூஜ்ய உடனடியாக "பூம்" என்று.

452
00:34:54,270 --> 00:34:59,690
பின்னர் உண்மையில், buggy2 செயல்படுத்த பார்க்க

453
00:34:59,690 --> 00:35:04,590
0, 1, அல்லது 2 - - அழைப்பு binky, இந்த, நான் ஒரு சீரற்ற எண் வருகிறது

454
00:35:04,590 --> 00:35:10,610
நான் 0 என்றால் அது oh_no அழைக்கும், வேறு அதை dinky அழைப்பு, இது இங்கு வரும்.

455
00:35:10,610 --> 00:35:18,100
நான், அழைப்பு oh_no 1 இருந்தால், வேறு, இங்கு வந்து இது, ஸ்லிங்கி அழைப்பு

456
00:35:18,100 --> 00:35:20,460
நான் 2 இருந்தால், oh_no அழைப்பு.

457
00:35:20,460 --> 00:35:24,720
நான் கூட ஒரு வழி உள்ளது நினைக்கவில்லை -

458
00:35:24,720 --> 00:35:30,030
யார் இந்த segfault என்று ஒரு திட்டத்தை உருவாக்கும் ஒரு வழி பார்க்க வேண்டும்?

459
00:35:30,030 --> 00:35:37,530
நான் ஏதாவது இழக்கிறேன் வரை நான் 0 இருந்தால், நீங்கள் உடனடியாக segfault வேண்டும், ஏனெனில்,

460
00:35:37,530 --> 00:35:41,250
வேறு நீங்கள், நான் உங்களுக்கு segfault 1 என்று ஒரு செயல்பாடு சென்று

461
00:35:41,250 --> 00:35:44,540
வேறு நான் இருந்தால் 2 நீங்கள் segfault ஒரு விழாவிற்கு போக.

462
00:35:44,540 --> 00:35:46,810
இல்லை, நீங்கள் என்ன செய்தாலும், அதனால், நீங்கள் segfault.

463
00:35:46,810 --> 00:35:52,380
>> நான், அதை பதிலாக எரிப்பதை ** கள் = NULL செய்து இருக்க வேண்டும் சரிசெய்ய ஒரு வழி சொல்லுங்க

464
00:35:52,380 --> 00:35:55,610
நீங்கள் அந்த சரம் இடைவெளி malloc முடியும்.

465
00:35:55,610 --> 00:36:04,230
Sizeof என்ன - நாம் malloc (sizeof) செய்ய முடியும்?

466
00:36:09,910 --> 00:36:15,190
[மாணவர்] (கரி) * 5? >> இது சரியான தெரியவில்லை?

467
00:36:15,190 --> 00:36:21,060
நான் உண்மையில் அது இயங்கிய இந்த வேலை அனுமானித்து, ஆனால் அதை நான் தேடிக்கொண்டிருக்கிறேன் என்ன இல்லை.

468
00:36:24,400 --> 00:36:32,940
கள் வகை பாருங்கள். இது int * சேர்க்க, அதனால் எண்ணாக * x.

469
00:36:32,940 --> 00:36:35,600
நான் (sizeof (int)) malloc செய்ய வேண்டும்.

470
00:36:35,600 --> 00:36:40,490
அல்லது நான் 5 ஒரு வரிசை விரும்பினால், நான் (sizeof (int) * 5) செய்ய வேண்டும்;

471
00:36:40,490 --> 00:36:44,210
நான் ஒரு முழு எண்ணாக ** இருந்தால்?

472
00:36:46,260 --> 00:36:49,140
என்ன நான் malloc என்று?

473
00:36:49,140 --> 00:36:53,510
சுட்டிக்காட்டியின் [மாணவர்] அளவு. >> சரி. (Sizeof (int *));

474
00:36:53,510 --> 00:36:56,960
கீழே இங்கே தான்.

475
00:36:56,960 --> 00:37:01,280
நான் (sizeof (எரிப்பதை *)) வேண்டும்;

476
00:37:06,170 --> 00:37:12,840
இந்த "பூம்" சுட்டி காட்டும் என்று சுட்டிக்காட்டி இடத்தை ஒதுக்க வேண்டும்.

477
00:37:12,840 --> 00:37:15,330
நான் "பூம்" தன்னை இடத்தை ஒதுக்க தேவையில்லை

478
00:37:15,330 --> 00:37:17,210
இந்த நான் முன்பு சொன்னதை அடிப்படையில் சமமாக இருப்பதால்

479
00:37:17,210 --> 00:37:20,870
எரிப்பதை ஒரு * x = "Boom".

480
00:37:20,870 --> 00:37:27,950
"பூம்" ஏற்கனவே உள்ளது. இது நினைவகம் வாசிப்பு மட்டும் பகுதியில் இருப்பதாக நடக்கிறது.

481
00:37:27,950 --> 00:37:35,200
கள் ஒரு எரிப்பதை ** என்று ஆனால் அது ஏற்கனவே, குறியீடு இந்த வரி அதாவது, உள்ளது

482
00:37:35,200 --> 00:37:43,900
பின்னர் * கள் ஒரு எரிப்பதை * மேலும் நீங்கள் "பூம்" சுட்டி இந்த எரிப்பதை * அமைப்பது தான்.

483
00:37:43,900 --> 00:37:50,040
நான் கள் மீது "பூம்" நகலெடுக்க விரும்பினால், நான் கள் இடைவெளி ஒதுக்க வேண்டும்.

484
00:37:55,170 --> 00:38:03,900
நான் செய்வேன் * கள் = malloc (sizeof (கரி) * 5);

485
00:38:03,900 --> 00:38:06,210
ஏன் 5?

486
00:38:06,210 --> 00:38:10,860
ஏன் 4? "பூம்" 4 எழுத்துக்கள் என்று தெரிகிறது. >> [மாணவர்] பூஜ்ய பாத்திரம்.

487
00:38:10,860 --> 00:38:14,580
Yeah. உங்கள் சரங்களை அனைத்து வெற்று தன்மையை வேண்டும் போகிறீர்கள்.

488
00:38:14,580 --> 00:38:23,590
இப்போது நான் strcat போன்ற ஏதாவது செய்ய முடியும் - ஒரு சரம் நகலெடுப்பதற்கான செயல்பாடு என்ன?

489
00:38:23,590 --> 00:38:28,520
[மாணவர்] cpy? >> Strcpy.

490
00:38:28,520 --> 00:38:32,700
மனிதன் strcpy.

491
00:38:36,120 --> 00:38:39,590
எனவே strcpy அல்லது strncpy.

492
00:38:39,590 --> 00:38:43,410
நீங்கள் குறிப்பிட முடியும் என்பதால் strncpy ஒரு பிட் பாதுகாப்பான என்பது எத்தனை எழுத்துக்கள்,

493
00:38:43,410 --> 00:38:46,190
எங்களுக்கு தெரியும் என்பதால், ஆனால் இங்கே அது இல்லை.

494
00:38:46,190 --> 00:38:50,340
எனவே strcpy மற்றும் வாதங்களை பாருங்கள்.

495
00:38:50,340 --> 00:38:53,100
முதல் வாதம் நமது இலக்காகும்.

496
00:38:53,100 --> 00:38:56,770
இரண்டாவது வாதம் எங்கள் ஆதாரமாக உள்ளது.

497
00:38:56,770 --> 00:39:10,310
நாம் நம் இலக்கை * ஒரு காப்பி போகிறோம் சுட்டிக்காட்டி "பூம்" கள்.

498
00:39:10,310 --> 00:39:19,820
ஏன் முன் பதிலாக நாம் வெறும் என்ன ஒரு strcpy இந்த செய்ய வேண்டும்

499
00:39:19,820 --> 00:39:22,800
* வி = "Boom"?

500
00:39:22,800 --> 00:39:28,630
அங்கு நீங்கள் இதை செய்ய வேண்டும் ஒரு காரணம், ஆனால் அந்த காரணம் என்ன?

501
00:39:28,630 --> 00:39:31,940
[மாணவர்] நீங்கள் "பூம்" ஏதாவது மாற்ற விரும்பினால். >> சரி.

502
00:39:31,940 --> 00:39:37,950
இப்போது நான் கள் போன்ற ஏதாவது செய்ய முடியும் [0] = 'எக்ஸ்';

503
00:39:37,950 --> 00:39:48,190
கள் புள்ளிகள் குவியல் மீது குவியல் மற்றும் அந்த இடத்தில் கள் சுட்டி காட்டியது என்று காரணம்

504
00:39:48,190 --> 00:39:52,320
"பூம்" சேமித்து இது குவியல், மேலும் இடத்தில் ஒரு சுட்டிக்காட்டி இருக்கிறது.

505
00:39:52,320 --> 00:39:55,150
எனவே "பூம்" இந்த நகல் குவியல் சேமிக்கப்படும்.

506
00:39:55,150 --> 00:39:58,780
எங்கள் திட்டத்தில் "பூம்" இரண்டு நகல்கள் தொழில்நுட்ப உள்ளன.

507
00:39:58,780 --> 00:40:03,500
இந்த "பூம்" சரம் தொடர்ந்து வழங்கப்படும் என்று முதல் ஒரு, அங்கு

508
00:40:03,500 --> 00:40:09,250
மற்றும் "பூம்" இரண்டாவது நகல், strcpy "பூம்" நகல் உருவாக்கப்பட்டது.

509
00:40:09,250 --> 00:40:13,100
ஆனால் "பூம்" நகல் குவியல் சேமிக்கப்படும், மற்றும் குவியல் நீங்கள் மாற்ற இலவச இருக்கும்.

510
00:40:13,100 --> 00:40:17,250
குவியல் படிக்க மட்டுமே அல்ல, அது அர்த்தம் கள் [0]

511
00:40:17,250 --> 00:40:20,500
நீங்கள் "பூம்" மதிப்பை மாற்ற நாம் என்ன.

512
00:40:20,500 --> 00:40:23,130
நீங்கள் அந்த பாத்திரங்களின் மாற்ற நாம் நடக்கிறது.

513
00:40:23,130 --> 00:40:26,640
>> கேள்விகள்?

514
00:40:27,740 --> 00:40:29,290
சரி.

515
00:40:29,290 --> 00:40:35,500
>> , Buggy3 என்று நாம் gdb ஐ buggy3 செல்லும்.

516
00:40:35,500 --> 00:40:39,840
நாம் அதை இயக்க மற்றும் நாம் ஒரு segfault செய்து பார்க்க.

517
00:40:39,840 --> 00:40:46,550
நாம் backtrace என்றால், இரண்டு செயல்பாடுகளை உள்ளன.

518
00:40:46,550 --> 00:40:52,970
எங்கள் முக்கிய செயல்பாடு போல சென்றால், நாம் இந்த வரியில் segfaulted என்று பார்க்க.

519
00:40:52,970 --> 00:41:00,180
அதனால் தான் (இந்த வரி பார்த்து எண்ணாக வரி = 0; fgets இந்த பொருள் சமமாக இல்லை NULL இல்லை

520
00:41:00,180 --> 00:41:03,770
வரி +).

521
00:41:03,770 --> 00:41:08,010
நமது முந்தைய சட்ட _IO_fgets அழைக்கப்பட்டது.

522
00:41:08,010 --> 00:41:10,720
நீங்கள் உள்ளமைக்கப்பட்ட சி செயல்பாடுகளை நிறைய பார்க்கலாம்

523
00:41:10,720 --> 00:41:15,350
நீங்கள் segfault போது, உண்மையில் புரிந்து செயல்பாடு பெயர்கள் இருக்கும் என்று

524
00:41:15,350 --> 00:41:18,090
இந்த _IO_fgets போல்.

525
00:41:18,090 --> 00:41:21,770
ஆனால் இந்த fgets அழைப்பு தொடர்புபடுத்த நடக்கிறது.

526
00:41:21,770 --> 00:41:25,850
இங்கு உள்ளே, நாம் segfaulting.

527
00:41:25,850 --> 00:41:30,340
நாம் fgets அளவுருக்களை பார்த்தால், நாம் இடையக அச்சிட முடியாது.

528
00:41:30,340 --> 00:41:41,180
அச்சு நாம் ஒரு - இல்லை, ஓ.

529
00:41:48,980 --> 00:41:51,900
அச்சு சரியாக நான் அதை விரும்பவில்லை வேலை போவதில்லை.

530
00:41:55,460 --> 00:41:58,000
உண்மையான திட்டம் பார்க்கிறேன்.

531
00:42:02,200 --> 00:42:09,640
இடையக ஒரு பாத்திரம் வரிசை ஆகும். இது 128 எழுத்துக்களை ஒரு பாத்திரம் வரிசை தான்.

532
00:42:09,640 --> 00:42:14,980
நான் அச்சு இடையக என்று சொல்லும் போது, அது, அந்த 128 எழுத்துக்கள் அச்சிட நடக்கிறது

533
00:42:14,980 --> 00:42:18,300
இதில் நான் நினைக்கிறேன் எதிர்பார்க்கப்படுகிறது உள்ளது.

534
00:42:18,300 --> 00:42:21,390
என்ன நான் தேடி கொண்டிருந்தேன், இடையக முகவரி அச்சிட உள்ளது

535
00:42:21,390 --> 00:42:23,680
ஆனால் உண்மையில் எனக்கு சொல்ல தெரியவில்லை.

536
00:42:23,680 --> 00:42:30,770
அதனால் நான் இங்கே x தாங்கல் வரை என்ன நடக்கும் போது, அது, என்னை 0xbffff090 காட்டுகிறது

537
00:42:30,770 --> 00:42:38,690
நீங்கள் முந்தைய அல்லது சில புள்ளி இருந்து நினைவில் என்றால், Oxbffff ஒரு ஸ்டேக்-ish பகுதியில் இருக்கிறது இது.

538
00:42:38,690 --> 00:42:46,020
ஸ்டாக் தான் 0xc000 கீழ் எங்காவது தொடங்க இருக்கிறது.

539
00:42:46,020 --> 00:42:51,890
இந்த முகவரியை பார்த்து, நான் இடையக ஸ்டேக்கில் நடக்கிறது என்று.

540
00:42:51,890 --> 00:43:04,500
தாங்குவதற்கு, வரை, ரன், என் திட்டத்தை மீண்டும் தொடங்குவதற்கு நாம் தான் எழுத்துக்கள் இந்த காட்சியை பார்த்தேன்

541
00:43:04,500 --> 00:43:06,530
அந்த அழகான மிகவும் பொருளற்றது ஆகும்.

542
00:43:06,530 --> 00:43:12,270
பின்னர் கோப்பு அச்சிடுதல், என்ன கோப்பு இருப்பான்?

543
00:43:15,120 --> 00:43:17,310
[மாணவர்] சுழியாக. >> சரி.

544
00:43:17,310 --> 00:43:22,610
, கோப்பு வகை FILE * ஒரு, எனவே அது ஒரு சுட்டிக்காட்டி உள்ளது

545
00:43:22,610 --> 00:43:26,610
என்று சுட்டிக்காட்டி மதிப்பு பூஜ்ஜிய உள்ளது.

546
00:43:26,610 --> 00:43:33,240
எனவே fgets, ஒரு மறைமுக வழி என்று சுட்டிக்காட்டி படிக்க முயற்சி போகிறது

547
00:43:33,240 --> 00:43:37,320
ஆனால் அந்த சுட்டியை அணுக, அதை dereference இது உள்ளது.

548
00:43:37,320 --> 00:43:40,550
அல்லது, அது dereferences இது, குறிக்கின்ற வேண்டும் என்ன அணுக.

549
00:43:40,550 --> 00:43:43,810
அது ஒரு வெற்று சுட்டிக்காட்டி அது segfaults dereferencing.

550
00:43:46,600 --> 00:43:48,730
நான் அங்கு அது மீண்டும்.

551
00:43:48,730 --> 00:43:52,170
எங்கள் முக்கிய கட்டத்தில் உடைத்து ரன் என்றால்,

552
00:43:52,170 --> 00:43:57,320
குறியீடு முதல் வரி எரிப்பதை * கோப்பு = "nonexistent.txt" என்று;

553
00:43:57,320 --> 00:44:00,870
இந்த திட்டம் தோல்வி ஏன் ஒரு அழகான பெரிய குறிப்பை கொடுக்க வேண்டும்.

554
00:44:00,870 --> 00:44:06,080
நான் இந்த கோப்பை திறக்க அங்கு அடுத்த தட்டச்சு, அடுத்த வரி என்னை கொண்டு

555
00:44:06,080 --> 00:44:11,140
பின்னர் நான் உடனடியாக ஒருமுறை நான் அடுத்த அடித்தார் நம் வரி, வர, அதை segfault போகிறது.

556
00:44:11,140 --> 00:44:16,880
யாரையும் நாங்கள் segfaulting வேண்டும் ஏன் ஒரு காரணம் துரத்த வேண்டும்?

557
00:44:16,880 --> 00:44:19,130
[மாணவர்] கோப்பு இல்லை. >> சரி.

558
00:44:19,130 --> 00:44:22,250
இந்த குறிப்பை இருக்க வேண்டும்

559
00:44:22,250 --> 00:44:29,570
நீங்கள் ஒரு கோப்பை திறந்து நீங்கள் எப்போது நீங்கள் கோப்பு உண்மையில் உள்ளது என்று பார்க்க வேண்டும் என்று.

560
00:44:29,570 --> 00:44:31,510
இங்கு, "nonexistent.txt";

561
00:44:31,510 --> 00:44:34,700
நாம் வாசிப்புக்கு fopen கோப்பு, நாம் சொல்ல வேண்டும் போது

562
00:44:34,700 --> 00:44:45,870
நீங்கள் (கோப்பு == NULL) மற்றும் printf ("கோப்பு இல்லை!" என்று

563
00:44:45,870 --> 00:44:56,340
அல்லது - இன்னும் சிறப்பாக - கோப்பு); திரும்பி 1;

564
00:44:56,340 --> 00:45:00,300
எனவே இப்போது நாம் அதை NULL என்று பார்க்கவும்

565
00:45:00,300 --> 00:45:03,930
முன் உண்மையில் தொடர்ந்து அந்த கோப்பு படிக்க முயற்சி.

566
00:45:03,930 --> 00:45:08,800
நாங்கள் தான் வேலை என்று பார்க்க அதை ரீ.

567
00:45:11,020 --> 00:45:14,970
நான் ஒரு புதிய வரியை சேர்க்கவும் நோக்கம்.

568
00:45:21,090 --> 00:45:25,290
எனவே இப்போது nonexistent.txt இல்லை.

569
00:45:26,890 --> 00:45:30,040
நீங்கள் எப்போதும் தான் இந்த வகையான சோதிக்க வேண்டும்.

570
00:45:30,040 --> 00:45:33,870
நீங்கள் எப்போதும் fopen NULL கொடுக்கிறது என்பதை சரிபார்க்க வேண்டும்.

571
00:45:33,870 --> 00:45:38,170
நீங்கள் எப்போதும், malloc NULL தராது என்று உறுதிப்படுத்தி கொள்ளுங்கள் வேண்டும்

572
00:45:38,170 --> 00:45:41,410
அல்லது வேறு நீங்கள் segfault.

573
00:45:42,200 --> 00:45:45,930
>> இப்போது buggy4.c.

574
00:45:49,190 --> 00:45:58,440
இயங்கும். நான் உள்ளீடு அல்லது சாத்தியமான எல்லையற்ற வளைவு காத்திருக்கும் இந்த யோசிக்காமல்.

575
00:45:58,440 --> 00:46:01,870
ஆமாம், அது முடிவில்லா வளைவு உள்ளது.

576
00:46:01,870 --> 00:46:05,560
Buggy4 எனவே. நாம் எல்லையற்ற வளைவு போல தெரிகிறது.

577
00:46:05,560 --> 00:46:12,590
நாங்கள் முக்கிய மணிக்கு உடைக்க முடியாது, நம்முடைய நிரலை.

578
00:46:12,590 --> 00:46:20,180
GDB இல், நீண்ட நீங்கள் பயன்படுத்த சுருக்கம் தெளிவான உள்ளது

579
00:46:20,180 --> 00:46:23,420
அல்லது அவர்கள் நீங்கள் வழங்கும் சிறப்பு சுருக்கங்கள்,

580
00:46:23,420 --> 00:46:29,020
நீங்கள் பதிலாக அடுத்த அனைத்து வழி தட்டச்சு செய்ய வைத்து அடுத்த பயன்படுத்த n பயன்படுத்தலாம்.

581
00:46:29,020 --> 00:46:33,730
இப்போது நான் ஹிட் n என்று, நான் அடுத்த செல்ல Enter அடிக்க முடியும்

582
00:46:33,730 --> 00:46:36,640
அதற்கு பதிலாக ஹிட் n உள்ளிடவும், n உள்ளிடவும், n உள்ளிடுக என்ற.

583
00:46:36,640 --> 00:46:44,630
நான் [நான்] 0 வரிசையில் அமைக்க என்று லூப் சில வகையான இருக்கிறேன் தெரிகிறது.

584
00:46:44,630 --> 00:46:50,510
அதை நான் லூப் இந்த வெளியே உடைத்து ஒருபோதும் நான் தெரிகிறது.

585
00:46:50,510 --> 00:46:54,780
நான் அச்சிட, அதனால் நான் 2 இருந்தால், நான் அடுத்த செல்லலாம்.

586
00:46:54,780 --> 00:46:59,250
நான் அடுத்த செல்வேன் பிறகு, நான் 3, நான் அச்சிட வேண்டும்.

587
00:46:59,250 --> 00:47:05,360
நான் அச்சிட வேண்டும் மற்றும் 3 ஆகும். அடுத்து, நான் அச்சிட, நான் 4.

588
00:47:05,360 --> 00:47:14,520
உண்மையில், அச்சு sizeof (வரிசை), மிகவும் வரிசை அளவு 20 ஆகும்.

589
00:47:16,310 --> 00:47:32,870
சில சிறப்பு gdb ஐ கட்டளையை ஏதாவது நடக்கும் வரை சென்று அங்கு போல் ஆனால் அது தெரிகிறது.

590
00:47:32,870 --> 00:47:37,620
அது மாறி மதிப்பு ஒரு நிலை அமைப்பது போல. ஆனால் அது என்னவென்று நான் நினைவில் இல்லை.

591
00:47:37,620 --> 00:47:44,100
- நாங்கள் போகும் நீங்கள்

592
00:47:44,100 --> 00:47:47,120
நீங்கள் என்ன சொல்கிறீர்கள்? நீ என்ன கொண்டு வந்தாய்?

593
00:47:47,120 --> 00:47:50,500
[மாணவர்] காட்ட நான் சேர்க்க - >> சரி. அதனால் நான் உதவ முடியும் காண்பிக்க.

594
00:47:50,500 --> 00:47:54,530
நாம் தான் நான் காட்ட இருந்தால், அது எனக்கு மதிப்பு என்ன என்பது இங்கு வைக்கும்

595
00:47:54,530 --> 00:47:56,470
நான் ஒவ்வொரு முறையும் அதை அச்சிட இல்லை.

596
00:47:56,470 --> 00:48:02,930
நாம் தான் அடுத்த போகும் என்றால், நாம் 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5 பார்க்க.

597
00:48:02,930 --> 00:48:08,530
ஏதாவது மோசமாக தவறாக நடக்கிறது, நான் 0 மீட்டமைக்கவும் வருகிறது.

598
00:48:13,330 --> 00:48:22,220
Buggy4.c பார்த்து, நாம் நடக்கும் என்று அனைத்து எண்ணாக வரிசை [5] பார்க்க;

599
00:48:22,220 --> 00:48:26,200
(நான் <= sizeof (வரிசை); நான் + நான் = 0)

600
00:48:26,200 --> 00:48:28,550
வரிசை [நான்] = 0;

601
00:48:28,550 --> 00:48:31,390
நாங்கள் இங்கே தவறு என்ன?

602
00:48:31,390 --> 00:48:39,480
ஒரு குறிப்பில் உள்ளது, நான் gdb ஐ buggy4 செய்து போது - பிரதான, ரன் உடைக்க நாம் -

603
00:48:39,480 --> 00:48:45,980
நான் அச்சு sizeof (வரிசை) தான் நான் இறுதியாக உடைத்து வேண்டும் நிலைமையை பார்க்க.

604
00:48:47,690 --> 00:48:51,100
நான் எங்கே? நான் ஓடி வந்தீங்க?

605
00:48:51,100 --> 00:48:54,280
நான் இன்னும் அறிவிக்க வில்லை.

606
00:48:54,280 --> 00:48:58,680
எனவே, sizeof (வரிசை) அச்சிட்டு என்று 20 தான்

607
00:48:58,680 --> 00:49:06,690
இது, என் வரிசை அளவு 5 என்பதால் எதிர்பார்க்கப்படுகிறது மற்றும் 5 முழுஎண்களின் தான்

608
00:49:06,690 --> 00:49:12,410
எனவே முழு விஷயம் sizeof (int) 4 இருக்கிறது, அங்கு 5 * sizeof (int) பைட்டுகள், இருக்க வேண்டும்.

609
00:49:12,410 --> 00:49:14,780
எனவே sizeof (வரிசை) 20 ஆகும்.

610
00:49:14,780 --> 00:49:17,420
இந்த என்ன வேண்டும்?

611
00:49:17,420 --> 00:49:21,720
[மாணவர்] sizeof (int) பிரிக்கப்படுகின்றன. >> சரி, / sizeof (int).

612
00:49:21,720 --> 00:49:30,630
இங்கே ஒரு பிரச்சினை இன்னும் தெரிகிறது. நான் இந்த இருக்க வேண்டும் என்று <

613
00:49:30,630 --> 00:49:36,960
அது மிகவும் அதிகமாக எப்போதும் இருந்து <மற்றும் ஒருபோதும் <=.

614
00:49:36,960 --> 00:49:44,860
இப்போது இந்த உண்மையில் உடைந்துவிட்டது ஏன் பற்றி யோசிக்கிறோம்.

615
00:49:44,860 --> 00:49:53,370
யாரையும் நான் ஏன் வளைய ஒவ்வொரு மறு செய்கை மூலம் 0 யூகங்களை மீட்டமைத்துள்ளோம்?

616
00:50:01,300 --> 00:50:09,350
இங்கு என்ன நடக்கிறது என்று உள்ளே தான் [நான்] 0 அமைக்கப்பட உள்ளது என்று வரிசை ஆகும்.

617
00:50:09,350 --> 00:50:15,350
எனவே எப்படியாவது, குறியீடு இந்த வரி நான் 0 அமைக்க நமது எண்ணாக ஏற்படுத்துகிறது.

618
00:50:16,730 --> 00:50:23,130
அதை நான் இந்த பகுதி நினைவக overriding ஏனென்றால் [மாணவர்] அது முடியவில்லை

619
00:50:23,130 --> 00:50:27,970
அது அணியின் அடுத்த உறுப்பு இருக்கிறது? நினைக்கிறார்கள் போது >> [Bowden] ஆமாம்.

620
00:50:27,970 --> 00:50:33,880
எங்கள் அணி இறுதியில் தாண்டி செல்கிறோம் போது,

621
00:50:33,880 --> 00:50:39,870
நாம் overriding என்று எப்படியோ அந்த இடத்தை நான் மதிப்பு overriding.

622
00:50:39,870 --> 00:50:48,030
நாம் buggy4 பார்க்க போனால் அதனால், முக்கிய, ரன் உடைக்க

623
00:50:48,030 --> 00:50:53,120
அது என் முகவரி அச்சிட வேண்டும்.

624
00:50:53,120 --> 00:50:57,280
இது bffff124 போல் தோன்றுகிறது.

625
00:50:57,280 --> 00:51:03,930
இப்போது வரிசைக்கு முகவரியை அச்சிட அனுமதிக்க [0]. 110.

626
00:51:03,930 --> 00:51:06,290
என்ன [1] பற்றி? 114.

627
00:51:06,290 --> 00:51:07,920
[2], 118.

628
00:51:07,920 --> 00:51:14,530
11c, 120. வரிசை [5] bfff124 உள்ளது.

629
00:51:14,530 --> 00:51:26,990
வரிசை மிக [5] நான், அந்த வரிசை [5] நான், அதாவது அதே முகவரி.

630
00:51:26,990 --> 00:51:30,720
அவர்கள் அதே முகவரி இருந்தால், அவர்கள் தான் இருக்கிறது.

631
00:51:30,720 --> 00:51:38,410
எனவே வரிசை [5] அமைக்க போது 0 முதல், நாம் 0 நான் அமைப்பது.

632
00:51:38,410 --> 00:51:46,070
நீங்கள் ஸ்டேக் அடிப்படையில், இதை பற்றி யோசிக்க வேண்டும்,

633
00:51:46,070 --> 00:51:55,590
int நான் ஸ்டேக் சில இடத்தை பெறுகின்றது அதாவது, முதலில் அறிவித்தார்.

634
00:51:55,590 --> 00:52:04,730
பின் வரிசை [5] மிகவும் பின் 20 பைட்டுகள் ஸ்டேக்கில் ஒதுக்கப்படுகிறது, ஒதுக்கீடு.

635
00:52:04,730 --> 00:52:08,400
அதனால் நான் இந்த 20 பைட்டுகள் ஒதுக்கீடு செய்து, முதல் ஒதுக்கீடு.

636
00:52:08,400 --> 00:52:11,400
அதனால் நான், சரியான வரிசை முன் நடக்கும்

637
00:52:11,400 --> 00:52:19,230
ஏனெனில் வழி, போன்ற நான், தொழில்நுட்ப ஸ்டேக் கீழே வளரும் இடத்தில், கடந்த வாரம் கூறினார்

638
00:52:19,230 --> 00:52:28,520
ஒரு வரிசைக்கு சென்று போது குறியீட்டு, நாங்கள் உத்தரவாதம் என்று வரிசையில் 0th நிலை

639
00:52:28,520 --> 00:52:31,970
எப்போதும் வரிசையில் முதல் இடத்தை முன் நடக்கும்.

640
00:52:31,970 --> 00:52:35,900
இந்த நான் கடந்த வாரம் வரைந்த எப்படி வகையான.

641
00:52:35,900 --> 00:52:42,210
கீழே நாம் முகவரியை 0 மற்றும் மேலே நாம் முகவரியை மேக்ஸ் என்று பாருங்கள்.

642
00:52:42,210 --> 00:52:44,880
ஸ்டாக் எப்போதும் கீழே வளர்ந்து வருகிறது.

643
00:52:48,100 --> 00:52:53,500
நாம் நான் ஒதுக்க வேண்டும்.

644
00:52:53,500 --> 00:52:59,680
நாம் முழு ஒதுக்க நான், நாம் தான் இங்கே முழு எனக்கு ஒதுக்கப்பட்ட விடும் வரை என்று பொருள்.

645
00:52:59,680 --> 00:53:06,420
நாம் அந்த அடியில் அதாவது 5 முழுஎண்களின் எங்கள் அணி, ஒதுக்கி

646
00:53:06,420 --> 00:53:11,230
ஸ்டாக் கீழே வளர்ந்து பின்னர், அந்த 5 முழு ஒதுக்கீடு.

647
00:53:11,230 --> 00:53:15,900
ஆனால் அணிகளை எவ்வாறு காரணமாக, நாங்கள் உத்தரவாதம் என்று வரிசையில் முதல் நிலை

648
00:53:15,900 --> 00:53:22,260
எப்போதும் வரிசையில் இரண்டாவது விஷயம் குறைவான ஒரு முகவரி.

649
00:53:22,260 --> 00:53:28,270
எனவே வரிசை நிலையை 0 எப்போதும், நினைவக முதல் நடக்க வேண்டும்

650
00:53:28,270 --> 00:53:30,700
வரிசை நிலை 1 என்று பின் நடக்க வேண்டும், அதேசமயம்

651
00:53:30,700 --> 00:53:33,310
மற்றும் வரிசை நிலை 2, பின்னர் நடக்க வேண்டும்

652
00:53:33,310 --> 00:53:37,900
அந்த வரிசை நிலையை 0, கீழே இங்கே எங்கோ நடக்கும் பொருள்

653
00:53:37,900 --> 00:53:40,690
வரிசை நிலை 1 என்று மேலே நடக்கும்

654
00:53:40,690 --> 00:53:45,530
மேலே நகர்ந்து அதிகபட்ச முகவரியை இங்கு என்பதால் அதிக முகவரிகள் பொருள். ஏனெனில்

655
00:53:45,530 --> 00:53:50,490
கீழே இங்கே வரிசை [0] எனவே, வரிசை [1] இங்கு, வரிசை [2] இங்கு, வரிசை [3] இங்கு.

656
00:53:50,490 --> 00:53:55,620
நாம் இங்கே நான் எல்லா வழி வரை, முழு ஒதுக்கீடு எப்படி முன் கவனிக்க

657
00:53:55,620 --> 00:54:01,040
எங்கள் அணி மேலும் மேலும் நகரும் போது, நாம் நெருக்கமாக மற்றும் நெருக்கமாக எங்கள் முழு எனக்கு கிடைக்கும்.

658
00:54:01,040 --> 00:54:07,640
அது மிக, இது எங்கள் அணி அப்பால் ஒரு நிலையில் தான், அந்த வரிசை [5] நடக்கிறது

659
00:54:07,640 --> 00:54:13,010
சரியாக நான் ஒதுக்கீடு வேண்டும் நடந்தது அங்கு முழு.

660
00:54:13,010 --> 00:54:16,920
அதனால் நாம் ஸ்டேக் இடத்தை தாக்கியதால் வேண்டும் நடக்கும் இடத்தில் விஷயம்

661
00:54:16,920 --> 00:54:21,680
அந்த முழு எனக்கு ஒதுக்கப்பட்ட, நாம் அந்த 0 அமைத்து கொண்டிருக்கிறோம்.

662
00:54:21,680 --> 00:54:26,160
>> அந்த வேலை செய்யும். கேள்விகள்? Yeah.

663
00:54:26,160 --> 00:54:30,710
[மாணவர்] பரவாயில்லை. சரி.

664
00:54:30,710 --> 00:54:33,090
[மாணவர்] எப்படி பிழைகள் இந்த வகையான தவிர்ப்பது?

665
00:54:33,090 --> 00:54:41,190
பிழைகள் இந்த வகையான? உங்கள் நிரலாக்க மொழி போன்ற சி பயன்படுத்த வேண்டாம்.

666
00:54:41,190 --> 00:54:45,840
சோதனை வரிசை எல்லைக்கு என்று ஒரு மொழி பயன்படுத்த.

667
00:54:45,840 --> 00:54:55,900
நீண்ட நீங்கள் கவனமாக இருக்கிறோம், நீங்கள் உங்கள் வரிசைக்கு எல்லைக்கு கடந்த சென்று தவிர்க்க வேண்டும்.

668
00:54:55,900 --> 00:54:58,300
[மாணவர்] எனவே இங்கே உங்கள் வரிசைக்கு எல்லைக்கு கடந்த போது -

669
00:54:58,300 --> 00:55:01,840
[Bowden] விஷயங்கள் தவறாக நடக்கிறது தொடங்க அங்கு தான். >> [மாணவர்] ஓ, சரி.

670
00:55:01,840 --> 00:55:05,730
நீண்ட நீங்கள் உங்கள் வரிசை ஒதுக்கீடு நினைவகம் உள்ள தங்க, நீங்கள் நன்றாக இருக்கிறோம்.

671
00:55:05,730 --> 00:55:12,400
ஆனால் சி இல்லை பிழை சோதனை செய்கிறது. நான் வரிசை செய்தால் [1000], அதை மகிழ்ச்சியுடன் தான் என்ன நடந்தாலும் மாற்ற முடியும் -

672
00:55:12,400 --> 00:55:16,500
அது அணியின் தொடக்கத்தில் செல்லும், அது பின்னர் 1000 நிலைகளை சென்று அதை 0 என அமைக்கிறது.

673
00:55:16,500 --> 00:55:20,000
அது ஓ, இந்த உண்மையில் இது 1000 விஷயங்கள் இல்லை என்று எந்த சோதனை செய்ய மாட்டார்கள்.

674
00:55:20,000 --> 00:55:22,750
1000, வழியில் நான் மாற்ற வேண்டும் அப்பால் உள்ளது

675
00:55:22,750 --> 00:55:26,940
ஜாவா அல்லது ஏதாவது நீங்கள் எல்லைக்கு குறியீட்டின் வரிசை கிடைக்கும் அதேசமயம்

676
00:55:26,940 --> 00:55:29,820
அல்லது எல்லைக்கு விதிவிலக்கு குறியீட்டு அவுட்.

677
00:55:29,820 --> 00:55:33,950
அதிக மொழிகளில் நிறைய இந்த விஷயங்கள் இருக்கிறது அதனால் தான்

678
00:55:33,950 --> 00:55:37,340
நீங்கள் வரிசைக்கு எல்லைக்கு அப்பால் சென்றால், அங்கு, நீங்கள் தோல்வி

679
00:55:37,340 --> 00:55:40,070
நீங்கள் அடியில் இருந்து மாற்ற முடியாது என்று

680
00:55:40,070 --> 00:55:42,590
பின்னர் விஷயங்களை ஒரு விதிவிலக்கு பெற்று விட மோசமாக போய்

681
00:55:42,590 --> 00:55:44,940
நீங்கள் வரிசை இறுதியில் அப்பால் சென்று என்று.

682
00:55:44,940 --> 00:55:50,970
[மாணவர்] எனவே நாம் தான் மாற்ற வேண்டும் <= வெறும் <? >> [Bowden] சரி.

683
00:55:50,970 --> 00:55:54,800
அது <sizeof (வரிசை) / sizeof (int) இருக்க வேண்டும்;

684
00:55:54,800 --> 00:55:59,560
sizeof (வரிசை) 20 ஆகும், ஆனால் நாம் மட்டும் 5 வேண்டும் என்பதால். >> [மாணவர்] ரைட்.

685
00:55:59,560 --> 00:56:04,060
மேலும் கேள்விகள்? சரி.

686
00:56:04,060 --> 00:56:07,380
>> [மாணவர்] நான் ஒரு கேள்வி உள்ளது. >> சரி.

687
00:56:07,380 --> 00:56:16,440
[மாணவர்] உண்மையான வரிசை மாறி என்ன?

688
00:56:16,440 --> 00:56:20,000
[Bowden] போன்ற வரிசை என்ன?

689
00:56:20,000 --> 00:56:24,930
வரிசை தன்னை ஒரு சின்னமாக உள்ளது.

690
00:56:24,930 --> 00:56:31,490
அது நாம் குறிப்பிடும் அந்த 20 பைட்டுகள் தொடக்கத்தில் முகவரி ஆகும்.

691
00:56:31,490 --> 00:56:38,070
நீங்கள் ஒரு சுட்டிக்காட்டி அதை பற்றி யோசிக்க முடியும், ஆனால் அதை தொடர்ந்து சுட்டிக்காட்டி இருக்கிறது.

692
00:56:38,070 --> 00:56:44,140
விரைவில் விஷயங்களை தொகுத்து செய்து என, மாறி வரிசை இனி இல்லை.

693
00:56:44,140 --> 00:56:48,210
[மாணவர்] எப்படி அது அணியின் அளவு கண்டறிய?

694
00:56:48,210 --> 00:56:54,130
வரிசை அளவு அந்த சின்னத்தை குறிக்கும் என்று தொகுதி அளவை குறிக்கிறது.

695
00:56:54,130 --> 00:57:01,240
நான் printf போல ("% p \ n", வரிசை) செய்யும் போது;

696
00:57:01,240 --> 00:57:05,140
அதை இயக்க அனுமதிக்க.

697
00:57:12,960 --> 00:57:15,530
நான் என்ன தவறு செய்தேன்?

698
00:57:15,530 --> 00:57:19,220
வரிசை 'வரிசை' இங்கே அறிவித்தார்.

699
00:57:20,820 --> 00:57:23,200
ஓ, இங்கு.

700
00:57:23,200 --> 00:57:31,250
கணகண வென்ற சப்தம் புத்திசாலி, அதை நான் 5 கூறுகள் என வரிசை அறிவித்தார் என்று கவனிக்க நடக்கிறது

701
00:57:31,250 --> 00:57:34,540
ஆனால் நான் நிலையில் 1000 இல் அட்டவணையிடுவது.

702
00:57:34,540 --> 00:57:38,450
இந்த வெறும் மாறிலிகள் ஏனெனில் அது செய்ய முடியும்.

703
00:57:38,450 --> 00:57:43,370
அது தான் நான் வரிசைக்கு எல்லைக்கு அப்பால் செல்கிறேன் என்று கவனித்தேன் இதுவரை செல்ல முடியும்.

704
00:57:43,370 --> 00:57:46,880
ஆனால், நாம் இந்த தவறான இருக்கும் போது முன் அறிவிப்பு

705
00:57:46,880 --> 00:57:51,040
இது சாத்தியமான, நான் எடுத்து எப்படி பல மதிப்புகள் தீர்மானிக்க முடியாது

706
00:57:51,040 --> 00:57:55,540
அதை நான் வரிசை இறுதியில் அப்பால் என்று தீர்மானிக்க முடியாது.

707
00:57:55,540 --> 00:57:59,430
என்று தான் புத்திசாலி என்ற கணகண வென்ற சப்தம் தான்.

708
00:57:59,430 --> 00:58:03,340
>> ஆனால் இப்போது buggy4 செய்ய. எனவே நான் தவறாக வேறு என்ன செய்கிறேன்?

709
00:58:03,340 --> 00:58:05,970
உட்குறிப்பாக நூலகம் செயல்பாடு 'printf' என்று அறிவித்தார்.

710
00:58:05,970 --> 00:58:14,960
நான் # <stdio.h> சேர்க்க வேண்டும் போகிறேன்.

711
00:58:14,960 --> 00:58:18,710
சரி. இப்போது buggy4 இயங்கும்.

712
00:58:18,710 --> 00:58:24,840
இப்படி வரிசை மதிப்பு அச்சிடும் நான் ஒரு சுட்டிக்காட்டி அதை அச்சிட்டு, இங்கே இல்லை

713
00:58:24,840 --> 00:58:30,060
இந்த மாதிரி என்று அச்சிட்டு ஒன்று - bfb8805c - சில முகவரி இது

714
00:58:30,060 --> 00:58:33,450
அந்த ஸ்டேக்-ish பகுதியில் தான்.

715
00:58:33,450 --> 00:58:41,820
, அணி தன்னை ஒரு சுட்டிக்காட்டி இருக்கிறது, ஆனால் அது ஒரு உண்மையான சுட்டிக்காட்டி அல்ல

716
00:58:41,820 --> 00:58:45,410
வழக்கமான சுட்டிக்காட்டி இருந்து நாம் மாற்ற முடியும்.

717
00:58:45,410 --> 00:58:54,700
வரிசை சில மாறிலி. நினைவகம் 20 தொகுதிகள் முகவரியை 0xbfb8805c மணிக்கு தொடங்கும்.

718
00:58:54,700 --> 00:59:09,020
இந்த முகவரி மூலம் மிகவும் bfb8805c +20- அல்லது நான் -20 நினைக்கிறேன் -

719
00:59:09,020 --> 00:59:17,400
இந்த வரிசை ஒதுக்கீடு நினைவகம் அனைத்து ஆகும்.

720
00:59:17,400 --> 00:59:20,350
வரிசை, மாறி தன்னை எங்கேயும் சேமிக்கப்படும்.

721
00:59:20,350 --> 00:59:27,660
நீங்கள் ஒடுக்குவதற்கான போது, ஒடுக்கி - அது கை அலை -

722
00:59:27,660 --> 00:59:33,060
அது அணியின் வேண்டும் என்று அங்கு ஆனால் தொகுப்பி மட்டும் பயன்படுத்தும்.

723
00:59:33,060 --> 00:59:36,090
அந்த வரிசையில் துவங்குகிறது அது தெரியும்

724
00:59:36,090 --> 00:59:40,910
எனவே அது எப்போதும் தான் ஆரம்பத்தில் இருந்து ஈடு அடிப்படையில் விஷயங்களை செய்ய முடியும்.

725
00:59:40,910 --> 00:59:43,960
அது அணியின் பிரதிநிதியாக ஒரு மாறி தன்னை தேவையில்லை.

726
00:59:43,960 --> 00:59:53,730
ஆனால் நான் முழு எண்ணாக * ப = வரிசை போன்ற ஏதாவது போது; இப்போது, ப என்று வரிசை சுட்டி காட்டும் ஒரு சுட்டிக்காட்டி உள்ளது

727
00:59:53,730 --> 00:59:57,830
இப்போது ப உண்மையில் ஸ்டேக்கில் இருக்கிறது.

728
00:59:57,830 --> 01:00:01,950
நான் ப மாற்ற இலவச இருக்கிறேன். நான் ப = malloc செய்ய முடியும்.

729
01:00:01,950 --> 01:00:06,500
அதை முதலில் வரிசை சுட்டி காட்டினார்; இப்போது குவியல் சில இடத்தில் உள்ளது.

730
01:00:06,500 --> 01:00:09,620
நான் வரிசை = malloc செய்ய முடியாது.

731
01:00:09,620 --> 01:00:13,710
கணகண வென்ற சப்தம் புத்திசாலி இருந்தால், அதை சரியாக பேட் ஆஃப் என்னை கத்துவார்கள்.

732
01:00:17,000 --> 01:00:21,430
உண்மையில், நான் gcc இந்த என்று அழகாக தெரியும்.

733
01:00:21,430 --> 01:00:25,010
எனவே வரிசை வகை 'எண்ணாக [5]' காரணமாக அல்ல.

734
01:00:25,010 --> 01:00:28,040
நீங்கள் ஒரு வரிசை வகை ஏதாவது ஒதுக்க முடியாது

735
01:00:28,040 --> 01:00:30,500
வரிசை ஒரு நிலையான என்பதால்.

736
01:00:30,500 --> 01:00:34,760
அது குறிப்புகள் அந்த 20 பைட்டுகள் ஒரு சின்னமாக உள்ளது. நான் அதை மாற்ற முடியாது.

737
01:00:34,760 --> 01:00:37,690
>> [மாணவர்] மற்றும் வரிசை அளவு அங்கு சேமிக்கப்படுகிறது?

738
01:00:37,690 --> 01:00:40,670
[Bowden] இது எங்கு சேமிக்க இல்லை. அதை ஒடுக்குவதற்கான தான் போது அது.

739
01:00:40,670 --> 01:00:46,310
எனவே வரிசை அளவு அங்கு சேமிக்கப்படுகிறது?

740
01:00:46,310 --> 01:00:51,870
நீங்கள் மட்டும் வரிசை தன்னை அறிவித்தார் என்று செயல்பாடு உள்ளே sizeof (வரிசை) பயன்படுத்தலாம்.

741
01:00:51,870 --> 01:01:03,150
நான் சில செயல்பாடு, foo, அதை நான் செய்ய நீங்கள் (int வரிசை [])

742
01:01:03,150 --> 01:01:10,450
printf ("% d \ n", sizeof (வரிசை));

743
01:01:10,450 --> 01:01:21,330
பின்னர் கீழே இங்கே நான் foo (வரிசை) என்று;

744
01:01:21,330 --> 01:01:24,840
இந்த செயல்பாடு உள்ளே - அது இயங்க அனுமதிக்க.

745
01:01:34,200 --> 01:01:36,840
இந்த மீண்டும் புத்திசாலி என்று கணகண வென்ற சப்தம் இல்லை.

746
01:01:36,840 --> 01:01:43,890
அதை என்னிடம் அந்த அணியின் செயல்பாடு அளவுரு மீது sizeof

747
01:01:43,890 --> 01:01:46,690
'எண்ணாக *' அளவு வரும்.

748
01:01:46,690 --> 01:01:55,150
அதை நான் நடக்க என்ன இல்லை என்றால் இந்த பிழை இருக்கும்.

749
01:01:55,150 --> 01:01:58,960
அது உண்மையில் Werror அணைக்க வேண்டும்.

750
01:02:14,950 --> 01:02:17,590
எச்சரிக்கை. எச்சரிக்கைகள் நன்றாக இருக்கிறார்கள்.

751
01:02:17,590 --> 01:02:19,960
இது ஒரு எச்சரிக்கை என்று அது இன்னும் நீண்ட தொகுக்கும்.

752
01:02:19,960 --> 01:02:22,910
. / A.out 4 அச்சிட வேண்டும்.

753
01:02:22,910 --> 01:02:28,650
உருவாக்கப்படும் என்று எச்சரிக்கை தவறு என்ன ஒரு தெளிவான காட்டி உள்ளது.

754
01:02:28,650 --> 01:02:34,120
இந்த எண்ணாக வரிசை தான் sizeof (int *) அச்சிட வேண்டும்.

755
01:02:34,120 --> 01:02:39,790
நான் இங்கே உள்ள வரிசை [5] வைத்து கூட, அது இன்னும் ஒரு sizeof (int *) அச்சிட நடக்கிறது.

756
01:02:39,790 --> 01:02:47,440
எனவே விரைவில் நீங்கள், ஒரு செயல்பாடு அதை கடந்து என வரிசைகள் மற்றும் குறிப்புகள் இடையில் உள்ள வேறுபாடு

757
01:02:47,440 --> 01:02:49,670
எதுவுமில்லை.

758
01:02:49,670 --> 01:02:52,640
இந்த, ஸ்டாக் அறிவித்தார் என்று ஒரு வரிசை இருக்கும் நடக்கிறது

759
01:02:52,640 --> 01:02:58,300
ஆனால் விரைவில் நாம், அந்த மதிப்பு கடந்து என்று 0xbf அபத்தம், அபத்தம், இந்த செயல்பாடு ஒரு அபத்தம்,

760
01:02:58,300 --> 01:03:03,350
இந்த சுட்டியை ஸ்டேக் அந்த வரிசைக்கு சுட்டிக்காட்டியுள்ளது.

761
01:03:03,350 --> 01:03:08,310
Sizeof மட்டுமே வரிசை அறிவித்தார் என்று விழாவில் பொருந்தும் என்று பொருள் என்று,

762
01:03:08,310 --> 01:03:11,230
இது பொருள் என்று நீங்கள், இந்த செயல்பாடு ஒடுக்குவதற்கான போது

763
01:03:11,230 --> 01:03:17,330
கணகண வென்ற சப்தம் இந்த செயல்பாடு மூலம் செல்லும் போது, அது அணியின் அளவு 5 ஒரு எண்ணாக வரிசை என்று காண்கிறார்.

764
01:03:17,330 --> 01:03:20,640
எனவே அது sizeof (வரிசை) காண்கிறது. அந்த 20 தான்.

765
01:03:20,640 --> 01:03:26,440
அந்த sizeof அடிப்படையில் கிட்டத்தட்ட எல்லா நேரங்களில் எவ்வாறு உண்மையில் தான்.

766
01:03:26,440 --> 01:03:31,150
Sizeof ஒரு செயல்பாடு இல்லை, இது ஒரு ஆபரேட்டர் தான்.

767
01:03:31,150 --> 01:03:33,570
நீங்கள் sizeof செயல்பாடு அழைக்க கூடாது.

768
01:03:33,570 --> 01:03:38,280
Sizeof (int), ஒடுக்கி அந்த 4 மொழிபெயர்க்கும்.

769
01:03:41,480 --> 01:03:43,700
புரிந்ததா? சரி.

770
01:03:43,700 --> 01:03:47,520
>> [மாணவர்] எனவே முக்கிய மற்றும் foo உள்ள sizeof (வரிசை) இடையே உள்ள வேறுபாடு என்ன?

771
01:03:47,520 --> 01:03:52,840
நாம் வகை எண்ணாக * கொண்டது sizeof (வரிசை),, நீங்கள் சொல்கிறீர்கள் இது ஏனெனில்

772
01:03:52,840 --> 01:03:57,120
வரிசை கீழே இங்கே இல்லை வகை எண்ணாக * ஒரு அதேசமயம், அது ஒரு முழு எண்ணாக வரிசை தான்.

773
01:03:57,120 --> 01:04:04,540
>> [மாணவர்] எனவே நீங்கள் வரிசை [] பதிலாக எண்ணாக * வரிசையில் அளவுரு செய்தால்,

774
01:04:04,540 --> 01:04:09,230
இப்போது அது ஒரு சுட்டிக்காட்டி ஏனென்றால் நீங்கள் இன்னும் வரிசை மாற்ற முடியும் என்று அர்த்தம் என்று?

775
01:04:09,230 --> 01:04:14,250
[Bowden] இந்த போலவே? >> [மாணவர்] சரி. நீங்கள் இப்போது செயல்பாடு உள்ள வரிசை மாற்ற முடியும்?

776
01:04:14,250 --> 01:04:18,420
[Bowden] நீங்கள் இருவரும் சந்தர்ப்பங்களில் வரிசை மாற்ற முடியும்.

777
01:04:18,420 --> 01:04:23,130
இந்த வழக்குகளை இரண்டிலும் நீங்கள் வரிசை [4] = 0 என்று இலவசம்.

778
01:04:23,130 --> 01:04:26,590
[மாணவர்] ஆனால் நீங்கள் வேறு ஏதாவது வரிசையில் புள்ளி வைக்க முடியும்?

779
01:04:26,590 --> 01:04:30,230
[Bowden] ஓ. Yeah. அல்லது வழக்கு - >> [மாணவர்] சரி.

780
01:04:30,230 --> 01:04:38,410
[Bowden] வரிசை [] மற்றும் ஒரு முழு எண்ணாக * வரிசை இடையில் உள்ள வேறுபாடு, இல்லை.

781
01:04:38,410 --> 01:04:42,570
நீங்கள் இங்கே சில பல பரிமாண வரிசை பெற முடியும்

782
01:04:42,570 --> 01:04:47,050
சில வசதியான தொடரியல், ஆனால் அது இன்னும் ஒரு சுட்டிக்காட்டி இருக்கிறது.

783
01:04:47,050 --> 01:04:56,400
இந்த வரிசையில் செய்ய இலவச என்று பொருள் = malloc (sizeof (int)); இப்போது வேறு எங்கோ சுட்டி.

784
01:04:56,400 --> 01:04:59,610
ஆனால், இந்த நிரந்தரமாக மற்றும் எப்போதும் வேலை எப்படி இருக்கும்

785
01:04:59,610 --> 01:05:03,210
இது மூலம் இந்த வரிசை மாறி வேறு ஏதாவது சுட்டி

786
01:05:03,210 --> 01:05:07,570
இது, வாதம் நகலை தான் இங்கே இந்த வரிசை கீழே மாற்ற முடியாது

787
01:05:07,570 --> 01:05:10,780
அந்த வாதம் ஒரு சுட்டிக்காட்டி அல்ல.

788
01:05:10,780 --> 01:05:16,070
உண்மையில், அது போலவே தான் இன்னும் குறிப்பிடுதலாக -

789
01:05:16,070 --> 01:05:21,100
நாம் ஏற்கனவே அச்சிடும் வரிசை அச்சிட்டு என்ன பார்த்தேன் -

790
01:05:21,100 --> 01:05:31,410
என்ன நாம் வரிசைக்கு முகவரி அல்லது வரிசைக்கு முகவரி முகவரியை அச்சிட வேண்டும்

791
01:05:31,410 --> 01:05:36,290
அந்த ஒன்று?

792
01:05:41,770 --> 01:05:45,220
இந்த ஒரு தவிர்க்க வேண்டும்.

793
01:05:48,140 --> 01:05:51,660
சரி. இந்த நன்றாக. அது இப்போது. / A.out இயங்கும்.

794
01:05:51,660 --> 01:06:00,220
அச்சு அணி, பின் வரிசைக்கு முகவரியை அச்சிடுதல், அதையே தான்.

795
01:06:00,220 --> 01:06:02,870
வரிசை தான் இல்லை.

796
01:06:02,870 --> 01:06:08,190
அதை நீங்கள் வரிசை அச்சிடும் போது, அந்த 20 பைட்டுகள் குறிக்கும் சின்னமாக அச்சிடும் நீங்கள் தெரிகிறது.

797
01:06:08,190 --> 01:06:11,940
வரிசைக்கு முகவரியை அச்சிடுதல், நன்றாக, வரிசை இல்லை.

798
01:06:11,940 --> 01:06:17,200
அது ஒரு முகவரி இல்லை, அதனால் தான் அந்த 20 பைட்டுகள் முகவரி அச்சிடுகிறது.

799
01:06:20,820 --> 01:06:28,150
விரைவில் நீங்கள் கீழே தொகுக்க என, உங்கள் தொகுக்கப்பட்ட buggy4 போலவே. / A.out

800
01:06:28,150 --> 01:06:30,340
வரிசை எதுவுமில்லை.

801
01:06:30,340 --> 01:06:33,640
சுட்டிகள் உள்ளன. வரிசைகள் வேண்டாம்.

802
01:06:34,300 --> 01:06:38,060
வரிசை குறிக்கும் நினைவகம் தொகுதிகள் இன்னமும் உள்ளன

803
01:06:38,060 --> 01:06:43,270
ஆனால் மாறி வரிசை மற்றும் அந்த வகை மாறிகள் இல்லை.

804
01:06:46,260 --> 01:06:50,270
அந்த வரிசைகள் மற்றும் குறிப்புகள் இடையே முக்கிய வேறுபாடுகள் போன்ற

805
01:06:50,270 --> 01:06:55,590
விரைவில் நீங்கள் செயல்பாடு அழைப்புகளை என, எந்த வித்தியாசமும் கிடையாது.

806
01:06:55,590 --> 01:07:00,460
ஆனால் உள்ளே வரிசை தன்னை அறிவித்தார் என்று செயல்பாடு, sizeof வேறு வேலை

807
01:07:00,460 --> 01:07:05,190
நீங்கள் பதிலாக வகை அளவு தொகுதிகள் அளவு அச்சிடும் நீங்கள் இருந்து,

808
01:07:05,190 --> 01:07:08,950
அது ஒரு சின்னம் தான் நீங்கள் அதை மாற்ற முடியாது.

809
01:07:08,950 --> 01:07:14,370
விஷயம் என்னவென்றால், முகவரி அச்சிடும் அதையே அச்சிடுகிறது.

810
01:07:14,370 --> 01:07:18,480
மற்றும் அது மிகவும் அதிகம்.

811
01:07:18,480 --> 01:07:20,820
[மாணவர்] நீங்கள் ஒரு முறை சொல்ல முடியுமா?

812
01:07:21,170 --> 01:07:24,170
நான் எதையோ மிஸ்.

813
01:07:24,170 --> 01:07:29,260
வரிசைக்கு அச்சிடும் வரிசை மற்றும் முகவரி, அதையே அச்சிடுகிறது

814
01:07:29,260 --> 01:07:33,180
நீங்கள் சுட்டிக்காட்டி முகவரி மற்றும் ஒரு சுட்டிக்காட்டி அச்சிட என்றால் அதேசமயம்,

815
01:07:33,180 --> 01:07:36,010
ஒன்று நீங்கள் சுட்டி நீங்கள் என்ன முகவரி அச்சிடுகிறது,

816
01:07:36,010 --> 01:07:40,360
மற்ற ஸ்டேக்கில் சுட்டிக்காட்டி முகவரி அச்சிடுகிறது.

817
01:07:40,360 --> 01:07:47,040
நீங்கள் ஒரு சுட்டிக்காட்டி மாற்ற முடியும்; நீங்கள் ஒரு வரிசை சின்னமாக மாற்ற முடியாது.

818
01:07:47,740 --> 01:07:53,270
மற்றும் sizeof சுட்டிக்காட்டி என்று சுட்டிக்காட்டி வகை அளவு அச்சிட வேண்டும்.

819
01:07:53,270 --> 01:07:57,470
எனவே எண்ணாக * ப sizeof (ப), 4 அச்சிட போகிறது

820
01:07:57,470 --> 01:08:04,110
ஆனால் எண்ணாக வரிசை [5] அச்சு sizeof (வரிசை) 20 அச்சிட வேண்டும்.

821
01:08:04,110 --> 01:08:07,480
[மாணவர்] எனவே எண்ணாக வரிசை [5] 20 அச்சிட வேண்டும்? >> ஆமாம்.

822
01:08:07,480 --> 01:08:13,300
ஏன் உள்ளே buggy4 அதை sizeof (வரிசை) இருக்கும் போது அந்த

823
01:08:13,300 --> 01:08:16,660
இந்த நான் <20 செய்கிறேன், இதில் நாம் என்ன இல்லை.

824
01:08:16,660 --> 01:08:20,880
நாம் நான் <5 வேண்டும். >> [மாணவர்] சரி.

825
01:08:20,880 --> 01:08:25,569
[Bowden] பின்னர் விரைவில் நீங்கள் செயல்பாடுகளை கடந்து செல்லும் தொடங்கும் என,

826
01:08:25,569 --> 01:08:34,340
நாம் செய்தால் எண்ணாக * ப = வரிசை;

827
01:08:34,340 --> 01:08:39,779
இந்த செயல்பாடு உள்ளே, நாம் அடிப்படையில், அதே வழிகளில் p மற்றும் வரிசை பயன்படுத்தலாம்

828
01:08:39,779 --> 01:08:43,710
sizeof பிரச்சனை மற்றும் மாறும் பிரச்சனை தவிர.

829
01:08:43,710 --> 01:08:49,810
ஆனால் ப [0] = 1; வரிசை [0] = 1 என்று அதே தான்;

830
01:08:49,810 --> 01:08:55,600
மற்றும் விரைவில் நாம் foo (வரிசை) என்று குறிப்பிடப்படுகின்றன; அல்லது foo (ப);

831
01:08:55,600 --> 01:08:59,760
foo செயல்பாடு உள்ளே, இந்த முறை அதே அழைப்பு.

832
01:08:59,760 --> 01:09:03,350
இந்த இரண்டு அழைப்புகள் இடையே எந்த வித்தியாசமும் இல்லை.

833
01:09:07,029 --> 01:09:11,080
>> அந்த நல்ல எல்லோரும்? சரி.

834
01:09:14,620 --> 01:09:17,950
நாங்கள் 10 நிமிடங்கள் வேண்டும்.

835
01:09:17,950 --> 01:09:28,319
>> நாம், இந்த ஹாக்கர் Typer திட்டத்தின் மூலம் பெற முயற்சி செய்கிறேன்

836
01:09:28,319 --> 01:09:32,350
கடந்த ஆண்டு அல்லது ஏதாவது வெளியே வந்து இந்த இணையதளத்தில்,.

837
01:09:34,149 --> 01:09:41,100
நீங்கள் தோராயமாக தட்டச்சு மற்றும் அதை அச்சிடுகிறது போல் தான் இருக்க வேண்டும் -

838
01:09:41,100 --> 01:09:46,729
என்ன கோப்பு அதை ஏற்ற வேண்டும் நடந்தால் நீங்கள் தட்டச்சு போல தெரிகிறது என்ன.

839
01:09:46,729 --> 01:09:52,069
அதை இயக்க அமைப்பு குறியீடு சில வகையான தெரிகிறது.

840
01:09:53,760 --> 01:09:56,890
என்று நாம் நடைமுறைப்படுத்த வேண்டும்.

841
01:10:08,560 --> 01:10:11,690
நீங்கள் hacker_typer என்ற பைனரி இயக்க வேண்டும்

842
01:10:11,690 --> 01:10:14,350
அந்த கோப்பு, ஒரு வாதத்தை எடுத்து "ஹேக்கர் வகை."

843
01:10:14,350 --> 01:10:16,480
இயங்கக்கூடிய இயங்கும் திரை அழிக்க வேண்டும்

844
01:10:16,480 --> 01:10:20,850
பின்னர் பயனர் அச்சகங்கள் ஒரு முக்கிய ஒவ்வொரு முறை கடந்து-ல் இருந்து ஒரு பாத்திரம் அவுட் அச்சிட.

845
01:10:20,850 --> 01:10:24,990
நீங்கள் அழுத்தினால் என்ன முக்கிய எனவே, அதை எறியுங்கள் பதிலாக கோப்பு ஒரு பாத்திரம் அச்சிட வேண்டும்

846
01:10:24,990 --> 01:10:27,810
அந்த வாதம் ஆகும்.

847
01:10:29,880 --> 01:10:34,350
நான் அழகாக நாம் தெரிந்து கொள்ள வேண்டும் போகிறோம் விஷயங்கள் என்ன சொல்கிறேன்.

848
01:10:34,350 --> 01:10:36,440
ஆனால் நாம் termios நூலகம் அவுட் சரிபார்க்க வேண்டும்.

849
01:10:36,440 --> 01:10:44,840
நான் என் வாழ்நாள் முழுவதும் இந்த நூலகத்தை பயன்படுத்த வேண்டும், அது மிகவும் குறைந்த நோக்கங்களுக்காக உள்ளது.

850
01:10:44,840 --> 01:10:48,610
ஆனால் இந்த நாம் வெற்றி தன்மையை எறியுங்கள் பயன்படுத்தலாம் நூலகம் போகிறது

851
01:10:48,610 --> 01:10:52,390
நீங்கள் தரமான முறையில் தட்டச்சு செய்யும் போது

852
01:10:56,970 --> 01:11:05,840
எனவே hacker_typer.c, மற்றும் நாம் # <stdio.h> சேர்க்க வேண்டும் போகிறோம்.

853
01:11:05,840 --> 01:11:12,870
Termios man பக்கத்தை பார்த்து - I'm இது முனையத்தில் OS அல்லது ஏதாவது யோசிக்காமல் -

854
01:11:12,870 --> 01:11:16,240
நான் அதை படிக்க தெரியாது.

855
01:11:16,240 --> 01:11:21,040
இந்த பார்த்து, இந்த 2 கோப்புகளை சேர்க்க, எனவே நாம் அதை செய்யலாம்.

856
01:11:37,620 --> 01:11:46,820
>> முதல் விஷயம் முதல், நாம் திறக்க வேண்டும் கோப்பு ஒரு ஒற்றை வாதம், ஒரு எடுக்க வேண்டும்.

857
01:11:46,820 --> 01:11:52,420
அதனால் நான் என்ன செய்ய வேண்டும் என்று விரும்புகிறீர்கள்? எப்படி நான் ஒரு வாதம் இருக்கிறது பார்க்கவும்?

858
01:11:52,420 --> 01:11:56,480
[மாணவர்] argc அது சமமாக இருந்தால். >> [Bowden] சரி.

859
01:11:56,480 --> 01:12:21,250
நீங்கள் (argc = 2) printf ("பயன்பாடு:% s [கோப்பை திறக்க]").

860
01:12:21,250 --> 01:12:32,750
நான் ஒரு இரண்டாவது வாதம் இல்லாமல் இந்த இயக்க என்றால் இப்போது - ஓ, நான் புதிய வரி வேண்டும் -

861
01:12:32,750 --> 01:12:36,240
நீங்கள் சொல்வது பயன்பாடு பார்க்கலாம்:. / hacker_typer,

862
01:12:36,240 --> 01:12:39,770
பின்னர் இரண்டாவது வாதம் நான் திறக்க வேண்டும் கோப்பு இருக்க வேண்டும்.

863
01:12:58,430 --> 01:13:01,260
இப்போது நான் என்ன செய்ய?

864
01:13:01,260 --> 01:13:08,490
நான் இந்த கோப்பை படிக்க வேண்டும். எப்படி நான் ஒரு கோப்பை படிக்க?

865
01:13:08,490 --> 01:13:11,920
[மாணவர்] நீங்கள் முதல் திறக்க. >> சரி.

866
01:13:11,920 --> 01:13:15,010
எனவே fopen. Fopen என்ன இருப்பான்?

867
01:13:15,010 --> 01:13:22,980
[மாணவர்] கோப்புப்பெயர். >> [Bowden] கோப்புப்பெயர் argv [1] போகிறது.

868
01:13:22,980 --> 01:13:26,110
[மாணவர்] பிறகு என்ன நீங்கள் அதை செய்ய விரும்புகிறேன், எனவே - >> [Bowden] சரி.

869
01:13:26,110 --> 01:13:28,740
நீங்கள் நினைவில் இல்லை என்றால், அதனால், நீங்கள், மனிதன் fopen செய்ய மட்டுமே முடியும்

870
01:13:28,740 --> 01:13:32,960
அது பாதை கோப்பு எங்கே ஒரு கான்ஸ்ட் எரிப்பதை * பாதை இருக்க போகிறது அங்கு,

871
01:13:32,960 --> 01:13:34,970
கான்ஸ்ட் எரிப்பதை * முறை.

872
01:13:34,970 --> 01:13:38,660
நீங்கள் முறை என்ன நினைவில் இல்லை நேர்ந்தால், நீங்கள் முறை பார்க்க முடியாது.

873
01:13:38,660 --> 01:13:44,660
மனிதன் பக்கங்கள் உள்ளே, சாய்வு தன்மையை நீங்கள் விஷயங்களை தேட பயன்படுத்தலாம் என்று.

874
01:13:44,660 --> 01:13:49,790
அதனால் நான் முறையில் தேட / முறையில் தட்டச்சு.

875
01:13:49,790 --> 01:13:57,130
n மற்றும் N நீங்கள் தேடல் போட்டிகள் மூலம் சுழற்சி பயன்படுத்தலாம் என்ன.

876
01:13:57,130 --> 01:13:59,800
இங்கே ஒரு சரத்திற்கு வாதம் முறை புள்ளிகள் நிதி

877
01:13:59,800 --> 01:14:01,930
பின்வரும் காட்சிகளில் ஒன்று தொடங்கி.

878
01:14:01,930 --> 01:14:06,480
வாசிப்புக்கு r எனவே, திறந்த உரை கோப்பு. என்று நாம் செய்ய வேண்டும்.

879
01:14:08,930 --> 01:14:13,210
படித்து, மற்றும் நான் அந்த சேமிக்க வேண்டும் என்று.

880
01:14:13,210 --> 01:14:18,720
தான் ஒரு கோப்பு * போகிறது. இப்போது நான் என்ன செய்ய வேண்டும்?

881
01:14:18,720 --> 01:14:21,200
எனக்கு ஒரு இரண்டாவது கொடுக்க.

882
01:14:28,140 --> 01:14:30,430
சரி. இப்போது நான் என்ன செய்ய வேண்டும்?

883
01:14:30,430 --> 01:14:32,940
[மாணவர்] அதை NULL என்று பாருங்கள். >> [Bowden] சரி.

884
01:14:32,940 --> 01:14:38,690
நீங்கள் ஒரு கோப்பை திறக்க எந்த நேரத்திலும், நீங்கள் வெற்றிகரமாக திறக்க முடியும் என்பதை உறுதிப்படுத்தி கொள்ளுங்கள்.

885
01:14:58,930 --> 01:15:10,460
>> நான் முதல் என் தற்போதைய அமைப்புகளை படிக்க வேண்டும், அங்கு இப்போது நான் அந்த termios பொருள் செய்ய வேண்டும்

886
01:15:10,460 --> 01:15:14,050
மற்றும் ஏதாவது ஒரு அந்த சேமிக்க, நான் என் அமைப்புகளை மாற்ற வேண்டும்

887
01:15:14,050 --> 01:15:19,420
, நான் தட்டச்சு எந்த கேரக்டர் கைவிட

888
01:15:19,420 --> 01:15:22,520
பின்னர் நான் அந்த அமைப்புகளை மேம்படுத்த வேண்டும்.

889
01:15:22,520 --> 01:15:27,250
பின்னர் நிகழ்ச்சி முடிவில், நான் எனது அசல் அமைப்புகளை மீண்டும் மாற்ற வேண்டும்.

890
01:15:27,250 --> 01:15:32,080
எனவே struct வகை termios இருக்க போகிறது, நான் அந்த இரண்டு வேண்டும் போகிறேன்.

891
01:15:32,080 --> 01:15:35,600
முதல் ஒரு, என் current_settings போகிறது

892
01:15:35,600 --> 01:15:42,010
பின்னர் அவர்கள் என் hacker_settings போகிறாய்.

893
01:15:42,010 --> 01:15:48,070
முதல், நான், என் தற்போதைய அமைப்புகளை சேமிக்க வேண்டும் போகிறேன்

894
01:15:48,070 --> 01:15:53,790
நான், hacker_settings மேம்படுத்த வேண்டும் போகிறேன்

895
01:15:53,790 --> 01:16:01,570
பின்னர் என் திட்டம் இறுதியில் வழி, நான் தற்போதைய அமைப்புகளை மாற்றியமைக்க வேண்டும்.

896
01:16:01,570 --> 01:16:08,660
எனவே, நாம் மனிதன் termios வேலை என்று வழி, தற்போதைய அமைப்புகளை சேமிப்பதில்.

897
01:16:08,660 --> 01:16:15,810
நாம் இந்த எண்ணாக tcsetattr, int tcgetattr என்று பார்க்க.

898
01:16:15,810 --> 01:16:22,960
நான் அதன் சுட்டியை ஒரு termios struct உள்ள கடக்க.

899
01:16:22,960 --> 01:16:30,640
இந்த இருக்கும் வழி - நலன் ஏற்கனவே செயல்பாடு என்று என்ன மறந்து.

900
01:16:30,640 --> 01:16:34,930
நகலெடுத்து ஒட்டுக.

901
01:16:39,150 --> 01:16:45,500
Tcgetattr எனவே, நான், நான் தகவல் சேமிப்பு என்று நான் struct உள்ள கடக்க வேண்டும்

902
01:16:45,500 --> 01:16:49,650
இதில், current_settings போகிறது

903
01:16:49,650 --> 01:16:59,120
முதல் வாதத்தை நான் பண்புகளை காப்பாற்ற வேண்டும் விஷயம் கோப்பு விளக்கி இருக்கிறது.

904
01:16:59,120 --> 01:17:04,360
என்ன கோப்பு விளக்கியை நீங்கள் ஒரு கோப்பை திறக்க எந்த நேரத்தில் தான், அது ஒரு கோப்பு விளக்கியை பெறுகிறார்.

905
01:17:04,360 --> 01:17:14,560
நான் fopen argv [1], அதை நீங்கள் குறிப்பிடும் எந்த ஒரு கோப்பு விளக்கியை பெறுகிறார்

906
01:17:14,560 --> 01:17:16,730
நீ அதை எழுத படிக்க வேண்டும் போதெல்லாம்.

907
01:17:16,730 --> 01:17:19,220
என்று நான் இங்கே பயன்படுத்த வேண்டும் கோப்பு விளக்கியை இல்லை.

908
01:17:19,220 --> 01:17:21,940
நீங்கள் முன்னிருப்பாக இருக்கும் மூன்று கோப்பு விளக்கிகளை உள்ளன

909
01:17:21,940 --> 01:17:24,310
இது, நிலையான அவுட், மற்றும் நிலையான பிழை தரமானதாக இருக்கும்.

910
01:17:24,310 --> 01:17:29,960
முன்னிருப்பாக, நான் அதை 0, நிலையான அவுட் 1, மற்றும் நிலையான பிழை 2 ஆகும் நிலையான நினைக்கிறேன்.

911
01:17:29,960 --> 01:17:33,980
எனவே நான் அமைப்புகளை மாற்ற வேண்டுமா?

912
01:17:33,980 --> 01:17:37,370
நான், நான் ஒரு கேரக்டர் வெற்றி போதெல்லாம் அமைப்புகளை மாற்ற வேண்டும்

913
01:17:37,370 --> 01:17:41,590
நான் அதை பதிலாக, திரையில் அச்சடிப்பதை தாரை அந்த பாத்திரத்தை தூக்கி வேண்டும்.

914
01:17:41,590 --> 01:17:45,960
என்ன ஸ்ட்ரீம் - - நிலையான அவுட், அல்லது நிலையான பிழை, நிலையான

915
01:17:45,960 --> 01:17:52,050
நான் விசைப்பலகை உள்ள தட்டச்சு போது எல்லாம் பதில்? >> >> சரி உள்ளே [மாணவர்] ஸ்டாண்டர்ட்.

916
01:17:52,050 --> 01:17:56,450
எனவே நான் ஒன்று 0 செய்ய முடியும் அல்லது நான் stdin செய்ய முடியும்.

917
01:17:56,450 --> 01:17:59,380
நான் உள்ளே தரத்தின் current_settings வருகிறது

918
01:17:59,380 --> 01:18:01,720
>> இப்போது நான், அந்த அமைப்புகளை மேம்படுத்த வேண்டும்

919
01:18:01,720 --> 01:18:07,200
எனவே முதல் நான் என் current_settings என்ன hacker_settings கொண்டு நகலெடுக்க வேண்டும்.

920
01:18:07,200 --> 01:18:10,430
மற்றும் structs வேலை எப்படி அதை நகலெடுத்து.

921
01:18:10,430 --> 01:18:14,510
நீங்கள் எதிர்பார்ப்பதை போல இந்த அனைத்து துறைகளில் நகலெடுக்கிறது.

922
01:18:14,510 --> 01:18:17,410
>> இப்போது நான் துறைகளில் சில புதுப்பிக்க வேண்டும்.

923
01:18:17,410 --> 01:18:21,670
Termios பார்த்து, நீங்கள் இந்த நிறைய மூலம் படிக்க வேண்டும்

924
01:18:21,670 --> 01:18:24,110
நீங்கள் பார்க்க வேண்டும் என்று பார்க்க,

925
01:18:24,110 --> 01:18:28,210
ஆனால் நீங்கள் பார்க்க வேண்டும் போகிறோம் கொடிகள், எதிரொலி ஆகும்

926
01:18:28,210 --> 01:18:33,110
எனவே எக்கோ உள்ளீடு எழுத்துக்கள் எதிரொலி.

927
01:18:33,110 --> 01:18:37,710
முதல் நான் அமைக்க வேண்டும் - துறைகளில் என்ன ஏற்கனவே மறந்து நலன்.

928
01:18:45,040 --> 01:18:47,900
இந்த struct போல் உள்ளது.

929
01:18:47,900 --> 01:18:51,060
உள்ளீடு முறைகள் அதனால் நாம் மாற்ற வேண்டும் என்று.

930
01:18:51,060 --> 01:18:54,210
நாம் என்று நாம் மாற்ற வேண்டும் என்ன என்பதை தீர்வு பார்க்க வேண்டும்.

931
01:19:04,060 --> 01:19:12,610
நாம் இந்த வழியாக பார்க்க தேவைப்படும் தடுக்க lflag மாற்ற வேண்டும்.

932
01:19:12,610 --> 01:19:14,670
நாங்கள் உள்ளூர் முறைகள் மாற்ற வேண்டும்.

933
01:19:14,670 --> 01:19:17,710
நீங்கள் எல்லாம் எங்கிருந்து புரிந்து கொள்ள இந்த முழு விஷயத்தையும் மூலம் படிக்க வேண்டும்

934
01:19:17,710 --> 01:19:19,320
நாம் மாற்ற வேண்டும் என்று.

935
01:19:19,320 --> 01:19:24,120
ஆனால் அதை நாம் மாற்ற வேண்டும் போகிறோம், அங்கு உள்ளூர் முறைகள் உள்ளே தான்.

936
01:19:27,080 --> 01:19:33,110
எனவே hacker_settings.cc_lmode இது என்று என்ன இருக்கிறது.

937
01:19:39,630 --> 01:19:43,020
c_lflag.

938
01:19:49,060 --> 01:19:52,280
நாம் பிட்நிலை செயற்குறிகள் பெற இந்த ஆகும்.

939
01:19:52,280 --> 01:19:54,860
நாம் நேரம் வெளியே என்ன இருக்கிறது, ஆனால் நாம் அது உண்மையான விரைவான வழியாக செல்லலாம்.

940
01:19:54,860 --> 01:19:56,600
நாம் பிட்நிலை செயற்குறிகள் பெற இந்த, உள்ளது

941
01:19:56,600 --> 01:19:59,950
நான் நினைக்கிறேன் நான் ஒரு முறை நீண்ட முன்பு என்று நீங்கள் கொடிகள் கையாள்வதில் தொடங்கும் போது,

942
01:19:59,950 --> 01:20:03,370
நீங்கள் பிட்வைஸ் ஆபரேட்டர் நிறைய பயன்படுத்தி கொள்ள போகிறோம்.

943
01:20:03,370 --> 01:20:08,240
கொடி ஒவ்வொரு பிட் நடத்தை ஒருவித ஒத்துள்ளது.

944
01:20:08,240 --> 01:20:14,090
இங்கு, இந்த கொடி அவர்கள் அனைவரும் வேறு அர்த்தம் அங்கு பல்வேறு விஷயங்கள், ஒரு கூட்டத்தை உள்ளது.

945
01:20:14,090 --> 01:20:18,690
ஆனால் நான் என்ன செய்யவேண்டும் என்று நான் எதிரொலி தொடர்புடைய பிட் அணைக்க.

946
01:20:18,690 --> 01:20:25,440
அதனால் திரும்ப என்று நான் ஆஃப் & = ¬ எக்கோ.

947
01:20:25,440 --> 01:20:30,110
உண்மையில், நான் அதை tECHO அல்லது வேறு ஏதாவதா நினைக்கிறேன். நான் மீண்டும் சரிபார்த்து போகிறேன்.

948
01:20:30,110 --> 01:20:34,050
நான் அதை termios முடியும். இது எதிரொலி.

949
01:20:34,050 --> 01:20:38,440
எக்கோ ஒரு பிட் போகிறது.

950
01:20:38,440 --> 01:20:44,230
¬ எக்கோ அனைத்து கொடிகள் உண்மை அமைக்கப்பட்டுள்ளது அதாவது, அனைத்து துணுக்குகள் 1 அமைக்கப்பட்டுள்ளது அர்த்தம் என்ன

951
01:20:44,230 --> 01:20:47,140
எக்கோ பிட் தவிர.

952
01:20:47,140 --> 01:20:53,830
இந்த என் உள்ளூர் கொடிகள் முடித்து, அது தற்போது உண்மை அமைக்க என்று அனைத்து கொடிகள் பொருள்

953
01:20:53,830 --> 01:20:56,520
இன்னும் உண்மை அமைக்கப்படும்.

954
01:20:56,520 --> 01:21:03,240
என் எக்கோ கொடி உண்மை அமைக்கப்பட்டால், இந்த அவசியம் எக்கோ கொடி மீது பொய்யான அமைக்கப்படுகிறது.

955
01:21:03,240 --> 01:21:07,170
எனவே குறியீடு இந்த வரியை மட்டும் எக்கோ கொடி இருந்து சுழல்கிறது.

956
01:21:07,170 --> 01:21:16,270
குறியீடு மற்ற வரிகளை, நான் அவர்களுக்கு நேரம் வட்டி நகலெடுத்து பின்னர் அவற்றை விளக்க வேண்டும்.

957
01:21:27,810 --> 01:21:30,180
கரைசலில், அவர் 0 கூறினார்.

958
01:21:30,180 --> 01:21:33,880
அதை வெளிப்படையாக stdin என்று கூறுவது நல்லது.

959
01:21:33,880 --> 01:21:42,100
>> இங்கே ICANON | நான் எக்கோ செய்கிறேன் என்று பாருங்கள்.

960
01:21:42,100 --> 01:21:46,650
ICANON நியமன முறையில் அதாவது தனி ஒன்று, குறிக்கிறது.

961
01:21:46,650 --> 01:21:50,280
நீங்கள் கட்டளை வரி அவுட் தட்டச்சு போது என்ன நியமன முறை என்பது, பொதுவாக உள்ளது

962
01:21:50,280 --> 01:21:54,670
நீங்கள் NEWLINE ஹிட் வரை உள்ள நிலையான எதையும் செயல்படுத்த முடியாது.

963
01:21:54,670 --> 01:21:58,230
எனவே நீங்கள் GetString போது, நீங்கள் NEWLINE வெற்றி பின்னர், பொருட்களை ஒரு கொத்து தட்டச்சு.

964
01:21:58,230 --> 01:22:00,590
அது உள்ளே தரத்தை அனுப்பும் போது தான்

965
01:22:00,590 --> 01:22:02,680
இயல்புநிலை தான்.

966
01:22:02,680 --> 01:22:05,830
நான், நீ அழுத்தவும் இப்போது ஒவ்வொரு தன்மையை நியமன முறையில் அணைக்க போது

967
01:22:05,830 --> 01:22:10,910
என்ன, இந்த விஷயங்களை செயல்படுத்த மெதுவாக தான் வழக்கமாக கெட்ட வகையான இது, பதப்படுத்தப்பட்ட

968
01:22:10,910 --> 01:22:14,330
இது முழு கோடுகள் அதை தாங்குவதற்கு நல்லது ஏன் இது.

969
01:22:14,330 --> 01:22:16,810
ஆனால் நான் ஒவ்வொரு தன்மையை செயல்படுத்த வேண்டும்

970
01:22:16,810 --> 01:22:18,810
நான் என்னை NEWLINE அடிக்க அதை காத்திருக்க விரும்பவில்லை இருந்து

971
01:22:18,810 --> 01:22:21,280
இது அனைத்து கதாபாத்திரங்கள் செயல்படுத்தி முன் நான் தட்டச்சு.

972
01:22:21,280 --> 01:22:24,760
இந்த நியமன முறையில் இருந்து சுழல்கிறது.

973
01:22:24,760 --> 01:22:31,320
அது உண்மையில் எழுத்துக்கள் செயல்படுத்தி போது இந்த விஷயங்களை தான் அர்த்தம்.

974
01:22:31,320 --> 01:22:35,830
, நான் அதை தட்டச்சு நான் அவற்றை செயல்படுத்த; இந்த உடனடியாக அவற்றை செயல்படுத்த வேண்டும்.

975
01:22:35,830 --> 01:22:42,510
இந்த, நிலையான என் அமைப்புகளை மேம்படுத்தும் இது விழா

976
01:22:42,510 --> 01:22:45,480
மற்றும் TCSA என்பது இப்போது அது.

977
01:22:45,480 --> 01:22:50,310
ஸ்ட்ரீம் தற்பொழுது என்று எல்லாம் செயலாக்கப்படும் வரை மற்ற விருப்பங்களை காத்திருக்க வேண்டும்.

978
01:22:50,310 --> 01:22:52,030
உண்மையில் இல்லை.

979
01:22:52,030 --> 01:22:56,920
இப்போது என் அமைப்புகள் hacker_typer_settings தற்போது என்ன என்று மாற்ற.

980
01:22:56,920 --> 01:23:02,210
நான் அதை hacker_settings என்று நினைக்கிறேன், எனவே அதை மாற்ற வேண்டும்.

981
01:23:09,610 --> 01:23:13,500
Hacker_settings எல்லாவற்றையும் மாற்ற.

982
01:23:13,500 --> 01:23:16,870
>> இப்போது எங்கள் திட்டம் இறுதியில் நாம் மாற்றியமைக்க வேண்டும் போகிறாய்

983
01:23:16,870 --> 01:23:20,210
normal_settings உள்ளே தற்போது என்ன செய்ய,

984
01:23:20,210 --> 01:23:26,560
இது வெறும் & normal_settings இருக்க போகிறது.

985
01:23:26,560 --> 01:23:30,650
நான் முதலில் அதை பெறுவதில் இருந்து என் normal_settings எந்த மாறவில்லை கவனிக்க.

986
01:23:30,650 --> 01:23:34,520
பின்னர் அவர்கள் மீண்டும் மாற்ற, நான் முடிவில் அவர்கள் திரும்பி செல்லும்.

987
01:23:34,520 --> 01:23:38,390
இந்த மேம்படுத்தல் இருந்தது. சரி.

988
01:23:38,390 --> 01:23:43,900
>> உள்ளே இங்கே இப்போது நான் கால வட்டி குறியீடு விளக்க வேண்டும்.

989
01:23:43,900 --> 01:23:46,350
அது மிகவும் குறியீடு அல்ல.

990
01:23:50,770 --> 01:24:03,750
நாம் கோப்பு ஒரு பாத்திரம் படிக்க பார்க்க. நாம் அது f என்று.

991
01:24:03,750 --> 01:24:07,850
இப்போது நீங்கள் மனிதன் fgetc முடியும், ஆனால் எப்படி fgetc வேலை நடக்கிறது

992
01:24:07,850 --> 01:24:11,910
அதை நீங்கள் படிக்க EOF அந்த பாத்திரத்தை திரும்ப நடக்கிறது என்பது,

993
01:24:11,910 --> 01:24:15,680
எந்த கோப்பு அல்லது சில பிழை நடக்கிறது இறுதியில் ஒத்துள்ளது.

994
01:24:15,680 --> 01:24:19,900
நாம், கோப்பு ஒரு ஒற்றை தன்மை வாசிக்க தொடர்ந்து, தேடுகிறது

995
01:24:19,900 --> 01:24:22,420
நாம் வாசிக்க எழுத்துக்கள் ரன் அவுட் வரை.

996
01:24:22,420 --> 01:24:26,650
நாங்கள் செய்கிறோம் போது மற்றும், நாம் உள்ளே நிலையான ஒரு ஒற்றை தன்மையை காத்திருக்க

997
01:24:26,650 --> 01:24:29,090
ஒவ்வொரு முறை நீங்கள், கட்டளை வரியில் ஏதோ தட்டச்சு

998
01:24:29,090 --> 01:24:32,820
உள்ளே நிலையான இருந்து ஒரு எழுத்தை வாசித்து என்று

999
01:24:32,820 --> 01:24:38,330
பின்னர் putchar நாங்கள் கோப்பில் நிலையான அவுட் இங்கே வரை படிக்க எரிப்பதை வைக்க போகிறது.

1000
01:24:38,330 --> 01:24:42,890
நீங்கள் மனிதன் putchar முடியும், ஆனால் இது வழக்கமான வெளியே வைத்து கொண்டு, அந்த எழுத்தை அச்சிடுகையில்.

1001
01:24:42,890 --> 01:24:51,600
அதே கருத்து; நீங்கள் தான் printf ("% கேட்ச்", கேட்ச்) செய்ய.

1002
01:24:53,330 --> 01:24:56,670
என்று நம் வேலை மொத்த செய்ய நடக்கிறது.

1003
01:24:56,670 --> 01:25:00,300
>> நாம் என்ன செய்ய வேண்டும் என்று நீங்கள் கடைசியாக ஒன்று தான் எங்கள் கோப்பு fclose உள்ளது.

1004
01:25:00,300 --> 01:25:03,310
நீங்கள் fclose என்றால், ஒரு நினைவக கசிவு தான்.

1005
01:25:03,310 --> 01:25:06,680
நாம் முதலில் திறந்து கோப்பு fclose வேண்டும், மற்றும் நான் நினைக்கிறேன்.

1006
01:25:06,680 --> 01:25:13,810
நாம் செய்தால், நான் ஏற்கனவே பிரச்சினைகளை கிடைத்தது.

1007
01:25:13,810 --> 01:25:17,260
பார்க்கலாம்.

1008
01:25:17,260 --> 01:25:19,960
இது பற்றி புகார் செய்தார்?

1009
01:25:19,960 --> 01:25:30,220
எதிர்பார்க்கப்படுகிறது 'எண்ணாக' ஆனால் வாதம் வகை 'struct _IO_FILE *' என்பது.

1010
01:25:36,850 --> 01:25:39,370
அந்த வேலை செய்தால் நாம் பார்க்கலாம்.

1011
01:25:45,210 --> 01:25:53,540
ஒரே C99 அனுமதி. Augh. சரி, hacker_typer செய்ய.

1012
01:25:53,540 --> 01:25:57,760
இப்போது நாம் மிகவும் பயனுள்ளதாக விளக்கங்கள் கிடைக்கும்.

1013
01:25:57,760 --> 01:25:59,900
எனவே அண்டிக்ளேர்டு அடையாளம் 'normal_settings' பயன்படுத்தும்.

1014
01:25:59,900 --> 01:26:04,170
நான் அதை normal_settings அழைக்க வில்லை. நான் அதை current_settings என்று.

1015
01:26:04,170 --> 01:26:12,090
எனவே அந்த அனைத்து மாற்ற வேண்டும்.

1016
01:26:17,920 --> 01:26:21,710
இப்போது வாதம் செல்லும்.

1017
01:26:26,290 --> 01:26:29,500
நான் இப்போது இந்த 0 செய்கிறேன்.

1018
01:26:29,500 --> 01:26:36,720
சரி. . / Hacker_typer cp.c.

1019
01:26:36,720 --> 01:26:39,590
நான் கூட ஆரம்பத்தில் திரையில் தெளிவாக இல்லை.

1020
01:26:39,590 --> 01:26:42,960
ஆனால் நீங்கள் திரையில் தெளிவாக எப்படி பார்க்க கடந்த பிரச்சனை தொகுப்பு திரும்பி பார்க்க முடியும்.

1021
01:26:42,960 --> 01:26:45,160
இது சில கதாபாத்திரங்களின் அச்சிடுதல்

1022
01:26:45,160 --> 01:26:47,210
இந்த நான் என்ன செய்யவேண்டும் என்று செய்து வருகின்றனர்.

1023
01:26:47,210 --> 01:26:48,900
சரி.

1024
01:26:48,900 --> 01:26:55,280
இந்த பதிலாக stdin 0 இருக்க வேண்டும் ஏன் நினைத்து,

1025
01:26:55,280 --> 01:27:00,560
இது #, 0 வரையறுக்க வேண்டும்

1026
01:27:00,560 --> 01:27:03,890
இந்த என்று புகார் -

1027
01:27:13,150 --> 01:27:19,360
நான் கோப்பு விளக்கிகளை இல்லை என்று ஆனால் நீங்கள் உங்கள் FILE * போது முன்,

1028
01:27:19,360 --> 01:27:23,210
ஒரு கோப்பு விளக்கியை, ஒரு ஒற்றை முழு

1029
01:27:23,210 --> 01:27:26,970
ஒரு கோப்பு * அது தொடர்புடைய விஷயங்களை ஒரு மொத்தமாக கொண்டுள்ளது, அதே சமயம்.

1030
01:27:26,970 --> 01:27:30,380
நாம் பதிலாக stdin 0 சொல்ல வேண்டும் காரணம்

1031
01:27:30,380 --> 01:27:37,480
அந்த stdin கோப்பு விளக்கியை 0 குறிக்கும் என்று தான் சுட்டி காட்டும் எந்த ஒரு கோப்பு * உள்ளது.

1032
01:27:37,480 --> 01:27:45,070
அதனால் கூட இங்கு நான் fopen செய்யும் போது (argv [1], நான் மீண்டும் ஒரு கோப்பை * வருகிறது.

1033
01:27:45,070 --> 01:27:51,180
ஆனால் எங்கோ கோப்பு * அந்த கோப்பு கோப்பு விளக்கியை தொடர்பான ஒரு விஷயம்.

1034
01:27:51,180 --> 01:27:57,430
நீங்கள் திறந்த man பக்கத்தை பார்த்து இருந்தால், நான் உனக்கு மனிதன் 3 திறந்த செய்ய வேண்டும் என்று - இல்லை -

1035
01:27:57,430 --> 01:27:59,380
மனிதன் 2 திறந்த - ஆமாம்.

1036
01:27:59,380 --> 01:28:06,250
நீங்கள் திறந்த ஐந்து பக்கம் பார்த்தால், திறந்த, ஒரு கீழ் நிலை fopen போல்

1037
01:28:06,250 --> 01:28:09,350
அது உண்மையான கோப்பு விளக்கியை திரும்பி.

1038
01:28:09,350 --> 01:28:12,050
fopen திறந்த மேல் பொருட்களை ஒரு கொத்து இல்லை,

1039
01:28:12,050 --> 01:28:17,640
அதற்கு பதிலாக கோப்பு விளக்கியை ஒரு முழு FILE * சுட்டிக்காட்டி கொடுக்கிறது என்று திரும்பி எந்த

1040
01:28:17,640 --> 01:28:20,590
உள்ளே இது எங்கள் சிறிய கோப்பு விளக்கி இருக்கிறது.

1041
01:28:20,590 --> 01:28:25,020
FILE * தான் குறிக்கிறது மிகவும் தரமான,

1042
01:28:25,020 --> 01:28:29,120
0 தன்னை ஒரு கோப்பு விளக்கியை தரத்தை குறிக்கிறது, அதேசமயம்.

1043
01:28:29,120 --> 01:28:32,160
>> கேள்விகள்?

1044
01:28:32,160 --> 01:28:35,930
[சிரிக்கிறார்] அந்த வழியாக பறந்தது.

1045
01:28:35,930 --> 01:28:39,140
எல்லாம் சரி. நாம் முடித்துவிட்டீர்கள். [சிரிக்கிறார்]

1046
01:28:39,140 --> 01:28:42,000
>> [CS50.TV]