1
00:00:00,000 --> 00:00:02,742

2
00:00:02,742 --> 00:00:05,680
>> स्पीकर 1: हाय सब लोग.

3
00:00:05,680 --> 00:00:07,530
हम शुरू करने जा रहे हैं.

4
00:00:07,530 --> 00:00:09,330
मैं लोगों को अभी भी जा रहे हैं
में छान हो.

5
00:00:09,330 --> 00:00:12,840
लेकिन समय के हित में, हम कर सकते हैं तो
समय पर यहाँ से बाहर तुम लोगों को मिलता है,

6
00:00:12,840 --> 00:00:14,110
हम शुरू करने जा रहे हैं.

7
00:00:14,110 --> 00:00:18,780
तो CS50 प्रश्नोत्तरी 0 समीक्षा करने का स्वागत करते हैं.

8
00:00:18,780 --> 00:00:23,020
एहसास नहीं है जो आप उन लोगों के लिए
अभी तक, आप बुधवार को एक सवाल है.

9
00:00:23,020 --> 00:00:25,700
वू हू.

10
00:00:25,700 --> 00:00:29,780
>> आप अभी तक पढ़ाई शुरू नहीं किया है या
यह अभी तक मौजूद है कि महसूस नहीं किया है,

11
00:00:29,780 --> 00:00:34,070
पिछले परीक्षाएँ और सब के बारे में जानकारी
अपने प्रश्नोत्तरी cs50.net/quizzes पर हैं.

12
00:00:34,070 --> 00:00:38,090
कुछ बहुत अच्छी चीजें वहाँ पर नहीं है,
10 पिछले से पिछले परीक्षाएँ

13
00:00:38,090 --> 00:00:43,760
वर्ष के रूप में अच्छी तरह से जानकारी
इस क्विज और विषयों के बारे में

14
00:00:43,760 --> 00:00:46,250
कि कवर किया जाएगा.

15
00:00:46,250 --> 00:00:48,980
तो चलो शुरू हो जाओ.

16
00:00:48,980 --> 00:00:54,240
>> तो तुम लोग, पहले याद हो सकता है
वर्ग दाऊद के दिन उन लैंप पर था.

17
00:00:54,240 --> 00:00:59,650
तो अनिवार्य रूप से, सब कुछ हो जाता है कि
एक कंप्यूटर के हुड के तहत पर

18
00:00:59,650 --> 00:01:00,860
बाइनरी में किया.

19
00:01:00,860 --> 00:01:04,080
बाइनरी यह लगता है कि क्या मतलब है
जैसे, 0 और 1 के.

20
00:01:04,080 --> 00:01:09,290
यह दो मूल्यों है कि
प्रतिनिधित्व किया जा सकता है.

21
00:01:09,290 --> 00:01:14,675
>> तो सिर्फ खंड के पहले दिन में जैसे
दाऊद एक रोशनी पर बदल गया जब

22
00:01:14,675 --> 00:01:21,990
बल्ब, हमारे कंप्यूटर पर प्रतिनिधित्व करते हैं, या 1 को
समझता 0 के रूप में द्विआधारी और

23
00:01:21,990 --> 00:01:24,110
1 की, पर या बंद.

24
00:01:24,110 --> 00:01:25,360
बाइनरी के मूल बातें.

25
00:01:25,360 --> 00:01:29,440

26
00:01:29,440 --> 00:01:32,470
हर जगह प्रतिनिधित्व किया है
बेस दो में.

27
00:01:32,470 --> 00:01:36,260
तो आप करने के लिए 0 2 जोड़
1 सभी तरह से 2.

28
00:01:36,260 --> 00:01:41,970
>> अपने द्विआधारी करने के लिए क्या है की गणना करने के लिए
दशमलव, तुम सिर्फ इस समीकरण का पालन करें

29
00:01:41,970 --> 00:01:42,840
प्रकार की बात.

30
00:01:42,840 --> 00:01:49,510
आप उन स्थानों में से किसी में एक 1 है,
आप से गुणा जो कुछ

31
00:01:49,510 --> 00:01:53,820
इसमें बेस के साथ, इसे जोड़ने के लिए, और
आप दशमलव मिलता है.

32
00:01:53,820 --> 00:01:57,930
तो यह आप भरोसा कैसे है
बाइनरी में से 5.

33
00:01:57,930 --> 00:02:01,400
बस हम पर क्या कर रहे थे जैसे
पिछले स्लाइड, यह आप कैसे होता है

34
00:02:01,400 --> 00:02:02,650
1 से 5 का प्रतिनिधित्व करते हैं.

35
00:02:02,650 --> 00:02:05,320

36
00:02:05,320 --> 00:02:09,660
>> इसी तरह, बस आप जोड़ सकते हैं की तरह है और
दशमलव में घटाना या 10 आधार है, या

37
00:02:09,660 --> 00:02:13,040
वास्तव में किसी भी आधार पर जोड़ सकते हैं
और बाइनरी में घटाना.

38
00:02:13,040 --> 00:02:18,400
जब आप आप उम्मीद करेंगे कि क्या वास्तव में
यह अधिक से अधिक के बराबर होती है, तो दो को जोड़ें

39
00:02:18,400 --> 00:02:24,220
1 से, आप एक 1, यह एक 0 कर ले,
और बस, इसके अलावा उस तरह से करते हैं

40
00:02:24,220 --> 00:02:29,910
जैसे आप नियमित रूप से उम्मीद करेंगे
दशमलव या किसी भी अन्य आधार.

41
00:02:29,910 --> 00:02:30,970
कूल.

42
00:02:30,970 --> 00:02:35,140
>> मैं, सब कुछ पहले की तरह कहा तो है कि
हमारे कंप्यूटर के हुड के नीचे चला जाता है

43
00:02:35,140 --> 00:02:37,560
0 और 1 का, या बाइनरी में किया जाता है.

44
00:02:37,560 --> 00:02:43,470
इसलिए हम व्यक्त करते कैसे, उदाहरण के लिए,
पत्र, या संख्याओं, या वर्ण?

45
00:02:43,470 --> 00:02:45,560
और जवाब है कि ASCII है.

46
00:02:45,560 --> 00:02:49,380
>> ASCII वर्ण के बीच एक मानचित्रण है
हम सामान्य रूप में देखना होगा कि

47
00:02:49,380 --> 00:02:53,360
एक के, बी जैसे अंग्रेजी भाषा,
सी, अंडरस्कोर, डैश, और

48
00:02:53,360 --> 00:02:54,910
ऐसा कुछ.

49
00:02:54,910 --> 00:02:57,260
और यह एक ASCII मूल्य के लिए नक्शे है कि.

50
00:02:57,260 --> 00:03:03,080
एक ASCII मूल्य सिर्फ एक संख्या है कि
अपने कंप्यूटर से समझा जा सकता है.

51
00:03:03,080 --> 00:03:07,430
और तुम इसके अलावा क्या कर सकते हैं बस की तरह और
संख्या के साथ घटाव, आप कर सकते हैं

52
00:03:07,430 --> 00:03:10,890
ASCII मूल्यों के साथ उन्हें.

53
00:03:10,890 --> 00:03:14,050
>> इस उदाहरण में तो क्या हुआ
इस बाहर मुद्रित होगा?

54
00:03:14,050 --> 00:03:26,790

55
00:03:26,790 --> 00:03:35,480
हाँ, तो सिर्फ एक अंतरिक्ष बी अंतरिक्ष सी अंतरिक्ष
डी जहाँ मेरे माउस गए थे?

56
00:03:35,480 --> 00:03:39,200

57
00:03:39,200 --> 00:03:43,380
आप 65 में एक पूर्णांक परिभाषित कर सकते हैं नोटिस.

58
00:03:43,380 --> 00:03:47,080
और आप का उपयोग कि बाहर प्रिंट जब
प्रतिशत सी, यह एक के रूप में है कि व्याख्या करेंगे

59
00:03:47,080 --> 00:03:49,330
चरित्र और ए बाहर प्रिंट होगा

60
00:03:49,330 --> 00:03:52,800
>> इसी तरह, आप घोषणा कर सकते हैं
यह एक चार के रूप में.

61
00:03:52,800 --> 00:03:56,860
और तुम प्रतिशत का उपयोग कर इसे बाहर प्रिंट जब
सी, के रूप में यह है कि व्याख्या करेंगे

62
00:03:56,860 --> 00:04:05,240
प्रतिशत डी और यदि आप जोड़ सकते हैं बस की तरह
संख्या, आप अक्षर हैं जोड़ सकते हैं

63
00:04:05,240 --> 00:04:06,878
इस मामले में ASCII मूल्यों,.

64
00:04:06,878 --> 00:04:11,370

65
00:04:11,370 --> 00:04:16,130
>> हर किसी के लिए तो एक छोटी सी सूचक.

66
00:04:16,130 --> 00:04:19,610
5, एक स्ट्रिंग के रूप में, नहीं करता
वास्तव में 5 बराबर.

67
00:04:19,610 --> 00:04:26,610
तो हम कैसे परिवर्तित हो सकता है
पूर्णांक से 5 स्ट्रिंग 5?

68
00:04:26,610 --> 00:04:28,930
किसी भी विचार?

69
00:04:28,930 --> 00:04:31,630
हाँ.

70
00:04:31,630 --> 00:04:36,720
>> इसलिए हम एक स्ट्रिंग के रूप में 5 है,
हम 0 घटाना कर सकते हैं.

71
00:04:36,720 --> 00:04:37,820
और कहा कि हमें 5 देता हूँ.

72
00:04:37,820 --> 00:04:41,670
और इसी तरह, हम एक के रूप में 5 है तो
पूर्णांक, स्ट्रिंग 0 तक कि जोड़ें.

73
00:04:41,670 --> 00:04:43,112
और कहा कि हमें स्ट्रिंग 5 देता है.

74
00:04:43,112 --> 00:04:46,350

75
00:04:46,350 --> 00:04:48,350
कूल.

76
00:04:48,350 --> 00:04:52,940
>> अब, एक जहां व्याख्यान के लिए वापस याद
हम एल्गोरिदम के बारे में बात की थी.

77
00:04:52,940 --> 00:04:57,260
इसलिए हम वास्तव में एक कंप्यूटर चाहते हैं कि कैसे
दिलचस्प बातें करते हैं?

78
00:04:57,260 --> 00:05:00,460
तुम बस जोड़ने और घटाकर, पता
संख्या और मुद्रण बातें बाहर नहीं है

79
00:05:00,460 --> 00:05:01,730
कि रोमांचक.

80
00:05:01,730 --> 00:05:04,620
आम तौर पर, हम करने के लिए हमारे कंप्यूटर चाहते हैं
एल्गोरिथ्म किसी तरह का प्रदर्शन करते हैं.

81
00:05:04,620 --> 00:05:07,820
एक छोटे से अधिक जटिल कुछ
सिर्फ साधारण अंकगणित से.

82
00:05:07,820 --> 00:05:11,930
>> एक एल्गोरिथ्म कदम सेट से सिर्फ एक कदम है
प्रदर्शन करने के लिए के लिए निर्देश की

83
00:05:11,930 --> 00:05:14,640
एक निश्चित task--

84
00:05:14,640 --> 00:05:15,660
सिर्फ एक नुस्खा की तरह.

85
00:05:15,660 --> 00:05:19,990
आप के पहले दिन याद हो सकता है
दाऊद हमें एक कमरे में गिनती की थी, जहां क्लास

86
00:05:19,990 --> 00:05:22,550
लोगों के और कितने लोग
कमरे में थे.

87
00:05:22,550 --> 00:05:24,480
आप गिनती करने के लिए इस्तेमाल किया जा सकता है
एक के बाद एक.

88
00:05:24,480 --> 00:05:25,860
1, 2, 3, 4.

89
00:05:25,860 --> 00:05:28,010
उस मामले में, एक रेखीय समय एल्गोरिथ्म.

90
00:05:28,010 --> 00:05:31,710
>> लेकिन दाऊद के लिए एक एल्गोरिथ्म शुरू की
आप कमरे में लोगों की गिनती करने के लिए

91
00:05:31,710 --> 00:05:37,340
हर किसी के ऊपर खड़ा है, जहां आप अपने कहना
किसी अन्य व्यक्ति के लिए संख्या, कि जोड़

92
00:05:37,340 --> 00:05:39,200
संख्या, और एक व्यक्ति नीचे बैठता है.

93
00:05:39,200 --> 00:05:40,410
और तुम उस दोहराएँ.

94
00:05:40,410 --> 00:05:42,910
कि एल्गोरिथ्म का एक प्रकार है.

95
00:05:42,910 --> 00:05:47,520
हम कैसे कुशल एक विश्लेषण कर सकते हैं
यह समय की दौड़ पर एल्गोरिथ्म आधारित है.

96
00:05:47,520 --> 00:05:49,680
लेकिन हम एक छोटा सा बात करेंगे
उस बारे में बाद में अधिक.

97
00:05:49,680 --> 00:05:52,740

98
00:05:52,740 --> 00:05:57,090
>> इतना सब एल्गोरिदम भी कर सकते हैं
pseudocode में लिखा जाना.

99
00:05:57,090 --> 00:06:01,120
Pseudocode बस की तरह एक अंग्रेजी है
वाक्यविन्यास का प्रतिनिधित्व करने के लिए इस्तेमाल किया

100
00:06:01,120 --> 00:06:02,420
एक प्रोग्रामिंग भाषा.

101
00:06:02,420 --> 00:06:06,070
उदाहरण के लिए, एक उपयोगकर्ता हम चाहते थे पूछने के लिए
मेरे पसंदीदा संख्या अनुमान करने के लिए, हम

102
00:06:06,070 --> 00:06:08,390
जैसे pseudocode हो सकता है.

103
00:06:08,390 --> 00:06:09,850
>> एक उपयोगकर्ताओं को लगता है कि हो जाओ.

104
00:06:09,850 --> 00:06:13,570
अनुमान सही है, तो उन्हें बताना
वे सही कर रहे हैं, और उन्हें बता

105
00:06:13,570 --> 00:06:15,560
वे सही नहीं कर रहे हैं.

106
00:06:15,560 --> 00:06:22,530
और pseudocode आसानी से करने का एक तरीका है
एक विचार या एक एल्गोरिथ्म का प्रतिनिधित्व.

107
00:06:22,530 --> 00:06:26,910
तो अब हम वास्तव में लिखने के लिए चाहते हो सकता है
इस भाषा में है कि कंप्यूटर

108
00:06:26,910 --> 00:06:27,980
समझ सकता है.

109
00:06:27,980 --> 00:06:35,660
इसलिए हम अपने pseudocode लिख सकता है और
स्रोत कोड में है कि व्याख्या.

110
00:06:35,660 --> 00:06:41,320
>> अब तक, स्रोत कोड का पालन करना होगा
की एक निश्चित वाक्यविन्यास को

111
00:06:41,320 --> 00:06:42,490
एक प्रोग्रामिंग भाषा.

112
00:06:42,490 --> 00:06:45,430
और अब तक, CS50 में, हम है
ज्यादातर सी का उपयोग किया गया.

113
00:06:45,430 --> 00:06:48,320
इसलिए इस सी के लिए स्रोत कोड हो सकता है.

114
00:06:48,320 --> 00:06:51,440
बाद में पाठ्यक्रम में, तुम रात में आ गए
अन्य प्रोग्रामिंग के साथ संपर्क में

115
00:06:51,440 --> 00:06:52,480
PHP जैसी भाषाओं.

116
00:06:52,480 --> 00:06:57,540
या फिर आप भी, आप अन्य कक्षाएं लेने अगर
जावा, अजगर, या भी OCML कर सकता है.

117
00:06:57,540 --> 00:07:01,570
लेकिन हमारे ग कार्यक्रम भाषा में, यह है
हम के लिए स्रोत कोड लिख सकते हैं कैसे

118
00:07:01,570 --> 00:07:04,760
pseudocode एल्गोरिथ्म कि
मैं तो बस पहले बताया.

119
00:07:04,760 --> 00:07:08,630

120
00:07:08,630 --> 00:07:11,430
>> तो कैसे वास्तव में आपके कंप्यूटर करता है
कि समझ में आया?

121
00:07:11,430 --> 00:07:14,490
मैं सिर्फ सच में, यह पहले कहा
शून्य और लोगों को समझता है.

122
00:07:14,490 --> 00:07:17,880
तो यह कैसे स्रोत से प्राप्त करता है
हो सकता है कि कुछ करने के लिए कोड

123
00:07:17,880 --> 00:07:18,960
समझा?

124
00:07:18,960 --> 00:07:22,920
ठीक है, हम कुछ है
एक संकलक कहा जाता है.

125
00:07:22,920 --> 00:07:28,450
>> आप में से अधिकांश में वापस याद है आपकी
psets, आप इस कार्यक्रम में किसी तरह का था

126
00:07:28,450 --> 00:07:30,370
एक डॉट सी फाइल में लिखा है.

127
00:07:30,370 --> 00:07:32,550
और फिर तुम बनाने टाइप करेंगे.

128
00:07:32,550 --> 00:07:35,970
तो क्या कर रही है?

129
00:07:35,970 --> 00:07:39,970
>> आप संकलन करने के लिए बनाने टाइप कर सकते हैं अपने
कार्यक्रम someone-- क्योंकि

130
00:07:39,970 --> 00:07:42,730
जो कोई भी अपने पी सेट लिखा था;
शायद David--

131
00:07:42,730 --> 00:07:44,190
एक बनाने फ़ाइल बनाया.

132
00:07:44,190 --> 00:07:51,320
और वह चलाने के लिए पता करने के लिए करना बताता है आपका
संकलक, कहा जाता बजना, कि वसीयत

133
00:07:51,320 --> 00:07:55,560
तो आपत्ति करने के लिए अपने स्रोत कोड संकलन
शून्य और लोगों जो कोड,

134
00:07:55,560 --> 00:07:57,720
अपने कंप्यूटर समझता है.

135
00:07:57,720 --> 00:08:01,610
लेकिन बाद में एक छोटे से, हम जायेंगे
compilers के बारे में अधिक गहराई में.

136
00:08:01,610 --> 00:08:05,640

137
00:08:05,640 --> 00:08:10,800
>> तो याद pset 0, where-- हाँ,
आप में एक सवाल है?

138
00:08:10,800 --> 00:08:11,620
>> दर्शक: [अश्राव्य]?

139
00:08:11,620 --> 00:08:12,490
>> स्पीकर 1: हाँ.

140
00:08:12,490 --> 00:08:14,960
मैं वास्तव में उन्हें लगता है कि
ऑनलाइन होना चाहिए.

141
00:08:14,960 --> 00:08:15,120
हाँ.

142
00:08:15,120 --> 00:08:16,572
>> दर्शक: यह [अश्राव्य] की तरह है?

143
00:08:16,572 --> 00:08:19,476

144
00:08:19,476 --> 00:08:20,830
>> स्पीकर 1: यह नहीं है.

145
00:08:20,830 --> 00:08:25,810
Cs50.net/quizzes पर हैं.

146
00:08:25,810 --> 00:08:32,900
>> दर्शक: स्लैश परीक्षाएँ, 2013 स्लेश
0 स्लेश, और बस के माध्यम से क्लिक करें

147
00:08:32,900 --> 00:08:35,956
परीक्षाएँ 2013 और प्रश्नोत्तरी 0,
खंड स्लाइड्स की समीक्षा करें.

148
00:08:35,956 --> 00:08:40,380
>> स्पीकर 1: हाँ, तो तुम लोगों के लिए चाहते हैं
यह पुल और पर इसे देखो अपने

149
00:08:40,380 --> 00:08:42,740
खुद के कंप्यूटर, वह भी ठीक है.

150
00:08:42,740 --> 00:08:43,130
फिर से कहो.

151
00:08:43,130 --> 00:08:44,546
>> दर्शक: [अश्राव्य].

152
00:08:44,546 --> 00:08:48,780
>> स्पीकर 1: हाँ, [अश्राव्य]
डमी चर रहा है.

153
00:08:48,780 --> 00:08:49,644
हाँ, ओह?

154
00:08:49,644 --> 00:08:51,372
>> दर्शक: [अश्राव्य]?

155
00:08:51,372 --> 00:08:54,300
>> स्पीकर 1: नहीं, हड़ताल
परीक्षा पर नहीं हैं.

156
00:08:54,300 --> 00:08:55,950
क्षमा करें, था उसे सवाल था,
परीक्षा पर हमले.

157
00:08:55,950 --> 00:08:59,530
और ऐसा नहीं है.

158
00:08:59,530 --> 00:09:05,780
तो pset 0, तुम लोग सब होना चाहिए
खरोंच का उपयोग कर कुछ लागू किया है.

159
00:09:05,780 --> 00:09:13,100
और हम कुछ बुनियादी प्रोग्रामिंग सीखा
खरोंच का उपयोग कर इमारत ब्लॉकों.

160
00:09:13,100 --> 00:09:15,590
>> तो चलो कुछ पर एक नज़र रखना
इन ब्लॉक का निर्माण

161
00:09:15,590 --> 00:09:18,170
कि एक कार्यक्रम बनाते हैं.

162
00:09:18,170 --> 00:09:20,570
पहले बूलियन अभिव्यक्ति है.

163
00:09:20,570 --> 00:09:24,540
बूलियन अभिव्यक्ति वाले हैं और
है कि 0 या कुछ भी

164
00:09:24,540 --> 00:09:25,700
दो संभावित मान.

165
00:09:25,700 --> 00:09:30,320
इस मामले में, सही है या गलत,
पर या बंद है, और हाँ या ना.

166
00:09:30,320 --> 00:09:35,390
बहुत आसान है, एक साधारण का एक उदाहरण है,
एक बूलियन का उपयोग करता है कि कार्यक्रम

167
00:09:35,390 --> 00:09:39,140
यहां अभिव्यक्ति की.

168
00:09:39,140 --> 00:09:43,220
>> इसलिए करने के लिए बूलियन अभिव्यक्ति के लिए आदेश में
उपयोगी हो सकता है, हम बूलियन ऑपरेटरों है.

169
00:09:43,220 --> 00:09:48,920
ये इस्तेमाल किया जा सकता है कि ऑपरेटरों रहे
निश्चित मूल्यों की तुलना करें.

170
00:09:48,920 --> 00:09:52,820
तो हमारे पास है और या नहीं के बराबर है, कम
से कम या अधिक से अधिक के बराबर या

171
00:09:52,820 --> 00:09:55,130
के बराबर, और से भी कम
से कम या अधिक से अधिक.

172
00:09:55,130 --> 00:09:59,060
लेकिन इन ऑपरेटरों बहुत उपयोगी नहीं हैं
हम उन्हें गठबंधन कर सकते हैं जब तक

173
00:09:59,060 --> 00:10:00,320
स्थितियां.

174
00:10:00,320 --> 00:10:04,370
>> तो तुम लोग खरोंच से याद कर सकते हैं
और अपने पी से हम उस सेट

175
00:10:04,370 --> 00:10:05,400
स्थितियां था.

176
00:10:05,400 --> 00:10:09,710
वे में कांटे की तरह, अनिवार्य रूप से कर रहे हैं,
अपने कार्यक्रम का तर्क है कि

177
00:10:09,710 --> 00:10:12,670
आधार पर कि क्या निष्पादित
एक शर्त पूरी कर रहा है.

178
00:10:12,670 --> 00:10:18,150
हम था कि स्थितियों की तो एक
इस कोर्स में कई बार इस्तेमाल किया है

179
00:10:18,150 --> 00:10:21,470
और, अगर, और बाकी की स्थिति, अगर.

180
00:10:21,470 --> 00:10:24,060
>> यहाँ का एक उदाहरण है
आप उसका इस्तेमाल कर सकते हैं.

181
00:10:24,060 --> 00:10:28,430
किसी के बीच फर्क पता है
सिर्फ बयानों अगर सब का उपयोग

182
00:10:28,430 --> 00:10:32,530
अगर, किसी और छंद नीचे रास्ता,
अगर, और बाकी संयुक्त?

183
00:10:32,530 --> 00:10:33,013
हाँ?

184
00:10:33,013 --> 00:10:34,263
>> दर्शक: [अश्राव्य].

185
00:10:34,263 --> 00:10:40,741

186
00:10:40,741 --> 00:10:42,160
>> स्पीकर 1: बिल्कुल.

187
00:10:42,160 --> 00:10:50,210
तो अगर मैं था, तो यह सभी तरह से नीचे
जिस तरह से, यहां तक ​​कि इस हालत देता है

188
00:10:50,210 --> 00:10:52,800
सच है, यह अभी भी जारी रहेगा
अगले दो परीक्षण.

189
00:10:52,800 --> 00:11:00,120
जबकि, एक और को, अगर, एक और को साथ
बयान, एक सच रिटर्न अगर,

190
00:11:00,120 --> 00:11:02,640
दूसरों का परीक्षण नहीं कर रहे हैं.

191
00:11:02,640 --> 00:11:05,955
उस के बारे में कोई सवाल?

192
00:11:05,955 --> 00:11:06,890
कूल.

193
00:11:06,890 --> 00:11:12,240
>> तो आप एक बाकी के एक अगर किसी और का उपयोग
यदि आप जानते हैं बयान कि यह केवल कर सकते हैं

194
00:11:12,240 --> 00:11:14,470
इन मामलों में से एक हो.

195
00:11:14,470 --> 00:11:21,550
एक्स 0 से कम है तो अगर हम यह पता है,
निश्चित रूप से नहीं किया जा रहा

196
00:11:21,550 --> 00:11:22,890
0 से अधिक.

197
00:11:22,890 --> 00:11:26,940

198
00:11:26,940 --> 00:11:31,480
>> इसके बाद, एक और इमारत ब्लॉक
हमने सीखा है कि छोरों हैं.

199
00:11:31,480 --> 00:11:33,310
हम छोरों के तीन प्रकार के हैं.

200
00:11:33,310 --> 00:11:35,830
छोरों के लिए, छोरों जबकि,
और छोरों जबकि करते हैं.

201
00:11:35,830 --> 00:11:38,730
और आम तौर पर, आप जब नीचे बैठने के लिए
कुछ लिखना, आप को फैसला करना है

202
00:11:38,730 --> 00:11:40,060
आप उपयोग करना चाहते तीन में से कौन सा.

203
00:11:40,060 --> 00:11:41,900
तो कैसे हम जो एक तय करते हैं?

204
00:11:41,900 --> 00:11:44,920

205
00:11:44,920 --> 00:11:48,790
>> हम जानते हैं कि हम आम तौर पर एक पाश के लिए उपयोग
कितनी बार हम पुनरावृति करना चाहते हैं

206
00:11:48,790 --> 00:11:53,650
कुछ के माध्यम से या कितनी बार
हम किसी कार्य को करने के लिए चाहते हैं.

207
00:11:53,650 --> 00:11:58,830
हम कुछ की जरूरत है अगर हम छोरों जबकि उपयोग
हालत चालू रखने के लिए सच हो सकता है.

208
00:11:58,830 --> 00:12:03,730
और हम बहुत समान है, जबकि ऐसा उपयोग
जबकि, लेकिन हम अपने कोड पर चलाना चाहते हैं

209
00:12:03,730 --> 00:12:04,880
कम से कम एक बार.

210
00:12:04,880 --> 00:12:09,410
>> Do में जो कुछ भी है तो करते हैं, करेंगे
हमेशा कम से कम एक बार चलाते हैं.

211
00:12:09,410 --> 00:12:13,120
जबकि, जबकि साथ, यह
अगर सब पर नहीं चल सकते

212
00:12:13,120 --> 00:12:15,490
हालत से संतुष्ट नहीं है.

213
00:12:15,490 --> 00:12:16,740
उस के साथ कोई सवाल?

214
00:12:16,740 --> 00:12:20,480

215
00:12:20,480 --> 00:12:22,860
>> पाश के लिए एक की तो संरचना.

216
00:12:22,860 --> 00:12:23,620
तुम लोग यह सब देखा है.

217
00:12:23,620 --> 00:12:25,320
आप यह इनिशियलाइज़.

218
00:12:25,320 --> 00:12:26,600
आप हालत किसी तरह का है.

219
00:12:26,600 --> 00:12:32,340
तो, उदाहरण के लिए, हम को प्रारंभ हो सकता है
के लिए के रूप में मैं 0 के बराबर होती है.

220
00:12:32,340 --> 00:12:34,040
मैं कम से कम 10 है.

221
00:12:34,040 --> 00:12:35,442
और मैं ++.

222
00:12:35,442 --> 00:12:39,010
हम किया है कि बहुत ही आसान एक.

