1
00:00:00,000 --> 00:00:00,487

2
00:00:00,487 --> 00:00:11,210
>> [संगीत खेल]

3
00:00:11,210 --> 00:00:12,100
>> आरओबी BODEN: सब ठीक है.

4
00:00:12,100 --> 00:00:15,620
वीडियो का पहला तो, पहली बात,
एक परिचित चेहरे से.

5
00:00:15,620 --> 00:00:22,080

6
00:00:22,080 --> 00:00:22,560
>> [वीडियो प्लेबैक]

7
00:00:22,560 --> 00:00:23,370
>> सब सही.

8
00:00:23,370 --> 00:00:27,150
इस CS50 है, और यह है
सप्ताह में तीन की शुरुआत.

9
00:00:27,150 --> 00:00:29,980
मुझे लगता है मैं तुम्हारे साथ नहीं हो सकता माफी चाहता हूँ
आज, लेकिन मुझे शुरू करने की अनुमति

10
00:00:29,980 --> 00:00:32,880
CS50 की अपनी रोब Boden.

11
00:00:32,880 --> 00:00:33,872
>> [अंत वीडियो प्लेबैक]

12
00:00:33,872 --> 00:00:39,340
>> [वाहवाही और चियर्स]

13
00:00:39,340 --> 00:00:41,277
>> आरओबी BODEN: में फिल्मोग्राफी
उस वीडियो शानदार है.

14
00:00:41,277 --> 00:00:47,280

15
00:00:47,280 --> 00:00:47,770
ठीक है.

16
00:00:47,770 --> 00:00:50,960
तो सबसे पहले, एक और दोपहर का भोजन नहीं है.

17
00:00:50,960 --> 00:00:52,330
यह 1:15 पर कल है.

18
00:00:52,330 --> 00:00:54,480
इस शुक्रवार कोई दोपहर का भोजन नहीं है.

19
00:00:54,480 --> 00:00:55,810
यह Quora साथ है.

20
00:00:55,810 --> 00:01:00,190
और टॉमी एक की लेकिन, अभी तक यहाँ नहीं है
पूर्व प्रमुख सीएफ है लोगों को,

21
00:01:00,190 --> 00:01:01,530
टॉमी McWilliam.

22
00:01:01,530 --> 00:01:02,730
तो वह एक मजेदार आदमी है.

23
00:01:02,730 --> 00:01:04,819
तुम आ जाना चाहिए.

24
00:01:04,819 --> 00:01:05,900
>> ठीक है.

25
00:01:05,900 --> 00:01:11,360
इसलिए पिछले हफ्ते, हम अलग तोड़ने शुरू कर दिया
एक स्ट्रिंग वास्तव में क्या है के बारे में.

26
00:01:11,360 --> 00:01:14,830
हम शुरुआत के बाद से जाना जाता है कि
यह वर्ण के एक दृश्य है.

27
00:01:14,830 --> 00:01:18,130
लेकिन पिछले हफ्ते, हम इस तथ्य में delved
क्या वास्तव में एक दृश्य है कि

28
00:01:18,130 --> 00:01:22,110
वर्ण, ठीक है, अब हम है
वर्णों की सरणियों.

29
00:01:22,110 --> 00:01:26,450
और हम एक स्ट्रिंग, यह एक सरणी है कि पता
वर्ण की, बहुत अंत में,

30
00:01:26,450 --> 00:01:30,920
हम इस विशेष अशक्त बाइट है, इस
बैकस्लैश 0, कि अंत का संकेत करता है

31
00:01:30,920 --> 00:01:32,230
स्ट्रिंग.

32
00:01:32,230 --> 00:01:36,970
>> और इसलिए एक स्ट्रिंग के एक सरणी है
वर्ण, लेकिन हम कर सकते हैं और अधिक से अधिक

33
00:01:36,970 --> 00:01:39,530
पात्रों का सिर्फ एक सरणी,
हम किसी की एक सरणी हो सकता है

34
00:01:39,530 --> 00:01:40,890
हम चाहते हैं कि बात के प्रकार.

35
00:01:40,890 --> 00:01:51,570
तो, अगर आप पिछले सप्ताह से याद करते हैं,
डेविड पेश किया कि उम्र के कार्यक्रम

36
00:01:51,570 --> 00:01:53,560
वास्तव में जल्दी.

37
00:01:53,560 --> 00:01:57,010
हम क्या करने जा रहे हैं तो पहली बात है
, एक पूर्णांक के लिए उपयोगकर्ता पूछना

38
00:01:57,010 --> 00:01:58,800
कमरे में लोगों की संख्या.

39
00:01:58,800 --> 00:02:01,260
हम चाहते हैं कि पूर्णांक है एक बार,
हम एक सरणी की घोषणा कर रहे हैं.

40
00:02:01,260 --> 00:02:02,890
इस ब्रैकेट वाक्यविन्यास सूचना है.

41
00:02:02,890 --> 00:02:04,540
तुम्हें पता है कि करने के लिए इस्तेमाल किया पाने के लिए जा रहे हैं.

42
00:02:04,540 --> 00:02:09,430
>> इसलिए हम पूर्णांकों की सरणी घोषणा कर रहे हैं
उम्र कहा जाता है, और एन रहे हैं

43
00:02:09,430 --> 00:02:12,080
इस सरणी में पूर्णांकों.

44
00:02:12,080 --> 00:02:16,480
यहीं तो इस पैटर्न, इस 4 INT
मुझे लगता है मैं ही, मैं कम से कम पता है, 0 के बराबर होती है

45
00:02:16,480 --> 00:02:20,580
साथ ही, यह भी कहा कि एक पैटर्न होने जा रहा है
तुम बहुत करने के लिए इस्तेमाल किया जाना है.

46
00:02:20,580 --> 00:02:24,000
कि बहुत ज्यादा आप कर रहे हैं कि कैसे क्योंकि
हमेशा सरणियों पुनरावृति करने जा रही है.

47
00:02:24,000 --> 00:02:26,330
तो पता है कि याद
हमारे सरणी की लंबाई.

48
00:02:26,330 --> 00:02:32,120
और तो यहाँ, हम बार बार पूछ रहे हैं
कमरे में व्यक्ति मैं की उम्र के लिए.

49
00:02:32,120 --> 00:02:36,640
>> इस के बाद, हम नीचे जाना, और जो कुछ भी
मनमाना कारण, हम तो

50
00:02:36,640 --> 00:02:40,220
वे जा रहे हैं कि कैसे पुराने प्रिंट आउट
अब से एक साल होने के लिए.

51
00:02:40,220 --> 00:02:49,980
और कहा कि कार्यक्रम चल रहा है, चलो
उम्र बनाने स्लैश उम्र डॉट.

52
00:02:49,980 --> 00:02:53,010
तो कमरे में लोगों की संख्या,
तीन वहाँ रहे हैं कहते हैं.

53
00:02:53,010 --> 00:02:59,880
और, पहले व्यक्ति 13 है, कहते हैं
अगले 26 है, और पिछले 30 है.

54
00:02:59,880 --> 00:03:05,080
तो फिर यह उन तीन पर पुनरावृति करेंगे
लोगों को, 14 से 27, और 31 प्रिंट.

55
00:03:05,080 --> 00:03:16,060
>> तो याद है कि हम एक घोषित
आकार n की सरणी, कि में सूचकांक

56
00:03:16,060 --> 00:03:19,950
सरणी, सरणी मान है और
सूचकांक 0, 1, 2, सभी तरह

57
00:03:19,950 --> 00:03:21,680
ऊपर n करने के लिए शून्य से 1.

58
00:03:21,680 --> 00:03:26,255
तो हमने कहा कि जब तीन लोग थे
कमरे में, और हम यहाँ में डाल

59
00:03:26,255 --> 00:03:29,850
इस के माध्यम से पहली यात्रा
पाश, मैं 0 होने जा रहा है.

60
00:03:29,850 --> 00:03:31,650
तो इंडेक्स 0 में.

61
00:03:31,650 --> 00:03:34,540
हम पहले बताए हैं
उपयोगकर्ता में प्रवेश करती है उम्र.

62
00:03:34,540 --> 00:03:38,870
फिर अगले एक में, हम प्रवेश कर रहे हैं
दूसरा N उपयोगकर्ता में प्रवेश करती है, और में

63
00:03:38,870 --> 00:03:40,580
दो, पिछले n करने के लिए अगले.

64
00:03:40,580 --> 00:03:44,200
>> तो नोटिस कि आकार की एक सरणी
तीन कुछ भी नहीं है

65
00:03:44,200 --> 00:03:46,040
सूचकांक तीन में.

66
00:03:46,040 --> 00:03:49,036
यह मान्य नहीं है.

67
00:03:49,036 --> 00:03:50,250
ठीक है.

68
00:03:50,250 --> 00:03:55,136
तो, यहाँ वापस जा रहा.

69
00:03:55,136 --> 00:03:57,650

70
00:03:57,650 --> 00:04:01,590
तो अब हम सरणियों के साथ पेश किया है कि,
हम कुछ परिचित है.

71
00:04:01,590 --> 00:04:03,780
अब हम आदेश पर स्थानांतरित करने के लिए जा रहे हैं
होने जा रहे हैं, जो लाइन तर्क,

72
00:04:03,780 --> 00:04:05,890
इस समस्या को सेट करने के लिए बहुत प्रासंगिक है.

73
00:04:05,890 --> 00:04:09,670
>> तो अब तक, जब भी तुम हो
अपने मुख्य समारोह घोषित, हम है

74
00:04:09,670 --> 00:04:11,230
int मुख्य शून्य कहा.

75
00:04:11,230 --> 00:04:14,070
तो शून्य सिर्फ मतलब है कि
हम किसी भी गुजर नहीं कर रहे हैं

76
00:04:14,070 --> 00:04:16,440
इस समारोह के लिए तर्क.

77
00:04:16,440 --> 00:04:19,190
अब हम चाहते हैं कि मुख्य देखने जा रहे हैं
कुछ तर्क ले सकते हैं.

78
00:04:19,190 --> 00:04:22,470
यहाँ हम argc INT उन्हें फोन
और स्ट्रिंग argv कोष्ठक.

79
00:04:22,470 --> 00:04:26,930
कोष्ठक, एक बार फिर, यह दर्शाता
हम सरणियों के साथ काम कर रहे हैं.

80
00:04:26,930 --> 00:04:31,850
तो यहाँ, स्ट्रिंग argv कोष्ठक, हम कर रहे हैं
तारों की एक सरणी के साथ काम कर.

81
00:04:31,850 --> 00:04:35,360
तो argc, संकेत मिलता है कि जा रहा है
हम है कि कितने तर्क

82
00:04:35,360 --> 00:04:37,580
इस कार्यक्रम के लिए दिया गया.

83
00:04:37,580 --> 00:04:46,050
और, इसका मतलब है कि क्या देखने के लिए
चलो इस बंद करते हैं.

84
00:04:46,050 --> 00:04:46,490
>> ठीक है.

85
00:04:46,490 --> 00:04:50,790
तो अब तक, हम हर भाग लिया
डॉट स्लेश उम्र की तरह कार्यक्रम.

86
00:04:50,790 --> 00:04:55,250
हम भी कर सकते हैं, कमांड लाइन पर, अतीत
तर्क पास, इस प्रकार शब्द, कमान

87
00:04:55,250 --> 00:04:56,550
लाइन तर्क.

88
00:04:56,550 --> 00:04:59,760
तो पहला तर्क, हैलो दुनिया.

89
00:04:59,760 --> 00:05:03,350
तो यहाँ, argc तीन होगा.

90
00:05:03,350 --> 00:05:07,720
यह तर्क की गिनती है
कमांड लाइन पर.

91
00:05:07,720 --> 00:05:12,840
Argc, हमेशा कम से कम 1 के बाद से डॉट
, खुद को उम्र स्लेश, में से एक के रूप में गिना जाता है

92
00:05:12,840 --> 00:05:14,490
कमांड लाइन तर्क.

93
00:05:14,490 --> 00:05:17,010
>> फिर नमस्ते सबसे पहले है.

94
00:05:17,010 --> 00:05:20,460
डॉट स्लेश उम्र तो, zeroth है तो
नमस्कार सबसे पहले है, और दुनिया है

95
00:05:20,460 --> 00:05:22,830
दूसरी कमांड लाइन तर्क.

96
00:05:22,830 --> 00:05:29,490
तो स्ट्रिंग argv, हम देखने जा रहे हैं,
तार, डॉट स्लेश शामिल

97
00:05:29,490 --> 00:05:33,830
उम्र, हैलो, और दुनिया.

98
00:05:33,830 --> 00:05:38,945
और दाऊद के अनुरोध से, हम जा रहे हैं
कि शुरू करने के लिए एक वीडियो खेलने के लिए.

99
00:05:38,945 --> 00:05:42,486

100
00:05:42,486 --> 00:05:43,890
>> [वीडियो प्लेबैक]

101
00:05:43,890 --> 00:05:46,240
>> ऊपर हमने कार्यक्रमों में अब तक
लिखा है, हम की घोषणा की है

102
00:05:46,240 --> 00:05:48,500
मुख्य रूप int मुख्य शून्य.

103
00:05:48,500 --> 00:05:51,170
और यह सब समय, उस शून्य है
बस को निर्दिष्ट किया गया है कि

104
00:05:51,170 --> 00:05:54,430
कार्यक्रम किसी भी नहीं ले करता है
कमांड लाइन तर्क.

105
00:05:54,430 --> 00:05:57,750
एक उपयोगकर्ता एक चलता है, तो दूसरे शब्दों में,
कार्यक्रम, वह या वह आदेश प्रदान कर सकते हैं

106
00:05:57,750 --> 00:06:01,710
अतिरिक्त लिख कर लाइन तर्क
शब्दों या वाक्यांशों के बाद कार्यक्रम की

