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
आप कर सकते हैं कि आईपी पते, jharvard@192.168.129.128 ssh 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
तुम सब FAS सर्वर पर मूलभूत FAS खातों के द्वारा होना चाहिए.

29
00:02:01,130 --> 00:02:06,840
मेरे लिए, मैं SSH rbowden@nice.fas.harvard.edu के लिए.

30
00:02:06,840 --> 00:02:11,610
यह आपको लगता है कि पहली बार पूछने के लिए जा रहा है, और आप हाँ कहते हैं.

31
00:02:11,610 --> 00:02:15,840
मेरा पासवर्ड सिर्फ मेरे FAS कूटशब्द होने जा रहा है.

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
मुझे लगता है कि खोलना करने के लिए जा रहा हूँ.

41
00:02:50,560 --> 00:02:55,670
समस्या हो सकता है कि आप जीएडिट की तरह कुछ का उपयोग करने के लिए इस्तेमाल कर रहे हैं के लिए जा रहा है

42
00:02:55,670 --> 00:02:58,160
या उपकरण के अंदर जो भी हो.

43
00:02:58,160 --> 00:03:01,830
आप के लिए कि FAS सर्वर पर नहीं जा रहे हैं.

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
नियंत्रण एक्स, नियंत्रण सी? हाँ.

53
00:03:32,760 --> 00:03:35,310
या आप विम का उपयोग कर सकते हैं, जो मैं क्या उपयोग है.

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 जाना आप नोटपैड के लिए एक लिंक देखेंगे + +,

62
00:04:03,780 --> 00:04:07,120
जो है क्या आप एक पीसी पर उपयोग कर सकते हैं.

63
00:04:07,120 --> 00:04:13,340
यह आप SFTP Notepad से देता है + +, जो मूल रूप से 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 पुस्तकालय में कार्यों का भी implementations.

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
यह भी नहीं 1s और 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
मानक बाहर, धारा, यह मतलब है कि आप सिर्फ यह करने के लिए 1s और 0s लिखने,

95
00:06:36,860 --> 00:06:40,220
और मानक बाहर के दूसरे छोर सिर्फ उस धारा से पढ़ता है.

96
00:06:40,220 --> 00:06:43,540
यह सिर्फ 1s और 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
तो अब अगर मैं रास, मैं देख रहा हूँ कि मैं एक नई फ़ाइल बुलाया फ़ाइल है.

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
अगले एक से पूछते हैं - यह इस बारे में पूछ नहीं है.

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
कि मानक त्रुटि redirecting है.

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, बनाने और इसे रोब, टॉमी, यूसुफ, टॉमी, यूसुफ, आरजे, रोब है,

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 रोब, टॉमी, यूसुफ के बाद होना चाहिए, आरजे इस फाइल में ही अनूठा नाम हैं.

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
यह वास्तव में छपाई - चलो देखते हैं, आदमी wc newlines, शब्द, और बाइट गिनती.

222
00:17:32,560 --> 00:17:38,270
अगर मैं केवल लाइनों के बारे में परवाह है, तो मैं सिर्फ wc-l names.txt कर सकते हैं.

223
00:17:41,730 --> 00:17:44,300
तो यह है कि एक कदम है.

224
00:17:44,300 --> 00:17:50,510
लेकिन मैं wc-l names.txt नहीं करना चाहते क्योंकि 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
यह मुझे यूसुफ, आरजे, रोब, टॉमी देता है,

236
00:18:43,390 --> 00:18:49,260
और मैं WC-एल इनपुट के रूप में उपयोग करना चाहते हैं कि,

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
कि यह पाइप और redirection के लिए है.

245
00:19:18,370 --> 00:19:24,090
>> अब हम वास्तविक सामान, कोडिंग सामान को पर चलते हैं.

246
00:19:24,090 --> 00:19:29,100
इस पीडीएफ के अंदर, आप इस कमांड देखेंगे,

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 खोलना चाहता हूँ,

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 में एक शून्य सूचक परिणाम अपसंदर्भन.

270
00:21:31,920 --> 00:21:37,210
जब आप एक सूचक को प्रारंभ करने के लिए नहीं होता है, तो यह एक कचरा मूल्य है,