223
00:12:39,010 --> 00:12:42,210
>> एक जबकि पाश के लिए, इसी तरह, आपके पास
आरंभीकरण का किसी तरह का है,

224
00:12:42,210 --> 00:12:44,980
हालत किसी तरह का, और
अद्यतन किसी तरह का.

225
00:12:44,980 --> 00:12:51,990
तो हम भी पाश के लिए हमारे लागू कर सकते हैं
एक जबकि पाश के रूप में इस का उपयोग कर.

226
00:12:51,990 --> 00:12:56,000
और इसी प्रकार एक जबकि पाश के साथ,
हम कुछ आरंभीकरण हो सकता है,

227
00:12:56,000 --> 00:12:58,640
, कुछ निष्पादित यह अद्यतन, और
तो हालत की जाँच करें.

228
00:12:58,640 --> 00:13:03,500

229
00:13:03,500 --> 00:13:05,140
>> तो अब काम करता है.

230
00:13:05,140 --> 00:13:06,460
हम सब कुछ एक साथ डाल दिया.

231
00:13:06,460 --> 00:13:10,140
हम कुछ लिखने के लिए चाहते हो सकता है
समारोह की तरह.

232
00:13:10,140 --> 00:13:12,790
आम समारोह कि तुम हो सकता है
पहले से ही देखा है मुख्य है.

233
00:13:12,790 --> 00:13:13,770
मुख्य एक समारोह है.

234
00:13:13,770 --> 00:13:16,160
यह एक प्रकार की वापसी, पूर्णांक है.

235
00:13:16,160 --> 00:13:18,470
यह मुख्य एक समारोह का नाम है.

236
00:13:18,470 --> 00:13:20,810
और यह तर्क, argc और argv है.

237
00:13:20,810 --> 00:13:24,040
तो मुख्य बस एक समारोह है.

238
00:13:24,040 --> 00:13:27,230
>> आप का इस्तेमाल किया गया हो सकता है अन्य कार्यों,
printf-- printf एक function-- है

239
00:13:27,230 --> 00:13:29,330
GetInt, toupper.

240
00:13:29,330 --> 00:13:32,010
लेकिन इन किया गया है के लिए होता है
द्वारा हमारे लिए लागू किया

241
00:13:32,010 --> 00:13:33,270
पुस्तकालय के कुछ प्रकार.

242
00:13:33,270 --> 00:13:37,400
तुम लोगों सहित याद है
इस CS50.h पुस्तकालय या

243
00:13:37,400 --> 00:13:38,510
मानक आई / ओ लाइब्रेरी.

244
00:13:38,510 --> 00:13:39,200
हाँ, सवाल?

245
00:13:39,200 --> 00:13:41,610
>> दर्शक: सी में सिर्फ निहित मुख्य है?

246
00:13:41,610 --> 00:13:44,740
यह बस की तरह [अश्राव्य] करता है?

247
00:13:44,740 --> 00:13:47,370
>> स्पीकर 1: सवाल है
मुख्य अगर ग में निहित है.

248
00:13:47,370 --> 00:13:51,460
और हाँ, सभी कार्य
एक मुख्य समारोह है.

249
00:13:51,460 --> 00:13:55,290
यह एक तरह कंप्यूटर के लिए आवश्यक है
शुरू करने के लिए जहां पता करने के लिए

250
00:13:55,290 --> 00:13:55,993
कोड चल रहा है.

251
00:13:55,993 --> 00:13:58,108
>> दर्शक: तो तुम नहीं होता [अश्राव्य]?

252
00:13:58,108 --> 00:13:59,480
>> स्पीकर 1: नहीं

253
00:13:59,480 --> 00:14:00,760
कोई अन्य प्रश्न?

254
00:14:00,760 --> 00:14:03,430

255
00:14:03,430 --> 00:14:04,770
कूल.

256
00:14:04,770 --> 00:14:08,050
आप एक समारोह का उपयोग कर सकते हैं तो बस की तरह
कि आप के लिए लिखा है, आप भी कर सकते हैं

257
00:14:08,050 --> 00:14:10,380
अपने खुद के समारोह में लिखें.

258
00:14:10,380 --> 00:14:17,050
यह किसी कि हो सकता है एक समारोह है
मात्रा की गणना करने के लिए लिखा है

259
00:14:17,050 --> 00:14:18,395
उदाहरण के लिए एक क्यू, के.

260
00:14:18,395 --> 00:14:21,300

261
00:14:21,300 --> 00:14:29,500
एक प्रकार की वापसी इस मामले में, यहाँ है
पूर्णांक, हमारे समारोह नाम क्यू और हमारे

262
00:14:29,500 --> 00:14:31,360
मापदंडों की सूची.

263
00:14:31,360 --> 00:14:34,550
>> और आप डेटा लिखने के लिए है कि ध्यान दें
आप करना चाहते पैरामीटर के प्रकार

264
00:14:34,550 --> 00:14:38,660
उपयोग या काम नहीं करता है बाकी
किस तरह का पता

265
00:14:38,660 --> 00:14:41,650
पैरामीटर मैं स्वीकार करना चाहिए.

266
00:14:41,650 --> 00:14:48,110
इसलिए, इस मामले में, हम चाहते हैं
हमारे निवेश के रूप में एक पूर्णांक.

267
00:14:48,110 --> 00:14:50,390
तो क्यों हम कार्यों का उपयोग करने के लिए चाहते हो सकता है?

268
00:14:50,390 --> 00:14:52,800
>> सबसे पहले संगठन के लिए महान.

269
00:14:52,800 --> 00:14:56,350
वे में अपने कोड को तोड़ने में मदद
अधिक मात्रा का आयोजन किया और कर

270
00:14:56,350 --> 00:14:57,960
यह पढ़ने के लिए आसान.

271
00:14:57,960 --> 00:14:59,760
सरलीकरण.

272
00:14:59,760 --> 00:15:01,740
इस डिजाइन के लिए अच्छा है.

273
00:15:01,740 --> 00:15:04,570
आप कोड का एक टुकड़ा पढ़ रहे हैं
और मुख्य समारोह, वास्तव में है

274
00:15:04,570 --> 00:15:07,750
वास्तव में लंबे समय से, यह करने के लिए कठिन हो सकता है
क्या हो रहा है के बारे में कारण.

275
00:15:07,750 --> 00:15:11,710
तो आप कार्यों में टूट अगर,
इसे पढ़ने के लिए आसान हो सकता है.

276
00:15:11,710 --> 00:15:12,750
और पुन: उपयोग करने की क्षमता.

277
00:15:12,750 --> 00:15:16,940
आप कोड का एक हिस्सा है, तो जा रहा है कि
कहा जाता है या कई बार चलाने,

278
00:15:16,940 --> 00:15:20,690
बजाय कि कोड 10 बार नए सिरे से लिखना के
अपने मुख्य समारोह में, तुम हो सकता है

279
00:15:20,690 --> 00:15:21,440
यह पुन: उपयोग करना चाहते हैं.

280
00:15:21,440 --> 00:15:25,740
और फिर हर बार आपको लगता है कि उपयोग करने की आवश्यकता
कोड का टुकड़ा, समारोह कॉल.

281
00:15:25,740 --> 00:15:30,550

282
00:15:30,550 --> 00:15:35,380
>> तो अब हम वापस खरोंच तक याद है,
हम भी कुछ अवधारणाओं के बारे में बात की थी

283
00:15:35,380 --> 00:15:37,680
जिनमें से एक सूत्रण है.

284
00:15:37,680 --> 00:15:41,120
थ्रेड कई की अवधारणा है
कोड के दृश्यों

285
00:15:41,120 --> 00:15:43,040
एक ही समय में क्रियान्वित.

286
00:15:43,040 --> 00:15:47,490
तब दाऊद था, जहां एक दिन के लिए वापस लगता है
तुम लोगों की संख्या से दूर गिनती

287
00:15:47,490 --> 00:15:48,440
कमरे में लोग.

288
00:15:48,440 --> 00:15:50,550
>> मूलतः, क्या जा रहा था
पर तुम लोगों की सब थे

289
00:15:50,550 --> 00:15:52,370
अलग धागे चल रहा है.

290
00:15:52,370 --> 00:15:55,540
और उन धागों को एक साथ आ रहे थे
जवाब किसी तरह का पाने के लिए.

291
00:15:55,540 --> 00:15:58,890
इसी तरह, स्क्रैच में, आप जब है
कई sprites, आप कर सकते हैं

292
00:15:58,890 --> 00:16:01,070
एक बिल्ली और एक कुत्ता है.

293
00:16:01,070 --> 00:16:08,770
और वे एक साथ होगा
उनकी खुद की स्क्रिप्ट चला रहा है.

294
00:16:08,770 --> 00:16:10,020
यही सूत्रण का एक उदाहरण है.

295
00:16:10,020 --> 00:16:12,860

296
00:16:12,860 --> 00:16:18,000
>> और दूसरी अवधारणा थी कि
खरोंच में शुरू की घटनाओं था.

297
00:16:18,000 --> 00:16:22,550
और घटनाओं की जब कई हिस्से हैं
अपने कोड एक दूसरे के साथ संवाद.

298
00:16:22,550 --> 00:16:26,840
आप का इस्तेमाल किया जब स्क्रैच में, यह था
प्रसारण नियंत्रण और जब मैं

299
00:16:26,840 --> 00:16:29,500
ब्लॉक मिले.

300
00:16:29,500 --> 00:16:35,170
>> और यह भी, समस्या सेट 4 में, हमने देखा
के रूप में अच्छी तरह की घटनाओं का एक छोटा सा.

301
00:16:35,170 --> 00:16:38,250
तुम लोग इस्तेमाल किया गया हो सकता है
Gevent पुस्तकालय.

302
00:16:38,250 --> 00:16:42,450
और वहाँ एक समारोह था waitForClick
जिसमें आप इंतजार कर रहे थे

303
00:16:42,450 --> 00:16:44,300
उपयोगकर्ता क्लिक करने के लिए.

304
00:16:44,300 --> 00:16:47,870
और अपने लिए क्लिक करें, इस मामले में, हो जाएगा
क्लिक के लिए घटना और इंतजार आपकी है

305
00:16:47,870 --> 00:16:49,120
ईवेंट हैंडलर.

306
00:16:49,120 --> 00:16:53,690

307
00:16:53,690 --> 00:16:58,630
>> और यह भी, अपने psets भर में चल रहा है
और अपने psets पर काम कर रहा है, तो आप

308
00:16:58,630 --> 00:17:01,920
साथ संपर्क में आ सकता है
इन आदेशों की कुछ.

309
00:17:01,920 --> 00:17:05,579
यह आप में टाइप क्या है आपकी
टर्मिनल विंडो या जो कुछ भी खिड़की

310
00:17:05,579 --> 00:17:12,119
कि, के लिए अपनी जी संपादित करें पर पता चलता है
अनिवार्य रूप से, अपने कंप्यूटर से नेविगेट.

311
00:17:12,119 --> 00:17:19,440
>> तो उदाहरण के लिए, लोकसभा सूचीबद्ध करता है
एक निर्देशिका की सामग्री.

312
00:17:19,440 --> 00:17:22,510
निर्देशिका एक नया फ़ोल्डर बनाता बनाओ.

313
00:17:22,510 --> 00:17:24,819
सीडी, परिवर्तन निर्देशिका.

314
00:17:24,819 --> 00:17:28,400
आरएम, हटाने, एक फ़ाइल को हटाता है
या कुछ निर्देशिका.

315
00:17:28,400 --> 00:17:31,050
और फिर निर्देशिका हटाने
एक निर्देशिका हटा.

316
00:17:31,050 --> 00:17:32,300
>> दर्शक: [अश्राव्य]?

317
00:17:32,300 --> 00:17:36,978

318
00:17:36,978 --> 00:17:38,370
>> स्पीकर 1: हाँ, ज़रूर.

319
00:17:38,370 --> 00:17:42,530

320
00:17:42,530 --> 00:17:46,040
क्षमा करें, सवाल था कि आप अगर
इस डालने का सुझाव होगा

321
00:17:46,040 --> 00:17:48,840
धोखा शीट पर.

322
00:17:48,840 --> 00:17:49,440
यह मदद कर सकता है.

323
00:17:49,440 --> 00:17:51,490
आप कमरा है, तो आप उस पर डाल सकते हैं.

324
00:17:51,490 --> 00:17:56,170
यह भी अभी काफी आम तौर पर अच्छा है
आप इसका इस्तेमाल क्योंकि जब याद करने के लिए

325
00:17:56,170 --> 00:17:59,060
तुम चाहते हो सकता है अभी
यह याद है.

326
00:17:59,060 --> 00:18:02,750
वह अपने जीवन को बहुत आसान बना देंगे.

327
00:18:02,750 --> 00:18:04,000
मैं आपके सवाल का जवाब?

328
00:18:04,000 --> 00:18:10,528

329
00:18:10,528 --> 00:18:14,290
>> तो अब, हम एक छोटा सा बात की
पुस्तकालयों के बारे में संक्षेप.

330
00:18:14,290 --> 00:18:18,570
लेकिन दो मुख्य वाले हम किया गया है कि
अब तक पाठ्यक्रम में हैं का उपयोग

331
00:18:18,570 --> 00:18:20,860
मानक मैं / हे और CS50.

332
00:18:20,860 --> 00:18:25,410
चीज़ें किस तरह शामिल हैं
मानक आई / ओ लाइब्रेरी में?

333
00:18:25,410 --> 00:18:28,410
>> हाँ, अब तक हम printf का उपयोग किया है.

334
00:18:28,410 --> 00:18:31,150
CS50 में, हम GetInt का उपयोग किया है
और GetString.

335
00:18:31,150 --> 00:18:37,200
और डेटा प्रकार स्ट्रिंग भी होता है
इस CS50 पुस्तकालय में घोषित किया जाना है.

336
00:18:37,200 --> 00:18:40,250
हम के बारे में गहराई में एक छोटे से अधिक बात करेंगे
कैसे पुस्तकालयों काम करते हैं और कैसे वे

337
00:18:40,250 --> 00:18:41,870
अपने कोड के बाकी के साथ बातचीत.

338
00:18:41,870 --> 00:18:46,220
लेकिन उन दो मुख्य वाले हैं कि हम
अब तक में साथ संपर्क में आ गए हैं

339
00:18:46,220 --> 00:18:48,430
बेशक.

340
00:18:48,430 --> 00:18:50,050
>> प्रकार.

341
00:18:50,050 --> 00:18:58,120
ये कितना याद करने के लिए अच्छा कर रहे हैं
प्रत्येक प्रकार कैसे द्वारा या प्रतिनिधित्व किया है

342
00:18:58,120 --> 00:19:02,840
कई बाइट्स प्रकार के प्रत्येक requires--

343
00:19:02,840 --> 00:19:04,990
पूर्णांक, 4 बाइट्स; चार, 1 बाइट.

344
00:19:04,990 --> 00:19:06,550
फ्लोट 4 बाइट्स है.

345
00:19:06,550 --> 00:19:07,782
एक डबल क्या है?

346
00:19:07,782 --> 00:19:09,032
>> दर्शक: [अश्राव्य].

347
00:19:09,032 --> 00:19:11,398

348
00:19:11,398 --> 00:19:16,240
>> स्पीकर 1: हाँ, तो एक नाव
लेकिन आकार दोगुना.

349
00:19:16,240 --> 00:19:17,150
क्या एक लंबे समय के बारे में?

350
00:19:17,150 --> 00:19:18,400
>> दर्शक: [अश्राव्य].

351
00:19:18,400 --> 00:19:21,614

352
00:19:21,614 --> 00:19:24,680
>> स्पीकर 1: ठीक है.

353
00:19:24,680 --> 00:19:25,410
एक लंबे समय क्या है?

354
00:19:25,410 --> 00:19:26,660
>> दर्शक: [अश्राव्य].

355
00:19:26,660 --> 00:19:29,400

356
00:19:29,400 --> 00:19:31,450
>> स्पीकर 1: हाँ, एक पूर्णांक दोगुना.

357
00:19:31,450 --> 00:19:34,240

358
00:19:34,240 --> 00:19:34,705
हाँ.

359
00:19:34,705 --> 00:19:36,100
>> दर्शक: [अश्राव्य].

360
00:19:36,100 --> 00:19:38,030
>> स्पीकर 1: लंबे [अश्राव्य].

361
00:19:38,030 --> 00:19:41,860
और फिर एक लंबे समय तक कि डबल है.

362
00:19:41,860 --> 00:19:42,814
>> दर्शक: नहीं, नहीं.

363
00:19:42,814 --> 00:19:47,107
एक लंबे समय तक सिर्फ एक पूर्णांक है.

364
00:19:47,107 --> 00:19:50,910
यह वास्तुकला पर निर्भर करता है
पहले [अश्राव्य]

365
00:19:50,910 --> 00:19:52,922
और पूर्णांक में एक ही आकार है.

366
00:19:52,922 --> 00:19:54,172
[अश्राव्य].

367
00:19:54,172 --> 00:19:58,841

368
00:19:58,841 --> 00:20:00,920
>> स्पीकर 1: तो एक लंबे और
एक पूर्णांक ही हैं.

369
00:20:00,920 --> 00:20:02,943
और फिर एक लंबे
डबल पूर्णांक है.

370
00:20:02,943 --> 00:20:03,910
कूल.

371
00:20:03,910 --> 00:20:05,550
और फिर, पिछले प्रकार क्या है?

372
00:20:05,550 --> 00:20:06,510
>> दर्शक: सूचक.

373
00:20:06,510 --> 00:20:10,350
>> स्पीकर 1: हाँ, तो हम सीखा
संकेत के बारे में एक छोटा सा.

374
00:20:10,350 --> 00:20:14,015
और चाहे एक सूचक है क्या की
यह to-- ओर इशारा करते हुए एक चार सितारा हो सकता है

375
00:20:14,015 --> 00:20:15,880
या एक पूर्णांक star--

376
00:20:15,880 --> 00:20:20,530
यह हमेशा एक संकेतक के लिए 4 बाइट्स है.

377
00:20:20,530 --> 00:20:21,633
उस के बारे में प्रश्न?

378
00:20:21,633 --> 00:20:22,116
हाँ?

379
00:20:22,116 --> 00:20:24,531
>> दर्शक: [अश्राव्य]?

380
00:20:24,531 --> 00:20:29,530
>> स्पीकर 1: तो एक लंबी और एक पूर्णांक हैं
इस CS50 उपकरण में एक ही.

381
00:20:29,530 --> 00:20:32,302
>> दर्शक: उपकरण पूरी तरह से कर रहे हैं
विनिमेय.

382
00:20:32,302 --> 00:20:33,510
>> स्पीकर 1: हाँ.

383
00:20:33,510 --> 00:20:36,610
तो फिर एक लंबी लंबी डबल एक पूर्णांक है.

384
00:20:36,610 --> 00:20:39,250
>> दर्शक: यह 32 बिट है?

385
00:20:39,250 --> 00:20:40,620
>> स्पीकर 1: 32 बिट, हाँ.

386
00:20:40,620 --> 00:20:43,572
>> दर्शक: तो [अश्राव्य]?

387
00:20:43,572 --> 00:20:46,790
>> स्पीकर 1: हाँ, अगर यह नहीं है
स्पष्ट रूप से, आप कहते हैं

388
00:20:46,790 --> 00:20:47,870
एक 32 बिट मान लेना चाहिए.

389
00:20:47,870 --> 00:20:50,040
>> दर्शक: यह कुछ कहेंगे
एक संभालने की तरह

390
00:20:50,040 --> 00:20:51,498
उपकरण की तरह वास्तुकला.

391
00:20:51,498 --> 00:20:58,800

392
00:20:58,800 --> 00:21:01,710
64 बिट, केवल बातों के लिए कि
परिवर्तन चाहता है और संकेत दिए गए हैं.

393
00:21:01,710 --> 00:21:05,614
वे दोनों [अश्राव्य].

394
00:21:05,614 --> 00:21:06,590
>> स्पीकर 1: हाँ?

395
00:21:06,590 --> 00:21:07,566
>> दर्शक: प्रश्न.

396
00:21:07,566 --> 00:21:10,982
अभ्यास परीक्षाएँ में से एक पर तो,
यह एक अहस्ताक्षरित पूर्णांक के बारे में पूछता है.

397
00:21:10,982 --> 00:21:15,374
तो कैसे है कि निर्धारित किया जाएगा
एक पूर्णांक [अश्राव्य] से?

398
00:21:15,374 --> 00:21:18,140
>> स्पीकर 1: एक अहस्ताक्षरित
में भी 4 बाइट्स है.

399
00:21:18,140 --> 00:21:21,172
लेकिन एक हस्ताक्षरित बारे में अलग क्या है
पूर्णांक और एक अहस्ताक्षरित int?

400
00:21:21,172 --> 00:21:22,422
>> दर्शक: [अश्राव्य].

401
00:21:22,422 --> 00:21:24,868

402
00:21:24,868 --> 00:21:25,630
>> स्पीकर 1: ठीक है.

403
00:21:25,630 --> 00:21:27,570
एक नकारात्मक मूल्यों का प्रतिनिधित्व कर सकते हैं.

404
00:21:27,570 --> 00:21:28,580
लेकिन कैसे यह है कि क्या करता है?

405
00:21:28,580 --> 00:21:30,536
>> दर्शक: [अश्राव्य].

406
00:21:30,536 --> 00:21:36,370
>> स्पीकर 1: हाँ, यह 1 बचाता है
बिट साइन प्रतिनिधित्व करने के लिए.

407
00:21:36,370 --> 00:21:40,910

408
00:21:40,910 --> 00:21:45,040
हस्ताक्षर किए एक सा है कि
साइन प्रतिनिधित्व करता है.

409
00:21:45,040 --> 00:21:48,886
और अहस्ताक्षरित सिर्फ सभी सकारात्मक है.

410
00:21:48,886 --> 00:21:50,365
>> दर्शक: ठीक है.

411
00:21:50,365 --> 00:21:54,230
तो तुम एक डबल का कहना है कि
एक नाव के दो बार आकार?

412
00:21:54,230 --> 00:21:58,202
>> स्पीकर 1: डबल दो बार है
एक नाव के आकार, हाँ.

413
00:21:58,202 --> 00:22:01,639
>> दर्शक: एक सूचक कैसे करता है
एक करने के लिए लंबे [अश्राव्य]?

414
00:22:01,639 --> 00:22:06,058

415
00:22:06,058 --> 00:22:10,870
>> स्पीकर 1: कैसे करता है तो सवाल यह है
एक लंबे long-- के लिए सूचक

416
00:22:10,870 --> 00:22:13,800
कैसे है कि केवल चार बाइट्स जब है
अपनी 8 बाइट्स एक लंबे.

417
00:22:13,800 --> 00:22:17,310
तो एक सूचक है क्या याद,
अनिवार्य रूप से, बहुत आधार मूल्य पर.

418
00:22:17,310 --> 00:22:19,046
>> दर्शक: [अश्राव्य].

419
00:22:19,046 --> 00:22:22,670
>> स्पीकर 1: हाँ, तो एक सूचक
सिर्फ एक स्मृति स्थान है.

420
00:22:22,670 --> 00:22:28,040
तो यह कितना अंतरिक्ष फर्क नहीं पड़ता
कि सूचक की ओर इशारा कर रहा है.

421
00:22:28,040 --> 00:22:32,060
यह केवल ट्रैक रखने के लिए 4 बाइट्स की जरूरत
कि स्मृति स्थान की.

422
00:22:32,060 --> 00:22:34,760

423
00:22:34,760 --> 00:22:36,010
कोई अन्य प्रश्न?

424
00:22:36,010 --> 00:22:39,800

425
00:22:39,800 --> 00:22:41,050
कूल.

426
00:22:41,050 --> 00:22:42,920

427
00:22:42,920 --> 00:22:47,460
>> तो आखिरी बात मैं है
मानक उत्पादन है.

428
00:22:47,460 --> 00:22:51,020
आप उन्हें बार बार इस्तेमाल करना चाहिए
आप याद कर सकते हैं कि बहुत हो गया.

429
00:22:51,020 --> 00:22:54,800
हम उपयोग लेकिन जब यह है
printf, उदाहरण के लिए.

430
00:22:54,800 --> 00:22:59,260
और हम इन प्लेसहोल्डर है कि
प्रारूप कोड कहा जाता था.

431
00:22:59,260 --> 00:23:03,910
>> तो पूर्णांक के लिए प्रतिशत ग चार, प्रतिशत मैं,
और हम भी प्रतिशत डी का उपयोग कर सकते हैं.

432
00:23:03,910 --> 00:23:05,130
यह एक ही बात है.

433
00:23:05,130 --> 00:23:08,200
लेकिन, आम तौर पर, में CS50 हम
प्रतिशत मैं उपयोग करने के लिए प्रयास करें.

434
00:23:08,200 --> 00:23:09,860
नाव के लिए प्रतिशत च.

435
00:23:09,860 --> 00:23:15,620
लंबे लंबे समय के लिए प्रतिशत एलडी और
स्ट्रिंग के लिए प्रतिशत है.

436
00:23:15,620 --> 00:23:18,550
>> इसी तरह, हम कुछ प्रयोग कर रहे थे
इन भागने दृश्यों की.

437
00:23:18,550 --> 00:23:22,431
उदाहरण के लिए, बैकस्लैश n के लिए नई लाइन के लिए.

438
00:23:22,431 --> 00:23:26,910
यह आपको स्वरूपण रहे हैं के लिए बस है
प्रिंट च के लिए अपने कोड.

439
00:23:26,910 --> 00:23:27,260
हाँ?

440
00:23:27,260 --> 00:23:28,906
>> दर्शक: प्रतिशत घ किस लिए है?

441
00:23:28,906 --> 00:23:31,850
>> स्पीकर 1: तो सवाल
प्रतिशत विकास के लिए क्या है?

442
00:23:31,850 --> 00:23:33,270
प्रतिशत डी ints के लिए है.

443
00:23:33,270 --> 00:23:37,392
प्रतिशत विकास तथा प्रतिशत मैं वही कर रहे हैं.

444
00:23:37,392 --> 00:23:41,130
>> दर्शक: के बीच क्या अंतर है
बैकस्लैश n और बैकस्लैश आर?

445
00:23:41,130 --> 00:23:45,300
>> स्पीकर 1: तो सवाल यह है कि क्या है
प्रतिक्रिया और एन के बीच अंतर

446
00:23:45,300 --> 00:23:48,615
प्रतिक्रिया आर?

447
00:23:48,615 --> 00:23:50,906
मैं बैकस्लैश आर लगता is--

448
00:23:50,906 --> 00:23:54,340
>> दर्शक: तो बैकस्लैश आर बस का तात्पर्य
लाइन की शुरुआत करने के लिए रिटर्न

449
00:23:54,340 --> 00:23:56,670
वास्तव में एक नई लाइन के लिए जा रहा बिना.

450
00:23:56,670 --> 00:24:01,000
तो तुम एक बैकस्लैश आर प्रिंट और आप अगर
लाइन की शुरुआत करने के लिए वापस जाओ

451
00:24:01,000 --> 00:24:04,005
तो आप के ऊपर लिख, अधिक सामान प्रिंट
पर पहले से ही है कि सामान

452
00:24:04,005 --> 00:24:04,390
[अश्राव्य].

453
00:24:04,390 --> 00:24:06,725
जबकि, एन वास्तव में एक नया करने के लिए चला जाता है
लाइन और [अश्राव्य] को जाता है.

454
00:24:06,725 --> 00:24:10,525

455
00:24:10,525 --> 00:24:13,915
>> स्पीकर 1: ठीक है, कोई अन्य प्रश्न?

456
00:24:13,915 --> 00:24:15,430
ठीक है.

457
00:24:15,430 --> 00:24:18,617
मैं करने के लिए इसे बंद हाथ करने के लिए जा रहा हूँ
जारी रहेगा जो दान.

458
00:24:18,617 --> 00:24:25,078
>> [वाहवाही]

459
00:24:25,078 --> 00:25:08,814

460
00:25:08,814 --> 00:25:09,720
>> दान: सभी righty.

461
00:25:09,720 --> 00:25:18,590
तो मैं एक और व्यापक के बारे में बात कर सकता हूँ
कर रहे हैं कि वर्ग से विचारों की श्रृंखला

462
00:25:18,590 --> 00:25:23,220
मोटे तौर पर दो सप्ताह के प्रतिनिधि और
सप्ताह में तीन की शुरुआत से शुरू

463
00:25:23,220 --> 00:25:28,690
का सिर्फ एक रास्ता है जो कास्टिंग, के साथ
एक खास प्रकार का एक मूल्य के रूप में इलाज