107
00:06:01,710 --> 00:06:03,000
प्रॉम्प्ट पर नाम है.

108
00:06:03,000 --> 00:06:06,550
>> खैर, आप अपने कार्यक्रम के लिए चाहते हैं यदि आप करते हैं
कमांड लाइन तर्क, एक या ले

109
00:06:06,550 --> 00:06:10,540
अधिक ऐसे शब्दों, हम बदलने की जरूरत
तर्क के एक जोड़े के साथ शून्य.

110
00:06:10,540 --> 00:06:12,200
तो चलो करते हैं.

111
00:06:12,200 --> 00:06:15,750
CS50.h. शामिल करें

112
00:06:15,750 --> 00:06:19,360
मानक io.h. शामिल करें

113
00:06:19,360 --> 00:06:20,760
मुख्य इंट.

114
00:06:20,760 --> 00:06:26,330
और अब, बजाय शून्य की, मैं जा रहा हूँ
एक argc बुलाया INT, और एक निर्दिष्ट

115
00:06:26,330 --> 00:06:28,780
argv बुलाया तार के सरणी.

116
00:06:28,780 --> 00:06:31,820
अब, argc और argv हैं
बस सम्मेलनों.

117
00:06:31,820 --> 00:06:34,000
>> हम इन तर्कों कहा हो सकता है
हम चाहते हैं कि सबसे कुछ.

118
00:06:34,000 --> 00:06:37,630
लेकिन क्या महत्वपूर्ण है argc है कि है
एक पूर्णांक परिभाषा के द्वारा, यह है, क्योंकि

119
00:06:37,630 --> 00:06:41,360
तर्क की गिनती होते जा रहे हैं,
कुल शब्दों की संख्या कि

120
00:06:41,360 --> 00:06:43,380
उपयोगकर्ता उसके प्रांप्ट पर टाइप किया गया है.

121
00:06:43,380 --> 00:06:47,910
argv, इस बीच, तर्क वेक्टर, है
वास्तव में भंडारण के एक सरणी होने जा रहा

122
00:06:47,910 --> 00:06:52,020
उपयोगकर्ता है कि शब्दों के सभी
अपने या अपने प्रांप्ट पर टाइप.

123
00:06:52,020 --> 00:06:54,500
>> चलो अब कुछ करने के लिए आगे बढ़ना
इनमें से एक या अधिक के साथ

124
00:06:54,500 --> 00:06:55,660
कमांड लाइन तर्क.

125
00:06:55,660 --> 00:07:00,070
विशेष रूप से, के आगे और प्रिंट चलते हैं
जो भी शब्द उपयोगकर्ता प्रकार

126
00:07:00,070 --> 00:07:03,960
कार्यक्रम के नाम के बाद
प्रॉम्प्ट पर.

127
00:07:03,960 --> 00:07:04,730
ओपन ब्रैकेट.

128
00:07:04,730 --> 00:07:06,240
बंद कोष्ठक.

129
00:07:06,240 --> 00:07:10,510
Printf प्रतिशत है बैकस्लैश और अल्पविराम.

130
00:07:10,510 --> 00:07:14,550
और अब मैं printf क्या मूल्य बताने की जरूरत
उस प्लेसहोल्डर में प्लग.

131
00:07:14,550 --> 00:07:18,600
मैं उपयोगकर्ता है कि पहला शब्द चाहते हैं
कार्यक्रम के नाम के बाद लिखा है,

132
00:07:18,600 --> 00:07:23,130
और इसलिए मैं निर्दिष्ट करने के लिए जा रहा हूँ
argv ब्रैकेट 1, करीब

133
00:07:23,130 --> 00:07:24,830
कोष्ठक, अर्धविराम.

134
00:07:24,830 --> 00:07:27,290
>> अब, क्यों ब्रैकेट 1 और नहीं ब्रैकेट 0?

135
00:07:27,290 --> 00:07:30,990
खैर, यह स्वचालित रूप से संग्रहीत पता चला है,
argv में 0 होने जा रहा है

136
00:07:30,990 --> 00:07:32,620
कार्यक्रम का वास्तविक नाम.

137
00:07:32,620 --> 00:07:36,180
तो पहला शब्द है कि उपयोगकर्ता प्रकार
कार्यक्रम के नाम से है, के बाद

138
00:07:36,180 --> 00:07:38,990
सम्मेलन होने जा रहा
argv 1 में संग्रहीत.

139
00:07:38,990 --> 00:07:42,380
चलो अब संकलन करते हैं और
इस कार्यक्रम चलाते हैं.

140
00:07:42,380 --> 00:07:47,780
>> Argv 0, डॉट स्लेश argv 0 बनाओ.

141
00:07:47,780 --> 00:07:50,520
और अब एक शब्द नमस्ते की तरह.

142
00:07:50,520 --> 00:07:51,670
दर्ज करें.

143
00:07:51,670 --> 00:07:53,520
और वहाँ हम नमस्कार, यह है.

144
00:07:53,520 --> 00:07:55,750
>> [अंत वीडियो प्लेबैक]

145
00:07:55,750 --> 00:07:57,000
>> आरओबी BODEN: सब ठीक है.

146
00:07:57,000 --> 00:07:59,380

147
00:07:59,380 --> 00:08:01,230
कि बंद.

148
00:08:01,230 --> 00:08:16,730
तो उस कार्यक्रम पर एक नज़र लेने कि
हम बस, ठीक है, हमारे पास अभी शुरू

149
00:08:16,730 --> 00:08:24,710
हम 0 argv मुद्रित अगर अब, बनाने, दिखाने के लिए
यह argv 0, डॉट स्लेश argv 0 क्या है.

150
00:08:24,710 --> 00:08:30,440
उम्मीद के रूप में तो, यह बाहर मुद्रण है
argv 0 है के बाद से, प्रोग्राम का नाम

151
00:08:30,440 --> 00:08:32,970
हमेशा होने जा रहा
प्रोग्राम का नाम.

152
00:08:32,970 --> 00:08:35,640
लेकिन कुछ एक करते हैं
अधिक दिलचस्प बिट.

153
00:08:35,640 --> 00:08:42,080
>> इसलिए इस समस्या सेट में, आप हो जाएगा
इस समारोह में, atoi के लिए पेश किया.

154
00:08:42,080 --> 00:08:44,440
तो क्या हम के लिए atoi प्रयोग करते हैं?

155
00:08:44,440 --> 00:08:48,550
यही कन्वर्ट करने के लिए जा रहा है एक
एक पूर्णांक के लिए स्ट्रिंग.

156
00:08:48,550 --> 00:08:53,280
तो मैं स्ट्रिंग पास है, एक दो तीन,
atoi करने के लिए, कि बदल देंगे कि

157
00:08:53,280 --> 00:08:56,910
पूर्णांक के लिए, एक दो तीन.

158
00:08:56,910 --> 00:09:01,480
इसलिए हम पहले कन्वर्ट करने के लिए जा रहे हैं
एक पूर्णांक के लिए कमांड लाइन तर्क,

159
00:09:01,480 --> 00:09:05,690
और फिर बस कि पूर्णांक मुद्रित.

160
00:09:05,690 --> 00:09:09,680
>> तो बुनियादी तौर पर, हम एक तरह से कर रहे हैं
बस, getint reimplementing

161
00:09:09,680 --> 00:09:12,350
पूर्णांक आदेश पर दर्ज किया गया है
रेखा के बजाय कार्यक्रम में

162
00:09:12,350 --> 00:09:14,560
interactively.

163
00:09:14,560 --> 00:09:23,170
तो फिर, argv 0 बनाने, चलो
यहां यह, और कहा कि बंद.

164
00:09:23,170 --> 00:09:27,670
तो argv 0 चल रहा है, और का प्रवेश
पूर्णांक, एक दो तीन चार एक दो.

165
00:09:27,670 --> 00:09:30,840
तो यह एक पूर्णांक मुद्रित करेंगे
दो तीन चार एक दो.

166
00:09:30,840 --> 00:09:35,500
कि atoi करने के लिए कुछ बारीकियों रहे हैं
यह कुछ के बारे में देखभाल बंद कर देंगे

167
00:09:35,500 --> 00:09:39,040
एक वैध संख्यात्मक चरित्र से परे,
लेकिन इससे कोई फर्क नहीं पड़ता.

168
00:09:39,040 --> 00:09:42,870
>> तो आप क्या होता है क्या लगता है
यदि मैं यह कर?

169
00:09:42,870 --> 00:09:45,520

170
00:09:45,520 --> 00:09:47,050
विभाजन गलती.

171
00:09:47,050 --> 00:09:50,410
तो ऐसा क्यों है?

172
00:09:50,410 --> 00:09:56,060
आप हमारे कार्यक्रम में वापस देखो, हम कर रहे हैं
argv 1, पहला तर्क परिवर्तित

173
00:09:56,060 --> 00:09:59,610
कार्यक्रम के नाम के बाद, एक पूर्णांक के लिए.

174
00:09:59,610 --> 00:10:03,350
लेकिन पारित कर कोई तर्क नहीं है
कार्यक्रम के नाम के बाद.

175
00:10:03,350 --> 00:10:08,060
यहाँ तो, हम इस एक छोटी गाड़ी है कि देखना
कार्यक्रम के बाद से, हम इसे चलाने के लिए प्रयास करें तो

176
00:10:08,060 --> 00:10:10,530
किसी भी तर्क के बिना,
यह बस दुर्घटना होगा.

177
00:10:10,530 --> 00:10:16,950
>> आप देखेंगे तो एक अन्य आम पैटर्न
कुछ की तरह, argc कम है

178
00:10:16,950 --> 00:10:21,100
वहाँ नहीं था यह दर्शाता है कि दो, की तुलना
कम से कम कार्यक्रम का नाम और एक

179
00:10:21,100 --> 00:10:29,100
पहला तर्क है, तो हम कुछ नहीं हूँ
जैसे printf, पर्याप्त नहीं

180
00:10:29,100 --> 00:10:31,190
कमांड लाइन तर्क.

181
00:10:31,190 --> 00:10:33,170
कि शायद मुद्रित करने के लिए एक अच्छा नहीं है,
यह पसंद है, शायद कुछ है

182
00:10:33,170 --> 00:10:35,440
आप एक पूर्णांक में प्रवेश करना चाहिए
कमांड लाइन पर.

183
00:10:35,440 --> 00:10:37,450
मैं बस वहाँ यह समाप्त होगा.

184
00:10:37,450 --> 00:10:39,600
और फिर 1 वापसी.

185
00:10:39,600 --> 00:10:44,740
इसलिए हमारे के अंत में याद है कि
कार्यक्रम, हम 0 वापसी अगर, उस तरह का

186
00:10:44,740 --> 00:10:47,060
सफलता का संकेत है.

187
00:10:47,060 --> 00:10:50,940
और मुख्य भी स्वतः
अगर तुम नहीं 0 देता.

188
00:10:50,940 --> 00:10:55,800
>> तो यहाँ, हम इंगित करने के लिए 1 retuning कर रहे हैं
उस सफलता नहीं है.

189
00:10:55,800 --> 00:11:01,000
और आप चाहते हैं जो कुछ भी वापसी कर सकते हैं,
बस, 0 सफलता को इंगित करता है, और

190
00:11:01,000 --> 00:11:03,390
कुछ और विफलता को इंगित करता है.

191
00:11:03,390 --> 00:11:04,855
तो चलो चीजों के इस संस्करण चलाते हैं.

192
00:11:04,855 --> 00:11:12,880

193
00:11:12,880 --> 00:11:16,600
तो अब, हम एक कमांड लाइन दर्ज नहीं करते हैं
तर्क, यह सही ढंग से बताता हूँ

194
00:11:16,600 --> 00:11:18,290
हमें पर्याप्त कमांड लाइन नहीं.

195
00:11:18,290 --> 00:11:20,610
वाक्य पूरा नहीं किया.

196
00:11:20,610 --> 00:11:24,950
वरना, हम वास्तव में यह एक पास हैं,
यह कार्यक्रम को पूरा कर सकते हैं.

197
00:11:24,950 --> 00:11:27,920
तो यह आप में argc प्रयोग करेंगे कैसे है
की संख्या को मान्य करने के आदेश

198
00:11:27,920 --> 00:11:30,630
कमांड लाइन तर्क है कि
वास्तव में पारित कर रहे हैं.

199
00:11:30,630 --> 00:11:39,360
>> तो चलो थोड़ा और अधिक इस कार्यक्रम बनाते हैं
जटिल है, और दूसरे को देखो

200
00:11:39,360 --> 00:11:42,180
बातों का चलना.

201
00:11:42,180 --> 00:11:46,310
तो अब, हम केवल मुद्रण नहीं कर रहे हैं
पहली कमांड लाइन तर्क.

202
00:11:46,310 --> 00:11:51,210
यहाँ, हम int मैं बराबरी से पुनरावृति रहे
0, मैं, मैं argc से भी कम है प्लस

203
00:11:51,210 --> 00:11:55,280
साथ ही, और मुद्रण argv, सूचकांक मैं.

204
00:11:55,280 --> 00:11:59,300
तो इस पैटर्न, फिर, यह एक ही है
बजाय छोड़कर पहले ही पैटर्न,

205
00:11:59,300 --> 00:12:02,600
चर बुलाने की
एन, हम argc प्रयोग कर रहे हैं.

206
00:12:02,600 --> 00:12:09,520
>> तो यह हर सूचकांक पर iterating है
सरणी में, और प्रत्येक मुद्रण

207
00:12:09,520 --> 00:12:11,910
उस सरणी में तत्व.

208
00:12:11,910 --> 00:12:20,300
और हां, तो हम इस प्रोग्राम चलाते हैं, ठीक है,
मैं किसी भी कमांड लाइन दर्ज नहीं किया