271
00:21:37,210 --> 00:21:41,520
और इसलिए जब आप भिन्नता के लिए कोशिश, सभी संभावना में आप स्मृति छू रहे हैं

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
तो जब आप भिन्नता है कि सूचक है जो आप प्रारंभ नहीं किया है,

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 - मैं अभी कुछ और करने के लिए जा रहा है.

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
हम सिर्फ buggy1 gdb करते हैं, कर सकते हैं और है कि अभी तक 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
लेकिन अगर आप बीटी या बैकट्रैस लिखें, जो करने के लिए समारोह होने जा रहा है

333
00:26:15,360 --> 00:26:19,430
कि हमें हमारे वर्तमान ढेर फ्रेम की सूची देता है.

334
00:26:19,430 --> 00:26:23,150
तो बैकट्रैस. ऐसा लग रहा है जैसे हम केवल दो ढेर फ्रेम है.

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
लेकिन मैं लगभग कभी नीचे - ऊपर या. हाँ.

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 लेबल फ्रेम करने के लिए जाना जाता है का कहना है.

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
हम CS50 चट्टानों और अशक्त strcmping रहे हैं, और इसलिए कि segfault करने के लिए जा रहा है.

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
हाँ. हम इसे किसी भी कमांड लाइन तर्क देना नहीं था.

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
हमारे बैकट्रैस को देखते हुए, हम देखते हैं कि हम समारोह oh_no में थे,

377
00:29:21,250 --> 00:29:23,900
है जो समारोह छोटे आकार का है, जो समारोह binky द्वारा बुलाया गया था द्वारा बुलाया गया था,

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
सुवेश और binky के लिए तर्क था 1.

381
00:29:34,680 --> 00:29:44,390
यदि हम oh_no समारोह को सूचीबद्ध करने के लिए, हम देखते हैं कि oh_no सिर्फ char ** = रिक्त कर रही है;

382
00:29:44,390 --> 00:29:47,410
* = "बूम";

383
00:29:47,410 --> 00:29:50,330
कि असफल क्यों चाहते हैं?

384
00:29:54,330 --> 00:29:58,380
[छात्र] आप अशक्त संकेतक भिन्नता नहीं कर सकते? >> हाँ.

385
00:29:58,380 --> 00:30:06,090
यह सिर्फ इतना कह रहा है नल है, चाहे तो वह एक char ** होता है,

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
यदि आप एक आदेश में प्रवेश नहीं करते हैं और आप बस फिर से मारा,

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
समारोह सुवेश का कहना है कि अगर मैं 1 है, तो oh_no कार्य करने के लिए जाना है,

401
00:31:13,640 --> 00:31:15,960
slinky कार्य करने के लिए जाना.

402
00:31:15,960 --> 00:31:18,700
और हम जानते हैं कि मैं एक है, क्योंकि हम यहाँ देखना होगा

403
00:31:18,700 --> 00:31:22,560
कि सुवेश 1 तर्क के साथ बुलाया गया था.

404
00:31:22,560 --> 00:31:27,560
या आप बस मैं प्रिंट कर सकते हैं और यह कहना होगा कि मैं 1 है.

405
00:31:27,560 --> 00:31:33,770
हम सुवेश में वर्तमान में कर रहे हैं, और अगर हम एक फ्रेम जाना है, हम जानते हैं कि हम binky में समाप्त होगा.

406
00:31:33,770 --> 00:31:36,600
ऊपर. अब हम binky में हैं.

407
00:31:36,600 --> 00:31:41,340
इस समारोह सूची से पहले आधे मुझे काट - लिस्ट -

408
00:31:41,340 --> 00:31:52,670
यह बंद करना शुरू कर के रूप में अगर मैं 0 है, तो हम के लिए यह oh_no कॉल करने के लिए जा रहे हैं, और छोटे आकार का फोन है.

409
00:31:52,670 --> 00:31:57,000
हम जानते हैं कि मैं 1 वर्ष के थे, तो यह छोटे आकार का कहा जाता है.

410
00:31:57,000 --> 00:32:05,030
और अब हम मुख्य में वापस आ गए हैं, और मुख्य बस int i = रैंड () 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
कोड की पहली पंक्ति कहते हैं कि अगर (i == 0), मैं एक कदम उठाने जा रहा है,