464
00:25:28,690 --> 00:25:30,830
एक अलग प्रकार के लिए मूल्य.

465
00:25:30,830 --> 00:25:34,110
तो हम करने के लिए घर का काम के साथ ऐसा कर सकते हैं
ints, ints को तैरता है, और

466
00:25:34,110 --> 00:25:35,360
लंबे समय से चाहता दोगुना करने के लिए.

467
00:25:35,360 --> 00:25:38,170

468
00:25:38,170 --> 00:25:44,500
>> इन सभी बातों के तरीके के रूप में इस्तेमाल किया जा सकता है
कुछ न्यूमेरिक मूल्य के इलाज का

469
00:25:44,500 --> 00:25:48,370
कुछ अन्य के रूप में शून्य से चार
न्यूमेरिक मूल्य.

470
00:25:48,370 --> 00:25:54,480
कुछ मुद्दों पर इस के साथ कर रहे हैं तो
आप डाली जब आता है, जो जाहिर है,

471
00:25:54,480 --> 00:25:57,860
ints के लिए नाव की तरह बातें.

472
00:25:57,860 --> 00:26:00,500
तो यह थोड़ा अजीब है.

473
00:26:00,500 --> 00:26:03,170
हम 1.31 है कि एक नाव है.

474
00:26:03,170 --> 00:26:05,220
हम 10,000 से गुणा.

475
00:26:05,220 --> 00:26:08,380
और फिर हम एक पूर्णांक के रूप में इसे प्रिंट.

476
00:26:08,380 --> 00:26:09,630
इस उत्पादन में क्या करता है?

477
00:26:09,630 --> 00:26:11,600

478
00:26:11,600 --> 00:26:14,020
10,000 बार 1.31.

479
00:26:14,020 --> 00:26:18,761
तो 13,000, अनुमान है कि है?

480
00:26:18,761 --> 00:26:20,685
>> दर्शक: मैं यह 10,000 है.

481
00:26:20,685 --> 00:26:24,234
>> दान: तो मैं 10,000 से गुणा कर रहा हूँ
मैं इसे कास्टिंग रहा हूँ से पहले.

482
00:26:24,234 --> 00:26:25,202
>> दर्शक: ओह.

483
00:26:25,202 --> 00:26:27,622
वहाँ एक 9 नहीं होगा
और कुछ 0 संख्या?

484
00:26:27,622 --> 00:26:29,270
>> दान: तुम कुछ अजीब अंक हो सकता है.

485
00:26:29,270 --> 00:26:32,410

486
00:26:32,410 --> 00:26:37,670
तो सही, यह 1.3 गुना 10,000 है.

487
00:26:37,670 --> 00:26:40,040
इसलिए कि 13,000 है.

488
00:26:40,040 --> 00:26:41,313
और इस अतिरिक्त weird--

489
00:26:41,313 --> 00:26:42,160
>> दर्शक: 13,100.

490
00:26:42,160 --> 00:26:42,650
>> दान: 13,100.

491
00:26:42,650 --> 00:26:44,910
, रोब धन्यवाद.

492
00:26:44,910 --> 00:26:46,610
और इस अतिरिक्त weirdness--

493
00:26:46,610 --> 00:26:48,060
इस 9,9--

494
00:26:48,060 --> 00:26:53,860
बस इस कास्टिंग क्योंकि
समाप्त हुआ नीचे जहां गोलाई

495
00:26:53,860 --> 00:26:55,394
यह नहीं होना चाहिए.

496
00:26:55,394 --> 00:26:55,871
हाँ.

497
00:26:55,871 --> 00:26:58,256
>> दर्शक: कास्टिंग होता है
कुछ और बाद?

498
00:26:58,256 --> 00:27:03,865
>> दान: इसलिए क्योंकि मैं यह प्रिंट में है
यह पहले इस गुणा करता है

499
00:27:03,865 --> 00:27:05,230
इस कास्टिंग करता है.

500
00:27:05,230 --> 00:27:06,140
>> दर्शक: [अश्राव्य].

501
00:27:06,140 --> 00:27:11,350
>> दान: मुझे लगता है कि यह पहले देना होगा लगता है
हाँ, 10,000 जो होगा.

502
00:27:11,350 --> 00:27:12,610
और कुछ?

503
00:27:12,610 --> 00:27:13,330
कूल.

504
00:27:13,330 --> 00:27:16,344
तो यह 13,099 है.

505
00:27:16,344 --> 00:27:17,840
ऐसा क्यों होता है?

506
00:27:17,840 --> 00:27:18,900
अस्पष्टता.

507
00:27:18,900 --> 00:27:21,020
>> तैरता सही नहीं हैं.

508
00:27:21,020 --> 00:27:27,550
वे केवल एक को संख्या का प्रतिनिधित्व कर सकते हैं
महत्वपूर्ण आंकड़े की निश्चित संख्या.

509
00:27:27,550 --> 00:27:35,120
हम पर 8 हस्ताक्षर अंजीर प्रिंट आउट तो अगर
इस नाव, हम एक तरह से मिलता है

510
00:27:35,120 --> 00:27:36,800
बदसूरत दिखने संख्या.

511
00:27:36,800 --> 00:27:45,580
और वह है क्योंकि 1.31 सही ढंग से नहीं कर सकते
सरल द्वारा प्रतिनिधित्व किया

512
00:27:45,580 --> 00:27:49,000
मशीन में दो की शक्तियों.

513
00:27:49,000 --> 00:27:53,530
यह निकटतम लेने को समाप्त होता है तो
जो समाप्त होता है, लगता है

514
00:27:53,530 --> 00:27:55,710
एक छोटे से कम किया जा रहा है.

515
00:27:55,710 --> 00:27:57,730
भावना करें?

516
00:27:57,730 --> 00:27:59,110
ठीक है.

517
00:27:59,110 --> 00:28:05,840
>> अब, स्विच का एक अलग तरीका है
सशर्त बयान जहां सब कर

518
00:28:05,840 --> 00:28:09,900
हम एक एकल चर रहा है के बारे में परवाह है.

519
00:28:09,900 --> 00:28:16,570
तो इस विशेष उदाहरण में, हम कर रहे हैं
उपयोगकर्ता से एक पूर्णांक हो रही है.

520
00:28:16,570 --> 00:28:21,070
और फिर हम देख रहे हैं
कि पूर्णांक है क्या.

521
00:28:21,070 --> 00:28:23,500
मुमकिन है, यह नंबर
एक और चार के बीच.

522
00:28:23,500 --> 00:28:24,800
यही कारण है कि हम के लिए पूछ रहे हैं.

523
00:28:24,800 --> 00:28:28,450
>> तो आप में से एक स्विच करना
चर नाम.

524
00:28:28,450 --> 00:28:34,290
तो फिर तुम संभव के मामलों की स्थापना
यह हो सकता है मूल्यों.

525
00:28:34,290 --> 00:28:37,730
तो एक मामला है, यह कम है कहना.

526
00:28:37,730 --> 00:28:41,080
और फिर तुम बाहर निकलना तोड़
स्विच हालत की तो

527
00:28:41,080 --> 00:28:43,270
तुम जा रहा रखने के लिए नहीं है.

528
00:28:43,270 --> 00:28:44,830
>> अगले case-- में

529
00:28:44,830 --> 00:28:46,940
इसलिए मामले में दो और मामले three--

530
00:28:46,940 --> 00:28:51,920
यह मामला दो अगर यह सिर्फ करने के लिए नीचे चला जाता है
इसके साथ के रूप में देखता कोड की पहली पंक्ति

531
00:28:51,920 --> 00:28:55,400
यह एक ब्रेक देखता है जब तक तीन मामले.

532
00:28:55,400 --> 00:29:00,430
तो कारण आप को मामले एक मिल
केवल प्रिंट कम है क्योंकि मैं

533
00:29:00,430 --> 00:29:01,890
यहाँ इस तोड़ दिया है.

534
00:29:01,890 --> 00:29:05,360
मैं तो, कहते हैं, इस break-- नजरअंदाज कर दिया
मैं इस breakaway-- फेंक दिया अगर

535
00:29:05,360 --> 00:29:09,740
यह कम प्रिंट होगा, और फिर यह होगा
मध्य प्रिंट, और फिर यह टूट जाएगा.

536
00:29:09,740 --> 00:29:12,200
>> टूट के एक महत्वपूर्ण हिस्सा हैं तो
की शर्तों को स्विच और

537
00:29:12,200 --> 00:29:14,340
वे वहाँ होना चाहिए.

538
00:29:14,340 --> 00:29:20,070
स्पष्ट रूप से कहा नहीं कर रहे हैं कि किसी भी मामले
डिफ़ॉल्ट रूप से नियंत्रित किया जाता है

539
00:29:20,070 --> 00:29:26,645
और स्विच में मामला डाली जानी चाहिए.

540
00:29:26,645 --> 00:29:31,363
>> दर्शक: तो 1, 2, 3,
और 4 N होगा?

541
00:29:31,363 --> 00:29:33,310
>> दान: n हो सकता है कि मूल्यों.

542
00:29:33,310 --> 00:29:34,654
हाँ.

543
00:29:34,654 --> 00:29:35,146
हाँ?

544
00:29:35,146 --> 00:29:37,606
>> दर्शक: तो तुम जब
[अश्राव्य] कि?

545
00:29:37,606 --> 00:29:44,002

546
00:29:44,002 --> 00:29:46,830
>> दान: तुम तो कम प्रिंट, और होता
यह मध्यम प्रिंट, और होता

547
00:29:46,830 --> 00:29:47,400
फिर यह टूट जाएगा.

548
00:29:47,400 --> 00:29:50,244
>> दर्शक: क्यों यह प्रिंट होगा
बीच अगर [अश्राव्य]?

549
00:29:50,244 --> 00:29:54,036

550
00:29:54,036 --> 00:30:00,550
>> दान: एक मामले के तहत तो सब कुछ
एक ब्रेक के अंतर्गत आती है पहले.

551
00:30:00,550 --> 00:30:09,390
इसलिए मामले एक प्रिंट के नीचे मामला है
के रूप में एक यह निम्नलिखित प्रिंट है.

552
00:30:09,390 --> 00:30:09,890
हाँ?

553
00:30:09,890 --> 00:30:11,140
>> दर्शक: [अश्राव्य]?

554
00:30:11,140 --> 00:30:15,890

555
00:30:15,890 --> 00:30:22,170
>> दान: तो यह संख्या सिर्फ एक विशेष है
मूल्य कि इस चर

556
00:30:22,170 --> 00:30:23,420
ठीक है, ले जा सकते हैं?

557
00:30:23,420 --> 00:30:26,740

558
00:30:26,740 --> 00:30:28,490
कि मतलब?

559
00:30:28,490 --> 00:30:28,990
हाँ.

560
00:30:28,990 --> 00:30:31,490
>> दर्शक: [अश्राव्य]?

561
00:30:31,490 --> 00:30:34,130
>> दान: हाँ, मामला दो प्रिंट होगा
मध्यम और फिर टूट गया.

562
00:30:34,130 --> 00:30:35,380
>> दर्शक: [अश्राव्य]?

563
00:30:35,380 --> 00:30:37,954

564
00:30:37,954 --> 00:30:40,050
>> Dan: मैं किसी भी लगता है?

565
00:30:40,050 --> 00:30:43,855
क्या अन्य डेटा प्रकार
आप पर स्विच कर सकते हैं?

566
00:30:43,855 --> 00:30:46,320
>> दर्शक: आप बदल सकते हैं
किसी भी डेटा से अधिक प्रकार के.

567
00:30:46,320 --> 00:30:50,905
लेकिन यह केवल घर का काम अधिक कुछ भी मतलब
और ints और इस तरह से सामान, क्योंकि

568
00:30:50,905 --> 00:30:55,600
आप एक सूचक पर स्विच कर रहे हैं
कि वास्तव में, मतलब नहीं है

569
00:30:55,600 --> 00:30:59,555
यह भी चलो, तो भार पर स्विच
आप क्योंकि चल बिन्दु का ऐसा

570
00:30:59,555 --> 00:31:02,840
परिशुद्धता में, आप वास्तव में नहीं होता
वैसे भी करना चाहते हैं.

571
00:31:02,840 --> 00:31:07,320
इसलिए बहुत ज्यादा, बस ints और
लगता है कि जैसे घर का काम और सामान.

572
00:31:07,320 --> 00:31:12,360
>> दान: आप स्पष्ट है जब हाँ, यह बात है
तुम्हें पता है मानों कि, मुझे लगता है, हो सकता है

573
00:31:12,360 --> 00:31:14,250
एक स्विच है कि वास्तव में उपयोगी है.

574
00:31:14,250 --> 00:31:17,094

575
00:31:17,094 --> 00:31:18,990
अच्छा है?

576
00:31:18,990 --> 00:31:21,370
ठीक है.

577
00:31:21,370 --> 00:31:26,180
>> स्कोप एक घोषित कि सीमा है
चर फैली हुई है.

578
00:31:26,180 --> 00:31:32,190
मेरे पास कोड के इस छोटे से हिस्सा में तो,
यह त्रुटियों से भरा होगा.

579
00:31:32,190 --> 00:31:41,450
और कारण है कि मैं इस पूर्णांक घोषित किया जाता है
मैं पाश के लिए इस के दायरे के भीतर.

580
00:31:41,450 --> 00:31:46,390
और फिर मैं उस संदर्भ की कोशिश कर रहा हूँ
मैं पाश क्षेत्र के लिए उस के बाहर.

581
00:31:46,390 --> 00:31:50,330
>> तो बुनियादी तौर पर, आप गुंजाइश के बारे में सोच सकते हैं
आप घोषणा कि कुछ के रूप में

582
00:31:50,330 --> 00:31:59,750
घुंघराले ब्रेसिज़ के एक सेट के अंदर के साथ ही
उन घुंघराले ब्रेसिज़ के भीतर मौजूद है.

583
00:31:59,750 --> 00:32:04,990
और आप कोशिश करते हैं और कि चर का उपयोग करें
उन घुंघराले ब्रेसिज़ के बाहर, तुम हूँ

584
00:32:04,990 --> 00:32:08,356
संकलक से कोई त्रुटि मिलती है.

585
00:32:08,356 --> 00:32:08,812
हाँ?

586
00:32:08,812 --> 00:32:09,724
>> दर्शक: तो यह एक काम नहीं करता है?

587
00:32:09,724 --> 00:32:11,790
>> दान: यह हाँ, काम नहीं करता है.

588
00:32:11,790 --> 00:32:17,190

589
00:32:17,190 --> 00:32:18,660
स्ट्रिंग्स.

590
00:32:18,660 --> 00:32:19,780
स्ट्रिंग एक चार *.

591
00:32:19,780 --> 00:32:22,250
वे वही कर रहे हैं.

592
00:32:22,250 --> 00:32:25,540
वे सिर्फ पात्रों को संकेत दिए गए हैं.

593
00:32:25,540 --> 00:32:33,000
और आप हैं कि किसी भी तार समाप्त होना चाहिए
बस जो बैकस्लैश शून्य, साथ

594
00:32:33,000 --> 00:32:34,410
एक सी कन्वेंशन.

595
00:32:34,410 --> 00:32:36,680
>> यह अशक्त टर्मिनेटर कहा जाता है.

596
00:32:36,680 --> 00:32:39,050
और NULL--

597
00:32:39,050 --> 00:32:41,670
राजधानी एन, राजधानी यू, राजधानी
एल, राजधानी L--

598
00:32:41,670 --> 00:32:44,290
के रूप में ही नहीं है
नल टर्मिनेटर.

599
00:32:44,290 --> 00:32:46,640
यह एक संकेत है.

600
00:32:46,640 --> 00:32:48,280
यह एक चरित्र है.

601
00:32:48,280 --> 00:32:49,530
वे बहुत अलग हैं.

602
00:32:49,530 --> 00:32:50,200
यह याद रखें.

603
00:32:50,200 --> 00:32:52,320
यह शायद, प्रश्नोत्तरी पर होगा.

604
00:32:52,320 --> 00:32:54,040
मैं प्रश्नोत्तरी नहीं देखा है.

605
00:32:54,040 --> 00:32:57,880

606
00:32:57,880 --> 00:32:58,840
हाँ?

607
00:32:58,840 --> 00:33:01,232
>> दर्शक: तो नल सूचक है, कहते हैं, है ना?

608
00:33:01,232 --> 00:33:01,995
>> दान: हाँ.

609
00:33:01,995 --> 00:33:05,170
>> दर्शक: क्या [अश्राव्य] करता है?

610
00:33:05,170 --> 00:33:10,050
>> दान:, कहते हैं, malloc कहा जाता है जब आप
प्राप्त करने के लिए पर्याप्त स्मृति नहीं है

611
00:33:10,050 --> 00:33:14,400
जो कुछ भी आप के लिए पूछ रहे हैं आकार,
malloc नल वापसी करेंगे.

612
00:33:14,400 --> 00:33:19,550
एक समारोह में जब भी यह मूल रूप से है
एक सूचक वापस करने के लिए माना जाता है, आप

613
00:33:19,550 --> 00:33:22,600
नल क्योंकि खिलाफ जांच की जरूरत
नल एक सुंदर good-- है

614
00:33:22,600 --> 00:33:25,260
यह है, की तरह, कचरा मूल्य है.

615
00:33:25,260 --> 00:33:27,050
यह जहाँ तक संकेत दिए जाने के रूप में एक शून्य है.

616
00:33:27,050 --> 00:33:29,630

617
00:33:29,630 --> 00:33:32,250
>> जब भी आप एक समारोह कॉल,
कि एक सूचक देता है.

618
00:33:32,250 --> 00:33:35,960
आप होना जाँच करना चाहते करने जा रहे हैं
कि सूचक नल नहीं है कि

619
00:33:35,960 --> 00:33:37,760
नल बहुत आम है.

620
00:33:37,760 --> 00:33:40,160
यह एक कचरा वापसी की तरह है.

621
00:33:40,160 --> 00:33:44,902
कुछ सही नहीं गया था तो, अगर
बस के बजाय रिक्त वापसी.

622
00:33:44,902 --> 00:33:45,898
>> दर्शक: [अश्राव्य]?

623
00:33:45,898 --> 00:33:48,922
>> दान: हाँ, और कहा कि यह है.

624
00:33:48,922 --> 00:33:51,750
>> दर्शक: [अश्राव्य]?

625
00:33:51,750 --> 00:33:52,800
>> दान: इस रूप में यह जादू.

626
00:33:52,800 --> 00:33:54,150
यह अशक्त टर्मिनेटर है.

627
00:33:54,150 --> 00:33:56,560
यह छोटा अक्षर एन यू एल एल यदि है
आप यह वर्तनी रहे हैं.

628
00:33:56,560 --> 00:33:59,860
>> दर्शक: और मैं बस चला गया
पीठ और यह परीक्षण किया गया.

629
00:33:59,860 --> 00:34:03,010
और अगर आप एक चल बिन्दु डाल करने की कोशिश
एक स्विच में मूल्य, यह तुम पर चिल्लाना हूँ

630
00:34:03,010 --> 00:34:05,916
कह, बयान अभिव्यक्ति की आवश्यकता
पूर्णांक प्रकार की.

631
00:34:05,916 --> 00:34:07,166
>> दान: वहाँ तुम जाओ.

632
00:34:07,166 --> 00:34:09,639

633
00:34:09,639 --> 00:34:12,246
लेकिन हाँ, प्रश्न फिर क्या था?

634
00:34:12,246 --> 00:34:13,496
>> दर्शक: [अश्राव्य]?

635
00:34:13,496 --> 00:34:16,150

636
00:34:16,150 --> 00:34:23,679
>> दान: तो राजधानी एन, राजधानी यू, राजधानी
एल, राजधानी एल एक वास्तविक सी बात है.

637
00:34:23,679 --> 00:34:29,719
यह शून्य सूचक है और होगा
केवल इस तरह के रूप में व्यवहार किया.

638
00:34:29,719 --> 00:34:33,530
आप कभी कोशिश और जादू नहीं होगा
रिक्त चरित्र और किसी भी देखते हैं

639
00:34:33,530 --> 00:34:35,630
इस के अलावा अन्य तरीका है.

640
00:34:35,630 --> 00:34:36,610
हाँ?

641
00:34:36,610 --> 00:34:42,490
>> दर्शक: तो अधिकतम चार लौटने या
नोट में कुछ है, यह होगा

642
00:34:42,490 --> 00:34:43,960
एक ही समारोह में अवतार लेना
[अश्राव्य] के रूप में?

643
00:34:43,960 --> 00:34:50,655

644
00:34:50,655 --> 00:34:54,949
>> दर्शक: तो आप की बात कर रहे हैं
getchar से चार अधिकतम लौटने, या

645
00:34:54,949 --> 00:34:55,444
जो कुछ भी यह है?

646
00:34:55,444 --> 00:34:55,940
>> दर्शक: हाँ.

647
00:34:55,940 --> 00:34:58,620
>> दर्शक: हाँ, सामान्य तो
उन सभी बातों के लिए अवधि

648
00:34:58,620 --> 00:34:59,920
प्रहरी मान रहे हैं.

649
00:34:59,920 --> 00:35:03,640
तो GetInt से पूर्णांक अधिकतम लौटने की तरह
और getchar से चार मैक्स, यह है

650
00:35:03,640 --> 00:35:06,010
अगर, सब ठीक है, की तरह होना चाहिए
इन बातों को, हमारे लिए लौट रहे हैं

651
00:35:06,010 --> 00:35:07,210
कुछ गलत हो गया.

652
00:35:07,210 --> 00:35:09,950
>> संकेत के लिए, हम बस के लिए होता है
इस प्रहरी मूल्य कि हर कोई

653
00:35:09,950 --> 00:35:10,750
पर सहमत हैं.

654
00:35:10,750 --> 00:35:13,210
और यह आपके लौटने की बात है
कोई बात बिगड़ जाए जब.

655
00:35:13,210 --> 00:35:15,910
तो चार अधिकतम हम प्रयोग कर रहे हैं क्या है
कुछ का प्रतिनिधित्व करने के लिए

656
00:35:15,910 --> 00:35:18,100
अशक्त या getchar की तरह.

657
00:35:18,100 --> 00:35:23,420
>> दर्शक: आप getchar का परीक्षण कर रहे हैं तो,
तुम सिर्फ रिक्त डाल सकता है?

658
00:35:23,420 --> 00:35:23,910
कि एक फर्क होता?

659
00:35:23,910 --> 00:35:25,400
>> दान: तुम सिर्फ रिक्त जाँच नहीं कर सका.

660
00:35:25,400 --> 00:35:30,130
आप क्योंकि चार मैक्स की जांच करने के लिए होगा
समारोह से वापसी मान है

661
00:35:30,130 --> 00:35:35,416
एक चरित्र नहीं एक सूचक.

662
00:35:35,416 --> 00:35:35,888
हाँ?

663
00:35:35,888 --> 00:35:38,248
>> दर्शक: इस सवाल पूछता है
स्ट्रिंग की लंबाई के लिए.

664
00:35:38,248 --> 00:35:40,136
रिक्त चरित्र शामिल करता है?

665
00:35:40,136 --> 00:35:41,000
>> दान: नहीं

666
00:35:41,000 --> 00:35:45,930
और वह कैसे स्ट्रिंग लंबाई वास्तव में है
इसके माध्यम से चला जाता है क्योंकि रोकने के लिए जानता है

667
00:35:45,930 --> 00:35:49,070
वर्ण के अपने सरणी तक
यह एक रिक्त चरित्र देखता है.

668
00:35:49,070 --> 00:35:51,030
और फिर यह सब की तरह है,
ठीक है, मैं काम कर रहा हूँ.

669
00:35:51,030 --> 00:35:52,130
>> दर्शक: [अश्राव्य] पाँच?

670
00:35:52,130 --> 00:35:53,990
>> दान: हैलो पाँच होगा.

671
00:35:53,990 --> 00:35:55,240
हां.

672
00:35:55,240 --> 00:35:59,580

673
00:35:59,580 --> 00:36:02,880
तो सरणियों लगातार कर रहे हैं
स्मृति के ब्लॉक.

674
00:36:02,880 --> 00:36:08,480
वे कह कर तुरंत उपयोग कर सकते है
घुंघराले में, सरणी का नाम और उसके बाद

675
00:36:08,480 --> 00:36:16,720
आप जाना चाहते हैं जो कुछ भी सूचकांक ब्रेसिज़,
, वे के माध्यम से शून्य से अनुक्रमित रहे हैं करने के लिए

676
00:36:16,720 --> 00:36:20,100
1 शून्य से सरणी की लंबाई.

677
00:36:20,100 --> 00:36:23,070
>> और वे के प्रकार से घोषित कर रहे हैं
आप में भंडारण कर रहे हैं कि बात

678
00:36:23,070 --> 00:36:29,750
सरणी, सरणी के नाम, और उसके बाद
जो आकार है कि सरणी की है.

679
00:36:29,750 --> 00:36:36,660
तो इस लंबाई का एक चार सरणी है
इन मूल्यों है कि छह.

680
00:36:36,660 --> 00:36:42,050

681
00:36:42,050 --> 00:36:42,700
हाँ?

682
00:36:42,700 --> 00:36:43,950
>> दर्शक: [अश्राव्य]?

683
00:36:43,950 --> 00:36:47,980

684
00:36:47,980 --> 00:36:48,460
>> दान: हाँ.

685
00:36:48,460 --> 00:36:51,340
>> दर्शक: [अश्राव्य]?

686
00:36:51,340 --> 00:36:56,700
>> दान: तुम क्या हो रहा है है
सरणी में पहले से ही बनाया है.

687
00:36:56,700 --> 00:37:02,260
तो आप के बजाय यह निर्दिष्ट कर सकता है, के रूप में
का कहना है कि, चार, जो कुछ नाम आपके

688
00:37:02,260 --> 00:37:12,200
सरणी खाली कोष्ठक घुंघराले बराबर होती है,
एच अल्पविराम ई अल्पविराम एल अल्पविराम एल अल्पविराम ब्रेस

689
00:37:12,200 --> 00:37:16,290
हे अल्पविराम रिक्त चरित्र
और घुंघराले ब्रेस.

690
00:37:16,290 --> 00:37:18,180
वह भी एक घोषणा के रूप में काम करेगा.

691
00:37:18,180 --> 00:37:20,886
>> दर्शक: [अश्राव्य]?

692
00:37:20,886 --> 00:37:23,110
>> दान: फिर आप की जरूरत है
आकार पहले से ही बनाया है.

693
00:37:23,110 --> 00:37:23,896
>> दर्शक: [अश्राव्य]?

694
00:37:23,896 --> 00:37:25,146
>> दान: हाँ.

695
00:37:25,146 --> 00:37:30,114

696
00:37:30,114 --> 00:37:32,420
सभी righty.

697
00:37:32,420 --> 00:37:36,430
कमांड लाइन तर्क का एक तरीका है
उपयोगकर्ता के रूप से निवेश हो रहा

698
00:37:36,430 --> 00:37:39,380
मुख्य तर्क.

699
00:37:39,380 --> 00:37:40,600
मुख्य दो तर्क लेता है.

700
00:37:40,600 --> 00:37:47,680
जा रहा है कि तर्क की संख्या
आदेश पंक्ति और एक साथ पारित

701
00:37:47,680 --> 00:37:55,340
स्ट्रिंग वेक्टर या एक स्ट्रिंग सरणी
तर्कों का सभी का.

702
00:37:55,340 --> 00:38:07,840
>> इसलिए मुझे लगता है, कहते हैं, इस तरह के रूप में एक समारोह में कहा कि अगर
1 अंतरिक्ष, 2 अंतरिक्ष, तीन बाहर एक बिंदी,

703
00:38:07,840 --> 00:38:10,110
argc 4 होगा.

704
00:38:10,110 --> 00:38:17,370
और argv 0 बाहर एक डॉट होगा.

705
00:38:17,370 --> 00:38:19,130
Argv1 1 होगा.

706
00:38:19,130 --> 00:38:23,030
argv2 2 argv3 होगा होगा
3, कि विशेष मामले में.

707
00:38:23,030 --> 00:38:23,310
हाँ?

708
00:38:23,310 --> 00:38:25,400
>> दर्शक: [अश्राव्य]?

709
00:38:25,400 --> 00:38:34,010
>> दान: सरणी में पिछले तत्व
सरणी लंबाई argc है क्योंकि प्लस

710
00:38:34,010 --> 00:38:41,050
ARGB में से एक, पिछले तत्व
नल सूचक है.

711
00:38:41,050 --> 00:38:42,580
यह argc प्लस 1 है.

712
00:38:42,580 --> 00:38:46,210