209
00:12:20,300 --> 00:12:22,540
तर्क, सिर्फ प्रिंट यह तो
कार्यक्रम का नाम.

210
00:12:22,540 --> 00:12:26,053
मैं चीजों की एक गुच्छा दर्ज करते हैं, यह हूँ
एक, अपनी पंक्ति में प्रत्येक मुद्रित.

211
00:12:26,053 --> 00:12:31,213

212
00:12:31,213 --> 00:12:32,210
>> ठीक है.

213
00:12:32,210 --> 00:12:34,770
तो चलो यह एक कदम आगे ले लो.

214
00:12:34,770 --> 00:12:38,890
और बदले प्रत्येक तर्क छपाई की
अपनी पंक्ति में, एक प्रिंट

215
00:12:38,890 --> 00:12:42,590
प्रत्येक तर्क का चरित्र
अपनी पंक्ति में.

216
00:12:42,590 --> 00:12:46,700
तो argv है कि याद
तारों की एक सरणी.

217
00:12:46,700 --> 00:12:50,960
तो क्या एक स्ट्रिंग है, लेकिन
अक्षर की एक सरणी?

218
00:12:50,960 --> 00:12:57,140
इसलिए कि argv वास्तव में इसका मतलब है कि एक
अक्षर की एक सरणी के सरणी.

219
00:12:57,140 --> 00:13:04,920
इसलिए इस बात का फायदा उठाते हुए
चलो अभी के लिए इस की उपेक्षा करते हैं.

220
00:13:04,920 --> 00:13:08,190
चलो बस स्ट्रिंग argv 0 विचार करें.

221
00:13:08,190 --> 00:13:14,170
>> हम प्रत्येक चरित्र के लाना चाहते हैं तो
argv 0 अपनी पंक्ति में है, तो मैं चाहता हूँ

222
00:13:14,170 --> 00:13:19,500
हम करने के लिए इस्तेमाल कर रहे हैं पैटर्न क्या करना, मैं है
सरणी की लंबाई से कम,

223
00:13:19,500 --> 00:13:23,990
यहां के strlen है, जो कि है
मैं नहीं करना चाहता क्या, स्ट्रिंग

224
00:13:23,990 --> 00:13:26,450
एस argv 0 के बराबर होती है.

225
00:13:26,450 --> 00:13:30,390
इसलिए मैं अपने की लंबाई की तुलना में कम है
इस मामले में एक सरणी है जो सरणी,

226
00:13:30,390 --> 00:13:34,410
वर्ण, मैं प्लस प्लस.

227
00:13:34,410 --> 00:13:41,040
हम पिछले सप्ताह देखा और हां, यह आदर्श है
हम बाहर strlen कि अगर इस कदम

228
00:13:41,040 --> 00:13:45,210
हालत की, क्योंकि n जोड़ दिया जाएगा
एस के strlen हम चले हर समय

229
00:13:45,210 --> 00:13:47,720
पाश के माध्यम से, और यह बात है
बदलते नहीं होने जा रहा.

230
00:13:47,720 --> 00:13:50,230
तो हम यहाँ पर पता करने के लिए बराबर यह निर्धारित करेंगे.

231
00:13:50,230 --> 00:13:54,260

232
00:13:54,260 --> 00:13:55,170
>> ठीक है.

233
00:13:55,170 --> 00:14:01,320
तो अब, हम पर iterating कर रहे हैं
सरणी में प्रत्येक सूचकांक.

234
00:14:01,320 --> 00:14:05,630
और हां, तो हम प्रत्येक मुद्रित करना चाहते हैं
उस सरणी, प्रतिशत सी में चरित्र है

235
00:14:05,630 --> 00:14:06,880
हम प्रयोग करना चाहते झंडा
पात्रों के लिए.

236
00:14:06,880 --> 00:14:10,750

237
00:14:10,750 --> 00:14:19,770
और अब एक ब्रैकेट मैं होने जा रहा है
स्ट्रिंग, सूचकांक चरित्र मैं, यदि ऐसा है तो

238
00:14:19,770 --> 00:14:20,970
स्ट्रिंग नमस्कार थे.

239
00:14:20,970 --> 00:14:27,530
फिर ब्रैकेट, 0 घंटे होने जा रहा है एस एस
1 इतने पर ई हो जाएगा, और.

240
00:14:27,530 --> 00:14:30,800
>> तो अब हम गठबंधन चाहते हैं
इन दो बातें.

241
00:14:30,800 --> 00:14:35,440
हम प्रत्येक वर्ण मुद्रित करना चाहते हैं
प्रत्येक कमांड लाइन तर्क की.

242
00:14:35,440 --> 00:14:38,950
तो हम करने जा रहे हैं
एक पाश के लिए नेस्ट.

243
00:14:38,950 --> 00:14:47,480
और पारंपरिक, पहले काउंटर
मैं अगले जम्मू होने जा रहा है, n है

244
00:14:47,480 --> 00:14:54,450
argv मैं के strlen हो जाएगा, मैं
कम से कम पता है, मैं अधिक से अधिक है.

245
00:14:54,450 --> 00:14:59,150

246
00:14:59,150 --> 00:15:06,870
और अब के बजाय मुद्रण argv मैं की, तो
मैं सूचकांक जा रहा है argv ब्रैकेट -

247
00:15:06,870 --> 00:15:14,280
कि मैं वें कमांड लाइन होने जा रहा है
तर्क, argv मैं, जम्मू जा रहा है

248
00:15:14,280 --> 00:15:16,925
JTH चरित्र का होना
मैं वें तर्क.

249
00:15:16,925 --> 00:15:20,580

250
00:15:20,580 --> 00:15:24,810
मैं अब यहाँ इस के ऊपर से छुटकारा मिल जाएगा
हम चाहते हैं कि पाश में डाल दिया है.

251
00:15:24,810 --> 00:15:33,900
तो स्ट्रिंग के बराबर होती है के बराबर है
argv मैं, और फिर एस ब्रैकेट जम्मू.

252
00:15:33,900 --> 00:15:36,980
>> खैर, हम घोषित करने की जरूरत नहीं है
इस चर है.

253
00:15:36,980 --> 00:15:44,530
इसके बजाय, हम सिर्फ इन गठबंधन करेंगे
हम क्या था में दो, जम्मू मैं argv.

254
00:15:44,530 --> 00:15:45,780
>> स्पीकर 1 [सुनाई].

255
00:15:45,780 --> 00:15:48,850

256
00:15:48,850 --> 00:15:49,680
>> आरओबी BODEN: फोन अच्छा है.

257
00:15:49,680 --> 00:15:52,936
तो यह टूट गया है.

258
00:15:52,936 --> 00:15:55,510
मैं वास्तव में यह भाग गया, तो हम करेंगे
इस एहसास हो गया है.

259
00:15:55,510 --> 00:16:01,210
मैं देखभाल के बारे में तो काउंटर
के लिए यह विशेष रूप से

260
00:16:01,210 --> 00:16:05,410
पाश जम्मू, iterator है.

261
00:16:05,410 --> 00:16:08,560
तो अगर आप मुद्दों में चला गया होगा,
शायद एक अनंत लूप, अगर हम

262
00:16:08,560 --> 00:16:09,540
कि ठीक नहीं किया गया था.

263
00:16:09,540 --> 00:16:12,220
हम भी बात कर रहे हैं यही कारण है कि
के बारे में आज डिबगिंग.

264
00:16:12,220 --> 00:16:13,120
>> ठीक है.

265
00:16:13,120 --> 00:16:15,240
तो चलो इस कार्यक्रम चलाते हैं.

266
00:16:15,240 --> 00:16:21,200
और हम वास्तव में एक अलग printf जोड़ दें
यहीं बस प्रिंट होगा कि

267
00:16:21,200 --> 00:16:27,480
इसका मतलब यह है के बाद से एक और लाइन, जब हम
कार्यक्रम चलाने के लिए, एक खाली वहाँ हो जाएगा

268
00:16:27,480 --> 00:16:31,830
प्रत्येक चरित्र के बीच में लाइन
प्रत्येक कमांड लाइन तर्क.

269
00:16:31,830 --> 00:16:33,448
खैर, हम मतलब है कि क्या देखेंगे.

270
00:16:33,448 --> 00:16:37,310

271
00:16:37,310 --> 00:16:37,790
OOP.

272
00:16:37,790 --> 00:16:39,870
कुछ बग मिला.

273
00:16:39,870 --> 00:16:42,860
त्रुटि उलझाव की घोषणा
पुस्तकालय समारोह strlen.

274
00:16:42,860 --> 00:16:51,630
>> इसलिए हमारे कार्यक्रम में वापस जा रहे हैं, मैं
string.h शामिल हैश करने के लिए भूल गया.

275
00:16:51,630 --> 00:16:54,240

276
00:16:54,240 --> 00:16:57,730
तो string.h होने जा रहा है
वाणी कि हेडर फाइल

277
00:16:57,730 --> 00:16:58,980
समारोह strlen.

278
00:16:58,980 --> 00:17:04,650

279
00:17:04,650 --> 00:17:06,060
ठीक है, यह compiles.

280
00:17:06,060 --> 00:17:09,109
अब, इसे चलाते हैं.

281
00:17:09,109 --> 00:17:10,930
तो बस.

282
00:17:10,930 --> 00:17:17,790
इसे बाहर प्रिंट करने जा रहा है हमारे
कार्यक्रम का नाम, हैलो दुनिया.

283
00:17:17,790 --> 00:17:23,510
यह हर, हर बात मुद्रित करने के लिए जा रहा है
अपनी पंक्ति में चरित्र,.

284
00:17:23,510 --> 00:17:24,540
ठीक है.

285
00:17:24,540 --> 00:17:30,625
>> तो चलो वास्तव में इस ले जाने
एक कदम आगे.

286
00:17:30,625 --> 00:17:34,050

287
00:17:34,050 --> 00:17:39,700
और बदले string.h का उपयोग कर के, चलो
हम अपने ही लागू होगी के बारे में सोचना

288
00:17:39,700 --> 00:17:41,420
strlen समारोह.

289
00:17:41,420 --> 00:17:45,600
तो मैं तुरंत दे दूँगा
एक समारोह के हस्ताक्षर.

290
00:17:45,600 --> 00:17:52,900
तो चलो my_strlen में फोन करते हैं, और यह बात है
एक तर्क के रूप में एक स्ट्रिंग लेने के लिए जा रहा है,

291
00:17:52,900 --> 00:17:57,220
और हम वापसी की उम्मीद
कि स्ट्रिंग की लंबाई.

292
00:17:57,220 --> 00:18:03,430
तो, जहां उस आदमी है?

293
00:18:03,430 --> 00:18:04,990
हां.

294
00:18:04,990 --> 00:18:06,740
ठीक है.

295
00:18:06,740 --> 00:18:12,900
तो पहले स्लाइड से याद है कि
पिछले सप्ताह से भी था कि एक

296
00:18:12,900 --> 00:18:18,890
पात्रों की सरणी, अच्छी तरह से, एक स्ट्रिंग,
तो चलो यह हमारी स्ट्रिंग एस कहते हैं.

297
00:18:18,890 --> 00:18:29,870
तो चलो स्ट्रिंग है, तो हैलो, तो,
एच ई एल एल ओ, स्मृति में, कि जा रहा है

298
00:18:29,870 --> 00:18:35,610
तो इस बैकस्लैश हो, और
0 चरित्र.

299
00:18:35,610 --> 00:18:39,170
>> तो कैसे हम एस की लंबाई मिलता है?

300
00:18:39,170 --> 00:18:43,190
खैर, चाल इस बात के लिए लग रही है
0 चरित्र, इस अशक्त बैकलैश

301
00:18:43,190 --> 00:18:44,380
टर्मिनेटर.

302
00:18:44,380 --> 00:18:50,270
तो एल्गोरिथ्म जा रहा है
कुछ ऐसा कुछ हो

303
00:18:50,270 --> 00:18:51,510
पर्याप्त वर्ण कि -

304
00:18:51,510 --> 00:18:56,180
चलो इस हाथ से कुछ का प्रतिनिधित्व करते हैं
काउंटर, चलो इस INT लंबाई कहते हैं.

305
00:18:56,180 --> 00:19:00,060
तो, यहाँ से शुरू करते हुए, हम कर रहे हैं
हमारे स्ट्रिंग अधिक पुनरावृति करने के लिए जा रहा है.

306
00:19:00,060 --> 00:19:04,100
>> इसलिए, यह एच पहला वर्ण है,
और इसे वापस तो, 0 स्लेश नहीं है

307
00:19:04,100 --> 00:19:05,170
लंबाई 1 है.

308
00:19:05,170 --> 00:19:08,050
अगले चरित्र को पुनरावृति,
ई, और यह 0 बैकस्लैश नहीं है.

309
00:19:08,050 --> 00:19:09,630
लंबाई 2 है.

310
00:19:09,630 --> 00:19:10,960
एल, 3.

311
00:19:10,960 --> 00:19:11,850
एल, 4.

312
00:19:11,850 --> 00:19:13,050
हे, 5.

313
00:19:13,050 --> 00:19:16,690
और अंत में, हम बैकस्लैश तक पहुँचने
0, और तो इसका मतलब है, ठीक है,

314
00:19:16,690 --> 00:19:17,780
इस स्ट्रिंग खत्म हो गया है.

315
00:19:17,780 --> 00:19:20,130
तो चलो 5 वापस कर दें.

316
00:19:20,130 --> 00:19:33,630
>> तो वास्तव में, पहले, कि लागू
मेरी एन लंबाई मेरे दाहिने हाथ, 0 के बराबर होती है.

317
00:19:33,630 --> 00:19:36,088
और हम पुनरावृति करने के लिए जा रहे हैं -