436
00:33:42,040 --> 00:33:44,930
हम देखते हैं हम सुवेश में खत्म.

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
जो छोटे आकार का (i) कॉल करने के लिए जा रहा है.

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
ठीक है, तो मैं एक कदम उठाया है और अब मैं सुवेश (i) में हूँ,

443
00:34:10,800 --> 00:34:14,120
आपको लगता है कि हो सकता है इसका मतलब यह होगा मैं = 0 या कुछ और.

444
00:34:14,120 --> 00:34:18,980
नहीं, यह सिर्फ मतलब है कि वह जानता है कि यह सीधे लाइन सुवेश (i) के लिए छड़ी कर सकते हैं.

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
यह सिर्फ अगली पंक्ति यह वास्तव में निष्पादित, जो छोटे आकार का है (i) के लिए जाना जा रहा है.

448
00:34:31,570 --> 00:34:36,090
सुवेश (i) में कदम, हम देखते हैं अगर (i == 1).

449
00:34:36,090 --> 00:34:42,670
हम i = 1 पता नहीं है, इसलिए जब हम कदम है, हम जानते हैं कि हम oh_no में खत्म हो जा रहे

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 कहता है, और यह छोटे आकार का कहता है, जो यहाँ आता है.

455
00:35:10,610 --> 00:35:18,100
अगर मैं 1, कॉल oh_no, और slinky कॉल, जो यहाँ आ रहा है,

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
और आप एक समारोह जो अगर मैं 1 आप segfault जाना,

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
>> मैं यह char ** = रिक्त करने के बजाय होगा फिक्सिंग के एक तरीका लगता है,

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 * जोड़ने के लिए, तो int * x.

469
00:36:32,940 --> 00:36:35,600
मैं malloc (sizeof (int)).

470
00:36:35,600 --> 00:36:40,490
या अगर मैं 5 की एक सरणी चाहता था, मैं (sizeof (int) * 5) करना होगा;

471
00:36:40,490 --> 00:36:44,210
क्या होगा यदि मैं एक int ** है?

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 = "बूम".

480
00:37:20,870 --> 00:37:27,950
"बूम" पहले से मौजूद है. यह केवल पढ़ने के लिए स्मृति के क्षेत्र में करने के लिए मौजूद होता है.

481
00:37:27,950 --> 00:37:35,200
लेकिन यह पहले से ही मौजूद है, जो कोड की इस पंक्ति का अर्थ है, अगर एस एक char ** है,

482
00:37:35,200 --> 00:37:43,900
फिर * एक चार * है और आप इस चार * स्थापित कर रहे हैं "बूम" को इंगित.

483
00:37:43,900 --> 00:37:50,040
अगर मैं s में 'बूम' की नकल करना चाहता था, तो मैं एस के लिए जगह आवंटित की आवश्यकता होगी.

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
हाँ. अपने तार के सभी अशक्त चरित्र की जरूरत के लिए जा रहे हैं.

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
* s = "बूम"?

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
बैकट्रैस हम अगर, वहाँ केवल दो कार्य कर रहे हैं.

518
00:40:46,550 --> 00:40:52,970
यदि हम हमारे मुख्य समारोह में जाना है, तो हम देखते हैं कि हम इस लाइन पर segfaulted.