713
00:38:46,210 --> 00:38:52,150
मैं सिर्फ यह कहा कि मामले में तो
0 argv जाएगी बाहर एक डॉट है.

714
00:38:52,150 --> 00:38:56,330
argv 1 1 argv2 3 3 2 argv है.

715
00:38:56,330 --> 00:39:03,490
एक बड़ा है जो argv 4,
argc से रिक्त हो जाएगा.

716
00:39:03,490 --> 00:39:04,870
>> और वह नल सूचक है.

717
00:39:04,870 --> 00:39:06,590
हाँ.

718
00:39:06,590 --> 00:39:11,250
स्ट्रिंग है क्योंकि और वह है
एक चार सितारा एक सूचक है.

719
00:39:11,250 --> 00:39:14,102
तो यह एक ही प्रकार हो गया है.

720
00:39:14,102 --> 00:39:14,595
हाँ?

721
00:39:14,595 --> 00:39:16,074
>> दर्शक: दो सवाल.

722
00:39:16,074 --> 00:39:21,004
एक तो, अंतर के बीच क्या है
एक प्रकार से अन्य यह और GetString

723
00:39:21,004 --> 00:39:22,483
उपयोगकर्ता इंजन में?

724
00:39:22,483 --> 00:39:25,934
और दो, यह भीतर संग्रहीत किया जाता है
अपनी हाल की स्मृति?

725
00:39:25,934 --> 00:39:28,399
तो इस तरह के GetString होगा
[अश्राव्य] हो?

726
00:39:28,399 --> 00:39:31,357

727
00:39:31,357 --> 00:39:33,650
>> दान: जहाँ यह संग्रहीत किया जाता है?

728
00:39:33,650 --> 00:39:34,905
यह संग्रह किया गया है, जहां मैं नहीं जानता.

729
00:39:34,905 --> 00:39:40,000
>> दर्शक: तो, वास्तव में, आप कैसे किसी भी पता
आप यह तर्क है कॉल समारोह

730
00:39:40,000 --> 00:39:42,170
ढेर में जमा हो जाती है?

731
00:39:42,170 --> 00:39:46,610
तो argc और argv तर्क मुख्य करने के लिए कर रहे हैं
और वे ढेर पर हैं, या वास्तव में

732
00:39:46,610 --> 00:39:49,131
बस के रूप में आप क्या सोचते हैं ऊपर
ढेर की शुरुआत.

733
00:39:49,131 --> 00:39:53,490
अन्य हिस्सा क्या था
प्रश्न का?

734
00:39:53,490 --> 00:39:56,821
>> दर्शक: तो क्या [अश्राव्य]?

735
00:39:56,821 --> 00:40:00,990
>> दान: हाँ, यह सिर्फ एक अलग तरीका है
के उपयोगकर्ता से इनपुट हो रही है.

736
00:40:00,990 --> 00:40:06,030
यह एक थोड़ा और अधिक कुशल और
यह स्क्रिप्ट के लिए handier है क्योंकि आप

737
00:40:06,030 --> 00:40:10,070
बस अपने मुख्य तर्क पारित कर सकते हैं
समारोह बल्कि प्रतीक्षा करने के लिए होने से

738
00:40:10,070 --> 00:40:13,400
उपयोगकर्ताओं के लिए आप किसी भी उपयोगकर्ताओं को नहीं है.

739
00:40:13,400 --> 00:40:16,280
>> दर्शक: और हाँ, तार मिल
[अश्राव्य] होगा.

740
00:40:16,280 --> 00:40:17,922
यह आप की जरूरत के सामान की दुकान होगी.

741
00:40:17,922 --> 00:40:18,834
>> दान: हाँ?

742
00:40:18,834 --> 00:40:21,114
>> दर्शक: [अश्राव्य]?

743
00:40:21,114 --> 00:40:27,545
>> दान: हाँ, argv 0 हमेशा शामिल
डॉट समारोह कॉल के स्लेश.

744
00:40:27,545 --> 00:40:28,042
हाँ?

745
00:40:28,042 --> 00:40:29,292
>> दर्शक: [अश्राव्य]?

746
00:40:29,292 --> 00:40:33,509

747
00:40:33,509 --> 00:40:37,310
>> दान: हाँ, तर्कों के प्रत्येक रहे हैं
रिक्त चरित्र में समाप्त हो गया है क्योंकि वे

748
00:40:37,310 --> 00:40:38,310
तार कर रहे हैं.

749
00:40:38,310 --> 00:40:40,892
>> दर्शक: [अश्राव्य]?

750
00:40:40,892 --> 00:40:44,116
>> दान: हाँ, argv argc एक शून्य सूचक है.

751
00:40:44,116 --> 00:40:45,112
>> दर्शक: [अश्राव्य]?

752
00:40:45,112 --> 00:40:47,104
>> दान: ओह, हाँ.

753
00:40:47,104 --> 00:40:48,100
हाँ, माफ करना.

754
00:40:48,100 --> 00:40:49,594
>> दर्शक: तो [अश्राव्य]?

755
00:40:49,594 --> 00:41:08,518

756
00:41:08,518 --> 00:41:16,340
>> दान: तुम था अगर सवाल है तो
कमांड लाइन डॉट, 2, 1 बाहर एक डॉट स्लेश

757
00:41:16,340 --> 00:41:20,410
होता कमांड लाइन की संख्या
तर्क दो हो या यह तीन हो सकता है?

758
00:41:20,410 --> 00:41:24,420

759
00:41:24,420 --> 00:41:28,240
>> दर्शक: मैं यह नहीं करता है लगता है
सच बात.

760
00:41:28,240 --> 00:41:31,370
मैं ओह, आप पारित नहीं किया था, कहने के लिए करते हैं
जब किसी भी कमांड लाइन तर्क,

761
00:41:31,370 --> 00:41:32,730
जाहिर है, आप समारोह में कहा.

762
00:41:32,730 --> 00:41:37,950
इसलिए मैं शब्दो में बाहर करने के लिए करते हैं
कमांड लाइन से समारोह

763
00:41:37,950 --> 00:41:40,350
यह भले ही तर्क
argv में शामिल थे.

764
00:41:40,350 --> 00:41:42,600
>> दान: लेकिन यह test-- पर था

765
00:41:42,600 --> 00:41:46,550
yeah-- और भी आप कुछ कहना अगर
argc 3 बराबर होती है जैसे,

766
00:41:46,550 --> 00:41:48,512
आप सुरक्षित खड़े रहे.

767
00:41:48,512 --> 00:41:49,416
हाँ?

768
00:41:49,416 --> 00:41:50,666
>> दर्शक: [अश्राव्य]?

769
00:41:50,666 --> 00:42:00,990

770
00:42:00,990 --> 00:42:09,510
>> Dan: मैं तो बजाय इस फोन के बारे में सोच
argc और स्ट्रिंग argv कोष्ठक में

771
00:42:09,510 --> 00:42:14,350
लेकिन एक ही प्रकार रखा और अभी फोन
एक तरह अलग उन्हें कुछ

772
00:42:14,350 --> 00:42:16,640
और बी, यह अभी भी काम करेगा?

773
00:42:16,640 --> 00:42:18,790
और यह अभी भी काम करेगा,
आप just-- होगा

774
00:42:18,790 --> 00:42:21,520
बजाय argc-- का उपयोग करने का
आप ए और बी का उपयोग होता.

775
00:42:21,520 --> 00:42:24,436

776
00:42:24,436 --> 00:42:25,408
हाँ?

777
00:42:25,408 --> 00:42:26,658
>> दर्शक: [अश्राव्य]?

778
00:42:26,658 --> 00:42:34,642

779
00:42:34,642 --> 00:42:38,850
>> दान: तो सवाल GetString है
ढेर में स्मृति की दुकान के लिए जा रहा

780
00:42:38,850 --> 00:42:42,280
GetString चार है क्योंकि *.

781
00:42:42,280 --> 00:42:47,530
यह क्योंकि ढेर में स्मृति भंडार
वास्तविक भीतर अब malloc कॉल

782
00:42:47,530 --> 00:42:49,258
GetString का कार्यान्वयन.

783
00:42:49,258 --> 00:42:53,210

784
00:42:53,210 --> 00:42:55,090
ठीक है, पर चलती है.

785
00:42:55,090 --> 00:42:55,950
>> सुरक्षा.

786
00:42:55,950 --> 00:43:01,090
इसलिए सही मायने में सुरक्षित होने के लिए, यदि आप कोई पर भरोसा
एक और आप किसी को कोई भी उपयोग की अनुमति

787
00:43:01,090 --> 00:43:04,540
आपकी जानकारी के जो क्यों है
हर कोई अपने ही मशीनों बनाता है

788
00:43:04,540 --> 00:43:09,580
अपने खुद के ऑपरेटिंग सिस्टम, अपने सभी
खरोंच से कार्यक्रम, और जाहिर है

789
00:43:09,580 --> 00:43:13,410
किसी भी अन्य मशीनों से कनेक्ट नहीं है
इंटरनेट के माध्यम से.

790
00:43:13,410 --> 00:43:17,350
तो कंप्यूटर असुरक्षित हैं.

791
00:43:17,350 --> 00:43:19,200
वे वास्तव में हैं.

792
00:43:19,200 --> 00:43:20,940
हम अन्य लोगों पर भरोसा करना होगा.

793
00:43:20,940 --> 00:43:26,500
>> और सुरक्षा के विचार आप कर रहे हैं वह यह है कि
की राशि को सीमित करने की कोशिश कर रहा

794
00:43:26,500 --> 00:43:27,540
जरूरत है कि आप पर भरोसा है.

795
00:43:27,540 --> 00:43:32,080
और इसका मतलब है की एक तुम हो कि
क्रिप्टोग्राफी के माध्यम से है.

796
00:43:32,080 --> 00:43:34,950
क्रिप्टोग्राफी, अनिवार्य रूप से, है
हम रहस्य है.

797
00:43:34,950 --> 00:43:38,880
>> कभी कभी हम अपने रहस्यों को पारित करने के लिए है
साथ के माध्यम से, कहते हैं, इंटरनेट या

798
00:43:38,880 --> 00:43:39,980
अन्य बातों के.

799
00:43:39,980 --> 00:43:43,180
और हम लोग नहीं चाहते हैं
इन रहस्यों को जानने के लिए.

800
00:43:43,180 --> 00:43:50,100
इसलिए हम एक रास्ता में हमारे रहस्यों को एनक्रिप्ट
कि हम कोई भी समझ सकता है उम्मीद है.

801
00:43:50,100 --> 00:43:51,600
>> इसलिए हम used--

802
00:43:51,600 --> 00:43:54,340
इस class-- के पाठ्यक्रम के माध्यम से

803
00:43:54,340 --> 00:44:00,750
सीज़र सिफर तरह बातें और
दोनों बहुत, बहुत हैं जो [अश्राव्य],

804
00:44:00,750 --> 00:44:03,200
बातें encrypting के असुरक्षित तरीके.

805
00:44:03,200 --> 00:44:07,930
वे यह पता लगाने के लिए आसान कर रहे हैं क्या वे
कर रहे हैं और अपने रहस्य क्या हैं.

806
00:44:07,930 --> 00:44:12,130
असली दुनिया और अधिक का उपयोग करता है
जटिल एन्क्रिप्शन योजनाओं.

807
00:44:12,130 --> 00:44:13,880
और हम में नहीं मिलेगा
कि अधिक से अधिक.

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> डिबगिंग.

810
00:44:19,430 --> 00:44:20,785
GDB सबसे अच्छा है.

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
मैं फिर से इस तनाव के लिए जा रहा हूँ.

813
00:44:25,810 --> 00:44:30,920
GDB हर समय हर प्रयोग करें
समय आप एक समस्या है.

814
00:44:30,920 --> 00:44:36,030
GDB में उपयोगी होते हैं कि कमानों हैं
आप एक पंक्ति या तो पारित, जो तोड़

815
00:44:36,030 --> 00:44:41,330
नंबर एक समारोह का नाम अनिवार्य रूप से
जहां अपने कोड में आप बंद करना चाहते हैं,

816
00:44:41,330 --> 00:44:45,600
और नियंत्रण लेने में सक्षम हो.

817
00:44:45,600 --> 00:44:54,140
>> प्रिंट एक चर लेता है और बाहर प्रिंट
कि चर उस पर जो भी है

818
00:44:54,140 --> 00:44:55,990
अपने निष्पादन में बिंदु.

819
00:44:55,990 --> 00:45:00,130
अगले अपने निष्पादन चालें
एक कदम के साथ.

820
00:45:00,130 --> 00:45:05,050
और एक समारोह के अंदर कदम कदम
अपने निष्पादन में.

821
00:45:05,050 --> 00:45:10,480
>> अन्य चीजें कैसे है जो, चलाए जा रहे हैं
आप वास्तव में अपने कोड चलाते हैं.

822
00:45:10,480 --> 00:45:16,630
जारी रखें सभी आवश्यक कदम उठा लेता है
अगले ब्रेक के बात करने के लिए.

823
00:45:16,630 --> 00:45:18,300
और बहुत से, वहाँ कई अन्य हैं.

824
00:45:18,300 --> 00:45:19,040
उन्हें देखो.

825
00:45:19,040 --> 00:45:19,901
वे महान हैं.

826
00:45:19,901 --> 00:45:20,863
हाँ?

827
00:45:20,863 --> 00:45:22,113
>> दर्शक: [अश्राव्य]?

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> दान: हाँ, एक डिबगर है.

830
00:45:28,200 --> 00:45:34,230
तो एक डिबगर एक प्रोग्राम है कि
यदि आप अपने कार्यक्रम डिबग करने देता है.

831
00:45:34,230 --> 00:45:39,931
इसके लिए कीड़े पाता है कि एक कार्यक्रम नहीं है
आप, हालांकि यह बहुत अच्छा होगा.

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> और खोज मेरे लिए पिछले है.

834
00:45:46,040 --> 00:45:51,470
हम बात है कि खोज के प्रकार तो
इस वर्ग में के बारे में रैखिक खोज रहे हैं,

835
00:45:51,470 --> 00:45:55,960
जो आप प्रत्येक के माध्यम से देखो कि बस है
खोज अंतरिक्ष के तत्व, एक

836
00:45:55,960 --> 00:46:00,410
एक समय पर तत्व, आपको क्या लगता है, जब तक
आप के लिए या आप जब तक देख रहे हैं

837
00:46:00,410 --> 00:46:03,350
अपनी खोज को अंतरिक्ष के अंत जिस पर
क्या आप नहीं मिल सकता है का कहना है कि बिंदु

838
00:46:03,350 --> 00:46:06,360
आप के लिए देख रहे थे कि तत्व.

839
00:46:06,360 --> 00:46:13,450
और यह, पर सबसे अच्छा निरंतर समय लगता है
जो 1 से 0 और सबसे खराब रैखिक पर

840
00:46:13,450 --> 00:46:16,070
n के 0 है जो समय,.

841
00:46:16,070 --> 00:46:19,250
>> जरूरत है जो द्विआधारी खोज,
घिनौना तत्वों.

842
00:46:19,250 --> 00:46:24,230
आप अपने तत्वों के बीच में जाना है,
देखते हैं अगर आप के लिए देख रहे हैं तत्व

843
00:46:24,230 --> 00:46:30,120
तत्व से भी बड़ा या छोटा होता है
आप बीच में कर रहे हैं कि.

844
00:46:30,120 --> 00:46:36,510
यह बड़ा है, आप नीचे का कहना है कि
अपनी खोज के अंतरिक्ष अपनी है

845
00:46:36,510 --> 00:46:41,550
वर्तमान स्थान, मध्य,
और आप इस प्रक्रिया को पुनः आरंभ.

846
00:46:41,550 --> 00:46:46,150
यह छोटा है, तो आप कहते हैं कि देखो
हाँ, क्या बात है the-- कि?

847
00:46:46,150 --> 00:46:47,400
>> दर्शक: [अश्राव्य]?

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> दान: हाँ.

850
00:46:54,260 --> 00:46:58,360
में सिखाया गया है कि तरह के किसी भी तरह
कक्षा की परीक्षा के लिए निष्पक्ष खेल है.

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [हंसी]

853
00:47:04,920 --> 00:47:10,260
>> दान: और तुम नहीं किया है कि तथ्य
एक समस्या सेट के लिए यह करने के लिए, यह उचित है

854
00:47:10,260 --> 00:47:12,420
परीक्षण के लिए खेल.

855
00:47:12,420 --> 00:47:15,186
>> दर्शक: हम इस पर कैसे जा सकते हैं to--

856
00:47:15,186 --> 00:47:17,052
>> दान: यह खत्म हो गया होगा.

857
00:47:17,052 --> 00:47:20,496
>> अध्यक्ष 2: के लिए वास्तविक कोड
[अश्राव्य] study.cs50.net पर है.

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
आप अभ्यास समस्या को देखो तो
के मर्ज क्रमबद्ध पेज में

860
00:47:32,680 --> 00:47:35,880
study.cs50.net, कोड नहीं है
क्रमबद्ध विलय को लागू करने के लिए.

861
00:47:35,880 --> 00:47:38,550
तो आप को लागू करने की जरूरत नहीं है
यह अपने आप को आज रात.

862
00:47:38,550 --> 00:47:42,090
लेकिन यकीन है कि आप बल्कि यह समझ कर
से बस यह याद रखना.

863
00:47:42,090 --> 00:47:45,035
>> दर्शक: [अश्राव्य]?

864
00:47:45,035 --> 00:47:49,720
>> अध्यक्ष 2: पर मर्ज क्रमबद्ध पेज
study.cs50.net, एक अभ्यास है

865
00:47:49,720 --> 00:47:53,570
आप के माध्यम से क्लिक करते हैं कि, समस्या
समस्या, बहुत अंत में वहाँ एक

866
00:47:53,570 --> 00:47:56,280
मर्ज है जो समाधान,
क्रमबद्ध कार्यान्वयन.

867
00:47:56,280 --> 00:47:58,510
लेकिन यकीन है कि आप इसे समझते हैं
बल्कि सिर्फ यह याद रखना से

868
00:47:58,510 --> 00:47:59,760
या यह नीचे नकल.

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> दर्शक: और एक पूरी तरह से वैध
परीक्षा के लिए समस्या होगी

871
00:48:06,340 --> 00:48:07,990
यहाँ की तरह कुछ एक सूची है.

872
00:48:07,990 --> 00:48:12,100
इस सूची के बाद की तरह दिखता है क्या
चयन की तरह एक कदम या

873
00:48:12,100 --> 00:48:13,330
सम्मिलन सॉर्ट या जो भी हो.

874
00:48:13,330 --> 00:48:14,940
सूची में से एक पूर्ण चलना.

875
00:48:14,940 --> 00:48:18,530
आप की जरूरत के अंत नहीं है तो भी अगर
इसके लिए कोड, आपको यह समझने की जरूरत है

876
00:48:18,530 --> 00:48:20,440
यह कैसे हो रहा है पता करने के लिए पर्याप्त
इस सरणी संशोधित किया जाना है.

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> दान: कि मेरे लिए यह बात है.

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [वाहवाही]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> लुकास: हे सब लोग.

883
00:49:07,410 --> 00:49:08,390
मेरा नाम लुकास है.

884
00:49:08,390 --> 00:49:16,840
मैं सभी, प्रत्यावर्तन के बारे में बात करने जा रहा हूँ
हमने सीखा है कि प्रकार, और एक

885
00:49:16,840 --> 00:49:18,050
सभी संकेत का छोटा सा.

886
00:49:18,050 --> 00:49:18,740
ठीक है?

887
00:49:18,740 --> 00:49:20,340
तो सब से पहले, प्रत्यावर्तन.

888
00:49:20,340 --> 00:49:22,951
यह कहना है कि क्या मतलब है
एक समारोह पुनरावर्ती है?

889
00:49:22,951 --> 00:49:24,675
>> दर्शक: कहते हैं.

890
00:49:24,675 --> 00:49:26,500
>> लुकास: ठीक है, हाँ, खुद कहता है.

891
00:49:26,500 --> 00:49:27,700
तो उदाहरण के लिए इस तस्वीर की तरह.

892
00:49:27,700 --> 00:49:30,280
यह अंदर की तस्वीर की तरह है
एक तस्वीर के और इतने पर.

893
00:49:30,280 --> 00:49:35,740
तो उदाहरण के लिए, आप दान के रूप में have-- कर सकते हैं
कि द्विआधारी खोज के बारे में बात कर रहा था.

894
00:49:35,740 --> 00:49:41,840
एक तरह से जो में द्विआधारी खोज है
पुनरावर्ती आप कर रहे हैं कि तथ्य यह है

895
00:49:41,840 --> 00:49:43,130
एक संख्या को खोजने की कोशिश.

896
00:49:43,130 --> 00:49:44,250
तो आप बीच में चलते हैं.

897
00:49:44,250 --> 00:49:47,130
वहाँ संख्या तो आप जाँच
बाईं और सही में.

898
00:49:47,130 --> 00:49:49,650
>> और फिर आप नंबर पता लगाने अगर
बाईं तरफ होने जा रहा है, यह ऐसा ही है

899
00:49:49,650 --> 00:49:53,340
फिर से खोज कर के रूप में बात लेकिन
बस सूची के बाईं तरफ.

900
00:49:53,340 --> 00:49:57,350
यह कैसे लगता तो है कि
जैसे यह पुनरावर्ती है.

901
00:49:57,350 --> 00:50:01,870
तुम लोग पुनरावर्ती है तो इसलिए
मर्ज प्रकार के लिए समाधान.

902
00:50:01,870 --> 00:50:04,270
>> ठीक है, तो यहाँ एक उदाहरण है.

903
00:50:04,270 --> 00:50:07,280
तो चलो मैं चयन करना चाहते हैं कि हम कहते हैं
1 से n करने के लिए सभी नंबरों.

904
00:50:07,280 --> 00:50:13,790
मैं महसूस कर सकते हैं कि n का योग
संख्या n प्लस n शून्य से 1 1 पर निर्भर है.

905
00:50:13,790 --> 00:50:17,810
लेकिन फिर, मैं n शून्य से 1 पर नजर डालें तो प्लस
n शून्य से 2 प्लस 1, कि एक ही है

906
00:50:17,810 --> 00:50:20,680
संक्षेप संख्या के रूप में बात
n करने के लिए शून्य से 1 अप.

907
00:50:20,680 --> 00:50:25,890
तो मैं एक समान राशि की राशि कह सकता
n शून्य से 1 के एन प्लस राशि के बराबर होती है.

908
00:50:25,890 --> 00:50:28,010
कि मतलब?

909
00:50:28,010 --> 00:50:32,630
>> और मैं भी कुछ और होता
है, जो कि बेस मामले बुलाया

910
00:50:32,630 --> 00:50:37,440
ऊपर संख्याओं का योग
शून्य पर शून्य होगा.

911
00:50:37,440 --> 00:50:42,770
इसलिए जैसे ही मैं नंबर करने के लिए मिल के रूप में
शून्य, मैं गिनती करना बंद करो.

912
00:50:42,770 --> 00:50:45,330
कि मतलब?

913
00:50:45,330 --> 00:50:48,120
>> तो यहाँ का एक उदाहरण है
मुझे लगता है कि लागू कर सकते हैं.

914
00:50:48,120 --> 00:50:49,860
इसलिए मैं कुछ में यह कार्य किया है.

915
00:50:49,860 --> 00:50:51,700
कि एक पूर्णांक n लेता है.

916
00:50:51,700 --> 00:50:56,300
N है अगर तो यहाँ मैं पहले की जांच
कम या शून्य के बराबर होती है.

917
00:50:56,300 --> 00:51:00,310
तो यह शून्य करने के लिए कम या बराबर है तो मैं
हमारे आधार मामला है, जो शून्य वापसी.

918
00:51:00,310 --> 00:51:05,690
अन्यथा, मैं अभी वापस कर सकते हैं n प्लस
संख्याओं का योग से

919
00:51:05,690 --> 00:51:07,190
n शून्य से एक के लिए एक.

920
00:51:07,190 --> 00:51:09,360
भावना करें?

921
00:51:09,360 --> 00:51:10,100
ठीक है.

922
00:51:10,100 --> 00:51:11,610
>> तो यहाँ यह कैसा लग रहा है.

923
00:51:11,610 --> 00:51:15,260
आप 2 से बराबर की राशि
2 प्लस 1 का योग.

924
00:51:15,260 --> 00:51:18,930
और 1 के कुछ प्लस 1 है
0 जो 0 की राशि,.

925
00:51:18,930 --> 00:51:20,216
भावना करें?

926
00:51:20,216 --> 00:51:25,342
हम के ढेर पर लगता है तो आपके
कार्यक्रम, यह यह कैसा लग रहा है.

927
00:51:25,342 --> 00:51:26,820
>> सबसे पहले, हम मुख्य समारोह है.

928
00:51:26,820 --> 00:51:30,320
और फिर मुख्य समारोह
राशि 2 कहा जाता है.

929
00:51:30,320 --> 00:51:36,690
और फिर राशि 2 ओह, कहने के लिए जा रहा है, राशि
2 2 प्लस एक की राशि के बराबर होती है.

930
00:51:36,690 --> 00:51:39,460
तो मैं ढेर करने के लिए 1 का योग जोड़ें.

931
00:51:39,460 --> 00:51:43,860
और 1 का योग का योग कॉल करने के लिए जा रहा है
0, जो भी जोड़ा जा रहा है

932
00:51:43,860 --> 00:51:44,630
ढेर करने के लिए.

933
00:51:44,630 --> 00:51:49,240
और कर रहे हैं कि इन लोगों में से तो प्रत्येक
दूसरे के शीर्ष पर वापस जाने के लिए है

934
00:51:49,240 --> 00:51:52,020
अन्य लोगों के लिए जा रहा रख सकते हैं पहले.

935
00:51:52,020 --> 00:51:56,240
>> तो उदाहरण के लिए, यहाँ, 0 की राशि,
पहला, 0 वापसी करने जा रही है.

936
00:51:56,240 --> 00:51:58,320
और फिर 1 की राशि का चयन करें.

937
00:51:58,320 --> 00:52:00,850
फिर 1 का योग करने जा रहा है
2 की राशि के 1 वापसी.

938
00:52:00,850 --> 00:52:03,900
और अंत में, 2 का योग चल रहा है
मुख्य करने के लिए 3 लौटने के लिए.

939
00:52:03,900 --> 00:52:05,320
कि मतलब?

940
00:52:05,320 --> 00:52:09,496
>> यह समझने के लिए कैसे वास्तव में महत्वपूर्ण है
ढेर और काम कर करने की कोशिश कर रहा है

941
00:52:09,496 --> 00:52:11,980
यह समझ में आता है देखते हैं.

942
00:52:11,980 --> 00:52:13,260
ठीक है, तो छँटाई.

943
00:52:13,260 --> 00:52:16,170
तो क्यों, महत्वपूर्ण छँटाई है
सब से पहले?

944
00:52:16,170 --> 00:52:18,260
हम क्यों परवाह करूँ?

945
00:52:18,260 --> 00:52:20,310
कोई है?

946
00:52:20,310 --> 00:52:20,695
मुझे एक उदाहरण दे?

947
00:52:20,695 --> 00:52:21,040
हाँ?

948
00:52:21,040 --> 00:52:22,968
>> दर्शक: [अश्राव्य].

949
00:52:22,968 --> 00:52:24,700
>> लुकास: ठीक है, हाँ.

950
00:52:24,700 --> 00:52:26,090
तो आप और अधिक कुशलता से खोज सकते हैं.

951
00:52:26,090 --> 00:52:28,580
यह एक अच्छा तरीका है.

952
00:52:28,580 --> 00:52:32,462
तो, उदाहरण के लिए, हम एक बहुत की है
बातें, वास्तव में हमारे जीवन कि

953
00:52:32,462 --> 00:52:32,920
क्रमबद्ध हैं.

954
00:52:32,920 --> 00:52:34,830
उदाहरण के लिए, जानने के लिए.

955
00:52:34,830 --> 00:52:39,210
>> यह सब करने के लिए बहुत महत्वपूर्ण है
आदेश में किसी तरह का शब्द है कि हम

956
00:52:39,210 --> 00:52:41,970
आसानी से उपयोग कर सकते हैं.

957
00:52:41,970 --> 00:52:43,280
इसलिए कि वह क्या कह रहा था है.

958
00:52:43,280 --> 00:52:45,530
आप और अधिक कुशलता से खोज सकते हैं.

959
00:52:45,530 --> 00:52:48,740
यह एक के लिए किया जाएगा कितना मुश्किल के बारे में सोचो
शब्द हैं जिसमें शब्दकोश