318
00:19:36,088 --> 00:19:38,000
>> स्पीकर 1 [सुनाई]

319
00:19:38,000 --> 00:19:38,640
>> आरओबी BODEN: ओह, गोली मार.

320
00:19:38,640 --> 00:19:39,870
फोन अच्छा है.

321
00:19:39,870 --> 00:19:42,680
बूम.

322
00:19:42,680 --> 00:19:44,140
तो एन लंबाई 0 के बराबर होती है.

323
00:19:44,140 --> 00:19:46,910

324
00:19:46,910 --> 00:19:58,310
तो अब, जबकि लंबाई नहीं करता
तो बराबर और, बैकस्लैश 0.

325
00:19:58,310 --> 00:20:04,660
तो, यह बैकस्लैश 0 याद रखना, यह एक है
वास्तविक चरित्र, और यह इंगित करता है

326
00:20:04,660 --> 00:20:05,820
स्ट्रिंग के अंत.

327
00:20:05,820 --> 00:20:09,850
वैसे ही जैसे, भी, बैकस्लैश
n एक वास्तविक चरित्र है.

328
00:20:09,850 --> 00:20:14,040
बैकस्लैश 0 इंगित करने के लिए जा रहा है
हमारे स्ट्रिंग के अंत.

329
00:20:14,040 --> 00:20:15,414
मैं वहाँ रखा है कि नहीं करना चाहती.

330
00:20:15,414 --> 00:20:19,190

331
00:20:19,190 --> 00:20:25,620
और लंबाई से अनुक्रमित नहीं है, जबकि
अशक्त टर्मिनेटर के बराबर है, तो

332
00:20:25,620 --> 00:20:27,130
हम सिर्फ लंबाई बढ़ाने के लिए जा रहे हैं.

333
00:20:27,130 --> 00:20:29,860

334
00:20:29,860 --> 00:20:34,880
तो फिर, हमारे कार्यक्रम के अंत में,
लंबाई अंत में जा रहा है

335
00:20:34,880 --> 00:20:37,610
इस मामले में 5 हो.

336
00:20:37,610 --> 00:20:39,210
और हम बस लंबाई वापस कर देंगे.

337
00:20:39,210 --> 00:20:42,570

338
00:20:42,570 --> 00:20:43,530
>> ठीक है.

339
00:20:43,530 --> 00:20:48,290
तो अब यहाँ नीचे, मुझे नहीं पता
my_strlen करना.

340
00:20:48,290 --> 00:20:50,700
सुनिश्चित करने के लिए यह संकलन करते हैं
सब कुछ ठीक ठाक चलता है.

341
00:20:50,700 --> 00:20:55,820

342
00:20:55,820 --> 00:20:58,210
मैं 2 में कर रहा था?

343
00:20:58,210 --> 00:21:00,565
या 1 था?

344
00:21:00,565 --> 00:21:01,940
कि क्या करना चाहिए.

345
00:21:01,940 --> 00:21:02,690
ठीक है.

346
00:21:02,690 --> 00:21:08,490
तो इस argv 2 है.

347
00:21:08,490 --> 00:21:11,585
प्रत्याशित के रूप में काम करता है, हालांकि
एक मैं उस में किया था?

348
00:21:11,585 --> 00:21:15,060

349
00:21:15,060 --> 00:21:15,550
हां.

350
00:21:15,550 --> 00:21:16,760
ठीक है.

351
00:21:16,760 --> 00:21:21,820
चीजों के इस संस्करण में नहीं था
printf नई बाद लाइन, लेकिन यह

352
00:21:21,820 --> 00:21:22,910
कोई फर्क नहीं पड़ता.

353
00:21:22,910 --> 00:21:23,300
ठीक है.

354
00:21:23,300 --> 00:21:25,780
उम्मीद के रूप में तो काम किया.

355
00:21:25,780 --> 00:21:34,750
>> अब हम भी इस एक कदम गठजोड़ कर सकते हैं
इसके अलावा, यहां जहां नोटिस, अच्छी तरह से,

356
00:21:34,750 --> 00:21:38,920
सबसे पहले, हम argv की strlen हथियाने रहे हैं
मैं, और फिर हम पर iterating कर रहे हैं

357
00:21:38,920 --> 00:21:41,450
कि स्ट्रिंग में प्रत्येक चरित्र.

358
00:21:41,450 --> 00:21:47,480
तो बजाय कर रही है कि, क्या हुआ अगर हम
बस इंतजार कर के इस तर्क गठबंधन

359
00:21:47,480 --> 00:21:50,740
हम बैकस्लैश 0 सही मारा जब तक
पाश के लिए इस मामले में?

360
00:21:50,740 --> 00:21:53,740

361
00:21:53,740 --> 00:22:07,490
Argv मैं, जम्मू करता है इसलिए जब पुनरावृति
बराबर नहीं बैकस्लैश 0.

362
00:22:07,490 --> 00:22:10,680
तो चलो पहले इसे चलाते हैं.

363
00:22:10,680 --> 00:22:19,838

364
00:22:19,838 --> 00:22:21,180
>> ठीक है.

365
00:22:21,180 --> 00:22:27,655
यहाँ तो, इस हालत कह रहा है -

366
00:22:27,655 --> 00:22:38,090

367
00:22:38,090 --> 00:22:40,060
के स्पष्ट है कि चलो.

368
00:22:40,060 --> 00:22:49,140
तो अब, यह हमारे argv हो.

369
00:22:49,140 --> 00:22:55,290
तो मैं बस से पहले उस कार्यक्रम में भाग गया जब,
argv तारों की एक सरणी है.

370
00:22:55,290 --> 00:23:03,100
और हां, मैं डॉट स्लेश argv साथ इसे चलाने अगर
2, नमस्ते विश्व, तो argv

371
00:23:03,100 --> 00:23:07,650
खुद argv के लिए, लंबाई 3 है
शून्य, हैलो, और दुनिया.

372
00:23:07,650 --> 00:23:11,700

373
00:23:11,700 --> 00:23:19,660
>> और इन सूचकांकों में से प्रत्येक के अंदर है
खुद यह हो जाएगा, जहां एक सरणी,

374
00:23:19,660 --> 00:23:23,780
डॉट, इस कड़ी आलोचना हो जाएगा, मैं नहीं जानता
यह सही दिशा था, तो मैं

375
00:23:23,780 --> 00:23:25,680
यह था नहीं लगता.

376
00:23:25,680 --> 00:23:30,110
ए आर वी पानी का छींटा, अधिक स्थान की आवश्यकता है.

377
00:23:30,110 --> 00:23:32,570
चलो इस सरणी में कटौती करते हैं.

378
00:23:32,570 --> 00:23:38,230
ए आर वी पानी का छींटा 0, और फिर बैकस्लैश 0.

379
00:23:38,230 --> 00:23:43,160
और फिर अव्यवस्था में नमस्कार किया जाएगा.

380
00:23:43,160 --> 00:23:45,910
के, एच ​​ई बैकस्लैश 0 कहते हैं.

381
00:23:45,910 --> 00:23:51,130
और अंत में, डब्ल्यू ओ बैकस्लैश 0.

382
00:23:51,130 --> 00:23:59,730
>> तो हम सिर्फ लिखा था कि एल्गोरिथ्म,
वे क्या कर रहे हैं छोरों, के लिए नेस्ट

383
00:23:59,730 --> 00:24:07,321
कर, हम पहली बार है
मैं और फिर जम्मू मुकाबला.

384
00:24:07,321 --> 00:24:15,206
इस पर कोड के साथ आसान होगा
स्क्रीन, की पीठ इस के लिए चलते हैं.

385
00:24:15,206 --> 00:24:17,476
ठीक है.

386
00:24:17,476 --> 00:24:24,600
तो मैं है कि iterator है कि नोटिस
प्रत्येक निर्देश पर iterating

387
00:24:24,600 --> 00:24:25,610
लाइन तर्क.

388
00:24:25,610 --> 00:24:28,870
और जम्मू iterator पुनरावृति है
उस में प्रत्येक चरित्र के ऊपर

389
00:24:28,870 --> 00:24:30,410
कमांड लाइन तर्क.

390
00:24:30,410 --> 00:24:46,755
तो इस अंतरतम printf क्या कर रहा है
, हम argv 0 0, printf printf है है

391
00:24:46,755 --> 00:24:58,680
argv 0 1, printf argv 0 2, 0, 3 0 4, 0
5, 0, 6, लेकिन अब, argv 0 7 करने जा रहा है

392
00:24:58,680 --> 00:25:00,670
बराबर बैकस्लैश 0.

393
00:25:00,670 --> 00:25:05,730
>> तो फिर हम पाश के लिए है कि बाहर निकलने,
और अब मैं 1 के लिए iterates.

394
00:25:05,730 --> 00:25:10,910
और अब हम प्रिंट लिए जा रहे हैं
argv 1 0, argv 1 1 -

395
00:25:10,910 --> 00:25:17,040
खैर, अब, मैं कम नमस्ते कटौती के बाद से,
argv 1 2 फिर से होने जा रहा है

396
00:25:17,040 --> 00:25:18,170
बैकस्लैश 0.

397
00:25:18,170 --> 00:25:25,050
और हां, मैं वेतन वृद्धि और जारी है, और
इतने पर, जब तक हम सभी बाहर प्रिंट

398
00:25:25,050 --> 00:25:28,580
दुनिया, और उन तीन कमांड लाइन कर रहे हैं
तर्क, और हम में से बाहर निकलें हूँ

399
00:25:28,580 --> 00:25:31,670
सबसे बाहरी पाश, और
हमारे कार्यक्रम खत्म.

400
00:25:31,670 --> 00:25:38,390

401
00:25:38,390 --> 00:25:39,640
ठीक है.

402
00:25:39,640 --> 00:25:43,903

403
00:25:43,903 --> 00:25:46,795
>> तो चलो यहाँ वापस आते हैं.

404
00:25:46,795 --> 00:25:49,670

405
00:25:49,670 --> 00:25:52,370
तो आप के साथ कुछ परिचित मिलेगा
इस पर कमांड लाइन तर्क

406
00:25:52,370 --> 00:25:54,460
विशेष समस्या निर्धारित किया है.

407
00:25:54,460 --> 00:25:56,630
>> अब, डिबगिंग.

408
00:25:56,630 --> 00:26:01,680
तो आप शायद पहले से ही करना पड़ा है
अपने पिछले के साथ कुछ डिबगिंग

409
00:26:01,680 --> 00:26:03,120
समस्या निर्धारित किया है.

410
00:26:03,120 --> 00:26:08,420
और डिबगिंग का एक बहुत ही आसान तरीका,
पहले, चलो एक छोटी गाड़ी कार्यक्रम पर नजर डालते हैं.

411
00:26:08,420 --> 00:26:20,710

412
00:26:20,710 --> 00:26:23,830
खैर, इस कार्यक्रम के माध्यम से घूमना
हम एक के लिए उपयोगकर्ता पूछने के लिए जा रहे हैं

413
00:26:23,830 --> 00:26:29,350
पूर्णांक, कि पूर्णांक ले लो, और तब,
मनमाने ढंग से, हम एक समय पाश है कि

414
00:26:29,350 --> 00:26:32,280
बस घटती जा रही है
यह 10 के बराबर है मैं जब तक.

415
00:26:32,280 --> 00:26:35,820
चलो, अभी मैं प्रवेश कर रहा हूँ मान
10 से अधिक एक पूर्णांक.

416
00:26:35,820 --> 00:26:38,700
यह 10 के बराबर है तो मैं जब तक घटती.

417
00:26:38,700 --> 00:26:42,630
>> और फिर हम एक और जबकि पाश है
मैं 0 के बराबर नहीं है, हम कर रहे हैं, कि

418
00:26:42,630 --> 00:26:44,540
3 से मैं घटती जा रही है.

419
00:26:44,540 --> 00:26:49,790
तो आप बग की मंशा को देखते हैं
यहां, यह यह है कि मैं करने के लिए घटती हूँ कि

420
00:26:49,790 --> 00:26:57,010
10, और उसके बाद इस समय पाश इच्छा हो
1 से 4 से 7 को 10,,, से घटती मैं,

421
00:26:57,010 --> 00:27:02,880
नकारात्मक 2 के लिए, इतने पर 5 नकारात्मक, और करने के लिए
नकारात्मक अनन्तता करने के लिए, मैं के बाद से

422
00:27:02,880 --> 00:27:05,920
वास्तव में 0 के बराबर कभी नहीं.

423
00:27:05,920 --> 00:27:08,610
और फिर इस कार्यक्रम के अंत में,
हम जो foo समारोह है

424
00:27:08,610 --> 00:27:12,130
प्रिंट पर बाहर जा रहा है मुझे लगता है कि.

425
00:27:12,130 --> 00:27:16,520
>> तो यह एक छोटी और तुच्छ कार्यक्रम है
और बग स्पष्ट है,

426
00:27:16,520 --> 00:27:18,790
खासकर के बाद मैं बस
बग था क्या कहा.

427
00:27:18,790 --> 00:27:24,840
लेकिन यहाँ के इरादे ठीक है, यह हो सकता है,
वास्तव में से कुछ की तरह लग रहे अपने

428
00:27:24,840 --> 00:27:30,040
पिछले से लालची से समाधान
समस्या सेट, और शायद आप की क्या ज़रूरत है

429
00:27:30,040 --> 00:27:32,800
अपने कार्यक्रम में कुछ अनंत लूप,
और आपको पता नहीं है

430
00:27:32,800 --> 00:27:34,100
क्या यह कारण है.

431
00:27:34,100 --> 00:27:38,690
तो एक बहुत ही उपयोगी डिबगिंग तकनीक
बस printfs जोड़ने के लिए है

432
00:27:38,690 --> 00:27:40,180
आपके सभी कोड पर.