519
00:40:52,970 --> 00:41:00,180
तो बस इस लाइन पर देख रहे हैं, के लिए (int लाइन = 0; fgets इस सामान बराबर नहीं रिक्त करता है;

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
फ़ाइल एक फ़ाइल * प्रकार की है, तो यह एक सूचक है,

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
लेकिन क्रम में सूचक का उपयोग करने के लिए, यह भिन्नता है.

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
और अगर (फ़ाइल == रिक्त) का कहना है कि printf ("फ़ाइल मौजूद नहीं है!"

563
00:44:45,870 --> 00:44:56,340
या अभी तक बेहतर filename), 1 वापसी;

564
00:44:56,340 --> 00:45:00,300
तो अब हम देखने के लिए अगर यह रिक्त है

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 रिक्त रिटर्न की जाँच करनी चाहिए.

571
00:45:33,870 --> 00:45:38,170
आप हमेशा के लिए सुनिश्चित करें कि malloc रिक्त वापस नहीं करता है की जाँच करनी चाहिए,

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 है एक बार, मैं सिर्फ हिट दर्ज अगले जा रहा रखने के कर सकते हैं

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 में देख रहे हैं, हम देखते हैं कि सब होता int सरणी [5];

599
00:48:22,220 --> 00:48:26,200
(, मैं <= sizeof (सरणी), मैं + + मैं = 0) के लिए

600
00:48:26,200 --> 00:48:28,550
सरणी [i] = 0;

601
00:48:28,550 --> 00:48:31,390
हम क्या देख रहे हो कि यहाँ गलत है?

602
00:48:31,390 --> 00:48:39,480
एक संकेत के रूप में, जब मैं buggy4 gdb कर रहा था - चलो मुख्य रन, तोड़ -

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
तो पूरी बात 5 * sizeof (int) बाइट्स, जहां sizeof (int) 4 हो जाता है होना चाहिए.

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
यहाँ है कि क्या हो रहा है के अंदर ही बात है कि सरणी [i] 0 करने के लिए स्थापित किया जा रहा है.

617
00:50:09,350 --> 00:50:15,350
तो किसी भी तरह, कोड की इस पंक्ति हमारे int मैं 0 से स्थापित करने के लिए पैदा कर रहा है.

618
00:50:16,730 --> 00:50:23,130
[छात्र] यह हो सकता क्योंकि यह मैं के इस हिस्से की स्मृति अधिभावी

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
किसी भी तरह कि अंतरिक्ष कि हम अधिभावी कर रहे हैं मैं के मूल्य अधिभावी है.

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
और अगर आप stack के मामले में लगता है कि इस बारे में,

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
जब आप एक सरणी में सूचकांक, हम गारंटी है कि सरणी में 0 स्थिति

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 integers के हमारे सरणी, जो कि नीचे इसका मतलब है कि आवंटित

646
00:53:06,420 --> 00:53:11,230
के बाद से ढेर के नीचे से बढ़ रहा है, उन 5 integers आवंटित हो.

647
00:53:11,230 --> 00:53:15,900
लेकिन कैसे arrays काम की वजह से, हम गारंटी रहे हैं कि सरणी में प्रथम स्थान

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
>> यही कारण है कि यह कैसे काम करता है. प्रश्न? हाँ.

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
+20- तो इस पते के माध्यम से bfb8805c या मैं -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
और इसलिए यह हमेशा सिर्फ offsets के संदर्भ में बातें कर सकते हैं कि शुरू से ही करते हैं.

725
00:59:40,910 --> 00:59:43,960
यह एक चर में ही करने के लिए सरणी का प्रतिनिधित्व करने की जरूरत नहीं है.

726
00:59:43,960 --> 00:59:53,730
लेकिन जब मैं int * p = सरणी की तरह कुछ करते हैं, अब पी एक सूचक जो कि सरणी अंक है,

727
00:59:53,730 --> 00:59:57,830
और अब पी वास्तव में ढेर पर मौजूद नहीं है.

728
00:59:57,830 --> 01:00:01,950
मैं पी बदलने के लिए स्वतंत्र हूँ. मैं p = 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
वास्तव में, मैं बहुत यकीन है कि जीसीसी यह भी करना होगा हूँ.

733
01:00:21,430 --> 01:00:25,010
तो 'int [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
'int *' के आकार में वापस आ जाएगी.

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
इस int सरणी सिर्फ sizeof (* int) प्रिंट के लिए जा रहा है.

755
01:02:34,120 --> 01:02:39,790
यहां तक ​​कि अगर मैं यहाँ में [5] सरणी डाल दिया है, यह अभी भी सिर्फ sizeof (* int) प्रिंट जा रहा है.

756
01:02:39,790 --> 01:02:47,440
इसलिए जैसे ही आप इसे एक समारोह में पारित, arrays और संकेत के बीच भेद

757
01:02:47,440 --> 01:02:49,670
nonexistent है.

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 आकार के एक int सरणी है.

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 (सरणी) है, जो int * प्रकार की कह रहे हैं,

772
01:03:52,840 --> 01:03:57,120
जबकि सरणी नीचे यहाँ int * प्रकार की नहीं है, यह एक int सरणी है.

773
01:03:57,120 --> 01:04:04,540
>> [छात्र] तो, अगर आप पैरामीटर [] के बजाय int * सरणी में था

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] ओह. हाँ. या तो मामले में - >> [छात्र] हाँ.