960
00:52:48,740 --> 00:52:49,500
यादृच्छिक क्रम.

961
00:52:49,500 --> 00:52:53,120
आप बहुत ज्यादा, पर देखने के लिए होगा
हर एक शब्द जब तक आप पाते

962
00:52:53,120 --> 00:52:54,720
आप देख रहे हैं कि शब्द.

963
00:52:54,720 --> 00:52:58,710
>> आप भी फेसबुक का उपयोग कर रहे हैं, जब
आप अपने दोस्तों को देख रहे हैं, आप कर रहे हैं

964
00:52:58,710 --> 00:53:03,540
फेसबुक डाल कि देखने जा अपने
करीब दोस्त के शीर्ष पर है

965
00:53:03,540 --> 00:53:05,470
आप ज्यादा है कि बात नहीं है कि.

966
00:53:05,470 --> 00:53:08,080
आप की तह तक सभी तरह जाओ
अपने दोस्त की सूची, तुम को देखने के लिए जा रहे हैं

967
00:53:08,080 --> 00:53:11,250
आप शायद यह भी नहीं है कि लोग
आप दोस्तों के साथ कर रहे हैं कि याद है.

968
00:53:11,250 --> 00:53:14,590
और कहा कि फेसबुक प्रकार है क्योंकि
कैसे के आधार पर अपने मित्रों को

969
00:53:14,590 --> 00:53:16,472
आप उन्हें हैं बंद.

970
00:53:16,472 --> 00:53:17,930
>> तो डेटा के आयोजन.

971
00:53:17,930 --> 00:53:18,450
इसके अलावा नि.

972
00:53:18,450 --> 00:53:21,400
तो आप सभी Pokemons देखते हैं कि
नंबर हैं.

973
00:53:21,400 --> 00:53:27,210
और कहा कि एक आसान की तरह है
डेटा तक पहुँचने का रास्ता.

974
00:53:27,210 --> 00:53:29,050
>> दर्शक: नि पहुँचने.

975
00:53:29,050 --> 00:53:29,890
>> लुकास: हाँ.

976
00:53:29,890 --> 00:53:32,395
>> दर्शक: [अश्राव्य].

977
00:53:32,395 --> 00:53:33,460
>> लुकास: हाँ.

978
00:53:33,460 --> 00:53:35,140
ठीक है, तो चयन क्रमबद्ध.

979
00:53:35,140 --> 00:53:41,610
चुनाव में क्रमबद्ध चयन करने के लिए जा रहा है
एक सूची में सबसे छोटी unsorted मूल्य प्रत्येक

980
00:53:41,610 --> 00:53:43,300
प्रत्येक यात्रा में समय.

981
00:53:43,300 --> 00:53:46,800
यह एक तरह से है कि आप प्रकार की तरह है
आपके सिर में आप करने की कोशिश कर रहे हैं जब

982
00:53:46,800 --> 00:53:48,430
हाथ पर एक सूची तरह.

983
00:53:48,430 --> 00:53:51,990
>> असल में, तुम सब तुम देखो है
सबसे छोटी संख्या के लिए.

984
00:53:51,990 --> 00:53:54,280
आप हल सूची में डाल दिया.

985
00:53:54,280 --> 00:53:56,230
और फिर आप के लिए देखो
अगले सबसे छोटी संख्या.

986
00:53:56,230 --> 00:54:00,080
और फिर तुम क्या कर रखना
कि और इतने पर.

987
00:54:00,080 --> 00:54:04,600
>> इसलिए चयन क्रमबद्ध आप मूल रूप से है
हर समय छोटी से छोटी चयन

988
00:54:04,600 --> 00:54:05,750
unsorted मूल्य.

989
00:54:05,750 --> 00:54:10,840
क्रमबद्ध के अंत में रखो
सूची का हिस्सा है.

990
00:54:10,840 --> 00:54:12,370
और वह कर रखना.

991
00:54:12,370 --> 00:54:15,890
तो चलो जल्दी से देखते हैं क्या
इस तरह दिखता है.

992
00:54:15,890 --> 00:54:19,340
तो यहाँ हल
और unsorted सूची.

993
00:54:19,340 --> 00:54:23,350
>> सूची के अनुसार क्रमबद्ध के लिए तो,
यह शुरू में खाली है.

994
00:54:23,350 --> 00:54:26,760
और फिर मैं चयन करने के लिए जा रहा हूँ
2 जो यहाँ सबसे छोटी संख्या,.

995
00:54:26,760 --> 00:54:30,650
तो मैं नंबर 2 हो और मैं डाल
सूची के सामने.

996
00:54:30,650 --> 00:54:34,910
और फिर मैं अगले छोटी से छोटी के लिए देखो
3 जो तत्व,.

997
00:54:34,910 --> 00:54:37,050
तो मैं अंत में यह डाल
क्रमबद्ध सूची की.

998
00:54:37,050 --> 00:54:38,140
और फिर मुझे लगता है कि कर रखना.

999
00:54:38,140 --> 00:54:40,040
मैं 4 पाते और अंत में डाल दिया.

1000
00:54:40,040 --> 00:54:41,360
5 ढूँढें और अंत में डाल दिया.

1001
00:54:41,360 --> 00:54:44,830
>> और उस समय की कैसे सब पर देखने के लिए कि
मैं अंत है पर इसे डाल कह रहा हूँ

1002
00:54:44,830 --> 00:54:46,850
असल में, दो मानों गमागमन.

1003
00:54:46,850 --> 00:54:48,100
ठीक है?

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
और फिर आखरी तुम बस
एक और तत्व है.

1006
00:54:52,825 --> 00:54:55,870
तो यह पहले से ही हल है.

1007
00:54:55,870 --> 00:54:57,800
>> ठीक है, तो प्रविष्टि तरह.

1008
00:54:57,800 --> 00:55:03,180
निवेशन तरह आप भी लिए जा रहे हैं
एक हल होने की बात और

1009
00:55:03,180 --> 00:55:04,690
एक unsorted सूची.

1010
00:55:04,690 --> 00:55:14,540
केवल बात यह है कि हर बार कि
आप हल करने के लिए एक तत्व जोड़ रहे हैं

1011
00:55:14,540 --> 00:55:18,170
सूची, तुम सिर्फ तत्व उठा कि
unsorted सूची के सामने है.

1012
00:55:18,170 --> 00:55:20,880
और फिर तुम क्या खोजने के लिए जा रहे हैं
स्थिति यह हल में होना चाहिए

1013
00:55:20,880 --> 00:55:22,300
सूची का हिस्सा है.

1014
00:55:22,300 --> 00:55:25,840
>> चलो यह तो है देखते हैं क्या
यह और अधिक समझ में आता है.

1015
00:55:25,840 --> 00:55:29,360
इसलिए शुरू में, उदाहरण के लिए, मैं कोशिश कर रहा हूँ
में तीन नंबर डालने के लिए

1016
00:55:29,360 --> 00:55:30,680
सूची का हल हिस्सा.

1017
00:55:30,680 --> 00:55:31,800
तो सूची में कुछ भी नहीं है.

1018
00:55:31,800 --> 00:55:34,160
तो मैं बस संख्या 3 डाल सकते हैं.

1019
00:55:34,160 --> 00:55:37,480
>> अब, मैं करने के लिए 5 नंबर जोड़ना चाहते हैं
सूची का हल हिस्सा.

1020
00:55:37,480 --> 00:55:38,900
तो मैं नंबर 5 पर दिखेगा.

1021
00:55:38,900 --> 00:55:40,450
मैं इसे 3 से अधिक है कि नोटिस.

1022
00:55:40,450 --> 00:55:41,980
इसलिए मैं इसे 3 के बाद हो गया है कि पता है.

1023
00:55:41,980 --> 00:55:44,100
तो मैं 3 और 5 डाल दिया.

1024
00:55:44,100 --> 00:55:45,940
>> तब मैं नंबर 2 सम्मिलित करना चाहते हैं.

1025
00:55:45,940 --> 00:55:51,630
मैं नंबर 2 वास्तव में है कि नोटिस
फिर 3 और 5 दोनों पिछले.

1026
00:55:51,630 --> 00:55:54,580
इसलिए मैं वास्तव में यह सब डाल दिया है
सूची की शुरुआत में जिस तरह से.

1027
00:55:54,580 --> 00:55:59,030
इसलिए मुझे लगता है, एक तरह से, सभी शिफ्ट करने के लिए है
क्रमबद्ध सूची तो मैं कर सकता हूँ में तत्वों

1028
00:55:59,030 --> 00:56:01,970
संख्या 2 के लिए जगह बनाने.

1029
00:56:01,970 --> 00:56:03,160
>> तब मैं नंबर 6 को देखें.

1030
00:56:03,160 --> 00:56:05,450
मैं इसे 5 के बाद होना चाहिए कि देखते हैं.

1031
00:56:05,450 --> 00:56:06,240
तो मैं वहाँ रख दिया.

1032
00:56:06,240 --> 00:56:07,965
और अंत में, मैं नंबर 4 पर दिखेगा.

1033
00:56:07,965 --> 00:56:11,030
और मैं यह चाहिए नोटिस
3 और 5 के बीच हो.

1034
00:56:11,030 --> 00:56:14,870
और फिर मैं वहाँ रखा और पारी
अन्य सभी तत्वों.

1035
00:56:14,870 --> 00:56:16,120
भावना करें?

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> बुलबुला तरह.

1038
00:56:19,150 --> 00:56:25,730
इसलिए बुलबुला तरह आप क्या कर रहे हैं मूल रूप से है
जा रहा है कि हम बुलबुले इसे कहते do-- को

1039
00:56:25,730 --> 00:56:30,113
आप list-- के माध्यम से जाना क्रमबद्ध क्योंकि
मैं सिर्फ दिखाने अगर यह वास्तव में बेहतर है

1040
00:56:30,113 --> 00:56:32,300
आप this-- पसंद

1041
00:56:32,300 --> 00:56:35,030
और आप की तुलना करने के लिए जा रहे हैं
आसन्न संख्या.

1042
00:56:35,030 --> 00:56:38,410
और तुम स्वैप करने के लिए जा रहे हैं उनके
पदों वे नहीं कर रहे हैं

1043
00:56:38,410 --> 00:56:39,190
सही क्रम में.

1044
00:56:39,190 --> 00:56:42,570
>> तो बुनियादी तौर पर, के लिए क्या हो रहा है
यहाँ है हो सकता है, उदाहरण के लिए,

1045
00:56:42,570 --> 00:56:44,160
आप 8 और 6 है.

1046
00:56:44,160 --> 00:56:47,270
आपको लगता है कि हल आदेश होगा पता
वास्तव में सही 6 और 5, हो सकता है?

1047
00:56:47,270 --> 00:56:49,540
तो आप आदेश स्वैप करने के लिए जा रहे हैं.

1048
00:56:49,540 --> 00:56:51,370
तब मैं यहां 8 और 4 देखें.

1049
00:56:51,370 --> 00:56:52,250
और मैं एक ही बात करते हैं.

1050
00:56:52,250 --> 00:56:53,400
मैं फिर से स्वैप.

1051
00:56:53,400 --> 00:56:55,070
और अंत में, 2 और 8.

1052
00:56:55,070 --> 00:56:56,670
मैं भी उन्हें स्वैप.

1053
00:56:56,670 --> 00:57:01,690
>> यह बुलबुला तरह क्योंकि बाद कहा जाता है
इन पुनरावृत्तियों में से प्रत्येक, वास्तव में,

1054
00:57:01,690 --> 00:57:05,910
सूची में सबसे बड़ी संख्या सब हो जाता है
सूची के अंत में जिस तरह से.

1055
00:57:05,910 --> 00:57:06,940
कि मतलब?

1056
00:57:06,940 --> 00:57:11,880
यह यह गमागमन रहता है क्योंकि
और सही करने के लिए यह चलती.

1057
00:57:11,880 --> 00:57:14,440
>> ठीक है, तो यह दूसरी यात्रा है.

1058
00:57:14,440 --> 00:57:17,200
यह एक ही बात होगी.

1059
00:57:17,200 --> 00:57:20,190
मैं एक स्वैप करता हूँ और
तो आखरी.

1060
00:57:20,190 --> 00:57:23,290
कोई स्वैप कर रहे हैं मुझे लगता है कि
और सूची हल है.

1061
00:57:23,290 --> 00:57:27,460
बुलबुला प्रकार में तो, हम मूल रूप से रखना
सूची के माध्यम से जा रहा है और गमागमन

1062
00:57:27,460 --> 00:57:32,310
बातें मैं मैं नहीं किया है कि सूचना तक
कि चलना कर किसी भी स्वैप, जो

1063
00:57:32,310 --> 00:57:34,270
सूची में पहले से ही हल है कि इसका मतलब है.

1064
00:57:34,270 --> 00:57:35,520
भावना करें?

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> का एक छोटा सा बात करते हैं
समय चल रहा है के बारे में.

1067
00:57:40,870 --> 00:57:45,165
तो तुम लोग बिग याद है
हे, ओमेगा, और थीटा?

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
हाँ?

1070
00:57:50,990 --> 00:57:53,070
ठीक है, बड़ी हे सब से पहले, क्या है?

1071
00:57:53,070 --> 00:57:54,315
>> दर्शक: [अश्राव्य].

1072
00:57:54,315 --> 00:57:59,070
>> लुकास: हाँ, यह एक सबसे खराब स्थिति कहा जाता है
सिर्फ यह है कि इसका मतलब है जो देखने का समय,

1073
00:57:59,070 --> 00:58:03,470
आप कितना कार्यक्रम की उम्मीद
चलाने के लिए लेने के लिए.

1074
00:58:03,470 --> 00:58:04,910
जैसे, मामले में of--

1075
00:58:04,910 --> 00:58:06,660
इस case-- एन में.

1076
00:58:06,660 --> 00:58:09,150
में तत्वों की संख्या
सबसे खराब स्थिति में सूची.

1077
00:58:09,150 --> 00:58:12,520
जैसे, सबसे ज्यादा संभव मामले में.

1078
00:58:12,520 --> 00:58:17,100
>> बुलबुला प्रकार के लिए तो, उदाहरण के लिए,
हम n वर्ग की बड़ी हे है.

1079
00:58:17,100 --> 00:58:20,580
हम क्यों कि क्या करना है?

1080
00:58:20,580 --> 00:58:24,716
क्यों बुलबुला बड़ी हे n वर्ग तरह है?

1081
00:58:24,716 --> 00:58:27,614
>> दर्शक: [अश्राव्य].

1082
00:58:27,614 --> 00:58:35,670
>> लुकास: हाँ, तो सबसे ज्यादा मामले हो जाएगा
कि मैं n पुनरावृत्तियों करना होगा.

1083
00:58:35,670 --> 00:58:39,260
तो पुनरावृत्तियों में से प्रत्येक के लिए जा रहा है
अंत करने के लिए सबसे बड़ा तत्व लाना

1084
00:58:39,260 --> 00:58:40,290
सूची की.

1085
00:58:40,290 --> 00:58:44,230
तो सबसे खराब स्थिति है कि मैं है
बात यह है कि एन बार ऐसा करने के लिए.

1086
00:58:44,230 --> 00:58:48,550
और उस समय से प्रत्येक के लिए, मैं करने के लिए है
मैं तुलना करने के लिए है क्योंकि n स्वैप करना

1087
00:58:48,550 --> 00:58:49,870
प्रत्येक दो तत्वों.

1088
00:58:49,870 --> 00:58:53,730
यह n चुकता है तो इसलिए
यह एन बार पता है क्योंकि.

1089
00:58:53,730 --> 00:59:00,120
>> फिर, चयन क्रमबद्ध भी n वर्ग है
क्योंकि, प्रत्येक यात्रा के लिए, मैं करने के लिए है

1090
00:59:00,120 --> 00:59:02,650
हर एक तत्व को देखो
सूची में.

1091
00:59:02,650 --> 00:59:04,980
और फिर, सबसे छोटा लगता है
जो मैं करने के लिए इसका मतलब है कि

1092
00:59:04,980 --> 00:59:06,130
n तत्वों के माध्यम से देखो.

1093
00:59:06,130 --> 00:59:11,750
और मैं ऐसा इसलिए है क्योंकि एन बार क्या करना है
मैं सब n तत्वों का चयन किया है.

1094
00:59:11,750 --> 00:59:18,273
>> एक प्रविष्टि सॉर्ट भी n वर्ग है
सबसे बुरी स्थिति होगी क्योंकि

1095
00:59:18,273 --> 00:59:20,950
, एक हो, मैं डालने के लिए है
n संख्या, है ना?

1096
00:59:20,950 --> 00:59:22,765
तो मैं पहले से ही मैं जा रहा हूँ कि पता
n पुनरावृत्तियों है.

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
लेकिन मैं था उन लोगों की संख्या में से प्रत्येक के लिए, अगर
संख्या के सभी को देखने के लिए

1099
00:59:29,840 --> 00:59:34,380
क्रमबद्ध सूची और यह सभी तरह से रखा
सामने, कि n वर्ग होगा

1100
00:59:34,380 --> 00:59:36,230
यह एन बार n फिर से हो जाएगा.

1101
00:59:36,230 --> 00:59:38,280
भावना करें?

1102
00:59:38,280 --> 00:59:41,512
क्या ओमेगा के बारे में?

1103
00:59:41,512 --> 00:59:42,886
>> दर्शक: [अश्राव्य].

1104
00:59:42,886 --> 00:59:44,620
>> लुकास: यह सबसे अच्छी स्थिति है.

1105
00:59:44,620 --> 00:59:48,810
इसलिए यह समय की एक बहुत कुछ के लिए में, की तरह है
सबसे अच्छी स्थिति है, छँटाई

1106
00:59:48,810 --> 00:59:50,660
सूची में पहले से ही हल है जब.

1107
00:59:50,660 --> 00:59:52,670
तो आप वास्तव में नहीं है
कुछ भी करने को.

1108
00:59:52,670 --> 00:59:56,290
बुलबुला तरह सबसे अच्छा है
n की स्थिति.

1109
00:59:56,290 --> 00:59:58,820
तुम लोगों को पता है क्यों?

1110
00:59:58,820 --> 01:00:00,620
>> दर्शक: [अश्राव्य].

1111
01:00:00,620 --> 01:00:05,640
>> लुकास: हाँ, आप का ट्रैक रखने
डेटा राशन किसी भी स्वैप था कि क्या है या

1112
01:00:05,640 --> 01:00:10,533
आप कुछ है नहीं, करने के लिए सेट की तरह
एक चलना अगर वहाँ था, अगर सच

1113
01:00:10,533 --> 01:00:15,140
सूची में पहले से ही, मूल रूप से, हल है
क्या होने जा रहा है मैं जा रहा हूँ है

1114
01:00:15,140 --> 01:00:17,890
प्रत्येक दो स्वैप करने के लिए कोशिश
आसन्न तत्वों.

1115
01:00:17,890 --> 01:00:19,920
मुझे लगता है कि देखने के लिए जा रहा हूँ
कोई स्वैप कर रहे हैं.

1116
01:00:19,920 --> 01:00:21,230
और मैं सिर्फ सही दूर वापस.

1117
01:00:21,230 --> 01:00:24,240
>> तो यह है कि मैं बस के लिए किया था कि इसका मतलब
सूची एक समय के माध्यम से जाना.

1118
01:00:24,240 --> 01:00:28,990
मैं देखने के लिए क्योंकि तो यह n है
n तत्वों पर.

1119
01:00:28,990 --> 01:00:30,930
क्यों चयन क्रमबद्ध n वर्ग?

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> हाँ, सूची हल है, भले के लिए
चयन की तरह हर चलना, मैं

1122
01:00:45,520 --> 01:00:47,590
न्यूनतम तत्व का चयन किया है.

1123
01:00:47,590 --> 01:00:49,980
इसलिए कि मैं देखने के लिए बाहर का मतलब है कि
unsorted में सभी तत्वों पर

1124
01:00:49,980 --> 01:00:53,350
सूची और न्यूनतम लगता है
प्रत्येक यात्रा के लिए.

1125
01:00:53,350 --> 01:00:54,600
कि मतलब?

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> और सम्मिलन तलवार में, क्योंकि n है
मैं डालने की कोशिश कर रहा हूँ कि मामला

1128
01:01:04,690 --> 01:01:09,320
संख्या और संख्या के सभी, जब मैं
उन्हें सम्मिलित करने का प्रयास, मुझे लगता है वे देखते हैं कि

1129
01:01:09,320 --> 01:01:10,510
सही स्थिति में हैं.

1130
01:01:10,510 --> 01:01:15,120
मैं अन्य सभी की जांच जाने की जरूरत नहीं है
unsorted सूची में संख्या.

1131
01:01:15,120 --> 01:01:17,170
यह n हो जाएगा तो इसलिए.

1132
01:01:17,170 --> 01:01:19,480
भावना करें?

1133
01:01:19,480 --> 01:01:21,035
और थीटा क्या है?

1134
01:01:21,035 --> 01:01:23,410
>> दर्शक: [अश्राव्य].

1135
01:01:23,410 --> 01:01:24,380
>> लुकास: क्या, माफ करना?

1136
01:01:24,380 --> 01:01:24,960
फिर से कहो.

1137
01:01:24,960 --> 01:01:25,666
>> दर्शक: [अश्राव्य].

1138
01:01:25,666 --> 01:01:26,490
>> लुकास: बिल्कुल.

1139
01:01:26,490 --> 01:01:31,280
तो आपको लगता है कि केवल चयन देख सकते हैं
मर्ज में संग्रहीत क्रमबद्ध thetas है.

1140
01:01:31,280 --> 01:01:39,920
आप केवल थीटा है क्योंकि और वह है
बड़ी हे और ओमेगा दोनों एक ही हैं.

1141
01:01:39,920 --> 01:01:41,520
ठीक है.

1142
01:01:41,520 --> 01:01:44,210
और अंत में, लॉग n में तरह है विलय.

1143
01:01:44,210 --> 01:01:48,910
>> दान कह रहा था के रूप में और फिर,, की तरह मिलाएं
तरह का एक ही तरीका है की तरह है कि

1144
01:01:48,910 --> 01:01:50,320
आप द्विआधारी खोज करते हैं.

1145
01:01:50,320 --> 01:01:53,530
तो आप सूची मिलता है.

1146
01:01:53,530 --> 01:01:55,170
और तुम आधे में कटौती करने जा रहे हैं.

1147
01:01:55,170 --> 01:02:00,580
और फिर तुम उन्हें कटौती
छोटे हिस्सों में.

1148
01:02:00,580 --> 01:02:01,730
और तब आप उन्हें मर्ज.

1149
01:02:01,730 --> 01:02:02,960
तुम लोग सही, याद है कि?

1150
01:02:02,960 --> 01:02:04,960
ठीक है, वह कह रहा था.

1151
01:02:04,960 --> 01:02:08,330
>> ठीक है, संकेत.

1152
01:02:08,330 --> 01:02:11,078
तो एक सूचक क्या है?

1153
01:02:11,078 --> 01:02:12,050
>> दर्शक: [अश्राव्य].

1154
01:02:12,050 --> 01:02:12,820
>> लुकास: एक पते.

1155
01:02:12,820 --> 01:02:13,720
ठीक है.

1156
01:02:13,720 --> 01:02:18,530
मैं दाऊद का एक गुच्छा से पता चलता है कि पता
Binky के वीडियो और बातें इशारा कर

1157
01:02:18,530 --> 01:02:19,080
एक दूसरे को.

1158
01:02:19,080 --> 01:02:22,960
लेकिन मैं संकेत के बारे में सोचना पसंद
केवल एक पते के रूप में.

1159
01:02:22,960 --> 01:02:26,110
तो यह जा रहा है कि एक चर है
एक पते संग्रहीत करने के लिए.

1160
01:02:26,110 --> 01:02:31,940
>> तो यह सिर्फ इस विशेष चर है
कि चार बाइट्स लंबा है.

1161
01:02:31,940 --> 01:02:36,550
कुछ भी करने के लिए कि सूचक है, याद रखें
हमारे 32 बिट के लिए लंबे समय से हमेशा चार बाइट्स

1162
01:02:36,550 --> 01:02:39,370
मशीन के मामले के साथ तो
उपकरण.

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
और यह सिर्फ स्थान है
इसके अंदर एक चर की.

1165
01:02:47,050 --> 01:02:50,240
>> ठीक है, तो बुनियादी तौर पर, इस स्मृति नहीं है.

1166
01:02:50,240 --> 01:02:57,420
तो स्मृति के प्रत्येक ब्लॉक वास्तव में है एक
का पता है जो लेबल,

1167
01:02:57,420 --> 01:02:58,890
slotty स्मृति.

1168
01:02:58,890 --> 01:03:02,370
इसलिए कि मैं हो सकता है कि इसका मतलब है
के लिए एक संकेत इशारा

1169
01:03:02,370 --> 01:03:03,380
इन पतों की किसी भी.

1170
01:03:03,380 --> 01:03:09,930
इसलिए हम संकेत का उपयोग करेंगे कारण है
मैं स्थान याद है अगर

1171
01:03:09,930 --> 01:03:12,300
कि एक विशिष्ट चर एक स्मृति है.

1172
01:03:12,300 --> 01:03:16,560
>> और तुम लोग याद उन में से एक है कि
मैं एक समारोह है कि अगर मामलों था

1173
01:03:16,560 --> 01:03:20,820
मैं वास्तव में अगर आप चाहते हैं
reals के लिए स्वैप, मैं वास्तव में

1174
01:03:20,820 --> 01:03:22,110
एक सूचक भेज दिया है.

1175
01:03:22,110 --> 01:03:23,460
नहीं चर.

1176
01:03:23,460 --> 01:03:25,200
तुम लोगों को याद है?

1177
01:03:25,200 --> 01:03:26,450
फर्क between--

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
नाम क्या है?

1180
01:03:34,120 --> 01:03:36,010
मूल्य और फोन करके बुला
संदर्भ से, सही?

1181
01:03:36,010 --> 01:03:36,840
>> हाँ, ठीक है.

1182
01:03:36,840 --> 01:03:38,330
तो मूल्य से कहते हैं.

1183
01:03:38,330 --> 01:03:43,570
आप सिर्फ एक चर करने के लिए भेजते हैं
आप सिर्फ एक मूल्य भेज रहे कार्य करते हैं.

1184
01:03:43,570 --> 01:03:45,610
तो आप वास्तव में भेज रहे हैं
चर की एक प्रति.

1185
01:03:45,610 --> 01:03:49,720
और अपने कार्यक्रम कम परवाह नहीं कर सका
वास्तव में एक ही चर के बारे में अगर

1186
01:03:49,720 --> 01:03:51,650
एक प्रतिलिपि बनाता है.

1187
01:03:51,650 --> 01:03:56,330
>> और संदर्भ मतलब है कि द्वारा बुला
मैं वास्तव में की एक प्रति भेज रहा हूँ

1188
01:03:56,330 --> 01:03:57,550
उस चर के लिए संकेतक.

1189
01:03:57,550 --> 01:04:00,970
तो यह है कि मैं भेज रहा हूँ कि इसका मतलब
कि चर का स्थान.

1190
01:04:00,970 --> 01:04:04,440
इसलिए मैं का स्थान है भावना
चर, जब मैं फोन समारोह

1191
01:04:04,440 --> 01:04:09,700
संकेत के साथ, मैं वास्तव में करने में सक्षम हूँ
मुख्य में था कि डेटा को बदलने.

1192
01:04:09,700 --> 01:04:12,050
भावना करें?

1193
01:04:12,050 --> 01:04:17,560
>> हालांकि, सूचक एक प्रति है,
सूचक अभी का असली पता है

1194
01:04:17,560 --> 01:04:20,090
मैं बदलना चाहते है कि चर.

1195
01:04:20,090 --> 01:04:21,920
भावना करें?

1196
01:04:21,920 --> 01:04:24,290
>> तो संकेत का निर्माण.

1197
01:04:24,290 --> 01:04:28,410
हमेशा सूचक है, याद रखें
यह इशारा कर रहा है कि प्रकार

1198
01:04:28,410 --> 01:04:29,890
एक स्टार के लिए और उसके बाद.

1199
01:04:29,890 --> 01:04:31,030
और फिर आप नाम डाल दिया.

1200
01:04:31,030 --> 01:04:35,765
तो आप जब भी याद है कि
जो भी सितारा, यह करने के लिए एक सूचक की तरह है

1201
01:04:35,765 --> 01:04:38,990
जो भी चर कि
तुम था कि टाइप करें.

1202
01:04:38,990 --> 01:04:42,850
>> तो यहाँ सितारा में, उदाहरण के लिए, यह है
एक सूचक और एक पूर्णांक.