433
00:27:40,180 --> 00:27:49,200
>> यहाँ तो मैं बाहर एक printf चाहते हैं
पहला, जबकि पाश.

434
00:27:49,200 --> 00:27:53,155
और यहाँ मैं एक printf चाहते हैं,
और मैं सिर्फ मैं मुद्रित करेंगे.

435
00:27:53,155 --> 00:27:55,670

436
00:27:55,670 --> 00:27:58,330
पाश जबकि मैं भी मैं, पहले क्या करेंगे.

437
00:27:58,330 --> 00:28:05,130

438
00:28:05,130 --> 00:28:09,040
बाहर, दूसरा जबकि पाश.

439
00:28:09,040 --> 00:28:12,170
एक बार फिर, अंदर मुद्रित
यहाँ, मूल्य मैं.

440
00:28:12,170 --> 00:28:16,270

441
00:28:16,270 --> 00:28:17,520
और चलो इस चलाते हैं.

442
00:28:17,520 --> 00:28:22,620

443
00:28:22,620 --> 00:28:24,800
>> तो डॉट स्लेश डिबग.

444
00:28:24,800 --> 00:28:25,610
एक पूर्णांक दर्ज करें.

445
00:28:25,610 --> 00:28:28,150
13 करते हैं.

446
00:28:28,150 --> 00:28:28,760
और बूम.

447
00:28:28,760 --> 00:28:33,300
हम अनंत पाशन देखते हैं कि
जबकि दूसरा लूप के अंदर.

448
00:28:33,300 --> 00:28:36,305
तो अब हम बग क्या है.

449
00:28:36,305 --> 00:28:39,610

450
00:28:39,610 --> 00:28:45,610
लेकिन printf डीबगिंग, पूरी तरह से महान है
लेकिन अपने कार्यक्रमों के लिए एक बार

451
00:28:45,610 --> 00:28:50,560
अब और अधिक जटिल है, वहाँ रहे हैं
करने के लिए और अधिक परिष्कृत समाधान

452
00:28:50,560 --> 00:28:51,705
चीजें काम कर रही है.

453
00:28:51,705 --> 00:28:52,955
तो चलो इन सभी printfs को दूर करते हैं.

454
00:28:52,955 --> 00:29:06,242

455
00:29:06,242 --> 00:29:08,896
और यकीन है कि मैं नहीं था बनाते हैं
कुछ भी टूट गया.

456
00:29:08,896 --> 00:29:09,850
ठीक है.

457
00:29:09,850 --> 00:29:14,180
>> इसलिए हम जा रहे कार्यक्रम
लागू करने के लिए कहा जाता है

458
00:29:14,180 --> 00:29:16,715
ग्नू डिबगर के लिए GDB,.

459
00:29:16,715 --> 00:29:21,892

460
00:29:21,892 --> 00:29:27,510
खैर, असल में, के लिए डिबग को दूर करते हैं
एक दूसरा, और फिर डिबग बनाने.

461
00:29:27,510 --> 00:29:31,420

462
00:29:31,420 --> 00:29:34,440
खैर, असल में पहले, एक अच्छा सबक
कमांड लाइन तर्क में.

463
00:29:34,440 --> 00:29:37,780
इस बजना आदेश है कि नोटिस
सब कुछ दिया जा रहा है संकलन

464
00:29:37,780 --> 00:29:41,300
कमांड लाइन पर, इन
कमांड लाइन तर्क.

465
00:29:41,300 --> 00:29:46,250
आप का उपयोग करने जा रहे हैं तो क्या वास्तव में कैसे
कमांड लाइन तर्क के रूप में हम

466
00:29:46,250 --> 00:29:51,500
पहले किया था, और आप PSET में के रूप में होगा
2, कि बजना उन का उपयोग करना बताया गया.

467
00:29:51,500 --> 00:30:00,070
>> तो नोटिस कि यह पहली झंडा, पानी का छींटा
ggdb3, वह यह है कि क्या कह रहा है, बजना,

468
00:30:00,070 --> 00:30:03,790
आप के साथ इस फाइल संकलन चाहिए
आशय यह है कि हम अंत में होगा

469
00:30:03,790 --> 00:30:05,380
इसे डिबग करने की जरूरत है.

470
00:30:05,380 --> 00:30:13,840
तो जब तक आप उस ध्वज के रूप में,
तो हम GDB डिबग कर सकते हैं.

471
00:30:13,840 --> 00:30:17,380
और यह ग्नू डिबगर खोल देंगे.

472
00:30:17,380 --> 00:30:22,920
>> तो आदेशों की एक बहुत हैं
आप करने के लिए इस्तेमाल किया जाना चाहिए कि.

473
00:30:22,920 --> 00:30:27,100
पहले एक है कि आप शायद हूँ
तुरंत जरूरत चलाया जाता है.

474
00:30:27,100 --> 00:30:28,200
तो क्या क्या करने जा चलाया जाता है?

475
00:30:28,200 --> 00:30:30,910
यह हमारे कार्यक्रम शुरू करने जा रहा है.

476
00:30:30,910 --> 00:30:36,180
तो, शुरू कर कार्यक्रम, कार्यक्रम चलाने
एक पूर्णांक, 13 के लिए हमें पूछता है.

477
00:30:36,180 --> 00:30:39,170
और फिर यह अनंत पाशन के रूप में है
मैं हटा दिया है, सिवाय उम्मीद

478
00:30:39,170 --> 00:30:40,500
printfs, तो हम यह भी है कि नहीं दिख रहा है.

479
00:30:40,500 --> 00:30:43,320

480
00:30:43,320 --> 00:30:44,600
सामान्य रूप से बाहर हुआ.

481
00:30:44,600 --> 00:30:45,850
ओह.

482
00:30:45,850 --> 00:30:48,570

483
00:30:48,570 --> 00:30:53,640
यह लिपटे संभव है कि सभी
रास्ते के आसपास, वापस करने के लिए - कि अनदेखी.

484
00:30:53,640 --> 00:30:55,170
यह सामान्य रूप से नहीं निकता मान लें.

485
00:30:55,170 --> 00:30:59,500

486
00:30:59,500 --> 00:31:03,370
उस के लिए एक जटिल जवाब है.

487
00:31:03,370 --> 00:31:07,890
>> तो अब, कि बहुत उपयोगी नहीं है.

488
00:31:07,890 --> 00:31:11,480
तो बस के अंदर हमारे कार्यक्रम चल रहा है
इस डिबगर किसी में हमें मदद नहीं करता है

489
00:31:11,480 --> 00:31:15,610
हम बस कर सकता था, क्योंकि जिस तरह से,
डॉट GDB बाहर से डिबग स्लेश.

490
00:31:15,610 --> 00:31:21,250
तो एक आदेश है कि
आप शायद हूँ -

491
00:31:21,250 --> 00:31:22,970
और मैं यह पद छोड़ दूंगा.

492
00:31:22,970 --> 00:31:25,850
नियंत्रण-D या, काम दोनों को छोड़ दिया.

493
00:31:25,850 --> 00:31:29,550
तो चलो इसे फिर से खोलते हैं.

494
00:31:29,550 --> 00:31:31,130
>> एक अन्य आदेश है कि आप शायद हूँ
तुरंत करना चाहते हैं

495
00:31:31,130 --> 00:31:33,600
आदत हो तोड़ रहा है.

496
00:31:33,600 --> 00:31:37,120
तो हम अब के लिए मुख्य पर तोड़ दूँगा
और फिर मैं समझाता हूँ.

497
00:31:37,120 --> 00:31:41,010

498
00:31:41,010 --> 00:31:46,370
खैर, हम यहाँ हम एक ब्रेकपाइंट सेट देखना
debug.c में इस लाइन पर.

499
00:31:46,370 --> 00:31:50,160
तो क्या विराम का मतलब है कि जब मैं
रन लिखें, कार्यक्रम करने जा रहा है

500
00:31:50,160 --> 00:31:53,560
जब तक उनका प्रदर्शन जारी
मैं एक breakpoint मारा.

501
00:31:53,560 --> 00:31:59,390
मैं चलाने मारा तो, जब कार्यक्रम शुरू होता है,
और फिर इसे के रूप में जल्द ही के रूप में यह टूट जाता है

502
00:31:59,390 --> 00:32:01,940
मुख्य समारोह में प्रवेश करती है.

503
00:32:01,940 --> 00:32:06,930
मुख्य तोड़ कुछ होने जा रहा है
तुम बहुत आमतौर पर करते हैं.

504
00:32:06,930 --> 00:32:11,340
>> और अब, आप परिचय
कुछ और आदेशों को.

505
00:32:11,340 --> 00:32:14,330
यह हम कह रहा है कि, यहां नोटिस
है जो 11 लाइन, पर तोड़ा

506
00:32:14,330 --> 00:32:16,230
printf, एक पूर्णांक दर्ज करें.

507
00:32:16,230 --> 00:32:21,260
तो आदेश अगला कैसे होने जा रहा है
हम कोड की अगली पंक्ति में जाना.

508
00:32:21,260 --> 00:32:24,810
यह हमें कदम करने के लिए अनुमति देने के लिए जा रहा है
रेखा ने हमारे कार्यक्रम लाइन के माध्यम से.

509
00:32:24,810 --> 00:32:26,260
तो अगली.

510
00:32:26,260 --> 00:32:29,820
>> अब 12 लाइन, हम जा रहे हैं
पूर्णांक प्राप्त करने के लिए.

511
00:32:29,820 --> 00:32:30,450
अगला.

512
00:32:30,450 --> 00:32:34,290
आप बस फिर हिट दर्ज करें और अगर यह हूँ
तुमने किया था पिछले बात फिर से करना.

513
00:32:34,290 --> 00:32:36,480
इसलिए मैं टाइप करने की जरूरत नहीं है
अगले हर बार.

514
00:32:36,480 --> 00:32:40,100
तो एक पूर्णांक, 13 दर्ज करें.

515
00:32:40,100 --> 00:32:46,940
तो अब, रेखा 14, मैं अधिक से अधिक है, जबकि
10 से, और मैं आगे क्या करेंगे.

516
00:32:46,940 --> 00:32:48,685
और हम हम मैं घटती जा रहे हैं देखते हैं.

517
00:32:48,685 --> 00:32:50,210
तो हम फिर मैं घटती जा रहे हैं.

518
00:32:50,210 --> 00:32:53,620
>> तो अब, एक और उपयोगी
आदेश छापा है.

519
00:32:53,620 --> 00:32:55,750
तो प्रिंट बाहर मुद्रित करने के लिए जा रहा है
चर का मान.

520
00:32:55,750 --> 00:32:57,825
के मूल्य बाहर ले आओ
चर मैं की.

521
00:32:57,825 --> 00:32:58,705
कहते हैं कि मैं मुद्रित करते हैं.

522
00:32:58,705 --> 00:33:00,910
यह मैं 11 है कहने के लिए जा रहा है.

523
00:33:00,910 --> 00:33:03,330
अब हम अगले फिर जबकि
मैं 10 से अधिक है.

524
00:33:03,330 --> 00:33:05,590
इसलिए मैं अभी भी अधिक से अधिक है
यह 11 के बाद से 10,.

525
00:33:05,590 --> 00:33:06,920
मैं शून्य शून्य से.

526
00:33:06,920 --> 00:33:08,250
फिर मैं मुद्रित करते हैं.

527
00:33:08,250 --> 00:33:10,950
जैसी कि उम्मीद थी, यह 10 है.

528
00:33:10,950 --> 00:33:12,510
>> तो अब, अगले.

529
00:33:12,510 --> 00:33:16,250
यह वापस हालत जा रहा है, मैं है
10 से अधिक है, लेकिन मैं तो, अब 10 है

530
00:33:16,250 --> 00:33:20,040
यह 10 से अधिक नहीं है, तो हम उम्मीद
यह जबकि पाश से बाहर गिर करने के लिए.

531
00:33:20,040 --> 00:33:22,220
और अब हम कोड की है कि रेखा के नीचे हैं.

532
00:33:22,220 --> 00:33:28,750
और एक अन्य आदेश, सूची, सिर्फ जा रहा है
पिछले और अगले प्रदर्शित करने के लिए

533
00:33:28,750 --> 00:33:31,240
कोड की लाइनों में की जोड़ी
मामले में आप अपने आप को खो दिया है.

534
00:33:31,240 --> 00:33:35,420
तो हम बस, इस समय पाश से बाहर हुआ
और अब हम इस प्रवेश किया है

535
00:33:35,420 --> 00:33:37,080
जबकि पाश, रेखा 18.

536
00:33:37,080 --> 00:33:39,860
मैं 0 के बराबर है, जबकि नहीं तो.

537
00:33:39,860 --> 00:33:46,570
और, इसके बाद, मैं हम हूँ मैं शून्य से 3 के बराबर होती है, और
नोटिस, यह सिर्फ जा रखेंगे.

538
00:33:46,570 --> 00:33:48,270
और हम मैं मुद्रित कर सकते हैं.

539
00:33:48,270 --> 00:33:49,990
>> प्रत्येक आदेश की तरह शॉर्टकट है.

540
00:33:49,990 --> 00:33:51,720
तो पी प्रिंट के लिए छोटा है.

541
00:33:51,720 --> 00:33:53,400
इसलिए हम पी मैं कर सकता हूँ.

542
00:33:53,400 --> 00:33:57,550
सिर्फ n पकड़ रखने,
या अगला कर रखना.

543
00:33:57,550 --> 00:33:58,340
फिर मैं प्रिंट.

544
00:33:58,340 --> 00:34:00,380
आप इसे 167 नकारात्मक है अब देखते हैं.

545
00:34:00,380 --> 00:34:06,030
तो यह हमेशा के लिए पर जाना है, लेकिन नहीं होगा
वास्तव में हमेशा के लिए, तुम सिर्फ देखा था के बाद से, यह