780
01:04:30,230 --> 01:04:38,410
[Bowden] [] और एक int * सरणी सरणी के बीच अंतर है, वहाँ कोई नहीं है.

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
सरणी nonexistent है.

801
01:06:30,340 --> 01:06:33,640
सूचक मौजूद हैं. Arrays करना नहीं.

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
उन arrays और संकेत के बीच मुख्य अंतर की तरह कर रहे हैं

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
तो int * p sizeof (पी) 4 मुद्रित करने के लिए जा रहा है,

820
01:07:57,470 --> 01:08:04,110
लेकिन int [5] सरणी प्रिंट sizeof (सरणी) 20 मुद्रित करने के लिए जा रहा है.

821
01:08:04,110 --> 01:08:07,480
[छात्र] int [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
अगर हमने किया int * p = सरणी;

827
01:08:34,340 --> 01:08:39,779
इस समारोह के अंदर, हम मूल रूप से वास्तव में एक ही तरीके में पी और सरणी का उपयोग कर सकते हैं,

828
01:08:39,779 --> 01:08:43,710
sizeof समस्या और बदलने में समस्या के लिए छोड़कर.

829
01:08:43,710 --> 01:08:49,810
लेकिन p = 1 [0], [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
>> हम इस हैकर टाइपकर्ता कार्यक्रम के माध्यम से प्राप्त करने की कोशिश करेंगे,

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 के लिए आदमी पृष्ठ पर देख रहे हैं - मैं यह टर्मिनल ओएस या कुछ अनुमान लगा -

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
, जहां यह एक const चार * पथ, जहां पथ फ़ाइल नाम है होने जा रहा है

871
01:13:32,960 --> 01:13:34,970
const चार * मोड.

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 और एन कर रहे हैं कि तुम क्या खोज मेल के माध्यम से चक्र करने के लिए उपयोग कर सकते हैं.

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
[छात्र] जाँच करें अगर यह रिक्त है. >> [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
1 एक मेरे 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
हम देखते हैं कि हम इस int tcsetattr, tcgetattr int है.

898
01:16:15,810 --> 01:16:22,960
मैं अपने सूचक द्वारा termios struct में पारित.

899
01:16:22,960 --> 01:16:30,640
जिस तरह से यह दिखेगा है - 've पहले से ही भूल समारोह में बुलाया गया था.

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
वहाँ तीन फ़ाइल descriptors आप डिफ़ॉल्ट रूप से कर रहे हैं,

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
तो पहले मैं hacker_settings मेरे current_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
पहले मैं सेट करना चाहते हैं - 've पहले से ही भूल क्षेत्रों क्या कर रहे हैं.

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
आप एक बहुत bitwise ऑपरेटर का उपयोग करने के लिए होने जा रहे हैं.

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
ECHO बिट के लिए छोड़कर.

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
अगर मेरे ECHO ध्वज को सही करने के लिए सेट कर दिया जाता है, तो यह जरूरी इको झंडे पर गलत है.

955
01:21:03,240 --> 01:21:07,170
तो कोड की इस पंक्ति सिर्फ ECHO झंडा बदल जाता है.

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
हम देखते हैं कि हम फ़ाइल से एक चरित्र को पढ़ने. हम इसे च बुलाया.

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 कर सकता है ("% c", ग), समान विचार.

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 *' उम्मीद 'int' लेकिन तर्क है.

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
और क्यों इस 0 stdin के बजाय जरूरत के बारे में सोच रही है,

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
पहले, जब मैंने कहा कि वहाँ फ़ाइल descriptors लेकिन फिर आप भी अपनी फ़ाइल *

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
यदि आप खोलने के लिए आदमी पृष्ठ पर देखो, इसलिए मुझे लगता है कि आप के आदमी 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
जो लौटने के बजाय सिर्फ इतना है कि संचिका विवरणक एक पूरी फ़ाइल * सूचक देता

1040
01:28:17,640 --> 01:28:20,590
अंदर जो हमारे छोटे फ़ाइल डिस्क्रिप्टर है.

1041
01:28:20,590 --> 01:28:25,020
तो मानक फ़ाइल * बात करने के लिए संदर्भित करता है,

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]