1203
01:04:42,850 --> 01:04:47,680
और फिर चार सितारा एक सूचक है
चार सितारा और बहुत आगे है.

1204
01:04:47,680 --> 01:04:47,960
हाँ?

1205
01:04:47,960 --> 01:04:52,710
>> दर्शक: क्या हम अगर एक
n करने के लिए सूचक एक्स स्टार के लिए.

1206
01:04:52,710 --> 01:04:55,255
मुझे लगता है कि एक्स के लिए एक संकेत बनाता है पता है.

1207
01:04:55,255 --> 01:04:59,432
यह भी एक पूर्णांक एक्स की घोषणा करता है?

1208
01:04:59,432 --> 01:05:05,170
>> लुकास: ठीक है, तो आप n सितारा एक्स जब कहते हैं,
आप एक के लिए एक संकेत नहीं पैदा कर रहे हैं

1209
01:05:05,170 --> 01:05:06,000
चर एक्स.

1210
01:05:06,000 --> 01:05:08,170
आप एक्स नाम का एक सूचक बना रहे हैं.

1211
01:05:08,170 --> 01:05:09,396
>> दर्शक: [अश्राव्य].

1212
01:05:09,396 --> 01:05:14,250
>> लुकास: मैं n सितारा एक्स कहना तो, जब मैं कर रहा हूँ
अरे, स्मृति में, मैं जा रहा हूँ, कह रही है

1213
01:05:14,250 --> 01:05:16,390
इन तीन बक्से में से एक मिलता है.

1214
01:05:16,390 --> 01:05:20,750
और मुझे लगता है कि कि कहने जा रहा हूँ
है, जो एक्स होने जा रहा है

1215
01:05:20,750 --> 01:05:22,000
जा रहा एक सूचक हो.

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
और संकेत के बारे में कुछ दिलचस्प
हम वे कहते हैं कि यह है कि

1218
01:05:30,640 --> 01:05:32,620
एक 32 बिट मशीन के लिए 4 बाइट्स.

1219
01:05:32,620 --> 01:05:36,320
और उसके लिए कारण है
4 बाइट्स 32 बिट कर रहे हैं.

1220
01:05:36,320 --> 01:05:40,490
>> 64 बिट वास्तव में कर रहे हैं कि और मशीनों
संकेत पते हैं

1221
01:05:40,490 --> 01:05:43,480
64 बिट लंबे होते हैं कि.

1222
01:05:43,480 --> 01:05:49,820
तो यह सिर्फ मतलब है कि का आकार
मशीन में पते अलग है.

1223
01:05:49,820 --> 01:05:52,270
>> तो संदर्भित और dereferencing.

1224
01:05:52,270 --> 01:05:54,310
दो ऑपरेटरों रहे हैं कि
तुम लोगों को याद रखना चाहिए.

1225
01:05:54,310 --> 01:05:55,450
पहले एम्परसेंड है.

1226
01:05:55,450 --> 01:05:56,810
दूसरा सितारा है.

1227
01:05:56,810 --> 01:06:05,060
कि स्टार और इस से भ्रमित मत जाओ
क्योंकि में, याद है कि स्टार

1228
01:06:05,060 --> 01:06:06,950
इस मामले में, आप n सितारा है.

1229
01:06:06,950 --> 01:06:08,700
>> यह एक साथ एक पूरी बात की तरह है.

1230
01:06:08,700 --> 01:06:10,720
कोई n अंतरिक्ष सितारा है.

1231
01:06:10,720 --> 01:06:12,070
तो यह है कि यह प्रकार है कि इसका मतलब है.

1232
01:06:12,070 --> 01:06:14,870
आप जब कि, याद रखें
चर सितारा, आप कर रहे हैं

1233
01:06:14,870 --> 01:06:16,230
प्रकार के बारे में बात कर.

1234
01:06:16,230 --> 01:06:20,540
>> आप तो बस सितारा और जब
चर का नाम, यह मतलब है कि

1235
01:06:20,540 --> 01:06:24,100
आप सूचक, dereferencing रहे हैं जो
आप देख रहे हैं कि इसका मतलब है

1236
01:06:24,100 --> 01:06:28,290
सूचक, पता खोजने यह है
, की ओर इशारा करते हैं कि पता करने के लिए जा रहा है,

1237
01:06:28,290 --> 01:06:30,850
और जब भी में देख
तुम वहाँ है.

1238
01:06:30,850 --> 01:06:34,310
इसलिए मैं तुम्हारे पास जब कि मेरे छात्रों बताओ
सितारा, आप यह है कि सोचना चाहिए

1239
01:06:34,310 --> 01:06:36,850
की सामग्री का संक्षिप्त नाम है.

1240
01:06:36,850 --> 01:06:39,770
>> आप एक सूचक है तो और आप
सितारा सूचक करते हैं, यह बात है

1241
01:06:39,770 --> 01:06:41,720
सूचक की सामग्री.

1242
01:06:41,720 --> 01:06:44,580
तो आप यह की ओर इशारा करते है जो कुछ करने के लिए जाना
और निरंतर सामग्री को देखो.

1243
01:06:44,580 --> 01:06:47,730
और एम्परसेंड ही है
के पते के रूप में बात.

1244
01:06:47,730 --> 01:06:52,560
>> मैं जैसे a-- एक चर है, तो चलो
पूर्णांक एक बराबर होती है कि मैंने किया कहना 3--

1245
01:06:52,560 --> 01:06:56,900
मुझे इस बात का पता लगाने के लिए चाहते हैं
चर एक स्मृति, मैं अभी कर सकते हैं

1246
01:06:56,900 --> 01:06:58,240
एक एम्परसेंड.

1247
01:06:58,240 --> 01:07:00,280
तो यह एक का पता है.

1248
01:07:00,280 --> 01:07:01,530
भावना करें?

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> तो यहाँ एक उदाहरण है.

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
इस पूर्णांक बी और int सी याद आ रही है.

1253
01:07:11,530 --> 01:07:16,520
3 साधन के बराबर होती है पूर्णांक तो यह है कि
मैं याद करने के लिए जा रहा हूँ.

1254
01:07:16,520 --> 01:07:19,870
और मैं एक स्लॉट खोजने के लिए जा रहा हूँ
और यहाँ 3 नंबर डाल दिया.

1255
01:07:19,870 --> 01:07:22,200
>> और फिर पूर्णांक बी 4 के बराबर होती है.

1256
01:07:22,200 --> 01:07:23,100
मैं एक ही बात करने जा रहा हूँ.

1257
01:07:23,100 --> 01:07:25,840
स्मृति में जाओ और एक नंबर डाल
बक्से में से एक में 4.

1258
01:07:25,840 --> 01:07:27,100
और int 5 के बराबर होती है.

1259
01:07:27,100 --> 01:07:29,740
एक और बॉक्स लगाएं और एक नंबर 5 डाल दिया.

1260
01:07:29,740 --> 01:07:36,160
>> इसलिए बाहर कर इस लाइन क्या है?
n सितारा देहात एम्परसेंड एक बराबर होती है.

1261
01:07:36,160 --> 01:07:37,800
तो सब से पहले, एन सितारा देहात.

1262
01:07:37,800 --> 01:07:39,050
यह क्या कर रहा है?

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> दर्शक: [अश्राव्य].

1265
01:07:42,298 --> 01:07:47,890
>> लुकास: हाँ, तो n सितारा देहात, सबसे पहले,
देहात नामक एक सूचक की घोषणा की.

1266
01:07:47,890 --> 01:07:53,720
और फिर इसका मूल्य बताए है
कि सूचक एक का पता होना चाहिए.

1267
01:07:53,720 --> 01:07:55,790
तो एक एम्परसेंड.

1268
01:07:55,790 --> 01:07:58,510
फिर, मैं सितारा पंजाब करते हैं,
एक सितारा पीबी क्या है?

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> ओह, माफ करना.

1271
01:08:03,150 --> 01:08:06,330
यह भी याद आ रही है. n सितारा पंजाब.

1272
01:08:06,330 --> 01:08:07,905
मैं स्टार पीसी मतलब.

1273
01:08:07,905 --> 01:08:11,200
मैं बहुत शर्मिंदा हूँ.

1274
01:08:11,200 --> 01:08:11,940
यह एक ही बात है.

1275
01:08:11,940 --> 01:08:16,408
लेकिन अब मैं एक सूचक बनाने की गिरफ्तारी अच्छा हूँ
फिर सी के लिए एक संकेत बी और को.

1276
01:08:16,408 --> 01:08:16,886
हाँ?

1277
01:08:16,886 --> 01:08:18,136
>> दर्शक: [अश्राव्य]?

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> लुकास: हाँ.

1280
01:08:26,670 --> 01:08:32,630
तो आप स्मृति के लिए जाना है और आप के लिए जाना
पा के लिए डेसिग्नेटर है कि बॉक्स,

1281
01:08:32,630 --> 01:08:37,149
आप वास्तव में करने के लिए जा रहे हैं
एक का कोई पता देखें.

1282
01:08:37,149 --> 01:08:38,399
ठीक है?

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
हाँ?

1285
01:08:43,300 --> 01:08:45,605
>> दर्शक: [अश्राव्य]?

1286
01:08:45,605 --> 01:08:49,260
>> लुकास: हाँ, सूचक एक पता है.

1287
01:08:49,260 --> 01:08:50,120
भूल जाते हैं कि कभी.

1288
01:08:50,120 --> 01:08:52,800
यह सबसे महत्वपूर्ण तरह है
संकेत के बारे में हिस्सा.

1289
01:08:52,800 --> 01:08:56,180
भंडारण और पता नहीं है
कुछ परिवर्तनशील है.

1290
01:08:56,180 --> 01:08:56,890
और कुछ?

1291
01:08:56,890 --> 01:08:58,370
कोई अन्य प्रश्न?

1292
01:08:58,370 --> 01:08:59,189
ठीक है.

1293
01:08:59,189 --> 01:09:00,399
>> तो सूचक और सारणियों.

1294
01:09:00,399 --> 01:09:08,189
याद रखें कि मैं सरणी 3 int करते हैं,
मूल रूप से, मैं क्या कर रहा हूँ मैं तरह, हूँ

1295
01:09:08,189 --> 01:09:12,779
की, एक सूचक में घोषित करने.

1296
01:09:12,779 --> 01:09:18,960
तो सरणी प्रकार के लिए एक संकेत की तरह है
स्मृति में विशिष्ट स्थान जिसमें मैं

1297
01:09:18,960 --> 01:09:21,999
पूर्णांकों के लिए तीन स्लॉट आवंटित.

1298
01:09:21,999 --> 01:09:23,430
कि मतलब?

1299
01:09:23,430 --> 01:09:30,250
>> मैं int सरणी 3 करते तो, जब मैं क्या कर रहा हूँ
कर रही है, असल में, तीन पैदा कर रही है

1300
01:09:30,250 --> 01:09:31,479
स्मृति में स्लॉट.

1301
01:09:31,479 --> 01:09:33,899
इसलिए मैं सिर्फ स्मृति में तीन स्लॉट हैं.

1302
01:09:33,899 --> 01:09:38,810
इसलिए मुझे लगता है, तो, एक सितारा सरणी, यह करते हैं
मूल रूप से सरणी की सामग्री का मतलब है,

1303
01:09:38,810 --> 01:09:46,180
जो मैं जाना, मैं सूचक मिटा मतलब
यह की ओर इशारा करते है कि उस जगह पर,

1304
01:09:46,180 --> 01:09:47,939
और मैं नंबर एक डाल दिया.

1305
01:09:47,939 --> 01:09:53,729
>> और फिर, मैं सितारा सरणी प्लस 1 करते हैं,
कि सरणी कर के रूप में एक ही बात है

1306
01:09:53,729 --> 01:09:59,690
बस मैं करने के लिए जाना है, जिसका अर्थ एक कोष्ठक
इस पर इशारा कर रहा है कि जगह.

1307
01:09:59,690 --> 01:10:03,000
और फिर प्लस 1 बनावट
मुझे एक बदलाव की स्थिति.

1308
01:10:03,000 --> 01:10:06,510
इसलिए मुझे लगता है, वास्तव में, इस स्थिति में जाना
और नंबर दो डाल.

1309
01:10:06,510 --> 01:10:10,900
>> और फिर, अंत में, मैं जब करना
सरणी प्लस 2, मैं कहाँ जाना

1310
01:10:10,900 --> 01:10:11,825
पर सरणी की ओर इशारा करते हुए.

1311
01:10:11,825 --> 01:10:14,690
और फिर मैं स्मृति ब्लॉक करने के लिए कदम.

1312
01:10:14,690 --> 01:10:16,240
और फिर मैं यहाँ तीन नंबर डाल दिया.

1313
01:10:16,240 --> 01:10:16,600
हाँ?

1314
01:10:16,600 --> 01:10:21,400
>> दर्शक: तो सितारा सरणी बस है
बहुत पहली बात कह रही है.

1315
01:10:21,400 --> 01:10:25,090
और तुम सिर्फ क्योंकि, 1 जोड़ सकते हैं
हम केवल सच हो

1316
01:10:25,090 --> 01:10:27,295
कि पहले पता संदर्भित.

1317
01:10:27,295 --> 01:10:28,545
>> लुकास: हाँ.

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
क्यों हम, उदाहरण के लिए, सरणी कहना है
0, सरणी 1 और सरणी 2?

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
मैं, तुम क्यों 0 करते हो, कह रहा हूँ
1, 2, 3 के बजाय 1, 2, 3?

1322
01:10:42,790 --> 01:10:46,550
कारणों में से एक, एक, कंप्यूटर है
प्रोग्रामर शुरू करने के लिए पसंद करते हैं

1323
01:10:46,550 --> 01:10:47,750
0 से गिनती.

1324
01:10:47,750 --> 01:10:52,370
आप सरणी 0 करते क्योंकि जब दो, है
यह सरणी कर के रूप में एक ही बात है

1325
01:10:52,370 --> 01:10:56,330
जिसका अर्थ है अधिक 0, मैं करने के लिए जाना
स्थिति यह है कि, और मैं नहीं है

1326
01:10:56,330 --> 01:10:59,320
किसी भी स्मृति ब्लॉकों को छोड़.

1327
01:10:59,320 --> 01:11:01,750
इसलिए मैं किसी भी स्मृति ब्लॉक कदम नहीं है.

1328
01:11:01,750 --> 01:11:02,015
हाँ?

1329
01:11:02,015 --> 01:11:03,265
>> दर्शक: [अश्राव्य]?

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> लुकास: तो वह क्या है पूछ रहा है
कर के बीच अंतर

1332
01:11:12,670 --> 01:11:14,000
इस या malloc कर.

1333
01:11:14,000 --> 01:11:17,550
अंतर यह है कि है
int सरणी 3 एक पैदा कर रही है

1334
01:11:17,550 --> 01:11:19,260
ढेर पर सरणी.

1335
01:11:19,260 --> 01:11:23,080
और मैं malloc करते हैं, यह
ढेर पर बनाता है.

1336
01:11:23,080 --> 01:11:25,250
कि मतलब?

1337
01:11:25,250 --> 01:11:28,870
>> तो कैसे malloc वास्तव में काम करता है?

1338
01:11:28,870 --> 01:11:32,245
तो क्यों न हम भी malloc का उपयोग करने की आवश्यकता है?

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
आंकड़े के अपने संकलक तरह बाहर सभी
आप घोषित चर कि.

1341
01:11:39,700 --> 01:11:44,040
और वह सभी के लिए जगह बनाता है
ढेर में उनमें से.

1342
01:11:44,040 --> 01:11:47,180
तो अपने चर के सभी जा रहे हैं
कहीं ढेर में किया जाना है.

1343
01:11:47,180 --> 01:11:49,460
यहाँ तो वातावरण चर है.

1344
01:11:49,460 --> 01:11:53,850
>> उन चर के लिए तो बुनियादी तौर पर, अंतरिक्ष
स्मृति में कम से आवंटित है

1345
01:11:53,850 --> 01:11:55,080
समय संकलन.

1346
01:11:55,080 --> 01:11:58,790
तो यह है कि आपके कंप्यूटर का मतलब
उन चर के सभी जानते हैं

1347
01:11:58,790 --> 01:11:59,790
पहले से.

1348
01:11:59,790 --> 01:12:02,500
यह क्या मूल्य पता करने की जरूरत नहीं है
आप उन्हें में डाल करने के लिए जा रहे हैं.

1349
01:12:02,500 --> 01:12:05,490
लेकिन यह कैसे पता करने की जरूरत
आप की जरूरत ज्यादा स्मृति.

1350
01:12:05,490 --> 01:12:09,380
>> लेकिन अब, उदाहरण के लिए, हम कहते हैं कि
आप एक सरणी बनाने या एक ले जा रहे हैं

1351
01:12:09,380 --> 01:12:13,430
आप ले जा रहे हैं कि स्ट्रिंग
उपयोगकर्ता से.

1352
01:12:13,430 --> 01:12:17,300
आप नहीं जानते कि कितनी देर स्ट्रिंग
उदाहरण के लिए, होने जा रहा है.

1353
01:12:17,300 --> 01:12:20,600
तो आप वास्तव में कितने पता नहीं है
स्मृति ब्लॉकों आप सही, आवंटित?

1354
01:12:20,600 --> 01:12:24,120
>> तो यह वास्तव में के लिए मतलब नहीं है
आप 100 अक्षरों डाल कहने के लिए.

1355
01:12:24,120 --> 01:12:26,420
और तब उपयोगकर्ता 150 लिखते हैं तो क्या होगा?

1356
01:12:26,420 --> 01:12:27,670
आप खराब हो जा रहे हैं.

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> तो बुनियादी तौर पर, आप कैसे के बारे में सुनिश्चित नहीं किया जा सकता
आप आवंटित की जरूरत ज्यादा स्मृति

1359
01:12:34,620 --> 01:12:35,960
जब आप प्रोग्राम संकलन.

1360
01:12:35,960 --> 01:12:38,240
तुम बस चलाने के समय पर पता है.

1361
01:12:38,240 --> 01:12:39,950
आप ढेर है तो यही कारण है कि है.

1362
01:12:39,950 --> 01:12:47,610
तो ढेर स्मृति किया जा रहा है
आप के दौरान आवंटन कर रहे हैं कि

1363
01:12:47,610 --> 01:12:50,810
कार्यक्रम चल रहा है की अवधि.

1364
01:12:50,810 --> 01:12:55,780
>> तो बुनियादी तौर पर, आप malloc करते हैं, क्या
आप में स्मृति का आवंटन कर रहे हैं

1365
01:12:55,780 --> 01:13:00,160
आप कर रहे हैं जिसका मतलब है कि देखने का समय,
उस वक्त पर सही निर्णय लेने कि आप

1366
01:13:00,160 --> 01:13:02,670
कि स्मृति होनी चाहिए.

1367
01:13:02,670 --> 01:13:04,210
आप यह आवंटन हो जाने पर तो है कि.

1368
01:13:04,210 --> 01:13:06,430
कि मतलब?

1369
01:13:06,430 --> 01:13:11,690
>> तो ढेर चर है, याद
उस समय संकलन पर बनाए जाते हैं.

1370
01:13:11,690 --> 01:13:14,560
और फिर ढेर चर है
तुम जाओ के रूप में बनाया जाता है

1371
01:13:14,560 --> 01:13:15,600
उदाहरण के लिए malloc, साथ.

1372
01:13:15,600 --> 01:13:16,850
>> दर्शक: [अश्राव्य]?

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> लुकास: तो GetString है
malloc फोन करने वाला.

1375
01:13:24,340 --> 01:13:26,710
मुझे malloc के बारे में बात करते हैं, और
मैं GetString समझाता हूँ.

1376
01:13:26,710 --> 01:13:32,000
तो malloc एक ही बात है
स्मृति आवंटन के रूप में.

1377
01:13:32,000 --> 01:13:34,600
तो यह आवंटित करने के लिए जा रहा है
ढेर पर स्मृति.

1378
01:13:34,600 --> 01:13:40,010
और यह एक सूचक वापस जाने के लिए जा रहा है
जहां कि स्मृति में आवंटित की गई थी.

1379
01:13:40,010 --> 01:13:43,090
>> तो आप do-- जब

1380
01:13:43,090 --> 01:13:44,910
यहाँ example-- के लिए

1381
01:13:44,910 --> 01:13:45,830
n सितारा सूचक.

1382
01:13:45,830 --> 01:13:50,520
और फिर सूचक malloc के बराबर होती है
इंच बार 10 का आकार.

1383
01:13:50,520 --> 01:13:52,110
मैं एक सूचक बना रहा हूँ.

1384
01:13:52,110 --> 01:13:59,020
और फिर मैं करने के लिए कि सूचक बताए हूँ
सूचक है कि malloc का मूल्य

1385
01:13:59,020 --> 01:13:59,680
मुझे दे रहा है.

1386
01:13:59,680 --> 01:14:04,150
>> तो मैं पूछ रहा हूँ malloc आप आवंटित कर सकते हैं
10 पूर्णांकों के लिए अंतरिक्ष.

1387
01:14:04,150 --> 01:14:05,390
यही बात कह रहा है.

1388
01:14:05,390 --> 01:14:09,020
और malloc मुझे वापस देता है एक
उस जगह के लिए संकेतक.

1389
01:14:09,020 --> 01:14:11,460
भावना करें?

1390
01:14:11,460 --> 01:14:12,270
ठीक है.

1391
01:14:12,270 --> 01:14:17,940
मैं और GetString, मूल रूप से, एक कर रही है
आप आवंटित कर सकते हैं ताकि malloc करने के लिए कॉल

1392
01:14:17,940 --> 01:14:21,680
क्रम के दौरान स्मृति.

1393
01:14:21,680 --> 01:14:26,460
>> हमेशा शून्य के लिए जाँच करने के लिए याद
malloc अशक्त वापस जाने के लिए जा रहा है क्योंकि

1394
01:14:26,460 --> 01:14:28,200
यह स्मृति आवंटित नहीं कर सकते हैं.

1395
01:14:28,200 --> 01:14:31,660
मान लीजिए कि आप एक हास्यास्पद के लिए पूछना है कि हम कहते हैं
स्मृति की राशि.

1396
01:14:31,660 --> 01:14:33,950
आपका कंप्यूटर नहीं किया जा रहा है
ज्यादा कि आवंटित करने में सक्षम.

1397
01:14:33,950 --> 01:14:36,410
>> तो malloc बस जा रहा है
अशक्त लौटने के लिए.

1398
01:14:36,410 --> 01:14:42,210
तो हमेशा के लिए जाँच अगर याद
आप malloc से मिला कि सूचक है

1399
01:14:42,210 --> 01:14:45,640
अशक्त या नहीं यह है, तो आप कर सकते हैं, क्योंकि
एक सूचक dereferencing किया और

1400
01:14:45,640 --> 01:14:48,340
पक्ष दोष के कारण.

1401
01:14:48,340 --> 01:14:50,930
और अंत में, मत भूलना
अपने मुक्त स्मृति.

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> Malloc ढेर में स्मृति पैदा कर रही है.

1404
01:15:00,560 --> 01:15:03,436
और आप स्मृति को मुक्त करने के लिए है
कार्यक्रम समाप्त होने से पहले.

1405
01:15:03,436 --> 01:15:05,370
ठीक है, यह सब मेरे लिए है.

1406
01:15:05,370 --> 01:15:07,900
क्षमा करें, रोब.

1407
01:15:07,900 --> 01:15:07,950
धन्यवाद.

1408
01:15:07,950 --> 01:15:09,878
>> [वाहवाही]

1409
01:15:09,878 --> 01:15:12,679
>> लुकास: किसी भी पिछले सवाल
रोब से पहले आता है?

1410
01:15:12,679 --> 01:15:13,138
नहीं?

1411
01:15:13,138 --> 01:15:13,597
हाँ?

1412
01:15:13,597 --> 01:15:15,892
>> दर्शक: मैं नहीं देखा था
यह एक ऑनलाइन.

1413
01:15:15,892 --> 01:15:17,269
आप अभी तक इसे अपलोड किया है?

1414
01:15:17,269 --> 01:15:19,106
>> लुकास: मैं डेव लगता है कि
जल्द ही इसे अपलोड.

1415
01:15:19,106 --> 01:15:19,880
>> डेव: यह पोस्ट किया जाएगा.

1416
01:15:19,880 --> 01:15:20,310
>> लुकास: यह ऑनलाइन हो जाएगा.

1417
01:15:20,310 --> 01:15:21,175
>> दर्शक: यह हो रहा है.

1418
01:15:21,175 --> 01:15:22,090
>> लुकास: यह हो रहा है?

1419
01:15:22,090 --> 01:15:23,157
ठीक है.

1420
01:15:23,157 --> 01:15:23,644
हाँ?

1421
01:15:23,644 --> 01:15:27,053
>> दर्शक: [अश्राव्य]?

1422
01:15:27,053 --> 01:15:30,285
>> लुकास: हाँ, तुम मुक्त करना चाहिए सभी
ढेर में डाल दिया है कि स्मृति.

1423
01:15:30,285 --> 01:15:31,535
>> दर्शक: [अश्राव्य]?

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> लुकास: हाँ.

1426
01:15:36,160 --> 01:15:39,980
आप एक संस्कृति malloc है कि किसी भी समय,
आप नि: शुल्क एक संस्कृति होनी चाहिए

1427
01:15:39,980 --> 01:15:42,640
तुम्हारे जाने के बाद कि चर का उपयोग बंद.

1428
01:15:42,640 --> 01:15:44,800
तो malloc और मुक्त हैं
हमेशा एक साथ.

1429
01:15:44,800 --> 01:15:45,410
उनकी सबसे अच्छी दोस्त.

1430
01:15:45,410 --> 01:15:46,720
हाँ.

1431
01:15:46,720 --> 01:15:47,970
रोब?

1432
01:15:47,970 --> 01:15:55,595

1433
01:15:55,595 --> 01:15:56,850
>> रोब: मैं जल्दी से जाना होगा.

1434
01:15:56,850 --> 01:16:00,466
और भी वीडियो डाल दिया जाएगा.

1435
01:16:00,466 --> 01:16:01,716
मैं पर mic है.

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> ठीक है, तो सप्ताह पांच चीजें.

1438
01:16:26,230 --> 01:16:27,970
हम पहली बात हो चुकी है.

1439
01:16:27,970 --> 01:16:33,390
तो केवल एक ढेर है कि वहाँ याद
सक्रिय समारोह कॉल प्रति फ्रेम.

1440
01:16:33,390 --> 01:16:34,710
हम एक दूसरे में देखेंगे.

1441
01:16:34,710 --> 01:16:37,850
और भी वास्तव में क्या जाता है याद
प्रत्येक ढेर फ्रेम में होने जा रहे हैं

1442
01:16:37,850 --> 01:16:41,880
हमारे कार्यों का स्थानीय चर,
में पारित कर रहे हैं कि तर्क हमारे

1443
01:16:41,880 --> 01:16:43,880
एक जोड़े के साथ काम करता है,
अन्य बातों के आप वास्तव में नहीं है

1444
01:16:43,880 --> 01:16:45,260
के बारे में चिंता करने की जरूरत है.

1445
01:16:45,260 --> 01:16:50,950
>> यहाँ तो जहां एक उदाहरण कार्यक्रम है,
नोटिस, मुख्य वापसी printfing है

1446
01:16:50,950 --> 01:16:52,830
foo 4 के लिए मूल्य.

1447
01:16:52,830 --> 01:16:57,930
foo बस वापस जाने के लिए जा रहा है
बार 4 अल्पविराम 6 के लिए मूल्य.

1448
01:16:57,930 --> 01:17:02,380
और बार कुछ स्थानीय सेट करने के लिए जा रहा है
4 बार 6 के बराबर चर एन.

1449
01:17:02,380 --> 01:17:03,920
और फिर n वापसी.

1450
01:17:03,920 --> 01:17:09,130
>> तो चलो भर में ढेर को देखो
इस कार्यक्रम की वास्तविक चलना.

1451
01:17:09,130 --> 01:17:10,500
इसलिए हमारे ढेर के नीचे है.

1452
01:17:10,500 --> 01:17:12,620
ढेर बढ़ता है याद रखें.

1453
01:17:12,620 --> 01:17:15,370
हमारे ढेर के नीचे तो, हम
मुख्य लिए एक ढेर फ्रेम किया है.

1454
01:17:15,370 --> 01:17:17,000
जब कार्यक्रम शुरू होता है, मुख्य
हमेशा पर होने जा रहा है

1455
01:17:17,000 --> 01:17:18,560
हमारे ढेर के नीचे.