546
00:34:06,030 --> 00:34:09,330
वास्तव में कुछ बिंदु पर खत्म हो जाएगा.

547
00:34:09,330 --> 00:34:15,699
>> इसलिए कि GDB शुरुआत है.

548
00:34:15,699 --> 00:34:19,504
लेकिन GDB में एक और बात करते हैं.

549
00:34:19,504 --> 00:34:20,754
उह, डिबग.

550
00:34:20,754 --> 00:34:23,540

551
00:34:23,540 --> 00:34:28,534
तो, इस विशेष मामले में,
अनंत लूप के अंदर हो हुआ

552
00:34:28,534 --> 00:34:30,050
मुख्य समारोह.

553
00:34:30,050 --> 00:34:35,779
और अब के लिए, सिर्फ मैं कर रहा हूँ कि उस स्वीकार
में अनंत लूप स्थानांतरित करने के लिए जा रहा

554
00:34:35,779 --> 00:34:37,029
foo समारोह.

555
00:34:37,029 --> 00:34:40,679

556
00:34:40,679 --> 00:34:43,730
बस इस के अंत में, कि याद
कार्यक्रम, ठीक है, यह मूल रूप से किया गया था

557
00:34:43,730 --> 00:34:46,210
बस था जो Foo, बुला
मैं मुद्रित करने के लिए जा रहा है.

558
00:34:46,210 --> 00:34:51,880
लेकिन अब हम है, जो foo बुला रहे हैं
यह 0 जब तक मैं घटती है, और करने के लिए जा रहा

559
00:34:51,880 --> 00:34:54,548
तब उस चर मुद्रित.

560
00:34:54,548 --> 00:34:55,469
ठीक है.

561
00:34:55,469 --> 00:34:57,970
उस बचाओ.

562
00:34:57,970 --> 00:35:00,175
डिबग बनाओ.

563
00:35:00,175 --> 00:35:03,310
और अब, GDB डिबग.

564
00:35:03,310 --> 00:35:04,090
ठीक है.

565
00:35:04,090 --> 00:35:10,580
>> मैं बस चलाते हैं तो फिर मैं नहीं जा रहा हूँ
वास्तव में के माध्यम से कदम करने में सक्षम हो मेरी

566
00:35:10,580 --> 00:35:11,730
कार्यक्रम लाइन से लाइन.

567
00:35:11,730 --> 00:35:19,820
तो चलो मुख्य में तोड़ देना,
और फिर रन लिखें.

568
00:35:19,820 --> 00:35:28,160
तो इस के माध्यम से जाना, printf, दर्ज
एक पूर्णांक, पूर्णांक, 13 मिलता है.

569
00:35:28,160 --> 00:35:34,180

570
00:35:34,180 --> 00:35:37,490
इसलिए हम decrementing रखने के लिए जा रहे हैं
मैं 10 से अधिक है जब तक.

571
00:35:37,490 --> 00:35:42,840
तो फिर हम के माध्यम से गिर करने के लिए जा रहे हैं
जबकि पाश, और रेखा को मिलता है -

572
00:35:42,840 --> 00:35:44,364
चलो एक अलग विंडो में इसे खोलते हैं.

573
00:35:44,364 --> 00:35:48,720

574
00:35:48,720 --> 00:35:53,300
मैं अब और नहीं था जब तक तो हम decremented
फिर 10 से अधिक, और हम

575
00:35:53,300 --> 00:35:55,700
Foo, समारोह में कहा.

576
00:35:55,700 --> 00:36:01,340
>> तो क्या हुआ, जैसे ही मैं हिट हुआ
समारोह foo, ठीक है, मैं foo कहा जाता है, और

577
00:36:01,340 --> 00:36:04,030
तो मैं अब और नहीं GDB पर नियंत्रण था.

578
00:36:04,030 --> 00:36:10,230
इसलिए जैसे ही मैं इस लाइन पर अगले हिट के रूप में,
ऐसा ही हुआ था जब तक चीजें जारी रखा,

579
00:36:10,230 --> 00:36:12,400
जब जहां कार्यक्रम से बाहर निकल गया -

580
00:36:12,400 --> 00:36:14,450
यह अंत में मौजूद नहीं था मान.

581
00:36:14,450 --> 00:36:16,390
आप यह हालांकि एक बिट के लिए थामने देखा.

582
00:36:16,390 --> 00:36:22,040
तो क्यों मैं पर नियंत्रण खो दिया
उस बिंदु पर कार्यक्रम?

583
00:36:22,040 --> 00:36:27,540
मैं अगले प्रकार जब ठीक है, कि करने के लिए चला जाता है
कोड का शाब्दिक अगली पंक्ति है कि

584
00:36:27,540 --> 00:36:28,850
अमल करेंगे.

585
00:36:28,850 --> 00:36:35,950
इतना होने के बाद लाइन 21, कोड की अगली पंक्ति
कि, रेखा 22 है क्रियान्वित करेगा

586
00:36:35,950 --> 00:36:38,520
मुख्य से बाहर निकल रहा है, जो है.

587
00:36:38,520 --> 00:36:43,810
तो मैं बस जाने के लिए नहीं करना चाहती
कोड की अगली पंक्ति में.

588
00:36:43,810 --> 00:36:48,170
मैं समारोह, foo में जाना चाहता हूँ,
और फिर भी माध्यम से कदम

589
00:36:48,170 --> 00:36:49,830
कोड की उन पंक्तियों.

590
00:36:49,830 --> 00:36:53,726
>> तो उस के लिए, हम एक विकल्प है.

591
00:36:53,726 --> 00:36:56,770
चलो फिर से कि छोड़ दिया.

592
00:36:56,770 --> 00:36:58,020
मुख्य तोड़ो.

593
00:36:58,020 --> 00:37:00,520

594
00:37:00,520 --> 00:37:06,370
उह, 1, अगले, अगले, 13, अगला,
इसके बाद, अगला, ध्यान,

595
00:37:06,370 --> 00:37:09,820
हम लाइन foo मारा पहले.

596
00:37:09,820 --> 00:37:10,520
ठीक है.

597
00:37:10,520 --> 00:37:13,700
>> तो अब, हम 21 लाइन पर रहे
हम foo कॉल जहां.

598
00:37:13,700 --> 00:37:17,100
हम अगले प्रकार नहीं करना चाहते हैं कि जब से
सिर्फ समारोह foo कहते हैं, और होगा

599
00:37:17,100 --> 00:37:18,710
कोड की अगली पंक्ति में जाना.

600
00:37:18,710 --> 00:37:20,840
क्या हम प्रयोग करना चाहते कदम है.

601
00:37:20,840 --> 00:37:25,690
तो चरण के बीच एक अंतर है
और चरण में कदम जहां अगले,

602
00:37:25,690 --> 00:37:28,190
समारोह, और अगला चला जाता है
समारोह की.

603
00:37:28,190 --> 00:37:32,830
यह बस के पूरी तरह कार्यान्वित
समारोह और रहता जा रहा है.

604
00:37:32,830 --> 00:37:37,210
>> तो कदम हमें लाने जा रही है
समारोह में, foo.

605
00:37:37,210 --> 00:37:41,160
और हम अब, हम पर वापस आ गए हैं, यहाँ देखें
सिद्धांत रूप में, यह है कि इस समय पाश,

606
00:37:41,160 --> 00:37:44,190
हमेशा के लिए जारी करने के लिए जा रहा है.

607
00:37:44,190 --> 00:37:50,420
और आप यह भी नहीं है जब कदम, मारा
कॉल करने के लिए एक समारोह है, तो यह बात है

608
00:37:50,420 --> 00:37:51,720
अगले करने के लिए समान.

609
00:37:51,720 --> 00:37:55,320
आप एक पंक्ति में रहे हैं इसलिए जब यह केवल कि
कदम है कि एक समारोह बुला रहा है

610
00:37:55,320 --> 00:37:56,970
अगला से अलग करने के लिए जा रहा है.

611
00:37:56,970 --> 00:37:57,930
तो कदम यहाँ हमें लाना होगा.

612
00:37:57,930 --> 00:38:02,100
कदम, कदम, कदम, कदम, कदम, कदम, और
हम हमेशा के लिए बस अनंत लूप हूँ.

613
00:38:02,100 --> 00:38:06,810
>> तो आप के रूप में है कि करने के लिए इस्तेमाल किया हो सकता है आपके
अनंत छोरों की पहचान करने का तरीका है,

614
00:38:06,810 --> 00:38:08,960
बस इस कुंजी दर्ज करने के लिए पकड़े
आप अटक जाते हैं, जहां देखते हैं.

615
00:38:08,960 --> 00:38:11,610

616
00:38:11,610 --> 00:38:14,780
वहाँ ऐसा करने के लिए बेहतर तरीके से कर रहे हैं, लेकिन
अभी के लिए, कि पूरी तरह से पर्याप्त है.

617
00:38:14,780 --> 00:38:17,967
और stylistically, शैली के अनुरूप
50, मैं यह कर देना चाहिए.

618
00:38:17,967 --> 00:38:21,550

619
00:38:21,550 --> 00:38:24,030
ठीक है.

620
00:38:24,030 --> 00:38:28,400
>> एक तो अंतिम आदेश लागू करने के लिए.

621
00:38:28,400 --> 00:38:30,810
ठीक है, चलो अंदर डिबग gdb जाने

622
00:38:30,810 --> 00:38:35,580
तो बजाय मुख्य पर तोड़ने की, अगर मैं
foo समारोह में पता भी है

623
00:38:35,580 --> 00:38:39,230
समस्या है, तो मैं कर सकता था बस
, इसके बजाय, foo पर विराम कहा.

624
00:38:39,230 --> 00:38:42,310
कहते हैं कि मैं पर विराम हम कहते हैं
मुख्य और foo दोनों.

625
00:38:42,310 --> 00:38:45,390
तो आप के रूप में कई breakpoints सेट कर सकते हैं
जैसा आप चाहते हैं.

626
00:38:45,390 --> 00:38:49,230
मैं रन लिखते हैं, तो यह जा रहा है
पर रोक -

627
00:38:49,230 --> 00:38:52,180
ऊह, के बाद से, चलो फिर कंपाइल जाने
मैं चीजों को बदल दिया है.

628
00:38:52,180 --> 00:38:55,950
यदि आप इस लाइन, चेतावनी, स्रोत देखेंगे
फ़ाइल निष्पादन योग्य से नवीनतम है.

629
00:38:55,950 --> 00:38:59,680
इसलिए कि मैं बस यहाँ में चला गया है कि इसका मतलब है
और शैली के अनुरूप करने के लिए इन बदला

630
00:38:59,680 --> 00:39:03,100
50, लेकिन मैं फिर कंपाइल नहीं किया
कार्यक्रम.

631
00:39:03,100 --> 00:39:04,870
तो GDB कि मेरे बारे में पता है.

632
00:39:04,870 --> 00:39:10,130
मैं, फिर डिबग बनाने, पद छोड़ दूंगा
GDB डिबग मारा.

633
00:39:10,130 --> 00:39:10,700
ठीक है.

634
00:39:10,700 --> 00:39:12,800
>> तो अब, वापस मैं क्या कर रहा था.

635
00:39:12,800 --> 00:39:15,720
मुख्य तोड़ने foo तोड़.

636
00:39:15,720 --> 00:39:20,680
अब मैं इस कार्यक्रम चलाने के लिए, तो यह है कि अगर
हिट जब तक जारी रखने के लिए जा रहा एक

637
00:39:20,680 --> 00:39:21,320
ब्रेकपाइंट.

638
00:39:21,320 --> 00:39:24,680
यही ब्रेकपाइंट के लिए होता है
मुख्य पर पहले एक रहो.

639
00:39:24,680 --> 00:39:28,630
अब, बजाय अगले कर रही है, अगले, अगले,
अगले, अगले, मैं foo मारा, जब तक मैं

640
00:39:28,630 --> 00:39:35,230
जारी रहेगा जारी है, जो टाइप कर सकते हैं
आप अगले ब्रेकपाइंट मारा जब तक.

641
00:39:35,230 --> 00:39:37,200
मैं पहली पूर्णांक में प्रवेश किया है.

642
00:39:37,200 --> 00:39:40,570
मैं मारा जब तक जारी रहेगा जारी
जो यह है कि अगले ब्रेकपाइंट,

643
00:39:40,570 --> 00:39:43,320
foo के समारोह.

644
00:39:43,320 --> 00:39:50,130
>> आप एक हिट तो जब तक चलाने जाएगा
जब ब्रेकपाइंट, लेकिन आप केवल संख्या लिखें

645
00:39:50,130 --> 00:39:54,060
आप, तो कार्यक्रम शुरू करने, और कर रहे हैं
तब से, यह जारी है.

646
00:39:54,060 --> 00:40:01,950
मैं सिर्फ मुख्य तोड़ दिया और यदि
तो भाग गया, इसे तोड़ दूँगा

647
00:40:01,950 --> 00:40:03,670
फिर मुख्य, और जारी है.

648
00:40:03,670 --> 00:40:10,050
मैं foo पर एक ब्रेक अंक है, नहीं है
पूर्णांक दर्ज करें, तो अब मैं कर रहा हूँ

649
00:40:10,050 --> 00:40:11,380
foo में तोड़ने नहीं जा रहा.

650
00:40:11,380 --> 00:40:16,318
यह सिर्फ अनंत के लिए जा रहा है
कि जब तक पाश.

651
00:40:16,318 --> 00:40:17,568
ठीक है.

652
00:40:17,568 --> 00:40:19,500

653
00:40:19,500 --> 00:40:24,420
>> इसलिए कि GDB के लिए परिचय है.

654
00:40:24,420 --> 00:40:27,790
आप इसे का उपयोग शुरू कर देना चाहिए
आपकी समस्या सेट में.