1456
01:17:18,560 --> 01:17:20,880
>> और के अंदर क्या है हमारी
मुख्य लिए फ्रेम ढेर?

1457
01:17:20,880 --> 01:17:23,810
तो कोई स्थानीय कर रहे हैं, भले ही
मुख्य करने के लिए चर मैंने पहले कहा, जैसे

1458
01:17:23,810 --> 01:17:29,670
हम argc और RGV स्थान ले रहा है
मुख्य ढेर फ्रेम के अंदर.

1459
01:17:29,670 --> 01:17:33,260
अब करने जा रहा है तो मुख्य
समारोह foo कहते हैं.

1460
01:17:33,260 --> 01:17:35,125
और कहा कि foo जा रहा है इसका मतलब
अपने स्वयं के ढेर फ्रेम मिलता है.

1461
01:17:35,125 --> 01:17:36,970
>> तो अब हम के अंदर हो
समारोह foo.

1462
01:17:36,970 --> 01:17:38,610
और क्या में जाने की जरूरत है
foo के ढेर फ्रेम?

1463
01:17:38,610 --> 01:17:41,100
खैर, foo एक तर्क n है.

1464
01:17:41,100 --> 01:17:45,440
उस के बाद से और एन 4 के बराबर है क्या
मुख्य foo के तर्क के रूप में गुजर रहा है.

1465
01:17:45,440 --> 01:17:48,490
>> तो अब foo बार फोन करने के लिए जा रहा है.

1466
01:17:48,490 --> 01:17:52,070
क्या बार के अंदर किया जा रहा है
'अपनी ढेर फ्रेम की?

1467
01:17:52,070 --> 01:17:55,610
यह छह के बराबर 4 वाई के बराबर एक्स है.

1468
01:17:55,610 --> 01:17:58,540
यही कारण है कि हम करने जा रहे हैं वह सब नहीं है
बार क्योंकि ढेर फ्रेम में

1469
01:17:58,540 --> 01:18:00,580
यह भी एक स्थानीय चर n है.

1470
01:18:00,580 --> 01:18:03,370
और एन हम 24 के बराबर सेट करने के लिए जा रहे हैं.

1471
01:18:03,370 --> 01:18:05,750
>> तो अब बार n वापस जाने के लिए जा रहा है.

1472
01:18:05,750 --> 01:18:09,300
तो बार के लिए 24 लौट रहा है
ढेर फ्रेम foo.

1473
01:18:09,300 --> 01:18:12,560
और बार है कि अब, लौट रहा है क्योंकि
हम ढेर फ्रेम popping रहे हैं इसका मतलब

1474
01:18:12,560 --> 01:18:14,250
ढेर से दूर पट्टी के लिए.

1475
01:18:14,250 --> 01:18:18,430
बार किया गया था कि इतना सब स्मृति
का उपयोग ढेर से दूर अब है.

1476
01:18:18,430 --> 01:18:21,550
>> अब, foo भी जा रहा है
मुख्य करने के लिए 24 लौटने के लिए.

1477
01:18:21,550 --> 01:18:25,470
तो अब है कि foo, स्मृति लौट रहा है
कि foo अपने 'में इस्तेमाल कर रहा था

1478
01:18:25,470 --> 01:18:27,550
ढेर फ्रेम भी चला गया है.

1479
01:18:27,550 --> 01:18:29,660
और अब, मुख्य printf कॉल करने के लिए जा रहा है.

1480
01:18:29,660 --> 01:18:31,660
तो printf बस एक समारोह है.

1481
01:18:31,660 --> 01:18:35,320
हम printf कहते हैं, यह होने जा रहा है
printf के लिए एक और ढेर फ्रेम

1482
01:18:35,320 --> 01:18:36,470
समारोह कॉल.

1483
01:18:36,470 --> 01:18:37,990
>> क्या हम printf गुजर रहे हैं?

1484
01:18:37,990 --> 01:18:40,090
कि जाने के लिए क्या हो रहा है
अपने ढेर फ्रेम पर.

1485
01:18:40,090 --> 01:18:44,970
बहुत कम से कम, हम गुजर रहे हैं
उस प्रतिशत मैं n बैकस्लैश और

1486
01:18:44,970 --> 01:18:47,180
तर्क 24.

1487
01:18:47,180 --> 01:18:50,370
यह ढेर फ्रेम में यह अधिक हो सकता है
printf कुछ का उपयोग किया जाना होता है

1488
01:18:50,370 --> 01:18:51,200
स्थानीय चर.

1489
01:18:51,200 --> 01:18:51,920
हम नहीं जानते.

1490
01:18:51,920 --> 01:18:53,810
>> लेकिन वह सब printf में चला जाता है
फ्रेम हो चुकी है.

1491
01:18:53,810 --> 01:18:55,740
यह printf निष्पादित करने के लिए जा रहा है.

1492
01:18:55,740 --> 01:18:56,830
तो printf किया है.

1493
01:18:56,830 --> 01:18:57,820
यह वापस आ जाएगी.

1494
01:18:57,820 --> 01:18:58,960
अंत में, मुख्य किया जाता है.

1495
01:18:58,960 --> 01:18:59,860
मुख्य वापसी करेंगे.

1496
01:18:59,860 --> 01:19:02,020
और फिर हमारे कार्यक्रम किया जाता है.

1497
01:19:02,020 --> 01:19:02,480
हाँ?

1498
01:19:02,480 --> 01:19:04,505
>> दर्शक: आप देख रहे हैं [अश्राव्य]

1499
01:19:04,505 --> 01:19:05,900
तर्क [अश्राव्य]

1500
01:19:05,900 --> 01:19:06,830
मापदंडों?

1501
01:19:06,830 --> 01:19:09,970
>> रोब: तो एक सूक्ष्म अंतर नहीं है
तर्क और मापदंडों के बीच.

1502
01:19:09,970 --> 01:19:14,400
और वास्तव में, आम बात में, लोगों को देते हैं
बस हर समय उन्हें मिश्रण करने के लिए.

1503
01:19:14,400 --> 01:19:17,550
लेकिन पैरामीटर सामान्य हैं
चीजों के नाम है.

1504
01:19:17,550 --> 01:19:20,180
>> तो argc और argv हैं
मुख्य करने के लिए पैरामीटर.

1505
01:19:20,180 --> 01:19:23,440
तर्क क्या आप वास्तव में कर रहे हैं
उन मापदंडों के रूप में गुजरती हैं.

1506
01:19:23,440 --> 01:19:28,340
तो वहाँ मैं 4 के Foo, 4 कॉल
मैं में गुजर रहा हूँ तर्क है.

1507
01:19:28,340 --> 01:19:31,460
और के अंदर पैरामीटर एन,
Foo, मूल्य 4 पर ले जाता है

1508
01:19:31,460 --> 01:19:32,880
4 के बाद से तर्क था.

1509
01:19:32,880 --> 01:19:35,826
>> दर्शक: [अश्राव्य]?

1510
01:19:35,826 --> 01:19:37,880
>> रोब: n बार एक स्थानीय चर रहा है.

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
एन, अभी भी foo के लिए स्थानीय है लेकिन
यह फू के लिए एक पैरामीटर है.

1513
01:19:44,960 --> 01:19:48,190
यह एक स्थानीय चर नहीं है.

1514
01:19:48,190 --> 01:19:48,546
हाँ?

1515
01:19:48,546 --> 01:19:51,180
>> दर्शक: [अश्राव्य]?

1516
01:19:51,180 --> 01:19:55,400
>> रोब: foo अभी बुला रहा है बार और
जो भी बार रिटर्न लौटने.

1517
01:19:55,400 --> 01:19:56,786
>> दर्शक: [अश्राव्य]?

1518
01:19:56,786 --> 01:19:59,591
>> रोब: हाँ, बस कई को देखने के लिए
फ्रेम हो चुकी है.

1519
01:19:59,591 --> 01:20:00,082
हाँ?

1520
01:20:00,082 --> 01:20:03,519
>> दर्शक: क्यों foo बुलाया गया था
printf से पहले?

1521
01:20:03,519 --> 01:20:05,920
>> रोब: क्यों foo printf से पहले कहा जाता था?

1522
01:20:05,920 --> 01:20:10,740
मैं हो सकता था तो, बजाय, कुछ किया
पूर्णांक की तरह एक्स 4 की foo के बराबर होती है

1523
01:20:10,740 --> 01:20:12,980
और फिर एक्स मुद्रित.

1524
01:20:12,980 --> 01:20:17,900
लेकिन इसके बजाय, मैं समारोह संयुक्त
printf तर्क में कहते हैं.

1525
01:20:17,900 --> 01:20:23,670
>> लेकिन सूचना है कि हम वास्तव में नहीं कर सकते
हम जब तक printf को कॉल निष्पादित

1526
01:20:23,670 --> 01:20:25,610
4 के foo क्या है पता.

1527
01:20:25,610 --> 01:20:27,480
इसलिए हम इस मूल्यांकन करने के लिए जा रहे हैं.

1528
01:20:27,480 --> 01:20:32,504
और जो कुछ किया है केवल एक बार जा रहे हैं
वापस आते हैं और इस मूल्यांकन करने के लिए.

1529
01:20:32,504 --> 01:20:32,990
हाँ?

1530
01:20:32,990 --> 01:20:37,364
>> दर्शक: दोनों बार के बाद से [अश्राव्य]

1531
01:20:37,364 --> 01:20:41,738
मूल्य, क्यों हम [अश्राव्य] नहीं है?

1532
01:20:41,738 --> 01:20:44,400
>> रोब: वे पूरी तरह से पूर्णांक होना चाहिए.

1533
01:20:44,400 --> 01:20:46,260
उस पर पकड़ा नहीं गया था
कई गुजरता.

1534
01:20:46,260 --> 01:20:49,010
तो यह पूर्णांक बार और पूर्णांक होना चाहिए
उन दोनों के बाद से foo

1535
01:20:49,010 --> 01:20:50,460
पूर्णांकों लौट रहे हैं.

1536
01:20:50,460 --> 01:20:54,214
वे नहीं जा रहे हैं तो शून्य ही है
वास्तविक मूल्यों को वापस जाने के लिए.

1537
01:20:54,214 --> 01:20:54,692
हाँ?

1538
01:20:54,692 --> 01:20:58,038
>> दर्शक: आप एक पंक्ति थी तो ऊपर
वापसी, [अश्राव्य]?

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> रोब: वापसी के ऊपर एक रेखा?

1541
01:21:03,730 --> 01:21:04,410
>> दर्शक: हाँ.

1542
01:21:04,410 --> 01:21:10,780
जैसा आप printf और [सुनाई] किया,
यह दो बार प्रिंट होगा?

1543
01:21:10,780 --> 01:21:12,992
>> रोब: foo के अंदर तो?

1544
01:21:12,992 --> 01:21:15,945
हम यहीं एक printf था?

1545
01:21:15,945 --> 01:21:16,750
>> दर्शक: हाँ.

1546
01:21:16,750 --> 01:21:19,510
>> रोब: तो अगर हम एक printf सही था
यहां, यह एक बार प्रिंट होगा.

1547
01:21:19,510 --> 01:21:23,400
हम एक बार सही foo बुला रहे हैं
यहाँ है, तो हम printf मारा हूँ.

1548
01:21:23,400 --> 01:21:24,620
तो फिर हम बार फोन करता हूँ.

1549
01:21:24,620 --> 01:21:25,710
और फिर foo वापस आ जाएगी.

1550
01:21:25,710 --> 01:21:26,275
और यह बात है.

1551
01:21:26,275 --> 01:21:30,985
हम केवल कभी मुठभेड़
एक बार printf.

1552
01:21:30,985 --> 01:21:31,482
हाँ?

1553
01:21:31,482 --> 01:21:32,973
>> दर्शक: [अश्राव्य]

1554
01:21:32,973 --> 01:21:37,950
हम पहली बार कर रहे हैं क्योंकि printf foo बुला
printf बुला और फिर हम गुजर रहे हैं

1555
01:21:37,950 --> 01:21:38,580
तर्क.

1556
01:21:38,580 --> 01:21:40,960
>> रोब: सिद्धांत में तो नहीं है,
printf foo बुला?

1557
01:21:40,960 --> 01:21:42,220
तो कोई.

1558
01:21:42,220 --> 01:21:47,360
सी जा रहा है कि बस आदेश
हम कर सकते हैं, इससे पहले इन बातों है निष्पादित

1559
01:21:47,360 --> 01:21:49,800
, तर्कों के सभी एक समारोह कॉल
समारोह के लिए है

1560
01:21:49,800 --> 01:21:51,600
पूरी तरह से मूल्यांकन किया जाना.

1561
01:21:51,600 --> 01:21:53,540
तो यह पूरी तरह से मूल्यांकन किया जाता है?

1562
01:21:53,540 --> 01:21:54,610
हाँ, यह सिर्फ एक स्ट्रिंग है.

1563
01:21:54,610 --> 01:21:55,480
यह सिर्फ एक मूल्य है.

1564
01:21:55,480 --> 01:21:57,200
>> तो फिर हम पूरी तरह से करने के लिए है
इस मूल्यांकन.

1565
01:21:57,200 --> 01:21:59,720
यह अब सभी की, बार किया जाता है
अपने तर्कों मूल्यांकन कर रहे हैं.

1566
01:21:59,720 --> 01:22:01,982
और अब हम कर सकते हैं
printf के लिए कहते हैं.

1567
01:22:01,982 --> 01:22:02,478
हाँ?

1568
01:22:02,478 --> 01:22:03,966
>> दर्शक: एक सवाल.

1569
01:22:03,966 --> 01:22:06,942
आप एक शून्य समारोह है, तो चाहिए
आप वापसी अर्धविराम है?

1570
01:22:06,942 --> 01:22:09,910
>> रोब: आप एक वापसी अर्धविराम नहीं करते
आप एक शून्य समारोह है.

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
ठीक है.

1573
01:22:14,780 --> 01:22:15,830
तो अब कुछ ढेर सामान.

1574
01:22:15,830 --> 01:22:19,640
तो ढेर हम सौदा करने जा रहे हैं कि कैसे
गतिशील स्मृति प्रबंधन के साथ.

1575
01:22:19,640 --> 01:22:23,100
और यह सीधे साथ विरोधाभासों
हम स्वत कहेंगे जो ढेर

1576
01:22:23,100 --> 01:22:24,100
स्मृति प्रबंधन.

1577
01:22:24,100 --> 01:22:27,140
>> ढेर पर तो, क्या तुम सच में है कभी नहीं
कैसे स्थानीय चर के साथ सौदा करने के लिए

1578
01:22:27,140 --> 01:22:30,400
धक्का दिया और सब बंद popped किया जा रहा है
इन ढेर फ्रेम और वह सब सामान.

1579
01:22:30,400 --> 01:22:31,070
आप इसके बारे में चिंता करने की ज़रूरत नहीं है.

1580
01:22:31,070 --> 01:22:32,070
यह स्वचालित है.

1581
01:22:32,070 --> 01:22:36,990
तो ढेर पुस्तिका है.

1582
01:22:36,990 --> 01:22:38,070
और [अश्राव्य]

1583
01:22:38,070 --> 01:22:41,260
इन कार्यों से आता है
malloc और मुक्त.

1584
01:22:41,260 --> 01:22:43,550
>> तो यहाँ एक और कार्यक्रम है.

1585
01:22:43,550 --> 01:22:47,145
हम क्या कर रहे सभी mallocing है
एक पूर्णांक.

1586
01:22:47,145 --> 01:22:49,360
हम स्टार एक्स में यह भंडारण कर रहे हैं.

1587
01:22:49,360 --> 01:22:52,520
बेशक, हम जाँच करने के लिए
एक्स शून्य है देखने के लिए.

1588
01:22:52,520 --> 01:22:56,400
तो हम बस क्या स्थापित करने के लिए जा रहे हैं
एक्स 50 करने के लिए इशारा कर रहा है.

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
, की ओर इशारा कर रहा है कि क्या एक्स प्रिंट
प्रिंट एक्स, और फिर फ्री एक्स.

1591
01:23:03,260 --> 01:23:08,920
>> तो कैसे यह वास्तव में लग रहा है
हम अपने ढेर और ढेर पर लगता है?

1592
01:23:08,920 --> 01:23:10,950
तो हम फिर से शुरू करेंगे.

1593
01:23:10,950 --> 01:23:12,580
पहले के रूप में हमारे ढेर के नीचे.

1594
01:23:12,580 --> 01:23:15,930
तुमको सीधे ढेर कि याद रखें
ढेर विरोध करता है?

1595
01:23:15,930 --> 01:23:18,850
तो हम करने जा रहे हैं
वहाँ हमारे ढेर के ऊपर.

1596
01:23:18,850 --> 01:23:22,590
>> हमारे ढेर के नीचे तो, हम हैं
मुख्य लिए हमारे ढेर फ्रेम.

1597
01:23:22,590 --> 01:23:28,000
यह argc, argv के लिए स्थान है, और हम
अब एक स्थानीय चर एक्स, जो है

1598
01:23:28,000 --> 01:23:30,030
एक पूर्णांक सितारा है.

1599
01:23:30,030 --> 01:23:32,240
इसलिए हम पुनरावृति करने के लिए जा रहे हैं
इस कार्यक्रम के माध्यम से.

1600
01:23:32,240 --> 01:23:34,420
हम पहली बात है
malloc के लिए एक फोन.

1601
01:23:34,420 --> 01:23:36,250
>> इसलिए हम malloc के लिए एक फोन कर रहे हैं.

1602
01:23:36,250 --> 01:23:37,100
Malloc एक समारोह है.

1603
01:23:37,100 --> 01:23:38,770
यह एक ढेर फ्रेम हो रहा है.

1604
01:23:38,770 --> 01:23:40,180
क्या हम malloc को पारित कर रहे हैं?

1605
01:23:40,180 --> 01:23:41,610
अंदर जाने के लिए जा रहा है
ढेर फ्रेम की.

1606
01:23:41,610 --> 01:23:45,130
हम 4 है जो एन, के आकार गुजर रहे हैं.

1607
01:23:45,130 --> 01:23:49,700
इसलिए कि malloc को पारित कर दिया है.

1608
01:23:49,700 --> 01:23:50,910
>> Malloc क्या करता है?

1609
01:23:50,910 --> 01:23:53,820
यह हमें ढेर पर कुछ जगह पकड़ लेता है.

1610
01:23:53,820 --> 01:23:55,320
तो हम ढेर करने के लिए जाने के लिए जा रहे हैं.

1611
01:23:55,320 --> 01:23:57,990
और हम हड़पने के लिए जा रहे हैं
ढेर से 4 बाइट्स.

1612
01:23:57,990 --> 01:24:01,500
तो चलो बस उस दे
एक मनमाना पता.

1613
01:24:01,500 --> 01:24:06,680
0x123 कि बस एक है नाटक
ढेर पर है कि पता.

1614
01:24:06,680 --> 01:24:12,300
>> तो उस के अंदर वास्तव में क्या है
पता Ox123 पर स्मृति के क्षेत्र?

1615
01:24:12,300 --> 01:24:13,080
कचरा.

1616
01:24:13,080 --> 01:24:15,270
इसलिए हम इसमें कुछ भी जमा नहीं किया है.

1617
01:24:15,270 --> 01:24:18,830
तो जहाँ तक हम जानते हैं
कुछ भी हो सकता है.

1618
01:24:18,830 --> 01:24:20,560
आप यह शून्य है मान नहीं होना चाहिए.

1619
01:24:20,560 --> 01:24:23,870
यह नहीं शून्य सबसे अधिक संभावना है.

1620
01:24:23,870 --> 01:24:26,260
>> तो अब malloc रिटर्न.

1621
01:24:26,260 --> 01:24:28,020
और हम जब malloc रिटर्न क्या करते हो?

1622
01:24:28,020 --> 01:24:29,800
हम यह रिटर्न क्या निर्धारित किया है.

1623
01:24:29,800 --> 01:24:32,290
हम के बराबर एक्स सेट
यह लौट रहा है.

1624
01:24:32,290 --> 01:24:33,690
तो क्या यह लौट रहा है?

1625
01:24:33,690 --> 01:24:38,150
उस के बाद से यह 0x123 लौट रहा है
स्मृति के ब्लॉक का पता यह है कि

1626
01:24:38,150 --> 01:24:40,850
सिर्फ ढेर में आवंटित.

1627
01:24:40,850 --> 01:24:47,160
>> तो 0x123 एक्स अब सेट किया जा रहा है लौटने
0x123 के बराबर है, जो pictorially,

1628
01:24:47,160 --> 01:24:52,940
हम अक्सर एक वास्तविक होने एक्स के रूप में आकर्षित
उस ब्लॉक की ओर इशारा करते तीर.

1629
01:24:52,940 --> 01:24:55,820
लेकिन एक्स सिर्फ उस पते जमा कर रहा है.

1630
01:24:55,820 --> 01:24:58,670
तो अब हम एक्स शून्य है की जाँच करने के लिए है.

1631
01:24:58,670 --> 01:24:59,120
यह शून्य नहीं है.

1632
01:24:59,120 --> 01:25:02,170
हम चाहते हैं कि malloc सफल रहा कि नाटक.

1633
01:25:02,170 --> 01:25:04,950
>> तो अब स्टार एक्स 50 के बराबर होती है.

1634
01:25:04,950 --> 01:25:08,450
तो सितारा यह मतलब को याद
उस पते पर जाना.

1635
01:25:08,450 --> 01:25:12,700
तो 0x123 हम करने जा रहे हैं
उस पते पर जाना.

1636
01:25:12,700 --> 01:25:14,660
इसलिए कि वहां हमें लाता है.

1637
01:25:14,660 --> 01:25:16,310
हम उस पते पर क्या कर रहे हैं?

1638
01:25:16,310 --> 01:25:19,020
हम 50 भंडारण कर रहे हैं.

1639
01:25:19,020 --> 01:25:22,500
>> तो इस लाइन के बाद, क्या है
चीजों की तरह देखने के लिए जा रहे हैं.

1640
01:25:22,500 --> 01:25:24,640
तो अब यह नहीं रह गया है
वहां कचरा.

1641
01:25:24,640 --> 01:25:28,910
अब हम 50 में है कि पता है कि
विशेष पते क्योंकि

1642
01:25:28,910 --> 01:25:32,410
हम चाहते हैं कि करने के लिए यह निर्धारित किया है.

1643
01:25:32,410 --> 01:25:32,790
ठीक है?

1644
01:25:32,790 --> 01:25:34,370
तो अब हम एफ मुद्रित करने के लिए जा रहे हैं.

1645
01:25:34,370 --> 01:25:38,490
>> तो पहले हम स्टार एक्स मुद्रित करने के लिए जा रहे हैं.

1646
01:25:38,490 --> 01:25:39,640
तो स्टार एक्स क्या है?

1647
01:25:39,640 --> 01:25:44,300
फिर, स्टार एक्स के लिए जाने का मतलब
एक्स की ओर इशारा कर रहा है कि बात.

1648
01:25:44,300 --> 01:25:47,140
तो एक्स कि को 0x123 जाओ जमा कर रहा है.

1649
01:25:47,140 --> 01:25:48,490
हम 50 मिलता है.

1650
01:25:48,490 --> 01:25:50,540
इसलिए कि च मुद्रित.

1651
01:25:50,540 --> 01:25:54,900
और यह बात 50 मुद्रित करने के लिए जा रहा है इसका मतलब है.

1652
01:25:54,900 --> 01:25:56,850
और फिर देता है.

1653
01:25:56,850 --> 01:25:58,340
>> और फिर हम दूसरे printf है.

1654
01:25:58,340 --> 01:25:59,370
अब हम प्रतिशत पी रहे हैं.

1655
01:25:59,370 --> 01:26:01,680
आप इसे नहीं देखा है, तो वह है
बस आपको एक सूचक प्रिंट कैसे.

1656
01:26:01,680 --> 01:26:04,960
इसलिए हम प्रतिशत प्रतिशत मैं है
एफ, और पहले से ही उन सब के सब.

1657
01:26:04,960 --> 01:26:07,160
तो प्रतिशत पी, एक सूचक मुद्रित.

1658
01:26:07,160 --> 01:26:08,920
>> तो एक्स एक सूचक है.

1659
01:26:08,920 --> 01:26:13,440
तो हम खुद को एक्स मुद्रित करने के लिए जा रहे हैं,
हम अंदर वास्तव में है क्या मुद्रण कर रहे हैं

1660
01:26:13,440 --> 01:26:19,220
तो पहले 0x123 है जो एक्स,
प्रिंट एफ 50 मुद्रित करने के लिए जा रहा है.

1661
01:26:19,220 --> 01:26:23,620
दूसरा छापा च जा रहा है
हाँ 0x123 मुद्रित करने के लिए?

1662
01:26:23,620 --> 01:26:27,460
>> दर्शक: आप प्रतिशत का उपयोग न करें
एक्स एक सूचक मुद्रित करने के लिए?

1663
01:26:27,460 --> 01:26:31,200
>> रोब: तो तुम प्रतिशत का उपयोग करते हैं
एक्स एक सूचक मुद्रित करने के लिए?

1664
01:26:31,200 --> 01:26:38,350
तो, आप कर सकते हैं, लेकिन प्रतिशत एक्स बस है
आम तौर पर, के लिए जैसे आप कुछ है तो

1665
01:26:38,350 --> 01:26:40,325
पूर्णांक और आप मुद्रित करना चाहते हैं
यह एक हेक्साडेसिमल के रूप में.

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
आप ऐसा कैसे सिर्फ है कि.

1668
01:26:44,880 --> 01:26:47,160
>> जबकि, प्रतिशत घ होगा
दशमलव के रूप में मुद्रित.

1669
01:26:47,160 --> 01:26:50,310
हम प्रतिशत प्राप्त किया गया है कि है
डी. मैं सिर्फ पूर्णांक है.

1670
01:26:50,310 --> 01:26:52,690
प्रतिशत P विशेष रूप से है
संकेत के लिए.

1671
01:26:52,690 --> 01:26:54,060
>> तो एक्स एक सूचक है.

1672
01:26:54,060 --> 01:26:56,360
हम प्रतिशत P उपयोग करना चाहते हैं.

1673
01:26:56,360 --> 01:26:57,937
लेकिन प्रतिशत एक्स काम कर सकता था.

1674
01:26:57,937 --> 01:26:58,414
हाँ?

1675
01:26:58,414 --> 01:26:59,664
>> दर्शक: [अश्राव्य]?

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> रोब: हाँ.

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
इस के लिए कम से कम इतना call-- मैं
इसे यहाँ में शामिल नहीं किया था.

1680
01:27:13,440 --> 01:27:19,850
लेकिन इन दोनों तर्कों जरूरी हैं
इस ढेर फ्रेम के अंदर

1681
01:27:19,850 --> 01:27:23,040
किसी भी स्थानीय चर के साथ
printf का उपयोग होना होता है.

1682
01:27:23,040 --> 01:27:27,020
और फिर अगले कॉल अब printf को
printf के अंदर ढेर फ्रेम है

1683
01:27:27,020 --> 01:27:33,960
प्रतिशत पी बैकस्लैश n और जो कुछ भी
एक्स के मूल्य 0x123 है, जो है.

1684
01:27:33,960 --> 01:27:34,425
हाँ?

1685
01:27:34,425 --> 01:27:35,675
>> दर्शक: [अश्राव्य]?

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> रोब: यह कुछ प्रिंट हूँ
कि इस तरह दिखता है.

1688
01:27:40,880 --> 01:27:41,846
>> दर्शक: [अश्राव्य].

1689
01:27:41,846 --> 01:27:44,510
>> रोब: तो यह पता फार्म में यह प्रिंट.

1690
01:27:44,510 --> 01:27:47,003
यह एक पते की तरह लग रहा है.

1691
01:27:47,003 --> 01:27:47,494
हाँ?

1692
01:27:47,494 --> 01:27:49,458
>> दर्शक: [अश्राव्य]?

1693
01:27:49,458 --> 01:27:51,075
>> रोब: क्यों क्या है?

1694
01:27:51,075 --> 01:27:52,920
>> दर्शक: [अश्राव्य]?

1695
01:27:52,920 --> 01:27:55,240
>> रोब: क्यों इस सूचक 4 बाइट्स है?

1696
01:27:55,240 --> 01:27:58,500
तो एक पूरी गुच्छा रहे हैं
इस के सामने 0 के के.

1697
01:27:58,500 --> 01:28:03,740
तो यह वास्तव में 0x0000000123 है.

1698
01:28:03,740 --> 01:28:06,510
एक 64 बिट सिस्टम पर, वहाँ होगा
अधिक शून्य की एक पूरी गुच्छा.

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
हाँ?