655
00:40:27,790 --> 00:40:30,550
यह बहुत उपयोगी हो सकता है
कीड़े की पहचान करने के लिए.

656
00:40:30,550 --> 00:40:35,280
आप वास्तव में सिर्फ लाइन से लाइन, जाओ
अपने कोड के माध्यम से, और क्या है तुलना

657
00:40:35,280 --> 00:40:39,740
वास्तव में आप क्या उम्मीद के साथ हो
ऐसा करने के लिए, तो यह बहुत है

658
00:40:39,740 --> 00:40:41,060
अपने कीड़े को याद करने के लिए मुश्किल.

659
00:40:41,060 --> 00:40:45,280

660
00:40:45,280 --> 00:40:46,530
ठीक है.

661
00:40:46,530 --> 00:40:48,310

662
00:40:48,310 --> 00:40:54,040
>> इसलिए पिछले हफ्ते दाऊद इस पाला
के लिए गुप्त कुंजी क्रिप्टोग्राफी सामान

663
00:40:54,040 --> 00:40:59,350
हम नहीं चाहते हैं, जहां पहली बार,
पासवर्ड की बस पर संग्रहीत किया जा हमारी

664
00:40:59,350 --> 00:41:03,210
कुछ सादे पाठ फ़ाइल में कंप्यूटर, जहां
किसी के ऊपर और बस आ सकता है

665
00:41:03,210 --> 00:41:04,660
इसे खोलने और उन्हें पढ़ा है.

666
00:41:04,660 --> 00:41:07,530
आदर्श रूप में, वे एन्क्रिप्टेड किया जाएगा
किसी तरह से.

667
00:41:07,530 --> 00:41:13,340
और इस समस्या को 2 सेट में, आप काम हो जाएगा
एन्क्रिप्शन की एक विधि के साथ,

668
00:41:13,340 --> 00:41:16,520
या, ठीक है, दो तरीकों, लेकिन
वे इतना महान नहीं हैं.

669
00:41:16,520 --> 00:41:20,050
आप हैकर संस्करण करते हैं, तो आप कर रहे हैं
भी साथ काम कर रहे हो जा

670
00:41:20,050 --> 00:41:22,150
कुछ बातें decrypting.

671
00:41:22,150 --> 00:41:29,770
>> इसलिए इस मुद्दे अब ठीक है, भले ही है,
हम मजबूत एन्क्रिप्शन है

672
00:41:29,770 --> 00:41:34,830
दुनिया में एल्गोरिथ्म, अगर आप एक का चयन
विशेष रूप से गरीब पासवर्ड, तो यह

673
00:41:34,830 --> 00:41:37,720
, बहुत ज्यादा मदद नहीं करेगा क्योंकि लोग
अभी भी यह पता लगाने में सक्षम हो जाएगा.

674
00:41:37,720 --> 00:41:41,530
एन्क्रिप्टेड स्ट्रिंग को देखने और यहाँ तक कि यदि
यह कचरा का एक गड़बड़ की तरह दिखता है

675
00:41:41,530 --> 00:41:44,760
यही है, अगर उन्हें कोई मतलब नहीं है कि वे
अभी बस कुछ ही पासवर्ड का प्रयास करने की आवश्यकता

676
00:41:44,760 --> 00:41:50,560
आप तो, यह समझ से बाहर
बहुत सुरक्षित नहीं हैं.

677
00:41:50,560 --> 00:41:55,890
तो एक वीडियो देख रहा है कि
कि बात करता है.

678
00:41:55,890 --> 00:41:59,587

679
00:41:59,587 --> 00:42:00,970
>> [वीडियो प्लेबैक]

680
00:42:00,970 --> 00:42:02,100
>> हेलमेट, आप लेनेवाला.

681
00:42:02,100 --> 00:42:03,370
क्या चल रहा है?

682
00:42:03,370 --> 00:42:05,170
तुम मेरी बेटी को क्या कर रहे हो?

683
00:42:05,170 --> 00:42:09,910
>> शानदार लागू करने के लिए परमिट
युवा प्लास्टिक सर्जन, डॉ. फिलिप

684
00:42:09,910 --> 00:42:13,730
Schlotkin, सबसे बड़ी नाक
पूरे में काम आदमी

685
00:42:13,730 --> 00:42:16,080
ब्रह्मांड, और बेवर्ली हिल्स.

686
00:42:16,080 --> 00:42:17,210
>> आपका महारानी.

687
00:42:17,210 --> 00:42:18,070
>> -नाक नौकरी?

688
00:42:18,070 --> 00:42:18,670
मैं नहीं समझा.

689
00:42:18,670 --> 00:42:20,090
वह पहले से ही एक नाक नौकरी मिली है.

690
00:42:20,090 --> 00:42:21,910
यह एक मिठाई सोलह उपस्थित थे.

691
00:42:21,910 --> 00:42:22,140
>> नहीं.

692
00:42:22,140 --> 00:42:23,690
यह आप क्या सोचते नहीं है.

693
00:42:23,690 --> 00:42:25,420
यह बहुत, बहुत बुरा है.

694
00:42:25,420 --> 00:42:30,300
आप मुझे संयोजन नहीं देते हैं
हवा ढाल, डा. Schlotkin होगा

695
00:42:30,300 --> 00:42:34,226
उसके पुराने नाक अपनी बेटी को वापस दे.

696
00:42:34,226 --> 00:42:35,476
>> नहीं.

697
00:42:35,476 --> 00:42:38,712

698
00:42:38,712 --> 00:42:40,516
आप कहाँ से मिला?

699
00:42:40,516 --> 00:42:41,440
>> सब सही.

700
00:42:41,440 --> 00:42:42,180
मैं बताता हूँ.

701
00:42:42,180 --> 00:42:43,381
मैं बताता हूँ.

702
00:42:43,381 --> 00:42:44,263
नहीं, पिताजी.

703
00:42:44,263 --> 00:42:45,590
नहीं, तुम नहीं करना चाहिए.

704
00:42:45,590 --> 00:42:46,860
>> -तुम ठीक कह रहे, मेरे प्रिय.

705
00:42:46,860 --> 00:42:48,450
मैं अपने नए नाक याद करेंगे.

706
00:42:48,450 --> 00:42:52,090
लेकिन मैं उसे संयोजन बता नहीं होगा,
कोई बात नहीं क्या.

707
00:42:52,090 --> 00:42:53,680
>> बहुत अच्छी तरह से.

708
00:42:53,680 --> 00:42:55,685
डॉ. Schlotkin, अपने सबसे खराब करते हैं.

709
00:42:55,685 --> 00:42:56,914
>> मेरा खुशी.

710
00:42:56,914 --> 00:43:00,690
>> [टूल्स तेज किया जा रहा है]

711
00:43:00,690 --> 00:43:01,910
>> नहीं.

712
00:43:01,910 --> 00:43:02,520
रुको.

713
00:43:02,520 --> 00:43:03,836
रुको.

714
00:43:03,836 --> 00:43:05,300
मैं बताता हूँ.

715
00:43:05,300 --> 00:43:06,880
मैं बताता हूँ.

716
00:43:06,880 --> 00:43:09,130
>> मैं यह काम होता था.

717
00:43:09,130 --> 00:43:09,900
ठीक है.

718
00:43:09,900 --> 00:43:12,850
इसे मुझे दे.

719
00:43:12,850 --> 00:43:16,918
>> संयोजन एक है.

720
00:43:16,918 --> 00:43:17,406
>> एक.

721
00:43:17,406 --> 00:43:18,382
>> एक.

722
00:43:18,382 --> 00:43:19,358
>> दो.

723
00:43:19,358 --> 00:43:19,846
>> दो.

724
00:43:19,846 --> 00:43:20,822
>> दो.

725
00:43:20,822 --> 00:43:21,310
>> तीन.

726
00:43:21,310 --> 00:43:21,798
>> तीन.

727
00:43:21,798 --> 00:43:22,774
>> तीन.

728
00:43:22,774 --> 00:43:23,262
>> चार.

729
00:43:23,262 --> 00:43:23,750
>> चार.

730
00:43:23,750 --> 00:43:26,150
>> चार.

731
00:43:26,150 --> 00:43:27,010
>> पांच.

732
00:43:27,010 --> 00:43:27,670
>> पांच.

733
00:43:27,670 --> 00:43:29,010
>> पांच.

734
00:43:29,010 --> 00:43:34,770
>> तो संयोजन, एक है
दो, तीन, चार, पांच.

735
00:43:34,770 --> 00:43:37,460
यही बेवकूफी संयोजन है
मैं कभी भी अपने जीवन में सुना.

736
00:43:37,460 --> 00:43:39,710
उस चीज़ की तरह एक मूर्ख है
उसके सामान पर होगा.

737
00:43:39,710 --> 00:43:42,000
>> राजा साहब, आप का शुक्र है.

738
00:43:42,000 --> 00:43:43,530
>> क्या आप ऐसा क्यों किया?

739
00:43:43,530 --> 00:43:44,490
>> मैं दीवार को बंद कर दिया.

740
00:43:44,490 --> 00:43:45,420
>> -नहीं, तुम नहीं किया था.

741
00:43:45,420 --> 00:43:45,840
आप पूरी फिल्म को बंद कर दिया.

742
00:43:45,840 --> 00:43:46,930
>> मैं गलत बटन दबाया गया होगा.

743
00:43:46,930 --> 00:43:48,265
>> खैर, पीठ पर रख दिया.

744
00:43:48,265 --> 00:43:49,110
पीठ पर फिल्म रखो.

745
00:43:49,110 --> 00:43:49,510
>> हां, सर.

746
00:43:49,510 --> 00:43:49,917
हाँ, सर.

747
00:43:49,917 --> 00:43:50,324
>> के, अर्नोल्ड जाना करते हैं.

748
00:43:50,324 --> 00:43:51,140
, ग्रेचेन आओ.

749
00:43:51,140 --> 00:43:53,060
बेशक, आप मुझे अब भी जानता हूँ कि
इस के लिए बिल के लिए है.

750
00:43:53,060 --> 00:43:53,440
>> [अंत वीडियो प्लेबैक]

751
00:43:53,440 --> 00:43:54,690
>> आरओबी BODEN: सब ठीक है.

752
00:43:54,690 --> 00:43:59,690

753
00:43:59,690 --> 00:44:08,430
हम पहले से ही के बारे में बात कर रहे हैं तो अब है कि
कुछ मायनों में सुरक्षा, अच्छा

754
00:44:08,430 --> 00:44:16,050
छोटे से फिल्म के पोस्टर, तो हाल में
राष्ट्रीय सुरक्षा सलाहकार के साथ दिन, इन मुद्दों

755
00:44:16,050 --> 00:44:17,300
सब कुछ निगरानी.

756
00:44:17,300 --> 00:44:21,840

757
00:44:21,840 --> 00:44:26,930
यह आप की तरह महसूस करने के लिए मुश्किल हो सकता है
में गोपनीयता के कुछ प्रकार है

758
00:44:26,930 --> 00:44:34,540
ऑनलाइन दुनिया में, मैं नहीं बता सकता है, हालांकि
आप चश्मे के विवरण के अधिकांश.

759
00:44:34,540 --> 00:44:42,130
तो चश्मे से परे चलती है, हम नहीं जा रहे हैं
अब, इस बारे में बात कर रही हो

760
00:44:42,130 --> 00:44:44,030
अपने लैपटॉप के बारे में सोचते हैं.

761
00:44:44,030 --> 00:44:48,360
तो यहाँ, मैं स्विच करना चाहते हैं
मेरी वास्तविक खाते में,

762
00:44:48,360 --> 00:44:50,370
मेरे छोटे पेंगुइन के साथ.

763
00:44:50,370 --> 00:44:57,310
तो मैं एक पासवर्ड सेट है, और है कि
पासवर्ड मैं इसे देखना चाहते हैं जो कुछ भी है.

764
00:44:57,310 --> 00:45:02,430
>> लेकिन याद रखना कि क्या मैं प्रवेश कर रहा हूँ
, तो इस लॉगिन के साथ में

765
00:45:02,430 --> 00:45:04,850
शीघ्र, कुछ कार्यक्रम है.

766
00:45:04,850 --> 00:45:07,910
यह था कि कुछ कार्यक्रम है
कुछ व्यक्ति ने लिखा है.

767
00:45:07,910 --> 00:45:13,250
और हां, तो उस व्यक्ति को, अगर वे कर रहे हैं
विशेष रूप से दुर्भावनापूर्ण, वे सकता है

768
00:45:13,250 --> 00:45:17,780
कहा है, सब ठीक है, यदि हां, तो पासवर्ड
मैं में प्रवेश के बराबर है मेरा

769
00:45:17,780 --> 00:45:22,800
वास्तविक पासवर्ड, या यह बराबर है
कुछ विशेष पासवर्ड के लिए -

770
00:45:22,800 --> 00:45:25,550
डेविड भयानक या कुछ और है -

771
00:45:25,550 --> 00:45:27,190
फिर उन्हें अंदर जाने

772
00:45:27,190 --> 00:45:33,760
तो एक दुर्भावनापूर्ण प्रोग्रामर हो सकता था
अपने एमएसीएस के सभी, या करने के लिए उपयोग

773
00:45:33,760 --> 00:45:36,150
विंडोज, या कुछ भी.

774
00:45:36,150 --> 00:45:41,980
>> तो यह है कि, के बाद से, एक चिंता का ज्यादा नहीं है
मेरा मतलब है, इस लॉगिन कार्यक्रम है

775
00:45:41,980 --> 00:45:48,720
कि ओएस एक्स, सैकड़ों के साथ भेज दिया है
या लोगों के हजारों है

776
00:45:48,720 --> 00:45:50,020
इस कोड की समीक्षा की.