1701
01:28:11,900 --> 01:28:13,150
>> दर्शक: [अश्राव्य].

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> रोब: तो पहले printf
print-- जा रहा है

1704
01:28:21,130 --> 01:28:21,980
>> दर्शक: [अश्राव्य].

1705
01:28:21,980 --> 01:28:24,420
>> रोब: हाँ, यह मुद्रित करने के लिए जा रहा है
क्या एक्स की ओर इशारा कर रहा है.

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
स्टार यह क्या कहते हैं
बात की ओर इशारा करते.

1708
01:28:29,070 --> 01:28:30,300
यह पकड़ो.

1709
01:28:30,300 --> 01:28:31,455
तो यह की ओर इशारा कर रहा है क्या?

1710
01:28:31,455 --> 01:28:31,850
50.

1711
01:28:31,850 --> 01:28:32,410
यह पकड़ो.

1712
01:28:32,410 --> 01:28:33,390
यही कारण है कि हम मुद्रित करने के लिए जा रहे हैं.

1713
01:28:33,390 --> 01:28:37,020
अगले एक, जबकि, हम कर रहे हैं
अभी से ही एक्स मुद्रण.

1714
01:28:37,020 --> 01:28:38,850
च के अंदर क्या है?

1715
01:28:38,850 --> 01:28:43,710
0x123.

1716
01:28:43,710 --> 01:28:44,500
ठीक है.

1717
01:28:44,500 --> 01:28:46,620
>> और फिर, अंत में, हम स्वतंत्र है.

1718
01:28:46,620 --> 01:28:48,040
क्या हम मुक्त करने के लिए पारित कर रहे हैं?

1719
01:28:48,040 --> 01:28:49,470
हम एक्स गुजर रहे हैं.

1720
01:28:49,470 --> 01:28:52,380
मैं वास्तव में प्रदर्शित समय
यह ढेर फ्रेम में.

1721
01:28:52,380 --> 01:28:56,370
>> इसलिए हम मूल्य गुजर रहे हैं
0x123 मुक्त करने के लिए.

1722
01:28:56,370 --> 01:28:59,070
तो अब जानता मुक्त, सब ठीक है,
मैं ढेर करने के लिए ऊपर जाना है

1723
01:28:59,070 --> 01:29:00,050
और कहा कि स्मृति मुक्त.

1724
01:29:00,050 --> 01:29:03,920
यह अब उपयोग कर रहा है
पते 0x123 पर है.

1725
01:29:03,920 --> 01:29:07,010
>> तो नि: शुल्क जारी करने जा रहा है
ढेर से कि.

1726
01:29:07,010 --> 01:29:09,490
अब हमारी ढेर फिर खाली है.

1727
01:29:09,490 --> 01:29:11,120
हम कोई स्मृति लीक है.

1728
01:29:11,120 --> 01:29:12,940
अब मुफ्त में वापस आ जाएगी.

1729
01:29:12,940 --> 01:29:16,130
कि एक्स अभी भी 0x123 नोटिस.

1730
01:29:16,130 --> 01:29:18,240
लेकिन यह है कि अब मान्य स्मृति नहीं है.

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
हम अब भिन्नता एक्स चाहिए.

1733
01:29:23,986 --> 01:29:24,440
हाँ?

1734
01:29:24,440 --> 01:29:27,240
>> दर्शक: 0 बेमानी वापसी है?

1735
01:29:27,240 --> 01:29:28,290
>> रोब: 0 बेमानी returen है?

1736
01:29:28,290 --> 01:29:31,110
हाँ.

1737
01:29:31,110 --> 01:29:33,950
हम सिर्फ वहाँ क्योंकि उस डाल
हम हवा के लिए एक वापसी एक है.

1738
01:29:33,950 --> 01:29:36,830
तो यह हाँ, देता है, की तरह है
0 वापसी शामिल हैं.

1739
01:29:36,830 --> 01:29:37,310
हाँ?

1740
01:29:37,310 --> 01:29:38,560
>> दर्शक: [अश्राव्य]?

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> रोब: तो नि: शुल्क एक्स के बाद, क्या होता है अगर
हम संकेतक भिन्नता की कोशिश की?

1743
01:29:45,580 --> 01:29:47,240
यह कुछ भी गलत हो जाता है कि संभव है.

1744
01:29:47,240 --> 01:29:49,330
हम अभी भी 50 मिल जाएगा कि यह संभव है.

1745
01:29:49,330 --> 01:29:53,590
>> ऐसा लगता है कि स्मृति है कि, यह भी संभव है,
अब कुछ और के लिए इस्तेमाल किया जा रहा है.

1746
01:29:53,590 --> 01:29:57,140
तो यह अपरिभाषित व्यवहार है.

1747
01:29:57,140 --> 01:30:00,772
और अपरिभाषित कुछ भी मतलब
हो सकता है.

1748
01:30:00,772 --> 01:30:01,250
हाँ?

1749
01:30:01,250 --> 01:30:02,500
>> दर्शक: [अश्राव्य]?

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> रोब: नहीं, तो आप आवंटित अगर
कुछ और करने के लिए एक्स.

1752
01:30:10,830 --> 01:30:15,870
तो यहीं अगर हम एक्स के बराबर होती कहा
malloc कुछ else--

1753
01:30:15,870 --> 01:30:17,100
malloc आकार event--

1754
01:30:17,100 --> 01:30:20,180
फिर उस मूल ब्लॉक
स्मृति से मुक्त नहीं है.

1755
01:30:20,180 --> 01:30:21,490
और हम आधिकारिक तौर पर इसे खो दिया है.

1756
01:30:21,490 --> 01:30:23,150
यह एक स्मृति रिसाव है.

1757
01:30:23,150 --> 01:30:25,090
हम सभी संदर्भ खो दिया है
स्मृति की कि ब्लॉक करने के लिए.

1758
01:30:25,090 --> 01:30:26,827
इसलिए हम कभी यह मुक्त कर सकते हैं कोई रास्ता नहीं है.

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
ठीक है, तो फिर किया 0 साधन वापसी.

1761
01:30:36,630 --> 01:30:37,900
>> ठीक है, तो ढेर अतिप्रवाह.

1762
01:30:37,900 --> 01:30:39,320
यहाँ विचार क्या है?

1763
01:30:39,320 --> 01:30:41,210
तो याद है, ढेर नीचे जा रहा है.

1764
01:30:41,210 --> 01:30:43,480
ढेर ऊपर जा रहा है.

1765
01:30:43,480 --> 01:30:48,000
तो इस व्याख्यान से उदाहरण था,
मैं जहां मुख्य बस जा रहा है, लगता है कि

1766
01:30:48,000 --> 01:30:51,380
जा रहा है जो इस समारोह foo, कॉल
अधिक बारी बारी से अपने आप कॉल करने के लिए और

1767
01:30:51,380 --> 01:30:52,320
फिर से.

1768
01:30:52,320 --> 01:30:55,370
>> तो फ्रेम करने के लिए जा रहे हैं ढेर
वास्तव में एक ही काम करते हैं.

1769
01:30:55,370 --> 01:30:58,130
इसलिए हम मुख्य के साथ शुरू करने जा रहे हैं
नीचे ढेर फ्रेम के रूप में.

1770
01:30:58,130 --> 01:31:02,000
फिर मुख्य, foo कॉल करने के लिए जा रहा है, जो
एक ढेर फ्रेम हो रहा है.

1771
01:31:02,000 --> 01:31:04,260
>> फिर foo foo कॉल करने के लिए जा रहा है
फिर, जो हो रहा है

1772
01:31:04,260 --> 01:31:05,500
एक और ढेर फ्रेम.

1773
01:31:05,500 --> 01:31:08,270
और फिर, और फिर, और फिर,
और फिर जब तक, अंत में, हम चलाते हैं

1774
01:31:08,270 --> 01:31:09,190
ढेर में.

1775
01:31:09,190 --> 01:31:11,990
तो यह है कि हम कैसे मिलता है
एक ढेर अतिप्रवाह.

1776
01:31:11,990 --> 01:31:14,910
और इस बिंदु पर, आप गलती SEG.

1777
01:31:14,910 --> 01:31:17,335
या फिर आप वास्तव में SEG से पहले गलती होगी
इस बिंदु लेकिन हाँ.

1778
01:31:17,335 --> 01:31:19,660
>> दर्शक: कोर डंप है
SEG गलती के रूप में एक ही?

1779
01:31:19,660 --> 01:31:26,140
>> रोब: तो आप विभाजन देखेंगे
गलती कोर फेंक दिया.

1780
01:31:26,140 --> 01:31:28,760
आप एक कोर डंप जब मिल
आप गलती SEG.

1781
01:31:28,760 --> 01:31:32,580
और यह सभी की एक डंप की तरह है
अपने मौजूदा स्मृति की सामग्री तो

1782
01:31:32,580 --> 01:31:36,670
आप कोशिश करते हैं और पहचान कर सकते हैं
क्यों आप गलती SEG.

1783
01:31:36,670 --> 01:31:37,135
हाँ?

1784
01:31:37,135 --> 01:31:38,385
>> दर्शक: [अश्राव्य]?

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> रोब: तो विखंडन दोष साधन
एक पोट अतिप्रवाह है.

1787
01:31:45,460 --> 01:31:47,060
इसलिए जरूरी नहीं.

1788
01:31:47,060 --> 01:31:49,880
विखंडन दोष आप कर रहे हैं कि इसका मतलब है
एक तरह से छू स्मृति

1789
01:31:49,880 --> 01:31:50,880
आप नहीं होना चाहिए.

1790
01:31:50,880 --> 01:31:54,750
तो जो हो रहा है की एक तरह से, जब है
आप हम छू शुरू, अतिप्रवाह हो चुकी है

1791
01:31:54,750 --> 01:31:58,736
हम नहीं होना चाहिए कि एक तरह से स्मृति.

1792
01:31:58,736 --> 01:31:59,208
हाँ?

1793
01:31:59,208 --> 01:32:00,458
>> दर्शक: [अश्राव्य]?

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> रोब: एक अनंत लूप के अंदर तो.

1796
01:32:05,830 --> 01:32:08,770
की तरह, यह एक पुनरावर्ती अनंत की तरह है
पाश और इसलिए हम एक और मिल

1797
01:32:08,770 --> 01:32:09,770
ढेर प्रत्येक समय सीमा.

1798
01:32:09,770 --> 01:32:13,540
लेकिन सिर्फ एक नियमित रूप से अंदर
अनंत one-- जबकि

1799
01:32:13,540 --> 01:32:16,390
ठीक है, चलो भी मुद्रित नहीं करते f--

1800
01:32:16,390 --> 01:32:17,040
कुछ करो.

1801
01:32:17,040 --> 01:32:18,390
जो भी हो.

1802
01:32:18,390 --> 01:32:20,610
>> हम हो रही हो नहीं जा रहे हैं
एक और ढेर फ्रेम.

1803
01:32:20,610 --> 01:32:22,530
हम सिर्फ पाशन रखने के लिए जा रहे हैं
इस एकल अनुदेश से अधिक.

1804
01:32:22,530 --> 01:32:23,920
ढेर नहीं बढ़ रहा है.

1805
01:32:23,920 --> 01:32:27,290
यह प्रत्येक पुनरावर्ती कि तथ्य है
कॉल हमें एक ढेर फ्रेम दे रहा है.

1806
01:32:27,290 --> 01:32:31,231
हम एक ढेर अतिप्रवाह मिल रहा है.

1807
01:32:31,231 --> 01:32:31,728
हाँ?

1808
01:32:31,728 --> 01:32:38,189
>> दर्शक: तो अगर आप पाने के लिए कहा
पाश जबकि और फिर [अश्राव्य]?

1809
01:32:38,189 --> 01:32:42,000
>> रोब: अगर जबकि पाश के अंदर तो
एक printf वहाँ था, आप अभी भी होगा

1810
01:32:42,000 --> 01:32:42,790
SEG नहीं गलती.

1811
01:32:42,790 --> 01:32:46,090
मैं सिर्फ बातें भ्रमित नहीं करना चाहता था.

1812
01:32:46,090 --> 01:32:46,610
यह पाश होगा.

1813
01:32:46,610 --> 01:32:48,225
आप एक एकल ढेर मिलता था
printf के लिए फ्रेम.

1814
01:32:48,225 --> 01:32:49,580
>> तो printf लौटेंगे.

1815
01:32:49,580 --> 01:32:50,280
तो फिर तुम फिर पाश था.

1816
01:32:50,280 --> 01:32:51,460
आप एक एकल ढेर मिलता था
printf के लिए फ्रेम.

1817
01:32:51,460 --> 01:32:52,850
यह लौटेंगे.

1818
01:32:52,850 --> 01:32:54,060
एकल ढेर फ्रेम.

1819
01:32:54,060 --> 01:33:00,215
तो आप इस अनंत नहीं मिल रहे
ढेर फ्रेम जमा.

1820
01:33:00,215 --> 01:33:03,185
>> दर्शक: [अश्राव्य]?

1821
01:33:03,185 --> 01:33:04,040
>> रोब: हाँ.

1822
01:33:04,040 --> 01:33:09,360
तो इस पर ढेर अतिप्रवाह होता है
इनमें से कोई नहीं क्योंकि

1823
01:33:09,360 --> 01:33:11,600
foo के लिए कॉल लौट रहे हैं.

1824
01:33:11,600 --> 01:33:15,250
हम वापस, तो हम करेंगे तो
ढेर फ्रेम खोने लगते हैं.

1825
01:33:15,250 --> 01:33:17,870
और फिर हम अतिप्रवाह हो चुकी है नहीं होगा.

1826
01:33:17,870 --> 01:33:20,070
आप एक आधार के मामले जरूरत यही कारण है कि
अपने निजी कार्यों के लिए.

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
हाँ?

1829
01:33:23,479 --> 01:33:27,375
>> दर्शक: संभावित आकार और है
ढेर के लिए उसी के लिए ढेर

1830
01:33:27,375 --> 01:33:29,880
सभी कार्यक्रमों?

1831
01:33:29,880 --> 01:33:31,910
>> रोब: मोटे तौर पर.

1832
01:33:31,910 --> 01:33:35,090
है ढेर के संभावित आकार और
सभी कार्यक्रमों के लिए एक ही ढेर?

1833
01:33:35,090 --> 01:33:37,180
मोटे तौर पर.

1834
01:33:37,180 --> 01:33:40,080
कुछ randomization के लिए है
जहां ढेर शुरू होता है और

1835
01:33:40,080 --> 01:33:42,400
जहां ढेर शुरू होता है.

1836
01:33:42,400 --> 01:33:45,870
आप की एक पूरी बहुत कुछ के लिए होता है
वैश्विक चर और बातें, आप कर सकते हैं

1837
01:33:45,870 --> 01:33:49,520
कुछ जगह से दूर ले
अपने ढेर के लिए.

1838
01:33:49,520 --> 01:33:54,060
>> एक 64 बिट सिस्टम पर, आप वस्तुतः
अनंत स्मृति है.

1839
01:33:54,060 --> 01:33:55,820
सिर्फ इतना नहीं है.

1840
01:33:55,820 --> 01:33:59,250
32 बिट और 64 बिट, कि बीच
एक महत्वपूर्ण अंतर है.

1841
01:33:59,250 --> 01:34:02,350
>> आप एक पूरी बहुत अधिक प्राप्त करने के लिए जा रहे हैं
एक 64 बिट पर ढेर और ढेर अंतरिक्ष

1842
01:34:02,350 --> 01:34:05,810
प्रणाली अभी और भी है क्योंकि
वे उपयोग कर सकते हैं पते.

1843
01:34:05,810 --> 01:34:09,360
लेकिन एक व्यक्ति प्रणाली पर, यह होगा
ढेर के लगभग एक ही राशि हो

1844
01:34:09,360 --> 01:34:10,785
और ढेर अंतरिक्ष.

1845
01:34:10,785 --> 01:34:13,635

1846
01:34:13,635 --> 01:34:15,530
ठीक है.

1847
01:34:15,530 --> 01:34:18,220
>> तो आखिरी बात संकलन है.

1848
01:34:18,220 --> 01:34:19,810
तो आप इस प्रक्रिया को पता होना चाहिए.

1849
01:34:19,810 --> 01:34:22,240
चार बड़े कदम उठाए हैं.

1850
01:34:22,240 --> 01:34:24,400
तो पहले एक होना चाहिए
याद करने के लिए आसान हो सकता है.

1851
01:34:24,400 --> 01:34:25,085
पूर्व प्रसंस्करण.

1852
01:34:25,085 --> 01:34:28,390
यह उस में पूर्व उपसर्ग है.

1853
01:34:28,390 --> 01:34:32,080
तो यह सब कुछ पहले आता है.

1854
01:34:32,080 --> 01:34:34,000
>> याद करने की बात हैश है.

1855
01:34:34,000 --> 01:34:37,250
तो हैश को परिभाषित करता है और हैश शामिल
उन सभी में.

1856
01:34:37,250 --> 01:34:39,560
उन सभी पूर्व प्रोसेसर हैं
निर्देशों.

1857
01:34:39,560 --> 01:34:42,030
ये बातें कर रहे हैं कि
पूर्व प्रोसेसर का ख्याल रखता है.

1858
01:34:42,030 --> 01:34:43,680
>> तो एक पूर्व प्रोसेसर क्या करता है?

1859
01:34:43,680 --> 01:34:44,850
यह एक सच में मूक बात है.

1860
01:34:44,850 --> 01:34:49,380
यह करने में सक्षम है इन सभी के सभी कर रहे हैं
प्रतिलिपि, और कटौती, और चिपकाने की कार्रवाई.

1861
01:34:49,380 --> 01:34:51,790
>> तो हैश मानक I0 डॉट घंटे भी शामिल है.

1862
01:34:51,790 --> 01:34:52,990
कर रही है कि क्या है?

1863
01:34:52,990 --> 01:34:56,610
यह मानक I0 डॉट घंटे हथियाने है
फ़ाइल और शीर्ष में चिपका

1864
01:34:56,610 --> 01:34:58,960
जहाँ भी यह हैश शामिल कहते हैं
मानक I0 डॉट घंटे.

1865
01:34:58,960 --> 01:35:02,480
>> और किसी भी हैश हम है कि परिभाषित
देखा, क्या कर रही है?

1866
01:35:02,480 --> 01:35:06,730
इसका हैश कि मूल्य नकल
के रूप में और चिपकाने परिभाषित किया गया है कि परिभाषित

1867
01:35:06,730 --> 01:35:08,500
जहाँ भी आप मूल्य का उपयोग कर रहे हैं.

1868
01:35:08,500 --> 01:35:13,400
तो पूर्वप्रक्रमक सिर्फ सच में करता है
सरल पाठ आधारित कार्रवाई.

1869
01:35:13,400 --> 01:35:15,870
यह स्मार्ट कुछ भी नहीं है.

1870
01:35:15,870 --> 01:35:18,920
तो सब कुछ है
अधिक जटिल.

1871
01:35:18,920 --> 01:35:22,970
>> तो अब है कि पूर्वप्रक्रमक है
किया है, हम वास्तव में संकलन.

1872
01:35:22,970 --> 01:35:24,320
तो संकलन क्या मतलब है?

1873
01:35:24,320 --> 01:35:27,310
हम अब सी कोड से जा रहे हैं
विधानसभा कोड के लिए.

1874
01:35:27,310 --> 01:35:27,570
हाँ?

1875
01:35:27,570 --> 01:35:28,820
>> दर्शक: [अश्राव्य]?

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> रोब: हाँ, हम उस पकड़ा.

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
तो संकलन.

1880
01:35:38,660 --> 01:35:40,310
हम विधानसभा के लिए सी से जा रहे हैं.

1881
01:35:40,310 --> 01:35:42,470
तो यह एक वास्तविक भाषा परिवर्तन है.

1882
01:35:42,470 --> 01:35:45,240
खुद संकलन से जाने का मतलब
करने के लिए एक उच्च स्तर की भाषा

1883
01:35:45,240 --> 01:35:47,340
एक कम स्तर की भाषा.

1884
01:35:47,340 --> 01:35:50,720
>> और सी एक उच्च स्तर की भाषा है
विधानसभा की तुलना में.

1885
01:35:50,720 --> 01:35:52,320
विधानसभा क्या है?

1886
01:35:52,320 --> 01:35:56,440
कर रहे हैं कि इसका निर्देश, सुंदर
बहुत, अपने CPU के लिए बनाया है.

1887
01:35:56,440 --> 01:35:59,130
लेकिन अगर आपके कंप्यूटर अभी भी करता है
विधानसभा समझ में नहीं.

1888
01:35:59,130 --> 01:36:01,570
यह केवल लोगों और शून्य को समझता है.

1889
01:36:01,570 --> 01:36:06,160
तो अगले कदम, संयोजन है जो
इन निर्देशों से हमें लाता है

1890
01:36:06,160 --> 01:36:08,760
आपके सीपीयू को समझता है और वास्तव में
करने के लिए, उन्हें तब्दील

1891
01:36:08,760 --> 01:36:10,820
लोगों और शून्य.

1892
01:36:10,820 --> 01:36:13,570
>> द्विआधारी करने के लिए विधानसभा के लिए सी तो.

1893
01:36:13,570 --> 01:36:15,870
लेकिन मैं अभी तक एक निष्पादन योग्य नहीं है.

1894
01:36:15,870 --> 01:36:19,550
तो CS50 पुस्तकालय के बारे में सोच.

1895
01:36:19,550 --> 01:36:23,070
हम एक द्विआधारी के लिए के साथ आप प्रदान की है
GetString है जो इस CS50 पुस्तकालय,

1896
01:36:23,070 --> 01:36:24,400
और GetInt और यह सब.

1897
01:36:24,400 --> 01:36:25,700
>> लेकिन CS50 library--

1898
01:36:25,700 --> 01:36:27,650
में और itself-- का कार्यान्वयन संभव नहीं है.

1899
01:36:27,650 --> 01:36:29,570
यह एक मुख्य समारोह नहीं है.

1900
01:36:29,570 --> 01:36:32,230
यह बाइनरी का एक गुच्छा है
आप उपयोग कर सकते हैं.

1901
01:36:32,230 --> 01:36:41,730
तो लिंक हम सब एक साथ लाने के लिए कैसे है
इन विभिन्न द्विआधारी फ़ाइलों की

1902
01:36:41,730 --> 01:36:43,110
एक वास्तविक निष्पादन में.

1903
01:36:43,110 --> 01:36:45,900
आप टाइप कर सकते हैं कि एक
डॉट डॉट बाहर स्लेश.

1904
01:36:45,900 --> 01:36:51,660
>> तो इस फ़ाइल की तरह है कि आप
, लिखा - जो कुछ भी अपने कार्यक्रम is--

1905
01:36:51,660 --> 01:36:53,620
Ceaser डॉट सी.

1906
01:36:53,620 --> 01:36:55,100
लेकिन अब यह संकलित किया गया है
द्विआधारी करने के लिए नीचे.

1907
01:36:55,100 --> 01:36:56,480
तो Ceaser डॉट ओ.

1908
01:36:56,480 --> 01:36:59,620
और यह हमारे CS50 द्विआधारी पुस्तकालयों है.

1909
01:36:59,620 --> 01:37:02,284
और वे संयुक्त किया जा रहा हो
एक एकल निष्पादन में.

1910
01:37:02,284 --> 01:37:02,758
हाँ?

1911
01:37:02,758 --> 01:37:04,008
>> दर्शक: [अश्राव्य]?

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> रोब: तो पहले शामिल हैं, याद रखना,
शामिल वास्तव में एक है हैश

1914
01:37:12,710 --> 01:37:13,810
पूर्व प्रोसेसर कदम.

1915
01:37:13,810 --> 01:37:14,750
लेकिन वह अलग है.

1916
01:37:14,750 --> 01:37:20,730
आप किसी भी कार्य का उपयोग नहीं कर रहे हैं कि
फिर अपने एकल फाइल के बाहर हैं,

1917
01:37:20,730 --> 01:37:26,100
नहीं, तुम कुछ भी लिंक करने की जरूरत नहीं है
तुम सब कुछ के बाद से.

1918
01:37:26,100 --> 01:37:30,310
>> उस ने कहा, printf में जोड़ा जा रहा है.

1919
01:37:30,310 --> 01:37:32,820
आप कभी printf का उपयोग करते हैं, कि कुछ है
उस में जुड़े होने की जरूरत

1920
01:37:32,820 --> 01:37:35,740
आपको लगता है कि लिखने के लिए नहीं था.

1921
01:37:35,740 --> 01:37:39,530
और, वास्तव में, printf स्वतः है
में जुड़े.

1922
01:37:39,530 --> 01:37:42,760
तुम्हें पता है कैसे कमांड लाइन पर या जब
आप इसे देख, बनाने के प्रकार

1923
01:37:42,760 --> 01:37:46,690
कड़ी है जो पानी का छींटा एल CS50,
CS50 पुस्तकालय में?

1924
01:37:46,690 --> 01:37:49,070
कि जैसे printf, और सामान, जा रहा है
स्वचालित रूप में जोड़ा जा सके.

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
किसी भी चीज पर अन्य प्रश्न?

1927
01:37:53,930 --> 01:37:56,280
>> दर्शक: [अश्राव्य]?

1928
01:37:56,280 --> 01:37:58,300
>> रोब: जोड़ने?

1929
01:37:58,300 --> 01:38:03,450
हम की एक पूरी गुच्छा है
अलग बाइनरी फ़ाइलें.

1930
01:38:03,450 --> 01:38:06,410
यह विहित उदाहरण है
कि हम इस्तेमाल CS50 पुस्तकालय है.

1931
01:38:06,410 --> 01:38:09,960
हम संकलित और आप के लिए दे दिया है
इस CS50 पुस्तकालय के लिए द्विआधारी.

1932
01:38:09,960 --> 01:38:12,410
>> आप GetString उपयोग करना चाहते हैं
अपने कार्यक्रम में.

1933
01:38:12,410 --> 01:38:14,750
तो तुम जाओ और GetString का उपयोग करें.

1934
01:38:14,750 --> 01:38:19,700
लेकिन के लिए मेरे बाइनरी कोड के बिना
GetString, आप अपने कोड संकलन जब

1935
01:38:19,700 --> 01:38:23,140
नीचे, आप वास्तव में नहीं चला सकते हैं अपने
कार्यक्रम GetString स्ट्रिंग है क्योंकि

1936
01:38:23,140 --> 01:38:25,080
अभी तक पूरी तरह से परिभाषित नहीं.

1937
01:38:25,080 --> 01:38:29,220
>> आप मेरे द्विआधारी में लिंक यह केवल जब
कि सब, कि अब GetString शामिल

1938
01:38:29,220 --> 01:38:31,130
ठीक है, मैं वास्तव में यह कर सकते हैं
GetString निष्पादित.

1939
01:38:31,130 --> 01:38:32,330
मेरी फाइल पूरा हो गया है.

1940
01:38:32,330 --> 01:38:34,208
और मैं यह भी चला सकते हैं.

1941
01:38:34,208 --> 01:38:34,697
हाँ?

1942
01:38:34,697 --> 01:38:37,631
>> दर्शक: परिवर्तित जोड़ने है
द्विआधारी निष्पादन करने के लिए?

1943
01:38:37,631 --> 01:38:42,032
आप अन्य नहीं है तो भी अगर
पुस्तकालयों, यह अभी नहीं होगा

1944
01:38:42,032 --> 01:38:44,477
अनुवाद करने के लिए आवश्यक
[अश्राव्य]?

1945
01:38:44,477 --> 01:38:48,640
>> रोब: तो एक निष्पादन
बाइनरी में अब भी है.

1946
01:38:48,640 --> 01:38:51,750
यह सिर्फ एक पूरे के संयोजन है
बायनेरिज़ का गुच्छा.

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> दर्शक: बहुत बहुत धन्यवाद.

1949
01:38:56,591 --> 01:38:58,560
>> रोब: कोई समस्या नहीं है.

1950
01:38:58,560 --> 01:38:59,540
कोई अन्य प्रश्न?

1951
01:38:59,540 --> 01:39:02,001
अन्यथा, हम पूरी तरह तैयार हैं.

1952
01:39:02,001 --> 01:39:02,690
ठीक है.

1953
01:39:02,690 --> 01:39:02,990
धन्यवाद.

1954
01:39:02,990 --> 01:39:03,590
>> [वाहवाही]

1955
01:39:03,590 --> 01:39:04,490
>> दर्शक: धन्यवाद.

1956
01:39:04,490 --> 01:39:05,740
>> रोब: हाँ.

1957
01:39:05,740 --> 01:39:06,582