777
00:45:50,020 --> 00:45:55,330
और हां, तो आप कहीं न कहीं अपने कोड में, अगर
इस स्ट्रिंग के बराबर होती है, तो कहना

778
00:45:55,330 --> 00:45:58,860
डेविड भयानक है, लॉगिन, तो किसी को है
होने जा रहा है, जैसे, रुको.

779
00:45:58,860 --> 00:45:59,800
यह सही नहीं है.

780
00:45:59,800 --> 00:46:01,790
यह यहाँ नहीं होना चाहिए.

781
00:46:01,790 --> 00:46:06,650
तो यह है कि हम चीजों को पाने के लिए एक रास्ता है
एक तरह से सुरक्षित हो.

782
00:46:06,650 --> 00:46:10,300
>> लेकिन फिर भी कार्यक्रमों के बारे में सोचना
आप लिखते हैं कि.

783
00:46:10,300 --> 00:46:13,000
मान लीजिए कि आप लॉगिन प्रोग्राम लिखा कहते हैं.

784
00:46:13,000 --> 00:46:20,440
आप ने लिखा है कि इसलिए इस लॉगिन कार्यक्रम,
तो जाहिर है, आप एक अच्छे हैं

785
00:46:20,440 --> 00:46:21,210
प्रोग्रामर.

786
00:46:21,210 --> 00:46:25,610
आप किसी भी दुर्भावनापूर्ण डाल करने के लिए नहीं जा रहे हैं
एक्स बराबर अगर दाऊद कमाल है

787
00:46:25,610 --> 00:46:27,860
अपने कोड में.

788
00:46:27,860 --> 00:46:31,930
लेकिन इस कार्यक्रम, तुम क्या
इस कार्यक्रम संकलन करने के लिए इस्तेमाल करते हैं?

789
00:46:31,930 --> 00:46:34,180
बजना ही कुछ.

790
00:46:34,180 --> 00:46:38,460
तो क्या हुआ अगर के लिए हुआ है, जो व्यक्ति
बजना में मामलों बजना विशेष लिखना

791
00:46:38,460 --> 00:46:44,310
कुछ, जैसे मैं संकलन हूँ अगर
कार्यक्रम लॉगिन, तो इस कोड को दर्ज

792
00:46:44,310 --> 00:46:49,720
अगर, कहते हैं कि लॉगिन कार्यक्रम में
एक्स के बराबर होती है दाऊद भयानक है के बराबर होती है?

793
00:46:49,720 --> 00:46:59,890
तो काफी नहीं है अभी तक, लेकिन हम एक ही है
यहां मुद्दा यह है, जहां बजना, अच्छी तरह से,

794
00:46:59,890 --> 00:47:03,790
हजारों, नहीं तो दसियों के हजारों की
लोगों को है, बजना पर ध्यान दिया है

795
00:47:03,790 --> 00:47:07,160
कोड के अपने लाइनों को देखा और कहा,
सब ठीक है, यहाँ बुरा कुछ भी नहीं है.

796
00:47:07,160 --> 00:47:10,680
जाहिर है, कोई भी कर रही है
इस दुर्भावनापूर्ण कुछ भी.

797
00:47:10,680 --> 00:47:15,780
>> लेकिन क्या, जैसे, खुद बजना है
क्या मैं बजना संकलन तो क्या होगा?

798
00:47:15,780 --> 00:47:20,900
क्या मैं कुछ संकलक है कि अगर
बजना में सम्मिलित करता है बजना संकलित

799
00:47:20,900 --> 00:47:25,610
कहते हैं कि इस विशेष हैक, सब ठीक है,
मैं बजना संकलन करते हैं, तो

800
00:47:25,610 --> 00:47:31,290
निष्पादन योग्य मैं विशेष रूप से देखना चाहिए मिलता है
लॉगिन कार्यक्रम और डालने के अंदर

801
00:47:31,290 --> 00:47:34,230
इस पासवर्ड, के बराबर होती है
डेव भयानक है?

802
00:47:34,230 --> 00:47:37,990
तो याद है कि आपके संकलक ही
कुछ बिंदु पर संकलित करने की आवश्यकता है.

803
00:47:37,990 --> 00:47:42,810
तो आप बजना संकलन करने के लिए चुनते हैं अगर
, खुद आप तो, दुर्भावनापूर्ण है साथ

804
00:47:42,810 --> 00:47:45,580
पूरे दबाव डाला जा सकता है
रास्ते नीचे लाइन.

805
00:47:45,580 --> 00:47:49,630
>> तो यहाँ, हम केन थॉम्पसन है
और डेनिस रिची.

806
00:47:49,630 --> 00:47:53,780
तो यह एक iconic तस्वीर है.

807
00:47:53,780 --> 00:47:55,470
डेनिस रिची सही पर है.

808
00:47:55,470 --> 00:47:58,740
उन्होंने कहा कि एक प्रमुख है -

809
00:47:58,740 --> 00:48:03,640
बहुत ज्यादा सी. लिखा है तो आप कर सकते हैं
इस वर्ग के लिए उसे धन्यवाद.

810
00:48:03,640 --> 00:48:04,840
केन थॉमसन बाईं तरफ है.

811
00:48:04,840 --> 00:48:07,780
उनमें से दो मूल रूप से यूनिक्स लिखा था.

812
00:48:07,780 --> 00:48:10,140
खैर, वे प्रमुख योगदानकर्ता थे
यूनिक्स में.

813
00:48:10,140 --> 00:48:11,310
कुछ और लोग भी थे.

814
00:48:11,310 --> 00:48:16,240
कुछ बिंदु पर तो केन थॉम्पसन,,
वह ट्यूरिंग पुरस्कार जीतता है.

815
00:48:16,240 --> 00:48:20,860
और ट्यूरिंग पुरस्कार, मैं हमेशा सुना है
इसे इस तरह से संदर्भित, यह है

816
00:48:20,860 --> 00:48:23,100
कंप्यूटर विज्ञान का नोबेल पुरस्कार.

817
00:48:23,100 --> 00:48:27,500
>> तो ट्यूरिंग पुरस्कार में, वह करने के लिए है
अपने स्वीकृति भाषण दे.

818
00:48:27,500 --> 00:48:31,790
और वह इस बहुत प्रसिद्ध भाषण देता है
अब, विश्वास पर विचार बुलाया

819
00:48:31,790 --> 00:48:35,620
हम जुड़ा हुआ है जो ट्रस्ट,
बेशक वेबसाइट पर है.

820
00:48:35,620 --> 00:48:41,670
और इस भाषण में उन्होंने सब ठीक है, कहते हैं
इसलिए मैं यूनिक्स लिखा था, और अब सभी की

821
00:48:41,670 --> 00:48:43,320
आप लोगों को यूनिक्स का उपयोग कर रहे हैं.

822
00:48:43,320 --> 00:48:46,960
अब, लिनक्स है कि आज याद
यूनिक्स के एक प्रत्यक्ष वंशज.

823
00:48:46,960 --> 00:48:50,140
ओएस एक्स सीधे यूनिक्स का उपयोग करता है.

824
00:48:50,140 --> 00:48:53,810
विंडोज इतना नहीं करता है, लेकिन एक बहुत
विचारों की यूनिक्स से लिया गया था.

825
00:48:53,810 --> 00:48:59,220
>> तो वह मंच तक जाता है और कहता है
ठीक है, मैं यूनिक्स लिखा था.

826
00:48:59,220 --> 00:49:03,940
और अभी तो तुम लोगों को पता है, मैं कर रहा हूँ
हर में प्रवेश करने में सक्षम

827
00:49:03,940 --> 00:49:05,590
आपके कंप्यूटर की एक एक.

828
00:49:05,590 --> 00:49:14,280
एक्स अगर मैं इन विशेष की एक डाल के बाद से
के बराबर होती है, केन थॉमसन भयानक है के बराबर होती है

829
00:49:14,280 --> 00:49:16,350
तब मैं प्रवेश की अनुमति हूँ.

830
00:49:16,350 --> 00:49:18,370
इसलिए लोगों को अच्छी तरह से, की तरह हैं
आप कैसे करेंगे?

831
00:49:18,370 --> 00:49:21,090
हम लॉगइन कार्यक्रम को देखा
और कुछ नहीं है.

832
00:49:21,090 --> 00:49:24,700
उन्होंने कहा कि ठीक है, मैं संकलक संशोधित, की तरह है
लॉगिन कार्यक्रम में लॉग इन करने के लिए

833
00:49:24,700 --> 00:49:30,490
लॉगिन कार्यक्रम अब होगा कि इतना
कि एक्स केन थॉम्पसन बराबर

834
00:49:30,490 --> 00:49:31,700
कमाल है.

835
00:49:31,700 --> 00:49:33,120
>> और वे अच्छी तरह से, यह सच नहीं है, कहते हैं.

836
00:49:33,120 --> 00:49:35,740
हम संकलक को देख रहे हैं, और
संकलक के किसी भी लाइन नहीं है

837
00:49:35,740 --> 00:49:36,400
कि जैसे कोड.

838
00:49:36,400 --> 00:49:40,540
उन्होंने कहा कि ठीक है, की तरह है, लेकिन आप क्या कर रहे हैं
संकलक के साथ संकलन?

839
00:49:40,540 --> 00:49:44,810
और, ठीक है, की तरह, उन्हें लगता है कि, और वह है
मैं आप संकलक दिया जो एक हूँ

840
00:49:44,810 --> 00:49:50,580
आप संकलक संकलन करने के लिए उपयोग कर रहा है, इसलिए कर रहे हैं
यदि आप एक संकलक संकलन कर रहे हैं कि

841
00:49:50,580 --> 00:49:56,390
खुद दुर्भावनापूर्ण है, और होगा
लॉगिन कार्यक्रम टूट गया.

842
00:49:56,390 --> 00:49:59,360
तो बुनियादी तौर पर, उस बिंदु पर, वहाँ है
आप स्रोत पर लग सकता है कोई रास्ता नहीं

843
00:49:59,360 --> 00:50:02,450
लॉगिन कार्यक्रम का कोड
क्या गलत है को देखने के लिए.

844
00:50:02,450 --> 00:50:04,220
तुम भी में नहीं लग सकता है
संकलक के स्रोत कोड

845
00:50:04,220 --> 00:50:06,790
क्या गलत है को देखने के लिए.

846
00:50:06,790 --> 00:50:11,940
>> आप मशीन को देखने की जरूरत होगी
कोड की वास्तविक बाइनरी

847
00:50:11,940 --> 00:50:16,760
इन, प्रतीक्षा, देखने के लिए संकलित संकलक
कोड की लाइनों यहाँ नहीं होना चाहिए.

848
00:50:16,760 --> 00:50:22,130
लेकिन केन थॉम्पसन यह एक कदम उठाया
आगे और अच्छी तरह से कर रहे हैं, ने कहा कि

849
00:50:22,130 --> 00:50:25,980
इन विशेष कार्यक्रमों है कि वास्तव में
आप कार्यक्रमों के द्विआधारी पढ़ने में मदद,

850
00:50:25,980 --> 00:50:29,340
और इसलिए किसी को उस कार्यक्रम का इस्तेमाल अगर
बाइनरी पढ़ते हैं, वे इन देखना होगा

851
00:50:29,340 --> 00:50:30,490
कोड की लाइनों.

852
00:50:30,490 --> 00:50:34,020
वह सब कहने के लिए, उन कार्यक्रमों संशोधित
ठीक है, आप देख रहे हैं

853
00:50:34,020 --> 00:50:38,460
संकलक, इस विशेष शो नहीं है
बाइनरी का सेट.

854
00:50:38,460 --> 00:50:42,830
>> तो फिर तुम्हें लेने की जरूरत है कि एक कदम
आगे और मूल रूप से, कि हो सकता है

855
00:50:42,830 --> 00:50:46,210
अविवेक से लिया कई स्तरों,
और कुछ बिंदु पर, कोई भी वास्तव में है

856
00:50:46,210 --> 00:50:47,990
जाँच होने जा रहा.

857
00:50:47,990 --> 00:50:52,590
कहानी का नैतिक तो आप कर रहे हैं, है
लिख नहीं किया जा रहा

858
00:50:52,590 --> 00:50:54,340
इस वर्ग में बजना.

859
00:50:54,340 --> 00:50:57,020
आप चढ़ाई का उपयोग करने जा रहे हैं
इस वर्ग में एक बहुत बजना.

860
00:50:57,020 --> 00:51:00,490
आप सभी जानते हैं, बजना एक दुर्भावनापूर्ण है
हर sabotaging है कि कार्यक्रम

861
00:51:00,490 --> 00:51:03,520
एक कार्यक्रम में आप कभी भी तैयार की है.

862
00:51:03,520 --> 00:51:08,206
और वह बहुत अशुभ पर आप छोड़ने के लिए
बुधवार को आप देखना, ध्यान दें.

863
00:51:08,206 --> 00:51:10,030
>> [वाहवाही]

864
00:51:10,030 --> 00:51:12,935
>> अध्यक्ष 2: अगले CS50 पर.

865
00:51:12,935 --> 00:51:14,580
>> स्पीकर 3: आप कहते हैं कि हिम्मत मत करना.

866
00:51:14,580 --> 00:51:15,930
आप ऐसा कर सकते हैं.

867
00:51:15,930 --> 00:51:19,440
आप पहले भी किया है, तो आप ऐसा कर सकते हैं
आज, आप कल ऐसा कर सकते हैं.

868
00:51:19,440 --> 00:51:20,930
आप साल के लिए कर दिया गया है.

869
00:51:20,930 --> 00:51:22,790
बस वहाँ जाना है और यह करते हैं.

870
00:51:22,790 --> 00:51:24,310
आप ऐसा कर सकते हैं.

871
00:51:24,310 --> 00:51:26,102
>> [संगीत खेल]