1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [समीक्षा] प्रश्नोत्तरी [0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi रॉस, टॉमी MacWilliam, लुकास Freitas, यूसुफ Ong] [हार्वर्ड विश्वविद्यालय]

3
00:00:05,000 --> 00:00:08,000
>> [यह CS50 है.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> अरे, सब लोग.

5
00:00:10,000 --> 00:00:15,000
0 प्रश्नोत्तरी, जो इस जगह बुधवार ले जा रहा है के लिए समीक्षा सत्र के लिए आपका स्वागत है.

6
00:00:15,000 --> 00:00:19,000
आज रात हम क्या करने जा रहे हैं, मैं 3 अन्य TFS के साथ हूँ,

7
00:00:19,000 --> 00:00:24,000
और हम एक साथ हम पाठ्यक्रम में क्या किया है अब तक की एक समीक्षा के माध्यम से जाने के लिए जा रहे हैं.

8
00:00:24,000 --> 00:00:27,000
यह 100% व्यापक होने नहीं जा रहा है, लेकिन इसे आप एक बेहतर विचार देना चाहिए

9
00:00:27,000 --> 00:00:31,000
क्या आप पहले से ही नीचे है और क्या आप अभी भी अध्ययन करने के लिए बुधवार से पहले की जरूरत है.

10
00:00:31,000 --> 00:00:34,000
और सवालों के साथ अपने हाथ उठाने के लिए स्वतंत्र महसूस हो रहा है जैसा कि हम साथ जा रहे हैं,

11
00:00:34,000 --> 00:00:38,000
लेकिन ध्यान में रखना है कि हम भी समय का एक छोटा सा होगा अंत

12
00:00:38,000 --> 00:00:41,000
अगर हम कुछ मिनट के साथ के माध्यम से मिलता है स्पेयर करने के लिए सामान्य प्रश्नों करते हैं,

13
00:00:41,000 --> 00:00:47,000
तो मन में रखने के लिए, और इसलिए हम 0 सप्ताह के शुरुआत में शुरू करने जा रहे हैं.

14
00:00:47,000 --> 00:00:50,000
>> प्रश्नोत्तरी [0 समीक्षा!] भाग [0] [Lexi रॉस] लेकिन इससे पहले कि हम करते हैं कि चलो के बारे में बात करते हैं

15
00:00:50,000 --> 00:00:53,000
प्रश्नोत्तरी के रसद.

16
00:00:53,000 --> 00:00:55,000
>> [रसद] [क्विज़ / 10 10 बुधवार पर व्याख्यान के एवज में जगह लेता है]

17
00:00:55,000 --> 00:00:57,000
>> [(विवरण के लिए http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf देखें)] यह बुधवार, 10 अक्तूबर है.

18
00:00:57,000 --> 00:01:00,000
>> कि इस बुधवार है, और अगर आप इस URL यहाँ जाने के लिए,

19
00:01:00,000 --> 00:01:03,000
जो भी CS50.net - वहाँ से सुलभ के लिए एक कड़ी यह

20
00:01:03,000 --> 00:01:06,000
आप देख सकते हैं जहां के आधार पर जाने के बारे में जानकारी

21
00:01:06,000 --> 00:01:10,000
अपने अंतिम नाम या स्कूल की मान्यता के रूप में के रूप में अच्छी तरह से

22
00:01:10,000 --> 00:01:14,000
यह प्रश्नोत्तरी के बारे में वास्तव में क्या कवर और प्रश्नों के प्रकार है कि आप को मिल जा रहे हैं बताता है.

23
00:01:14,000 --> 00:01:19,000
ध्यान में रखें कि आप भी एक अनुभाग में प्रश्नोत्तरी के लिए समीक्षा करने का मौका होगा,

24
00:01:19,000 --> 00:01:21,000
तो अपने TFS कुछ अभ्यास समस्याओं पर चल रहा होना चाहिए,

25
00:01:21,000 --> 00:01:29,000
और कहा कि एक और अच्छा मौका देखने के लिए जहां आप अभी भी प्रश्नोत्तरी के लिए अध्ययन की जरूरत है.

26
00:01:29,000 --> 00:01:32,000
बिट्स 'n बाइट्स के साथ शुरुआत में चलो शुरू करो.

27
00:01:32,000 --> 00:01:35,000
याद है एक सा ही एक 0 या 1 एक है,

28
00:01:35,000 --> 00:01:38,000
और एक बाइट 8 उन बिट्स के एक संग्रह है.

29
00:01:38,000 --> 00:01:42,000
बिट्स के इस संग्रह में सही यहाँ देखो.

30
00:01:42,000 --> 00:01:44,000
हम कितने बिट्स के लिए बाहर आंकड़ा करने में सक्षम होना चाहिए.

31
00:01:44,000 --> 00:01:48,000
हम कहाँ गिनती वहाँ सिर्फ 8 उनमें से आठ 0 या 1 यूनिट.

32
00:01:48,000 --> 00:01:51,000
और के बाद से वहाँ 8 बिट, कि 1 बाइट है,

33
00:01:51,000 --> 00:01:53,000
और यह हेक्साडेसिमल में बदलने.

34
00:01:53,000 --> 00:01:58,000
हेक्साडेसिमल 16 आधार है, और यह बहुत आसान है कन्वर्ट करने के लिए

35
00:01:58,000 --> 00:02:01,000
बाइनरी में एक नंबर है, जो कि क्या है हेक्साडेसिमल में एक संख्या है.

36
00:02:01,000 --> 00:02:04,000
हम सभी कर हम 4 के समूहों को देखो,

37
00:02:04,000 --> 00:02:07,000
और हम उन्हें उचित षोडश आधारी अंकों के साथ परिवर्तित.

38
00:02:07,000 --> 00:02:11,000
हम 4 के अधिकार सबसे समूह के साथ शुरू करते हैं, इतना 0011.

39
00:02:11,000 --> 00:02:16,000
यह एक 1 और 2 एक हो सकता है, तो एक साथ कि 3 बनाता जा रहा है.

40
00:02:16,000 --> 00:02:19,000
और फिर हम 4 के अन्य ब्लॉक में देखने.

41
00:02:19,000 --> 00:02:24,000
1101. कि एक 1, एक 4, 8 और एक होने जा रहा है.

42
00:02:24,000 --> 00:02:28,000
कि एक साथ 13 हो सकता है, जो डी. बनाता जा रहा है

43
00:02:28,000 --> 00:02:32,000
और हम याद करेंगे हेक्ज़ाडेसिमल में हम सिर्फ 9 के माध्यम से 0 नहीं जाना है.

44
00:02:32,000 --> 00:02:36,000
हम 0 एफ के माध्यम से जाना, 9 इतना होने के बाद, एक को 10 से मेल खाती है,

45
00:02:36,000 --> 00:02:40,000
11 बी, वगैरह जहां एफ 15 है.

46
00:02:40,000 --> 00:02:44,000
13 यहाँ एक डी है,

47
00:02:44,000 --> 00:02:49,000
तो यह दशमलव कन्वर्ट करने के लिए हम क्या हम वास्तव में है

48
00:02:49,000 --> 00:02:52,000
2 की एक शक्ति के रूप में प्रत्येक स्थिति का इलाज.

49
00:02:52,000 --> 00:02:58,000
यह एक 1, 2, एक शून्य 4s, 8s शून्य, एक 16, वगैरह है,

50
00:02:58,000 --> 00:03:03,000
और यह एक छोटे से अपने सिर में गणना करने के लिए मुश्किल है, लेकिन अगर हम अगली स्लाइड पर जाना

51
00:03:03,000 --> 00:03:05,000
हम देख सकते हैं कि जवाब.

52
00:03:05,000 --> 00:03:09,000
>> मूलतः हम सही से भर में वापस छोड़ दिया करने के लिए जा रहे हैं,

53
00:03:09,000 --> 00:03:14,000
और हम 2 की इसी शक्ति के द्वारा प्रत्येक अंक बढ़ रहे हैं.

54
00:03:14,000 --> 00:03:19,000
और याद है, हेक्सादशमलव के लिए हम 0x के साथ शुरुआत में इन नंबरों को निरूपित करने के लिए

55
00:03:19,000 --> 00:03:23,000
इसलिए हम इसे एक दशमलव संख्या के साथ भ्रमित नहीं है.

56
00:03:23,000 --> 00:03:29,000
पर, यह एक ASCII तालिका है,

57
00:03:29,000 --> 00:03:35,000
और क्या हम के लिए ASCII का उपयोग करने के लिए अक्षर से संख्यात्मक मूल्यों मैप है.

58
00:03:35,000 --> 00:03:39,000
क्रिप्टोग्राफी pset में याद है हम ASCII तालिका का व्यापक उपयोग किया

59
00:03:39,000 --> 00:03:43,000
आदेश में क्रिप्टोग्राफी के विभिन्न तरीकों का उपयोग करने के लिए,

60
00:03:43,000 --> 00:03:47,000
कैसर और Vigenère बीजलेख, अलग पत्र में परिवर्तित

61
00:03:47,000 --> 00:03:52,000
उपयोगकर्ता द्वारा दिए गए कुंजी के अनुसार एक स्ट्रिंग में.

62
00:03:52,000 --> 00:03:56,000
चलो ASCII गणित का एक छोटा सा पर देखने के.

63
00:03:56,000 --> 00:04:02,000
पर 'पी' में चरित्र फार्म का है कि क्यू होगा 1 + खोज रहे हैं,

64
00:04:02,000 --> 00:04:07,000
याद और '5 '≠ 5 कि.

65
00:04:07,000 --> 00:04:10,000
और वास्तव में हम कैसे उन 2 रूपों के बीच परिवर्तित होता है?

66
00:04:10,000 --> 00:04:13,000
यह वास्तव में बहुत मुश्किल नहीं है.

67
00:04:13,000 --> 00:04:16,000
5 क्रम में पाने के लिए हम घटाना '0 '

68
00:04:16,000 --> 00:04:20,000
क्योंकि वहाँ '0 के बीच 5 स्थानों रहे हैं और '5.

69
00:04:20,000 --> 00:04:23,000
आदेश में अन्य जिस तरह से हम सिर्फ 0 जोड़ने जाने के लिए,

70
00:04:23,000 --> 00:04:25,000
तो यह नियमित रूप से गणित की तरह तरह की है.

71
00:04:25,000 --> 00:04:29,000
बस याद है कि जब यह चारों ओर कुछ उद्धरण है यह एक चरित्र है

72
00:04:29,000 --> 00:04:37,000
और इस प्रकार ASCII तालिका में एक मूल्य के लिए मेल खाती है.

73
00:04:37,000 --> 00:04:40,000
अधिक सामान्य कंप्यूटर विज्ञान विषयों में चल रहा है.

74
00:04:40,000 --> 00:04:43,000
हमने सीखा है कि एक एल्गोरिथ्म है क्या और कैसे हम प्रोग्रामिंग का उपयोग

75
00:04:43,000 --> 00:04:45,000
एल्गोरिदम को लागू.

76
00:04:45,000 --> 00:04:48,000
एल्गोरिदम के कुछ उदाहरणों में सच की तरह कुछ सरल कर रहे हैं

77
00:04:48,000 --> 00:04:51,000
जाँच कर रहा है कि क्या एक भी या विषम संख्या है.

78
00:04:51,000 --> 00:04:54,000
के लिए याद है कि हम 2 द्वारा संख्या आधुनिक और जांच यदि परिणाम 0 है.

79
00:04:54,000 --> 00:04:57,000
यदि हां, तो यह भी है. यदि नहीं, तो यह अजीब है.

80
00:04:57,000 --> 00:04:59,000
और कहा कि वास्तव में एक बुनियादी एल्गोरिथ्म का एक उदाहरण है.

81
00:04:59,000 --> 00:05:02,000
>> एक और अधिक शामिल एक का एक छोटा सा द्विआधारी खोज है,

82
00:05:02,000 --> 00:05:05,000
जो हम पर समीक्षा सत्र में बाद में जाना होगा.

83
00:05:05,000 --> 00:05:09,000
और प्रोग्रामिंग अवधि हम एक एल्गोरिथ्म लेने के लिए उपयोग

84
00:05:09,000 --> 00:05:15,000
और यह कंप्यूटर कोड परिवर्तित पढ़ सकते हैं.

85
00:05:15,000 --> 00:05:20,000
प्रोग्रामिंग के 2 उदाहरण स्क्रैच है,

86
00:05:20,000 --> 00:05:22,000
जो है हम क्या 0 सप्ताह में किया.

87
00:05:22,000 --> 00:05:25,000
हालांकि हम वास्तव में बाहर नहीं कोड लिखें कि इसे लागू करने के लिए एक रास्ता है

88
00:05:25,000 --> 00:05:29,000
इस एल्गोरिथ्म, जो संख्या 1-10 मुद्रण है,

89
00:05:29,000 --> 00:05:32,000
और यहाँ हम सी प्रोग्रामिंग भाषा में ही करते हैं.

90
00:05:32,000 --> 00:05:41,000
ये कार्यात्मक समकक्ष, सिर्फ अलग अलग भाषाओं या वाक्य रचना में लिखा हैं.

91
00:05:41,000 --> 00:05:44,000
हम तो बूलीय अभिव्यक्ति के बारे में सीखा है,

92
00:05:44,000 --> 00:05:48,000
और एक बूलीयन एक मूल्य है कि या तो सही है या गलत है,

93
00:05:48,000 --> 00:05:51,000
और यहाँ बार बार बूलियन अभिव्यक्ति

94
00:05:51,000 --> 00:05:55,000
शर्तों के अंदर जाने के लिए, यदि ऐसा है तो (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
ठीक है, हम पहले से ही निर्धारित x = 5 तो, उस हालत को सच करने के लिए मूल्यांकन के लिए जा रहा है.

96
00:06:00,000 --> 00:06:03,000
और अगर यह सच है, जो कुछ भी कोड हालत नीचे है

97
00:06:03,000 --> 00:06:08,000
कंप्यूटर द्वारा मूल्यांकन किया जा रहा है, इतना है कि स्ट्रिंग मुद्रित किया जा रहा है

98
00:06:08,000 --> 00:06:12,000
मानक उत्पादन, और शब्द हालत

99
00:06:12,000 --> 00:06:16,000
बयान अगर कोष्ठक के अंदर जो कुछ भी करने के लिए संदर्भित करता है.

100
00:06:16,000 --> 00:06:20,000
सभी ऑपरेटर्स को याद रखें.

101
00:06:20,000 --> 00:06:26,000
| | गठबंधन जब हम कोशिश कर रहे हैं के लिए 2 या अधिक की स्थिति, यह && और याद रखें

102
00:06:26,000 --> 00:06:30,000
== नहीं = जाँच करें कि क्या 2 बातों के समान हैं.

103
00:06:30,000 --> 00:06:36,000
याद रखें कि = काम के लिए है जबकि == एक बूलियन ऑपरेटर है.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ और फिर अंतिम 2 आत्म व्याख्यात्मक हैं.

105
00:06:41,000 --> 00:06:45,000
बूलीयन तर्क का एक सामान्य समीक्षा यहाँ.

106
00:06:45,000 --> 00:06:48,000
और बूलियन अभिव्यक्ति भी loops में महत्वपूर्ण हैं,

107
00:06:48,000 --> 00:06:50,000
जो हम अब खत्म हो जाना होगा.

108
00:06:50,000 --> 00:06:56,000
हम loops के 3 प्रकार के बारे में अब तक CS50 में सीखा के लिए है, जबकि, और करते हैं, जबकि.

109
00:06:56,000 --> 00:06:59,000
और यह जानना महत्वपूर्ण है कि जबकि सबसे प्रयोजनों के लिए

110
00:06:59,000 --> 00:07:02,000
हम वास्तव में पाश के किसी भी प्रकार के आम तौर पर उपयोग कर सकते हैं

111
00:07:02,000 --> 00:07:06,000
वहाँ आम पैटर्न या उद्देश्यों के कुछ प्रकार के होते हैं

112
00:07:06,000 --> 00:07:09,000
प्रोग्रामिंग है कि विशेष रूप से इन loops के लिए कॉल में

113
00:07:09,000 --> 00:07:13,000
कि इसे बनाने के लिए सबसे कुशल या यह है कि रास्ते में कोड सुरुचिपूर्ण.

114
00:07:13,000 --> 00:07:18,000
चलो खत्म हो जाना क्या इन loops के प्रत्येक के लिए सबसे अधिक बार इस्तेमाल किया जा जाता है.

115
00:07:18,000 --> 00:07:21,000
>> एक पाश के लिए हम आम तौर पर पहले से ही पता है कि कितनी बार हम पुनरावृति करने के लिए करना चाहते हैं.

116
00:07:21,000 --> 00:07:24,000
यही कारण है कि हम क्या हालत में डाल दिया.

117
00:07:24,000 --> 00:07:28,000
के लिए, मैं = 0, मैं <10, उदाहरण के लिए.

118
00:07:28,000 --> 00:07:31,000
हम पहले से ही जानते हैं कि हम करने के लिए 10 बार कुछ करना चाहते हैं.

119
00:07:31,000 --> 00:07:34,000
अब, एक समय पाश के लिए, आम तौर पर हम जरूरी नहीं करते

120
00:07:34,000 --> 00:07:36,000
पता है कि कितनी बार हम पाश को चलाने के लिए करना चाहते हैं.

121
00:07:36,000 --> 00:07:39,000
लेकिन हम हालत के कुछ प्रकार जानते हैं कि हम यह चाहते हैं

122
00:07:39,000 --> 00:07:41,000
हमेशा सच हो या हमेशा गलत हो सकता है.

123
00:07:41,000 --> 00:07:44,000
उदाहरण के लिए, जबकि सेट कर दिया जाता है.

124
00:07:44,000 --> 00:07:46,000
चलो का कहना है कि एक बूलीयन चर है.

125
00:07:46,000 --> 00:07:48,000
हालांकि यह सच है कि हम कोड का मूल्यांकन करने के लिए करना चाहते हैं,

126
00:07:48,000 --> 00:07:52,000
तो एक छोटा सा अधिक एक्स्टेंसिबल पाश के लिए एक छोटे से अधिक एक सामान्य की तुलना में थोड़ा,

127
00:07:52,000 --> 00:07:55,000
लेकिन पाश के लिए किसी भी एक समय पाश में बदला जा सकता है.

128
00:07:55,000 --> 00:08:00,000
अंत में करते हैं, जबकि loops, जो trickiest सही दूर समझ सकता है,

129
00:08:00,000 --> 00:08:04,000
अक्सर इस्तेमाल किया जाता है जब हम कोड पहले से मूल्यांकन करना चाहते हैं

130
00:08:04,000 --> 00:08:06,000
पहली बार इससे पहले कि हम स्थिति की जाँच करें.

131
00:08:06,000 --> 00:08:09,000
एक के लिए एक आम उपयोग के मामले जबकि पाश

132
00:08:09,000 --> 00:08:12,000
जब आप उपयोगकर्ता इनपुट प्राप्त करना चाहते है, और आप जानते हैं कि आप उपयोगकर्ता पूछना चाहता हूँ

133
00:08:12,000 --> 00:08:15,000
इनपुट के लिए एक ही बार में कम से कम है, लेकिन अगर वे तुम्हें अच्छा इनपुट देना नहीं है सही दूर

134
00:08:15,000 --> 00:08:18,000
आप उन्हें पूछ जब तक वे तुम्हें अच्छा इनपुट दे रखना चाहते हैं.

135
00:08:18,000 --> 00:08:21,000
यह एक के सबसे आम उपयोग जबकि पाश है,

136
00:08:21,000 --> 00:08:23,000
और इन छोरों के वास्तविक संरचना में देखो.

137
00:08:23,000 --> 00:08:27,000
वे आम तौर पर हमेशा के लिए इन पैटर्न का पालन करते हैं.

138
00:08:27,000 --> 00:08:30,000
>> अंदर के लिए पाश में आप 3 घटक है:

139
00:08:30,000 --> 00:08:35,000
initialization तरह आम तौर पर कुछ int i = 0 जहाँ मैं काउंटर है,

140
00:08:35,000 --> 00:08:40,000
हालत है, जहां हम कहने के लिए पाश के लिए इस दौड़ इस हालत अभी भी धारण के रूप में लंबे समय के रूप में करना चाहते हैं,

141
00:08:40,000 --> 00:08:44,000
मैं 10 <, और फिर अंत में, अद्यतन, जो है हम कैसे वेतन वृद्धि की तरह

142
00:08:44,000 --> 00:08:47,000
पाश में प्रत्येक बिंदु पर काउंटर चर.

143
00:08:47,000 --> 00:08:50,000
वहाँ देखने के के लिए एक आम बात सिर्फ मैं + +,

144
00:08:50,000 --> 00:08:52,000
जो मैं 1 द्वारा हर बार वेतन वृद्धि का मतलब है.

145
00:08:52,000 --> 00:08:55,000
आप भी मैं + = 2 की तरह कुछ कर सकता है,

146
00:08:55,000 --> 00:08:58,000
जिसका मतलब है कि मैं 2 हर बार जब आप पाश के माध्यम से जाना जोड़ने.

147
00:08:58,000 --> 00:09:03,000
और फिर यह सिर्फ किसी भी कोड है कि वास्तव में पाश के भाग के रूप में चलाता है को संदर्भित करता है.

148
00:09:03,000 --> 00:09:09,000
और एक समय पाश के लिए, इस समय हम वास्तव में लूप के बाहर initialization है,

149
00:09:09,000 --> 00:09:12,000
तो उदाहरण के लिए, चलो कहना है कि हम पाश के एक ही प्रकार के रूप में मैं सिर्फ वर्णित करने की कोशिश कर रहे हैं.

150
00:09:12,000 --> 00:09:16,000
हम कहेंगे int i = 0 पहले पाश शुरू होता है.

151
00:09:16,000 --> 00:09:20,000
तो हम जब मैं 10 <यह क्या कह सकते हैं,

152
00:09:20,000 --> 00:09:22,000
तो इससे पहले के रूप में कोड की एक ही ब्लॉक,

153
00:09:22,000 --> 00:09:26,000
और इस बार कोड की अद्यतन उदाहरण के लिए, भाग, मैं + +,

154
00:09:26,000 --> 00:09:29,000
वास्तव में पाश के अंदर चला जाता है.

155
00:09:29,000 --> 00:09:33,000
और अंत में, के लिए करते हैं, जबकि यह जबकि पाश के लिए इसी तरह की है,

156
00:09:33,000 --> 00:09:36,000
लेकिन हमें याद है कि एक बार कोड का मूल्यांकन करेंगे

157
00:09:36,000 --> 00:09:40,000
हालत से पहले जाँच की है, तो यह एक बहुत अधिक समझ में आता है

158
00:09:40,000 --> 00:09:44,000
अगर आप ऊपर से नीचे के क्रम में इसे देखो.

159
00:09:44,000 --> 00:09:49,000
में एक जबकि पाश कोड का मूल्यांकन से पहले आप भी जबकि हालत में देखने के,

160
00:09:49,000 --> 00:09:55,000
जबकि एक समय पाश, यह पहले की जाँच करता है.

161
00:09:55,000 --> 00:09:59,000
विवरण और चर.

162
00:09:59,000 --> 00:10:04,000
जब हम एक नया चर बनाने चाहते हैं हम पहली बार यह इनिशियलाइज़ चाहते हैं.

163
00:10:04,000 --> 00:10:07,000
>> उदाहरण के लिए, int बार चर बार initializes,

164
00:10:07,000 --> 00:10:10,000
लेकिन यह एक मूल्य नहीं दे करता है, तो क्या अब बार मूल्य है?

165
00:10:10,000 --> 00:10:12,000
हम नहीं जानते.

166
00:10:12,000 --> 00:10:14,000
यह कुछ कचरा मूल्य है कि पहले स्मृति में किया गया था वहाँ जमा हो सकता है,

167
00:10:14,000 --> 00:10:16,000
और हम उस चर का उपयोग नहीं करना चाहते

168
00:10:16,000 --> 00:10:19,000
जब तक हम वास्तव में यह एक मूल्य दे,

169
00:10:19,000 --> 00:10:21,000
इसलिए हम इसे यहाँ की घोषणा.

170
00:10:21,000 --> 00:10:24,000
तो फिर हम यह नीचे 42 इनिशियलाइज़.

171
00:10:24,000 --> 00:10:28,000
अब, बेशक, हम जानते हैं कि इस लाइन पर एक, int = 42 बार किया जा सकता है.

172
00:10:28,000 --> 00:10:30,000
लेकिन सिर्फ कई कदम है कि पर जा रहे हैं स्पष्ट करने के लिए,

173
00:10:30,000 --> 00:10:34,000
घोषणा और आरंभीकरण अलग यहाँ हो रही हैं.

174
00:10:34,000 --> 00:10:38,000
यह एक कदम पर होता है, और अगले एक, int baz बार = 1 +,

175
00:10:38,000 --> 00:10:44,000
नीचे इस बयान है, तो इस कोड ब्लॉक के अंत में कि वेतन वृद्धि baz,

176
00:10:44,000 --> 00:10:48,000
अगर हम baz के मूल्य मुद्रित थे यह 44 होगा

177
00:10:48,000 --> 00:10:52,000
क्योंकि हम घोषणा और इसे प्रारंभ करने के लिए 1> बार,

178
00:10:52,000 --> 00:10:58,000
और फिर हम इसके साथ एक बार और अधिक वेतन वृद्धि + +.

179
00:10:58,000 --> 00:11:02,000
हम इस सुंदर संक्षेप में खत्म हो गया था, लेकिन यह अच्छा है करने के लिए एक सामान्य

180
00:11:02,000 --> 00:11:04,000
धागे और घटनाओं क्या कर रहे हैं की समझ है.

181
00:11:04,000 --> 00:11:06,000
हम मुख्य रूप से खरोंच में यह किया है,

182
00:11:06,000 --> 00:11:09,000
ताकि आप कोड के कई दृश्यों के रूप में धागे के बारे में सोच सकते हैं

183
00:11:09,000 --> 00:11:11,000
एक ही समय में चल रहा है.

184
00:11:11,000 --> 00:11:14,000
वास्तविकता में, यह शायद एक ही समय में नहीं चल रहा है,

185
00:11:14,000 --> 00:11:17,000
लेकिन सॉर्ट के सिद्धांत के रूप में हम यह है कि रास्ते में बारे में सोच सकते हैं.

186
00:11:17,000 --> 00:11:20,000
>> स्क्रैच में, उदाहरण के लिए, हम कई sprites था.

187
00:11:20,000 --> 00:11:22,000
यह एक ही समय में अलग कोड को क्रियान्वित करने जा सकता है.

188
00:11:22,000 --> 00:11:26,000
एक, जबकि अन्य कुछ कह रहा है चलने जा सकता है

189
00:11:26,000 --> 00:11:29,000
स्क्रीन के एक अलग हिस्से में.

190
00:11:29,000 --> 00:11:34,000
घटनाक्रम बाहर तर्क को अलग करने का एक और तरीका है

191
00:11:34,000 --> 00:11:37,000
अपने कोड के विभिन्न तत्वों के बीच,

192
00:11:37,000 --> 00:11:40,000
और खरोंच में हम घटनाओं अनुकरण प्रसारण का उपयोग करने में सक्षम थे,

193
00:11:40,000 --> 00:11:43,000
और कहा कि वास्तव में जब मैं प्राप्त मैं नहीं सुन जब,

194
00:11:43,000 --> 00:11:47,000
लेकिन अनिवार्य रूप से यह जानकारी संचारित करने के के लिए एक तरीका है

195
00:11:47,000 --> 00:11:49,000
एक प्रेत से दूसरे करने के लिए.

196
00:11:49,000 --> 00:11:52,000
उदाहरण के लिए, आप इस खेल को संचारित करना चाहते हो सकता है,

197
00:11:52,000 --> 00:11:56,000
और जब एक और प्रेत खेल खत्म प्राप्त करता है,

198
00:11:56,000 --> 00:11:58,000
यह एक निश्चित तरीके से प्रतिक्रिया करता है.

199
00:11:58,000 --> 00:12:03,000
यह प्रोग्रामिंग के लिए समझने के लिए एक महत्वपूर्ण मॉडल है.

200
00:12:03,000 --> 00:12:07,000
बस बुनियादी 0 सप्ताह पर जाने के लिए, क्या हम पर चला गया है अब तक,

201
00:12:07,000 --> 00:12:10,000
चलो इस साधारण सी कार्यक्रम में देखो.

202
00:12:10,000 --> 00:12:14,000
पाठ यहाँ से एक छोटे से छोटा सा हो सकता है, लेकिन मैं इसे खत्म हो जाना बहुत जल्दी होगा.

203
00:12:14,000 --> 00:12:20,000
हम 2 शीर्ष cs50.h, और stdio.h में हेडर फाइल सहित रहे हैं.

204
00:12:20,000 --> 00:12:23,000
हम तो एक निरंतर बुलाया सीमा को परिभाषित कर रहे हैं 100 साल.

205
00:12:23,000 --> 00:12:26,000
हम तो अपने मुख्य समारोह में लागू कर रहे हैं.

206
00:12:26,000 --> 00:12:29,000
चूंकि हम कमांड लाइन तर्क यहाँ का उपयोग नहीं करते हम शून्य डाल की जरूरत है

207
00:12:29,000 --> 00:12:32,000
मुख्य लिए तर्क के रूप में.

208
00:12:32,000 --> 00:12:38,000
हम मुख्य ऊपर int देखते हैं. यह वापसी प्रकार है, इसलिए नीचे में 0 वापसी.

209
00:12:38,000 --> 00:12:41,000
और हम CS50 पुस्तकालय समारोह का उपयोग कर रहे हैं int पाने के

210
00:12:41,000 --> 00:12:45,000
इनपुट के लिए उपयोगकर्ता पूछने के लिए, और हम इसे इस चर x में स्टोर,

211
00:12:45,000 --> 00:12:51,000
तो हम एक्स ऊपर घोषित, और हम इसे x = GetInt के साथ इनिशियलाइज़.

212
00:12:51,000 --> 00:12:53,000
>> हम तो देखने के लिए अगर उपयोगकर्ता हमें अच्छा इनपुट दिया की जाँच करें.

213
00:12:53,000 --> 00:12:59,000
यदि यह ≥ सीमा है हम 1 के एक त्रुटि कोड लौटने और एक त्रुटि संदेश प्रिंट चाहते हैं.

214
00:12:59,000 --> 00:13:02,000
और अंत में, अगर उपयोगकर्ता हमें दिया है अच्छा निवेश

215
00:13:02,000 --> 00:13:08,000
हम संख्या वर्ग और बाहर है कि परिणाम मुद्रित करने के लिए जा रहे हैं.

216
00:13:08,000 --> 00:13:11,000
बस सुनिश्चित करने के लिए कि उन सभी घर मारा

217
00:13:11,000 --> 00:13:17,000
आप यहाँ कोड के विभिन्न भागों के लेबल देख सकते हैं.

218
00:13:17,000 --> 00:13:19,000
मैं निरंतर, हेडर फाइल में उल्लेख किया है.

219
00:13:19,000 --> 00:13:21,000
ओह, int x. को याद है कि एक स्थानीय चर के लिए सुनिश्चित करें कि.

220
00:13:21,000 --> 00:13:24,000
कि यह एक वैश्विक चर से विरोधाभासों, जो हम के बारे में बात करेंगे

221
00:13:24,000 --> 00:13:27,000
बाद में एक छोटा सा समीक्षा सत्र में,

222
00:13:27,000 --> 00:13:30,000
और हम पुस्तकालय समारोह printf बुला रहे हैं,

223
00:13:30,000 --> 00:13:34,000
यदि ऐसा है तो हम stdio.h हैडर फ़ाइल शामिल नहीं था

224
00:13:34,000 --> 00:13:37,000
हम printf कॉल करने में सक्षम नहीं होगा.

225
00:13:37,000 --> 00:13:42,000
और मेरा मानना ​​है कि तीर है कि कट गया यहाँ% d इशारा कर रहा है,

226
00:13:42,000 --> 00:13:45,000
जो printf में स्वरूपण स्ट्रिंग है.

227
00:13:45,000 --> 00:13:52,000
इसे कहते हैं, बाहर संख्या,% d के रूप में इस चर मुद्रित.

228
00:13:52,000 --> 00:13:58,000
और कहा कि यह 0 सप्ताह के लिए है.

229
00:13:58,000 --> 00:14:06,000
अब लुकास के लिए जारी रखने के लिए जा रहा है.

230
00:14:06,000 --> 00:14:08,000
हे, दोस्तों. मेरा नाम लुकास है.

231
00:14:08,000 --> 00:14:10,000
मैं परिसर, माथर पर सबसे अच्छा घर में एक sophomore हूँ,

232
00:14:10,000 --> 00:14:14,000
और मैं 1 सप्ताह और 2.1 के बारे में थोड़ा बहुत बात करने के लिए जा रहा हूँ.

233
00:14:14,000 --> 00:14:16,000
[1 सप्ताह और 2.1] [लुकास Freitas]

234
00:14:16,000 --> 00:14:19,000
के रूप में Lexi कह रहा था, जब हम खरोंच से सी के लिए अपने कोड का अनुवाद शुरू

235
00:14:19,000 --> 00:14:23,000
एक चीजों की है कि हम देखा है कि आप बस नहीं कर सकते हैं

236
00:14:23,000 --> 00:14:26,000
अपने कोड लिखने और इसे चलाने के लिए अब एक हरा झंडा का उपयोग कर.

237
00:14:26,000 --> 00:14:30,000
असल में, आप के लिए कुछ कदम का उपयोग करने के लिए अपनी सी कार्यक्रम बनाना है

238
00:14:30,000 --> 00:14:33,000
एक निष्पादन योग्य फ़ाइल बन जाते हैं.

239
00:14:33,000 --> 00:14:36,000
असल में आप जब आप एक प्रोग्राम लिख रहे हैं क्या है कि

240
00:14:36,000 --> 00:14:40,000
आप एक भाषा कि एक संकलक समझ सकता में अपने विचार अनुवाद

241
00:14:40,000 --> 00:14:44,000
इसलिए जब आप सी में एक प्रोग्राम लिख रहे हैं

242
00:14:44,000 --> 00:14:47,000
आप क्या कर रहे हैं वास्तव में कुछ लिख रहा है कि अपने संकलक समझने जा रहा है,

243
00:14:47,000 --> 00:14:50,000
और तो संकलक कि कोड अनुवाद करने के लिए जा रहा है

244
00:14:50,000 --> 00:14:53,000
कुछ है कि आपके कंप्यूटर को समझने में.

245
00:14:53,000 --> 00:14:55,000
>> और बात है, अपने कंप्यूटर वास्तव में बहुत गूंगा है.

246
00:14:55,000 --> 00:14:57,000
आपका कंप्यूटर केवल 0s और 1s समझ सकते हैं,

247
00:14:57,000 --> 00:15:01,000
तो वास्तव में 1 कंप्यूटर में लोगों को आम तौर पर क्रमादेशित

248
00:15:01,000 --> 00:15:04,000
0s और 1s, लेकिन अब और नहीं का उपयोग करते हुए, भगवान का शुक्र है.

249
00:15:04,000 --> 00:15:07,000
हम 0s और 1s के लिए दृश्यों को याद नहीं है

250
00:15:07,000 --> 00:15:10,000
पाश के लिए या एक जबकि पाश और इतने के लिए एक के लिए.

251
00:15:10,000 --> 00:15:13,000
यही कारण है कि हम एक संकलक है.

252
00:15:13,000 --> 00:15:17,000
एक संकलक क्या करता है, यह मूल रूप से सी कोड अनुवाद,

253
00:15:17,000 --> 00:15:21,000
हमारे मामले में, एक भाषा है कि आपके कंप्यूटर को समझने के लिए,

254
00:15:21,000 --> 00:15:25,000
जो वस्तु कोड, और संकलक है कि हम प्रयोग कर रहे है

255
00:15:25,000 --> 00:15:30,000
है बजना कहा जाता है, तो यह वास्तव में बजना के लिए प्रतीक है.

256
00:15:30,000 --> 00:15:33,000
जब आप अपने कार्यक्रम है, तो आप 2 बातें करने के लिए है.

257
00:15:33,000 --> 00:15:37,000
सबसे पहले, आप अपने कार्यक्रम संकलन है, और फिर आप अपने कार्यक्रम को चलाने के लिए जा रहे हैं.

258
00:15:37,000 --> 00:15:41,000
आप विकल्पों में से एक बहुत कुछ ऐसा करने के लिए अपने कार्यक्रम संकलन.

259
00:15:41,000 --> 00:15:44,000
1 एक बजना इल्ली

260
00:15:44,000 --> 00:15:47,000
जिसमें कार्यक्रम अपने कार्यक्रम का नाम है.

261
00:15:47,000 --> 00:15:51,000
इस मामले में आप वे सिर्फ इतना कह रहे हैं देख सकते हैं "अरे, मेरे प्रोग्राम संकलन."

262
00:15:51,000 --> 00:15:56,000
आप यह नहीं कह या कुछ भी "मैं अपने कार्यक्रम के लिए इस नाम करना चाहते हैं" कर रहे हैं.

263
00:15:56,000 --> 00:15:58,000
>> दूसरा विकल्प अपने कार्यक्रम के लिए एक नाम दे रही है.

264
00:15:58,000 --> 00:16:02,000
आप बजना - ओ और फिर नाम कह सकते हैं कि आप चाहते हैं

265
00:16:02,000 --> 00:16:06,000
निष्पादन योग्य फ़ाइल के रूप में और फिर इल्ली का नाम दिया जाएगा.

266
00:16:06,000 --> 00:16:11,000
और तुम भी कार्यक्रम बनाने के लिए करते हैं, कर सकते हैं और देखने के लिए पहले 2 मामलों में कैसे

267
00:16:11,000 --> 00:16:15,000
मैं डाला. ग, और 3 एक में मैं ही कार्यक्रम है?

268
00:16:15,000 --> 00:16:18,000
हाँ, तुम वास्तव में नहीं है. ग डाल दिया जब आप बनाने के लिए उपयोग करना चाहिए.

269
00:16:18,000 --> 00:16:22,000
अन्यथा संकलक वास्तव में आप पर चिल्लाना जा रहा है.

270
00:16:22,000 --> 00:16:24,000
और यह भी, मैं अगर तुम लोगों को याद नहीं पता नहीं है,

271
00:16:24,000 --> 00:16:29,000
लेकिन कई बार हम भी या lm इस्तेमाल lcs50 का एक बहुत.

272
00:16:29,000 --> 00:16:31,000
कि जोड़ने कहा जाता है.

273
00:16:31,000 --> 00:16:35,000
यह सिर्फ संकलक बताता है कि आप उन पुस्तकालयों का उपयोग करेगा,

274
00:16:35,000 --> 00:16:39,000
इसलिए यदि आप cs50.h का उपयोग करना चाहते हैं आप वास्तव में टाइप करने के लिए है

275
00:16:39,000 --> 00:16:43,000
इल्ली - lcs50 बजना.

276
00:16:43,000 --> 00:16:45,000
यदि आप ऐसा नहीं करते, संकलक पता करने के लिए नहीं जा रहा है

277
00:16:45,000 --> 00:16:50,000
कि आप cs50.h. में उन कार्यों का उपयोग कर रहे हैं

278
00:16:50,000 --> 00:16:52,000
और जब आप अपने कार्यक्रम चलाने के लिए आपके पास 2 विकल्प चाहते हैं.

279
00:16:52,000 --> 00:16:57,000
यदि आप बजना इल्ली किया आप अपने कार्यक्रम के लिए एक नाम नहीं दिया.

280
00:16:57,000 --> 00:17:01,000
आप इसे चलाने के a.out / का उपयोग है.

281
00:17:01,000 --> 00:17:06,000
A.out एक मानक नाम है कि बजना अपने कार्यक्रम देता है अगर आप इसे एक नाम देना नहीं है.

282
00:17:06,000 --> 00:17:11,000
अन्यथा आप / कार्यक्रम करने जा रहे हैं यदि आप अपने कार्यक्रम के लिए एक नाम दिया है,

283
00:17:11,000 --> 00:17:15,000
और अगर आप भी कार्यक्रम नाम बनाने के लिए किया है कि एक कार्यक्रम के लिए पाने के लिए जा रहा है

284
00:17:15,000 --> 00:17:23,000
पहले से ही ग फ़ाइल के रूप में एक ही नाम के प्रोग्राम किया जा रहा है.

285
00:17:23,000 --> 00:17:26,000
तब हम डेटा प्रकार और डेटा के बारे में बात की थी.

286
00:17:26,000 --> 00:17:31,000
>> मूल रूप से डेटा प्रकार छोटे बक्से वे उपयोग के रूप में एक ही बात कर रहे हैं

287
00:17:31,000 --> 00:17:35,000
मूल्यों की दुकान है, तो डेटा प्रकार Pokémons तरह वास्तव में कर रहे हैं.

288
00:17:35,000 --> 00:17:39,000
वे सभी आकार और प्रकार में आते हैं.

289
00:17:39,000 --> 00:17:43,000
मैं अगर है कि सादृश्य समझ में आता है पता नहीं है.

290
00:17:43,000 --> 00:17:46,000
डेटा आकार वास्तव में मशीन वास्तुकला पर निर्भर करता है.

291
00:17:46,000 --> 00:17:49,000
सभी डेटा आकार है कि मैं यहाँ दिखाने के लिए जा रहा हूँ

292
00:17:49,000 --> 00:17:53,000
एक 32-bit मशीन है, जो हमारे उपकरण के मामले के लिए वास्तव में कर रहे हैं,

293
00:17:53,000 --> 00:17:56,000
लेकिन अगर आप वास्तव में अपने मैक या Windows में भी कोडिंग कर रहे हैं

294
00:17:56,000 --> 00:17:59,000
शायद आप एक 64-bit मशीन के लिए जा रहे हैं,

295
00:17:59,000 --> 00:18:03,000
इतना याद है कि डेटा आकार कि मैं जा रहा हूँ यहाँ दिखाने के लिए

296
00:18:03,000 --> 00:18:06,000
32-bit मशीन के लिए कर रहे हैं.

297
00:18:06,000 --> 00:18:08,000
पहली एक है कि हमने देखा कि एक int था,

298
00:18:08,000 --> 00:18:10,000
जो बहुत सीधा है.

299
00:18:10,000 --> 00:18:13,000
आप एक पूर्णांक की दुकान int का उपयोग करें.

300
00:18:13,000 --> 00:18:16,000
हम भी चरित्र, चार देखा.

301
00:18:16,000 --> 00:18:20,000
यदि आप एक पत्र या एक छोटे से प्रतीक का उपयोग करना चाहते हैं तो आप शायद एक चार का उपयोग करने के लिए जा रहे हैं.

302
00:18:20,000 --> 00:18:26,000
चार 1 बाइट, जो 8 बिट जैसे Lexi कहा, का मतलब है.

303
00:18:26,000 --> 00:18:31,000
असल में हम एक ASCII टेबल है कि 256 है

304
00:18:31,000 --> 00:18:34,000
0s और 1s के संभव संयोजनों,

305
00:18:34,000 --> 00:18:37,000
और फिर जब आप एक चार प्रकार अनुवाद करने के लिए जा रहा है

306
00:18:37,000 --> 00:18:44,000
चरित्र है कि आप एक संख्या है कि आप ASCII तालिका में Lexi की तरह है, आदानों कहा.

307
00:18:44,000 --> 00:18:48,000
हम भी नाव है, जो हम दशमलव नंबर स्टोर करने के लिए उपयोग किया है.

308
00:18:48,000 --> 00:18:53,000
यदि आप 3.14 का चयन करना चाहते हैं, उदाहरण के लिए, आप एक नाव का उपयोग करने जा रहे हैं

309
00:18:53,000 --> 00:18:55,000
या एक डबल है कि अधिक सटीक है.

310
00:18:55,000 --> 00:18:57,000
एक नाव 4 बाइट्स है.

311
00:18:57,000 --> 00:19:01,000
एक डबल 8 बाइट्स है, तो फर्क सिर्फ इतना सटीक है.

312
00:19:01,000 --> 00:19:04,000
हम यह भी है कि एक लंबे integers के लिए प्रयोग किया जाता है,

313
00:19:04,000 --> 00:19:09,000
और आप एक 32-bit मशीन को देखने के लिए एक int और एक लंबे समय के एक ही आकार के हो सकता है,

314
00:19:09,000 --> 00:19:13,000
तो यह वास्तव में समझ में नहीं पड़ता है एक 32-bit मशीन में एक लंबे समय का उपयोग करें.

315
00:19:13,000 --> 00:19:17,000
>> लेकिन अगर आप एक मैक और 64-bit मशीन का उपयोग कर रहे हैं, वास्तव में एक लंबा 8 आकार की है,

316
00:19:17,000 --> 00:19:19,000
तो यह वास्तव में वास्तुकला पर निर्भर करता है.

317
00:19:19,000 --> 00:19:22,000
32-bit मशीन के लिए यह समझ में नहीं करने के लिए वास्तव में एक लंबे समय का उपयोग करता है.

318
00:19:22,000 --> 00:19:25,000
और फिर एक लंबे, दूसरे हाथ पर, 8 बाइट्स है,

319
00:19:25,000 --> 00:19:30,000
तो यह बहुत अच्छा है अगर आप एक लंबी पूर्णांक चाहते.

320
00:19:30,000 --> 00:19:34,000
और अंत में, हम स्ट्रिंग है, जो वास्तव में एक चार * है,

321
00:19:34,000 --> 00:19:37,000
जो एक चार के लिए एक सूचक है.

322
00:19:37,000 --> 00:19:40,000
यह बहुत आसान लगता है कि स्ट्रिंग के आकार की तरह होने जा रहा है

323
00:19:40,000 --> 00:19:42,000
वर्णों की संख्या है कि तुम वहाँ है,

324
00:19:42,000 --> 00:19:45,000
लेकिन वास्तव में ही चार *

325
00:19:45,000 --> 00:19:49,000
एक चार, जो 4 बाइट्स के लिए एक सूचक का आकार है.

326
00:19:49,000 --> 00:19:52,000
एक चार * के आकार 4 बाइट्स है.

327
00:19:52,000 --> 00:19:56,000
यह बात अगर आप एक छोटे से शब्द या एक पत्र या कुछ भी कोई फर्क नहीं पड़ता है.

328
00:19:56,000 --> 00:19:58,000
यह 4 बाइट्स होने जा रहा है.

329
00:19:58,000 --> 00:20:01,000
हम भी कास्टिंग के बारे में एक छोटा सा सीखा है,

330
00:20:01,000 --> 00:20:04,000
तो जैसा कि आप देख सकते हैं, अगर आप हैं, उदाहरण के लिए, एक प्रोग्राम है कि कहते हैं

331
00:20:04,000 --> 00:20:08,000
int x = 3 और फिर printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
क्या तुम लोगों को पता है कि यह क्या स्क्रीन पर मुद्रित करने के लिए जा रहा है?

333
00:20:12,000 --> 00:20:14,000
>> किसी >> [छात्र] 2.

334
00:20:14,000 --> 00:20:16,000
1. 1 >>, हाँ.

335
00:20:16,000 --> 00:20:20,000
जब आप 2/3 करने के लिए यह 1.5 हो रहा है,

336
00:20:20,000 --> 00:20:24,000
लेकिन जब से हम एक पूर्णांक का उपयोग कर रहे हैं यह दशमलव भाग की उपेक्षा की जा रही है,

337
00:20:24,000 --> 00:20:26,000
और आप 1 के लिए जा रहे हैं.

338
00:20:26,000 --> 00:20:29,000
यदि आपको लगता है कि ऐसा करने के लिए आप क्या कर सकते हैं, उदाहरण के लिए नहीं करना चाहते,

339
00:20:29,000 --> 00:20:33,000
है एक नाव की घोषणा y = x.

340
00:20:33,000 --> 00:20:40,000
तो एक्स है कि 3 इस्तेमाल किया जा अब y में 3.000 होने जा रहा है.

341
00:20:40,000 --> 00:20:44,000
और फिर आप y / 2 मुद्रित कर सकते हैं.

342
00:20:44,000 --> 00:20:50,000
असल में, मैं 2 होना चाहिए. वहाँ पर.

343
00:20:50,000 --> 00:20:55,000
यह 3.00/2.00 करने जा रहा है,

344
00:20:55,000 --> 00:20:58,000
और आप 1.5 पाने के लिए जा रहे हैं.

345
00:20:58,000 --> 00:21:06,000
और हम इस .2 च सिर्फ दशमलव भाग में 2 दशमलव इकाइयों के लिए पूछने के लिए.

346
00:21:06,000 --> 00:21:12,000
यदि आप .3 च है यह वास्तव में 1.500 किया जा रहा है.

347
00:21:12,000 --> 00:21:16,000
यदि यह 2 से 1.50 होने जा रहा है.

348
00:21:16,000 --> 00:21:18,000
हम भी इस मामले यहाँ है.

349
00:21:18,000 --> 00:21:22,000
यदि आप नाव x = 3.14 और तब आप printf x

350
00:21:22,000 --> 00:21:24,000
आप 3.14 पाने के लिए जा रहे हैं.

351
00:21:24,000 --> 00:21:29,000
और अगर आप ऐसा x = x, int

352
00:21:29,000 --> 00:21:34,000
जो एक int के रूप में एक्स के इलाज का मतलब है और आप एक्स अभी मुद्रित

353
00:21:34,000 --> 00:21:36,000
आप 3.00 के लिए जा रहे हैं.

354
00:21:36,000 --> 00:21:38,000
क्या इसका यह मतलब है?

355
00:21:38,000 --> 00:21:41,000
क्योंकि आप पहले एक पूर्णांक के रूप में एक्स के इलाज कर रहे हैं, तो आप दशमलव भाग की अनदेखी कर रहे हैं,

356
00:21:41,000 --> 00:21:45,000
और फिर आप x मुद्रण कर रहे हैं.

357
00:21:45,000 --> 00:21:47,000
और अंत में, तुम भी यह कर सकते हैं,

358
00:21:47,000 --> 00:21:52,000
int x 65 =, और फिर आप एक चार ग = x की घोषणा,

359
00:21:52,000 --> 00:21:56,000
और फिर अगर आप ग को मुद्रित आप वास्तव में पाने के लिए जा रहे हैं

360
00:21:56,000 --> 00:21:59,000
ए, तो बुनियादी तौर पर आप यहाँ क्या कर रहे हैं

361
00:21:59,000 --> 00:22:02,000
चरित्र में पूर्णांक अनुवाद,

362
00:22:02,000 --> 00:22:05,000
बस जैसे ASCII तालिका करता है.

363
00:22:05,000 --> 00:22:08,000
हम भी गणित ऑपरेटरों के बारे में बात की थी.

364
00:22:08,000 --> 00:22:14,000
उनमें से ज्यादातर बहुत सीधा कर रहे हैं, तो +, -, *, /

365
00:22:14,000 --> 00:22:20,000
और हम भी आधुनिक है, जो 2 नंबर का एक प्रभाग के शेष के बारे में बात की थी.

366
00:22:20,000 --> 00:22:23,000
यदि आप 10 3%, उदाहरण के लिए है,

367
00:22:23,000 --> 00:22:27,000
इसका मतलब है 3 द्वारा 10 विभाजित है, और शेष क्या है?

368
00:22:27,000 --> 00:22:30,000
यह एक होने जा रहा है, तो यह वास्तव में कार्यक्रमों की एक बहुत कुछ करने के लिए बहुत ही उपयोगी है.

369
00:22:30,000 --> 00:22:38,000
Vigenère और सीज़र के लिए मुझे पूरा यकीन है कि तुम लोगों के सभी आधुनिक का इस्तेमाल कर रहा हूँ.

370
00:22:38,000 --> 00:22:43,000
गणित ऑपरेटरों के बारे में बहुत सावधान रहना जब * और / के संयोजन.

371
00:22:43,000 --> 00:22:48,000
>> उदाहरण के लिए, यदि आप करते हैं (3/2) 2 * आप क्या करने के लिए जा रहे हैं?

372
00:22:48,000 --> 00:22:50,000
2 [छात्र].

373
00:22:50,000 --> 00:22:54,000
हाँ, 2, 2 3 / क्योंकि 1.5 हो जा रहा है,

374
00:22:54,000 --> 00:22:57,000
लेकिन जब से तुम 2 integers के बीच कार्य कर रहे हैं

375
00:22:57,000 --> 00:22:59,000
आप वास्तव में सिर्फ 1 पर विचार करने जा रहे हैं,

376
00:22:59,000 --> 00:23:03,000
और फिर 1 2 * 2 होने जा रहा है, तो बहुत, बहुत सावधान रहना

377
00:23:03,000 --> 00:23:07,000
जब integers के साथ गणित कर रहे हैं क्योंकि

378
00:23:07,000 --> 00:23:12,000
उस मामले में आप 2 कि = 3, मिल सकता है.

379
00:23:12,000 --> 00:23:14,000
और भी वरीयता के बारे में बहुत सावधान रहना.

380
00:23:14,000 --> 00:23:21,000
आप आमतौर पर लघुकोष्ठकों का उपयोग करने के लिए सुनिश्चित करें कि आप जानते हैं कि आप क्या कर रहे हैं होना चाहिए.

381
00:23:21,000 --> 00:23:27,000
कुछ उपयोगी शॉर्टकट, ज़ाहिर है, एक मैं + + या मैं + = 1

382
00:23:27,000 --> 00:23:30,000
का उपयोग कर या + =.

383
00:23:30,000 --> 00:23:34,000
कि मैं मैं = 1 + कर के रूप में एक ही बात है.

384
00:23:34,000 --> 00:23:39,000
तुम भी मैं क्या कर सकते हैं या मैं - = 1,

385
00:23:39,000 --> 00:23:42,000
जो मैं मैं = -1 के रूप में एक ही बात है,

386
00:23:42,000 --> 00:23:46,000
कुछ आप लोग loops के लिए में एक बहुत का उपयोग करें, कम से कम.

387
00:23:46,000 --> 00:23:52,000
* इसके अलावा, अगर आप का उपयोग * = और यदि आप करते हैं, उदाहरण के लिए,

388
00:23:52,000 --> 00:23:57,000
मैं * = 2 मैं मैं = 2 * कह के रूप में एक ही बात है,

389
00:23:57,000 --> 00:23:59,000
और विभाजन के लिए एक ही बात है.

390
00:23:59,000 --> 00:24:08,000
यदि आप / मैं 2 = मैं = मैं / 2 के रूप में एक ही बात है.

391
00:24:08,000 --> 00:24:10,000
>> अब कार्यों के बारे में.

392
00:24:10,000 --> 00:24:13,000
तुम लोग सीखा है कि कार्य करता है कोड को बचाने के लिए एक बहुत अच्छा करने के लिए रणनीति है

393
00:24:13,000 --> 00:24:16,000
जब आप प्रोग्रामिंग कर रहे हैं, इसलिए यदि आप एक ही कार्य करने के लिए करना चाहते हैं

394
00:24:16,000 --> 00:24:20,000
कोड में फिर से और फिर, शायद आप के लिए एक समारोह का उपयोग करना चाहते हैं

395
00:24:20,000 --> 00:24:25,000
बस इतना तुम पर और फिर से कोड को कॉपी और पेस्ट नहीं है.

396
00:24:25,000 --> 00:24:28,000
दरअसल, मुख्य एक समारोह है, और जब मैं तुम्हें एक समारोह का स्वरूप दिखाने

397
00:24:28,000 --> 00:24:32,000
आप देख सकते हैं कि यह बहुत स्पष्ट है के लिए जा रहे हैं.

398
00:24:32,000 --> 00:24:35,000
हम भी कुछ पुस्तकालयों से कार्यों का उपयोग,

399
00:24:35,000 --> 00:24:39,000
उदाहरण के लिए, printf, Getin, जो CS50 पुस्तकालय से है,

400
00:24:39,000 --> 00:24:43,000
और toupper जैसे अन्य कार्य.

401
00:24:43,000 --> 00:24:46,000
उन कार्यों के सभी वास्तव में अन्य पुस्तकालयों में लागू कर रहे हैं,

402
00:24:46,000 --> 00:24:49,000
और जब आप अपने कार्यक्रम की शुरुआत में उन पगहा फ़ाइलें डाल दिया

403
00:24:49,000 --> 00:24:53,000
आप कह रहे हैं आप कृपया मुझे उन कार्यों के लिए कोड दे सकते हैं

404
00:24:53,000 --> 00:24:57,000
तो मैं उन्हें खुद के द्वारा लागू नहीं है?

405
00:24:57,000 --> 00:25:00,000
और तुम भी अपने खुद के कार्यों लिखते हैं, कर सकते हैं ताकि जब आप प्रोग्रामिंग शुरू

406
00:25:00,000 --> 00:25:04,000
आपको पता है कि पुस्तकालयों सभी कार्य करता है कि आप की जरूरत नहीं है.

407
00:25:04,000 --> 00:25:10,000
पिछले pset के लिए, उदाहरण के लिए, हम आकर्षित, हाथापाई, और लुकअप लिखा था,

408
00:25:10,000 --> 00:25:13,000
और यह बहुत, बहुत महत्वपूर्ण है करने के कार्यों को लिखने में सक्षम होना

409
00:25:13,000 --> 00:25:17,000
क्योंकि वे उपयोगी हैं, और हम उन्हें प्रोग्रामिंग में हर समय का उपयोग,

410
00:25:17,000 --> 00:25:19,000
और यह कोड का एक बहुत बचाता है.

411
00:25:19,000 --> 00:25:21,000
एक समारोह के प्रारूप में यह एक है.

412
00:25:21,000 --> 00:25:24,000
हम शुरुआत में वापस प्रकार है. वापसी प्रकार क्या है?

413
00:25:24,000 --> 00:25:27,000
यह बस जब अपने कार्य करने के लिए वापस जा रहा है.

414
00:25:27,000 --> 00:25:29,000
यदि आप उदाहरण के लिए एक समारोह है, भाज्य है,

415
00:25:29,000 --> 00:25:31,000
कि एक पूर्णांक के भाज्य की गणना करने के लिए जा रहा है,

416
00:25:31,000 --> 00:25:34,000
शायद यह एक पूर्णांक भी वापस जा रहा है.

417
00:25:34,000 --> 00:25:37,000
तो वापस प्रकार int होने जा रहा है,.

418
00:25:37,000 --> 00:25:41,000
Printf वास्तव में एक वापसी प्रकार शून्य है

419
00:25:41,000 --> 00:25:43,000
क्योंकि आप कुछ भी नहीं लौट रहे हैं.

420
00:25:43,000 --> 00:25:45,000
तुम सिर्फ स्क्रीन करने के लिए कर रहे हैं बातें मुद्रण

421
00:25:45,000 --> 00:25:48,000
और समारोह के बाद छोड़ने.

422
00:25:48,000 --> 00:25:51,000
तो फिर तुम समारोह का नाम है कि आप चुन सकते है.

423
00:25:51,000 --> 00:25:55,000
तुम एक छोटे से उचित हो सकता है, जैसे xyz की तरह एक नाम का चयन नहीं करते

424
00:25:55,000 --> 00:25:58,000
या x2f तरह.

425
00:25:58,000 --> 00:26:02,000
एक नाम है कि समझ में आता है बनाने की कोशिश करें.

426
00:26:02,000 --> 00:26:04,000
>> उदाहरण के लिए, अगर यह भाज्य है, भाज्य का कहना है.

427
00:26:04,000 --> 00:26:08,000
यदि यह एक समारोह में कहा कि कुछ आकर्षित करने के लिए जा रहा है, नाम है, यह आकर्षित.

428
00:26:08,000 --> 00:26:11,000
और फिर हम पैरामीटर, जो भी तर्क कहा जाता है,

429
00:26:11,000 --> 00:26:14,000
जो संसाधनों है कि अपने कार्य की जरूरत है की तरह कर रहे हैं

430
00:26:14,000 --> 00:26:17,000
अपने कोड से अपने कार्य करने के लिए.

431
00:26:17,000 --> 00:26:20,000
यदि आप एक संख्या का क्रमगुणित की गणना करना चाहते हैं

432
00:26:20,000 --> 00:26:23,000
शायद आप एक नंबर एक क्रमगुणित की गणना करने की जरूरत है.

433
00:26:23,000 --> 00:26:27,000
एक तर्क है कि आप के पास जा रहे हैं की संख्या ही है.

434
00:26:27,000 --> 00:26:31,000
और फिर यह करने के लिए कुछ करते हैं और अंत में मूल्य वापस करने के लिए जा रहा है

435
00:26:31,000 --> 00:26:35,000
जब तक यह एक शून्य समारोह है.

436
00:26:35,000 --> 00:26:37,000
चलो एक उदाहरण देखते हैं.

437
00:26:37,000 --> 00:26:40,000
अगर मैं एक समारोह में कहा कि पूर्णांकों की सरणी में सभी नंबरों को रकम लिखना चाहते हैं,

438
00:26:40,000 --> 00:26:43,000
सब से पहले, वापस प्रकार int होने जा रहा है,

439
00:26:43,000 --> 00:26:46,000
क्योंकि मैं पूर्णांकों की सरणी है.

440
00:26:46,000 --> 00:26:51,000
और फिर मैं sumArray तरह समारोह के नाम किया जा रहा हूँ,

441
00:26:51,000 --> 00:26:54,000
और फिर यह सरणी ही ले जा रहा है int nums,

442
00:26:54,000 --> 00:26:58,000
और तब सरणी तो मुझे पता है कि कितनी संख्या मैं करने के लिए राशि की लंबाई.

443
00:26:58,000 --> 00:27:02,000
तो मैं उदाहरण के लिए कहा जाता है एक चर राशि, 0 से आरंभ करने की है,

444
00:27:02,000 --> 00:27:08,000
और हर बार मैं सरणी में एक तत्व देखते मैं यह योग करने के लिए जोड़ है, तो मैं एक पाश के लिए किया.

445
00:27:08,000 --> 00:27:15,000
वैसे ही जैसे Lexi कहा, आप int i = 0, मैं <लंबाई और मैं + +.

446
00:27:15,000 --> 00:27:20,000
और सरणी में प्रत्येक तत्व के लिए मैं योग + = nums [i] किया था,

447
00:27:20,000 --> 00:27:24,000
और फिर मैं योग लौटे, तो यह बहुत आसान है, और यह कोड का एक बहुत बचाता है

448
00:27:24,000 --> 00:27:28,000
अगर आप इस समारोह में समय की एक बहुत का उपयोग कर रहे हैं.

449
00:27:28,000 --> 00:27:32,000
फिर हम स्थितियों पर एक नज़र लिया.

450
00:27:32,000 --> 00:27:38,000
हम अगर, बाकी है, और कुछ तो.

451
00:27:38,000 --> 00:27:42,000
चलो देखते हैं क्या उन लोगों के बीच अंतर है.

452
00:27:42,000 --> 00:27:45,000
इन 2 कोड पर एक नज़र रखना. उन दोनों के बीच क्या अंतर है?

453
00:27:45,000 --> 00:27:49,000
पहले एक - मूल रूप से किया गया है कोड आपको बताने के लिए करना चाहते हैं

454
00:27:49,000 --> 00:27:51,000
, या 0 - अगर एक संख्या + है.

455
00:27:51,000 --> 00:27:55,000
1 एक का कहना है कि अगर यह> 0 है तो यह सकारात्मक है.

456
00:27:55,000 --> 00:28:00,000
यदि यह = 0 से तो यह 0 है, और अगर यह <0 है, तो यह नकारात्मक है.

457
00:28:00,000 --> 00:28:04,000
>> और अगर, वरना, और अन्य एक कर रही है.

458
00:28:04,000 --> 00:28:07,000
दोनों के बीच अंतर यह है कि वास्तव में इस एक के लिए जा रहा है

459
00:28:07,000 --> 00:28:13,000
अगर> 0 <0 या = 0 तीन बार,

460
00:28:13,000 --> 00:28:17,000
यदि ऐसा है तो आप 2 नंबर है, उदाहरण के लिए, यह करने के लिए यहाँ आते हैं और कहते जा रहा है

461
00:28:17,000 --> 00:28:21,000
(x> 0), और अगर यह के लिए हाँ कह रहा है, तो मैं सकारात्मक मुद्रित करें.

462
00:28:21,000 --> 00:28:25,000
लेकिन फिर भी मैं पता है कि यह> 0 और 0 0 या <होने वाला नहीं है

463
00:28:25,000 --> 00:28:29,000
मैं अभी भी करने जा रहा हूँ यह 0 है, यह है <0,

464
00:28:29,000 --> 00:28:33,000
इसलिए मैं वास्तव में ifs हैं के अंदर जा रहा हूँ कि मैं नहीं था

465
00:28:33,000 --> 00:28:38,000
क्योंकि मैं पहले से ही पता है कि यह इन शर्तों के किसी को संतुष्ट करने के लिए नहीं जा रहा है.

466
00:28:38,000 --> 00:28:41,000
मैं अगर उपयोग कर सकते हैं, और अगर कुछ बयान.

467
00:28:41,000 --> 00:28:45,000
यह मूल रूप से कहते हैं कि अगर x = 0 मैं सकारात्मक मुद्रित करने के लिए.

468
00:28:45,000 --> 00:28:48,000
यदि ऐसा नहीं है, मैं भी इस परीक्षण के लिए जा रहा हूँ.

469
00:28:48,000 --> 00:28:51,000
यदि यह 2 है यह करने के लिए नहीं कर रहा हूँ मैं जा रहा है.

470
00:28:51,000 --> 00:28:54,000
वैसे, अगर मैं x = 2 था आप कहेंगे

471
00:28:54,000 --> 00:28:57,000
अगर (x> 0), हाँ, तो इस प्रिंट.

472
00:28:57,000 --> 00:29:00,000
अब जब कि मुझे पता है कि यह> 0 है और यह है कि अगर पहले संतुष्ट

473
00:29:00,000 --> 00:29:02,000
मैं भी करने के लिए इस कोड को चलाने के लिए नहीं जा रहा हूँ.

474
00:29:02,000 --> 00:29:09,000
कोड तेजी से चलाता है, वास्तव में, 3 गुना तेजी से यदि आप इस का उपयोग करें.

475
00:29:09,000 --> 00:29:11,000
हम यह भी के बारे में और या सीखा है.

476
00:29:11,000 --> 00:29:15,000
मैं इस के माध्यम से जाना है क्योंकि Lexi पहले से ही उनके बारे में बात करने के लिए नहीं जा रहा हूँ.

477
00:29:15,000 --> 00:29:17,000
यह सिर्फ && और | | ऑपरेटर.

478
00:29:17,000 --> 00:29:21,000
>> केवल एक चीज मैं कहता हूँ सावधान हो सकता है जब आप 3 की स्थिति है.

479
00:29:21,000 --> 00:29:24,000
लघुकोष्ठकों का उपयोग क्योंकि यह बहुत भ्रामक है जब आप एक शर्त है

480
00:29:24,000 --> 00:29:27,000
और एक और एक या एक दूसरे के.

481
00:29:27,000 --> 00:29:30,000
लघुकोष्ठकों का उपयोग सुनिश्चित करें कि अपनी शर्तों समझ बनाने के

482
00:29:30,000 --> 00:29:34,000
क्योंकि उस मामले में, उदाहरण के लिए, आप कल्पना कर सकते हैं कि

483
00:29:34,000 --> 00:29:38,000
यह पहली शर्त है और एक या एक से दूसरे हो सकता है

484
00:29:38,000 --> 00:29:41,000
या 2 एक में संयुक्त शर्तों और

485
00:29:41,000 --> 00:29:45,000
या 3 एक है, तो बस सावधान रहना.

486
00:29:45,000 --> 00:29:48,000
और अंत में, हम स्विच के बारे में बात की थी.

487
00:29:48,000 --> 00:29:53,000
एक स्विच बहुत उपयोगी है जब आप एक चर है.

488
00:29:53,000 --> 00:29:55,000
हम कहते हैं कि तुम n की तरह एक चर

489
00:29:55,000 --> 00:29:59,000
0, 1, 2 या हो सकता है, और उन मामलों में से प्रत्येक

490
00:29:59,000 --> 00:30:01,000
आप एक काम करने के लिए जा रहे हैं.

491
00:30:01,000 --> 00:30:04,000
आप चर स्विच करने के लिए कह सकते हैं, और यह इंगित करता है कि

492
00:30:04,000 --> 00:30:08,000
मूल्य value1 की तरह है तो मैं यह करने के लिए जा रहा हूँ,

493
00:30:08,000 --> 00:30:12,000
और फिर मैं तोड़ने, जिसका मतलब है मैं अन्य मामलों में से किसी में देखने के लिए नहीं जा रहा हूँ

494
00:30:12,000 --> 00:30:15,000
क्योंकि हम पहले से ही उस मामले संतुष्ट

495
00:30:15,000 --> 00:30:20,000
और फिर value2 और इतने पर है, और मैं भी एक डिफ़ॉल्ट स्विच कर सकते हैं.

496
00:30:20,000 --> 00:30:24,000
इसका मतलब है कि अगर यह मामलों था कि मैं किसी को संतुष्ट नहीं करता

497
00:30:24,000 --> 00:30:29,000
कि मैं कुछ और करने के लिए जा रहा हूँ, लेकिन यह है कि वैकल्पिक है.

498
00:30:29,000 --> 00:30:36,000
यह सब मेरे लिए है. अब चलो टॉमी है.

499
00:30:36,000 --> 00:30:41,000
ठीक है, यह 3 ish सप्ताह होने जा रहा है.

500
00:30:41,000 --> 00:30:45,000
इन विषयों हम को कवर किया जाएगा क्रिप्टो, गुंजाइश, arrays वगैरह की कुछ कर रहे हैं.

501
00:30:45,000 --> 00:30:49,000
क्रिप्टो पर बस एक त्वरित शब्द. हम इस घर हथौड़ा करने के लिए नहीं जा रहे हैं.

502
00:30:49,000 --> 00:30:52,000
>> हम 2 pset में इस किया था, लेकिन प्रश्नोत्तरी के लिए सुनिश्चित करें कि आपको फर्क पता

503
00:30:52,000 --> 00:30:54,000
सीज़र बीजलेख और Vigenère बीजलेख के बीच,

504
00:30:54,000 --> 00:30:57,000
कैसे उन सिफर काम के दोनों और क्या यह एन्क्रिप्ट करने के लिए की तरह है

505
00:30:57,000 --> 00:30:59,000
और डिक्रिप्ट पाठ उन 2 सिफर का उपयोग कर.

506
00:30:59,000 --> 00:31:03,000
याद रखें, कैसर बीजलेख बस एक ही राशि के द्वारा प्रत्येक चरित्र घूमता है,

507
00:31:03,000 --> 00:31:06,000
सुनिश्चित करें कि आप आधुनिक वर्णमाला में पत्रों की संख्या से बना रही है.

508
00:31:06,000 --> 00:31:09,000
और Vigenère बीजलेख, दूसरे हाथ पर, प्रत्येक वर्ण rotates

509
00:31:09,000 --> 00:31:12,000
एक अलग राशि के द्वारा, इसलिए बजाय कह से

510
00:31:12,000 --> 00:31:15,000
3 Vigenère द्वारा हर चरित्र घुमाया प्रत्येक वर्ण बारी बारी से होगा

511
00:31:15,000 --> 00:31:17,000
कुछ कीवर्ड के आधार पर एक अलग राशि से

512
00:31:17,000 --> 00:31:20,000
जहां कीवर्ड में प्रत्येक पत्र कुछ अलग राशि का प्रतिनिधित्व करता है

513
00:31:20,000 --> 00:31:26,000
स्पष्ट पाठ घुमाएगी.

514
00:31:26,000 --> 00:31:28,000
चर गुंजाइश के बारे में पहले बात करते हैं.

515
00:31:28,000 --> 00:31:30,000
वहाँ चर के 2 अलग अलग प्रकार के होते हैं.

516
00:31:30,000 --> 00:31:33,000
हम स्थानीय चर है, और इन में परिभाषित किया जा जा रहे हैं

517
00:31:33,000 --> 00:31:36,000
बाहर की मुख्य या किसी भी समारोह या ब्लॉक के बाहर,

518
00:31:36,000 --> 00:31:39,000
और इन सुलभ अपने कार्यक्रम में कहीं भी हो जाएगा.

519
00:31:39,000 --> 00:31:41,000
यदि आप एक समारोह है और उस समारोह में एक समय पाश है

520
00:31:41,000 --> 00:31:44,000
बड़ा वैश्विक चर हर जगह सुलभ है.

521
00:31:44,000 --> 00:31:48,000
एक स्थानीय चर, दूसरे हाथ पर, जगह है जहाँ यह परिभाषित किया गया है scoped है.

522
00:31:48,000 --> 00:31:53,000
>> यदि आप एक समारोह यहाँ है, उदाहरण के लिए, हम इस समारोह छ है,

523
00:31:53,000 --> 00:31:56,000
और जी के अंदर एक चर y बुलाया है,

524
00:31:56,000 --> 00:31:58,000
और इसका मतलब है कि यह एक स्थानीय चर है.

525
00:31:58,000 --> 00:32:00,000
हालांकि इस चर y कहा जाता है

526
00:32:00,000 --> 00:32:03,000
और इस चर इन 2 कार्यों y कहा जाता है

527
00:32:03,000 --> 00:32:06,000
कोई विचार नहीं है क्या कर रहे हैं एक दूसरे के स्थानीय चर है.

528
00:32:06,000 --> 00:32:10,000
दूसरी ओर, यहाँ हम int x = 5 कहते हैं,

529
00:32:10,000 --> 00:32:12,000
और यह किसी भी समारोह के दायरे से बाहर है.

530
00:32:12,000 --> 00:32:16,000
यह मुख्य के दायरे से बाहर है, तो यह एक वैश्विक चर है.

531
00:32:16,000 --> 00:32:20,000
यह है कि इन 2 कार्यों के अंदर का मतलब है जब मैं एक्स कहते हैं - या x + +

532
00:32:20,000 --> 00:32:26,000
मैं एक ही एक्स जिससे इस y और इस y विभिन्न चर तक पहुँचने हूँ.

533
00:32:26,000 --> 00:32:30,000
यह एक वैश्विक चर और एक स्थानीय चर के बीच अंतर है.

534
00:32:30,000 --> 00:32:33,000
जहाँ तक के रूप में डिजाइन का संबंध है, कभी कभी यह शायद एक अच्छा विचार है

535
00:32:33,000 --> 00:32:37,000
स्थानीय चर रखने के लिए जब भी आप संभवतः कर सकते हैं

536
00:32:37,000 --> 00:32:39,000
होने के बाद से वैश्विक चर का एक गुच्छा वास्तव में भ्रमित हो सकता है.

537
00:32:39,000 --> 00:32:42,000
यदि आप कार्यों का एक गुच्छा है सब एक ही बात को संशोधित

538
00:32:42,000 --> 00:32:45,000
क्या तुम अगर इस समारोह में गलती से इस वैश्विक modifies भूल सकता है,

539
00:32:45,000 --> 00:32:47,000
और यह अन्य समारोह में इसके बारे में पता नहीं है,

540
00:32:47,000 --> 00:32:50,000
और यह बहुत भ्रमित करता है के रूप में आप और अधिक कोड मिलता है.

541
00:32:50,000 --> 00:32:53,000
चर स्थानीय रखते हुए जब भी आप संभवतः कर सकते हैं

542
00:32:53,000 --> 00:32:56,000
सिर्फ अच्छे डिजाइन है.

543
00:32:56,000 --> 00:33:00,000
Arrays, याद है, बस एक ही प्रकार के तत्वों की सूची.

544
00:33:00,000 --> 00:33:04,000
सीआई के अंदर 2.0 1, जैसे एक सूची नहीं है, नमस्ते कर सकते हैं.

545
00:33:04,000 --> 00:33:06,000
हम सिर्फ ऐसा नहीं कर सकते.

546
00:33:06,000 --> 00:33:11,000
>> जब हम सी में एक सरणी की घोषणा तत्वों के सभी एक ही प्रकार के हैं.

547
00:33:11,000 --> 00:33:14,000
यहाँ मैं 3 integers के एक सरणी है.

548
00:33:14,000 --> 00:33:18,000
यहाँ मैं सरणी की लंबाई है, लेकिन अगर मैं सिर्फ इस वाक्यविन्यास में यह की घोषणा कर रहा हूँ

549
00:33:18,000 --> 00:33:21,000
जहाँ मैं निर्दिष्ट तत्वों के सभी क्या कर रहे हैं मैं तकनीकी रूप से इस 3 की जरूरत नहीं है.

550
00:33:21,000 --> 00:33:25,000
संकलक काफी समझदार के लिए बाहर आंकड़ा कितना बड़ा सरणी होना चाहिए है.

551
00:33:25,000 --> 00:33:28,000
अब जब मैं करने के लिए या एक सरणी के मूल्य निर्धारित करना चाहते हैं

552
00:33:28,000 --> 00:33:30,000
यह करने के लिए कि क्या वाक्यविन्यास है.

553
00:33:30,000 --> 00:33:33,000
यह वास्तव में सरणी के दूसरे तत्व को संशोधित क्योंकि याद करेंगे,

554
00:33:33,000 --> 00:33:36,000
नंबर 0 में शुरू होता है, 1 पर नहीं.

555
00:33:36,000 --> 00:33:42,000
अगर मैं उस मूल्य को पढ़ने के लिए चाहते हैं मैं कुछ कहने की तरह कर सकते हैं int x = सरणी [1].

556
00:33:42,000 --> 00:33:44,000
या अगर मैं कि मूल्य निर्धारित करना चाहते हैं, जैसे मैं यहाँ क्या कर रहा हूँ,

557
00:33:44,000 --> 00:33:47,000
मैं सरणी [1] कह सकते हैं = 4.

558
00:33:47,000 --> 00:33:50,000
उस समय उनके सूचकांक तत्वों तक पहुँचने

559
00:33:50,000 --> 00:33:52,000
या उनकी स्थिति या जहां वे सरणी में कर रहे हैं,

560
00:33:52,000 --> 00:33:57,000
और है कि लिस्टिंग 0 में शुरू होता है.

561
00:33:57,000 --> 00:34:00,000
हम भी arrays के arrays हो सकता है,

562
00:34:00,000 --> 00:34:03,000
और यह एक बहु - आयामी सरणी कहा जाता है.

563
00:34:03,000 --> 00:34:05,000
जब हम एक बहु - आयामी सरणी

564
00:34:05,000 --> 00:34:07,000
इसका मतलब है कि हम कुछ पंक्तियों और स्तंभों की तरह हो सकता है,

565
00:34:07,000 --> 00:34:11,000
और यह सिर्फ visualizing या इसके बारे में सोच का एक तरीका है.

566
00:34:11,000 --> 00:34:14,000
जब मैं एक बहु - आयामी सरणी है इसका मतलब है कि मैं करने की जरूरत शुरू करने के लिए जा रहा हूँ

567
00:34:14,000 --> 00:34:17,000
1 से अधिक सूचकांक क्योंकि अगर मैं एक ग्रिड

568
00:34:17,000 --> 00:34:19,000
कह रही है क्या आप पंक्ति में रहे हैं बस हमें एक संख्या देना नहीं है.

569
00:34:19,000 --> 00:34:22,000
यह वास्तव में सिर्फ हमें संख्याओं की एक सूची देने के लिए जा रहा है.

570
00:34:22,000 --> 00:34:25,000
चलो कहते हैं कि मैं इस सरणी यहाँ है.

571
00:34:25,000 --> 00:34:30,000
मैं एक ग्रिड सरणी कहा जाता है, और मैं यह 2 पंक्तियों और 3 कॉलम कह रहा हूँ,

572
00:34:30,000 --> 00:34:32,000
और तो यह यह visualizing की एक तरीका है.

573
00:34:32,000 --> 00:34:37,000
जब मैं कहता हूँ मैं [1] पर तत्व प्राप्त करना चाहते हैं [2]

574
00:34:37,000 --> 00:34:41,000
इसका मतलब है कि क्योंकि इन पंक्तियों के पहले और फिर स्तंभों

575
00:34:41,000 --> 00:34:44,000
मैं करने के लिए 1 पंक्ति के बाद से मैं 1 कहा कूदने के लिए जा रहा हूँ.

576
00:34:44,000 --> 00:34:49,000
>> तो मैं 2 स्तंभ यहाँ आने के लिए जा रहा हूँ, और मैं मान 6 पाने के लिए जा रहा हूँ.

577
00:34:49,000 --> 00:34:51,000
मतलब होता है?

578
00:34:51,000 --> 00:34:55,000
बहु - आयामी arrays, याद है, तकनीकी रूप से सिर्फ सरणियों की एक सरणी हैं.

579
00:34:55,000 --> 00:34:57,000
हम arrays के arrays के arrays हो सकता है.

580
00:34:57,000 --> 00:35:00,000
हम जा रखने के लिए कर सकते हैं, लेकिन के बारे में वास्तव में एक तरह लगता है

581
00:35:00,000 --> 00:35:03,000
यह कैसे बाहर रखा जा रहा है और क्या हो रहा है यह कल्पना है

582
00:35:03,000 --> 00:35:09,000
इस तरह एक ग्रिड में.

583
00:35:09,000 --> 00:35:12,000
जब हम कार्य करने के लिए arrays गुजरती हैं, वे व्यवहार करने जा रहे हैं

584
00:35:12,000 --> 00:35:16,000
जब हम कार्य करने के लिए नियमित रूप से चर के पास से एक छोटे से अलग बिट

585
00:35:16,000 --> 00:35:18,000
एक int या एक नाव पारित की तरह.

586
00:35:18,000 --> 00:35:21,000
जब हम एक int या चार या इन अन्य डेटा के किसी भी प्रकार के पास

587
00:35:21,000 --> 00:35:24,000
हम सिर्फ अगर समारोह modifies पर एक नज़र लिया

588
00:35:24,000 --> 00:35:28,000
कि परिवर्तन करने के लिए प्रचार करने के लिए नहीं जा रहा है कि चर के मूल्य

589
00:35:28,000 --> 00:35:32,000
बुला कार्य करने के लिए.

590
00:35:32,000 --> 00:35:35,000
एक सरणी के साथ, दूसरे हाथ पर, कि क्या होगा.

591
00:35:35,000 --> 00:35:39,000
अगर मैं कुछ कार्य करने के लिए एक सरणी में पास और उस समारोह तत्वों में से कुछ परिवर्तन,

592
00:35:39,000 --> 00:35:43,000
जब मैं समारोह में कहा कि यह कहा जाता है करने के लिए वापस आ

593
00:35:43,000 --> 00:35:47,000
मेरे सरणी अब अलग हो जा रहा है, और उस के लिए शब्दावली

594
00:35:47,000 --> 00:35:50,000
है arrays संदर्भ द्वारा पारित कर दिया जाता है, के रूप में हम बाद में देखेंगे.

595
00:35:50,000 --> 00:35:53,000
यह संकेत है, कैसे काम इन बुनियादी जहां डेटा प्रकार से संबंधित है,

596
00:35:53,000 --> 00:35:55,000
दूसरे हाथ पर, मान द्वारा पारित कर रहे हैं.

597
00:35:55,000 --> 00:35:59,000
>> हम जानते हैं कि कुछ चर की एक प्रतिलिपि बनाने और फिर नकल में गुजर रहा है के रूप में सोच सकते हैं.

598
00:35:59,000 --> 00:36:01,000
इससे कोई फर्क नहीं पड़ता है कि क्या हम उस चर के साथ करते हैं.

599
00:36:01,000 --> 00:36:06,000
बुला समारोह पता है कि यह बदल गया था नहीं होगा.

600
00:36:06,000 --> 00:36:10,000
Arrays सिर्फ एक छोटे से उस संबंध में थोड़ा अलग हैं.

601
00:36:10,000 --> 00:36:13,000
उदाहरण के लिए, के रूप में हम सिर्फ देखा, मुख्य बस एक समारोह है

602
00:36:13,000 --> 00:36:15,000
कि 2 बहस में ले जा सकते हैं.

603
00:36:15,000 --> 00:36:20,000
मुख्य समारोह के लिए 1 तर्क argc, या तर्कों की संख्या है,

604
00:36:20,000 --> 00:36:23,000
और दूसरा तर्क argv कहा जाता है,

605
00:36:23,000 --> 00:36:27,000
और उन उन तर्कों की वास्तविक मान रहे हैं.

606
00:36:27,000 --> 00:36:30,000
चलो कहते हैं कि मैं एक this.c कार्यक्रम बुलाया है,

607
00:36:30,000 --> 00:36:34,000
और मैं यह कहना है, और मैं कमांड लाइन पर चला जा रहा हूँ.

608
00:36:34,000 --> 00:36:38,000
अब कुछ बहस में अपने कार्यक्रम के लिए पारित यह कहा जाता है,

609
00:36:38,000 --> 00:36:42,000
मैं कुछ ऐसा कहना है / इस सीएस 50 है.

610
00:36:42,000 --> 00:36:45,000
यह है कि हम क्या दाऊद करने के लिए हर दिन की कल्पना टर्मिनल पर.

611
00:36:45,000 --> 00:36:48,000
लेकिन अब है कि कार्यक्रम के मुख्य समारोह के अंदर

612
00:36:48,000 --> 00:36:52,000
इन मूल्यों है, तो 4 argc है.

613
00:36:52,000 --> 00:36:56,000
यह थोड़ा भ्रमित हो सकता है क्योंकि वास्तव में हम केवल 50 सीएस में गुजर रहे हैं हो सकता है.

614
00:36:56,000 --> 00:36:58,000
यह केवल 3.

615
00:36:58,000 --> 00:37:02,000
लेकिन याद रखना कि argv के पहले तत्व या 1 तर्क

616
00:37:02,000 --> 00:37:05,000
समारोह ही नाम है.

617
00:37:05,000 --> 00:37:07,190
तो इसका मतलब है कि हम 4 बातें यहाँ है,

618
00:37:07,190 --> 00:37:10,530
और 1 तत्व / यह होने जा रहा है.

619
00:37:10,530 --> 00:37:12,970
और यह एक स्ट्रिंग के रूप में प्रतिनिधित्व किया जाएगा.

620
00:37:12,970 --> 00:37:18,590
तो शेष तत्वों रहे हैं जो हम इस कार्यक्रम के नाम के बाद में टाइप.

621
00:37:18,590 --> 00:37:22,720
तो बस के रूप में एक अलग रूप में हम शायद 2 pset में देखा था,

622
00:37:22,720 --> 00:37:28,780
याद है कि 50 स्ट्रिंग पूर्णांक 50 ≠ है.

623
00:37:28,780 --> 00:37:32,520
तो हम जैसे कुछ नहीं कह सकते हैं 'int = x 3 argv.'

624
00:37:32,520 --> 00:37:36,470
>> वह सिर्फ जा रहा है, समझ बनाने के लिए नहीं है क्योंकि यह एक स्ट्रिंग है, और यह एक पूर्णांक है.

625
00:37:36,470 --> 00:37:38,510
तो अगर आप 2 के बीच परिवर्तित करना चाहते हैं, याद है, हम जा रहे हैं

626
00:37:38,510 --> 00:37:40,810
इस जादू atoi समारोह बुलाया है.

627
00:37:40,810 --> 00:37:46,270
यह एक स्ट्रिंग लेता है और कि स्ट्रिंग के अंदर प्रतिनिधित्व पूर्णांक देता है.

628
00:37:46,270 --> 00:37:48,360
तो है कि एक आसान गलती प्रश्नोत्तरी बनाने,

629
00:37:48,360 --> 00:37:51,590
बस सोच रहा है कि यह स्वचालित रूप से सही प्रकार होगा.

630
00:37:51,590 --> 00:37:53,860
लेकिन सिर्फ इतना पता है कि ये हमेशा तार हो जाएगा

631
00:37:53,860 --> 00:38:00,920
यहां तक ​​कि अगर स्ट्रिंग केवल एक पूर्णांक या एक चरित्र या एक नाव शामिल हैं.

632
00:38:00,920 --> 00:38:03,380
तो अब समय चल रहा है के बारे में बात करते हैं.

633
00:38:03,380 --> 00:38:06,700
जब हम इन सभी एल्गोरिदम कि इन सब पागल बातें करते हैं

634
00:38:06,700 --> 00:38:11,580
यह वास्तव में उपयोगी हो जाता है के लिए सवाल पूछते हैं, "वे कैसे समय लेते हैं?"

635
00:38:11,580 --> 00:38:15,500
हम कुछ उपगामी संकेतन बुलाया के साथ कि प्रतिनिधित्व करते हैं.

636
00:38:15,500 --> 00:38:18,430
तो इसका मतलब है कि - ठीक है, चलो का कहना है कि हम हमारे एल्गोरिथ्म दे

637
00:38:18,430 --> 00:38:20,840
कुछ सच में, सच, सच में बड़ा इनपुट है.

638
00:38:20,840 --> 00:38:23,840
हम सवाल पूछना चाहता हूँ, "कब तक यह करने के लिए ले जा रहा है?

639
00:38:23,840 --> 00:38:26,370
कितने कदम यह हमारे एल्गोरिथ्म लेने के लिए चलेंगे

640
00:38:26,370 --> 00:38:29,980
इनपुट के आकार के एक समारोह के रूप में? "

641
00:38:29,980 --> 00:38:33,080
तो 1 जिस तरह से हम चलाने के लिए समय का वर्णन कर सकते हैं बड़ा ओ के साथ है

642
00:38:33,080 --> 00:38:35,380
और यह हमारे चलने सबसे ज्यादा मामले समय है.

643
00:38:35,380 --> 00:38:38,590
तो अगर हम एक सरणी सॉर्ट करना चाहते हैं, और हम हमारे एल्गोरिथ्म एक सरणी दे

644
00:38:38,590 --> 00:38:41,000
अवरोही क्रम में जब यह आरोही क्रम में होना चाहिए,

645
00:38:41,000 --> 00:38:43,130
कि सबसे खराब मामला होने जा रहा है.

646
00:38:43,130 --> 00:38:49,800
यह हमारे समय हमारे एल्गोरिथ्म ले जाएगा की अधिकतम लंबाई में ऊपरी बाध्य है.

647
00:38:49,800 --> 00:38:54,740
दूसरी ओर, इस Ω समय चल रहा है सबसे अच्छा मामले का वर्णन करने के लिए जा रहा है.

648
00:38:54,740 --> 00:38:58,210
तो अगर हम एक छँटाई एल्गोरिथ्म के लिए एक पहले से ही क्रमबद्ध सरणी देते हैं,

649
00:38:58,210 --> 00:39:00,940
कितनी देर तक यह इसे सुलझा ले जाएगा?

650
00:39:00,940 --> 00:39:06,610
और यह, फिर, एक कम समय चल रहा है पर बाध्य का वर्णन करता है.

651
00:39:06,610 --> 00:39:10,980
तो यहाँ सिर्फ कुछ शब्दों है कि कुछ सामान्य चल बार का वर्णन कर रहे हैं.

652
00:39:10,980 --> 00:39:13,120
ये आरोही क्रम में हैं.

653
00:39:13,120 --> 00:39:16,060
सबसे तेजी से चल रहा है समय हमारे पास लगातार कहा जाता है.

654
00:39:16,060 --> 00:39:19,800
>> यह कोई फर्क नहीं पड़ता कि कितने तत्वों हम हमारे एल्गोरिथ्म दे मतलब है,

655
00:39:19,800 --> 00:39:22,280
कोई फर्क नहीं पड़ता कि कैसे हमारे सरणी बड़ा है, यह छँटाई

656
00:39:22,280 --> 00:39:26,510
या जो कुछ भी कर हम सरणी के लिए कर रहे हैं हमेशा समय की एक ही राशि ले जाएगा.

657
00:39:26,510 --> 00:39:30,270
तो हम एक 1 है, जो एक स्थिर है कि बस के साथ प्रतिनिधित्व कर सकते हैं.

658
00:39:30,270 --> 00:39:32,410
हम लघुगणक चलाने के समय में भी देखा.

659
00:39:32,410 --> 00:39:34,800
तो द्विआधारी खोज की तरह कुछ logarithmic है,

660
00:39:34,800 --> 00:39:37,140
जहां हम हर आधे समय में समस्या में कटौती

661
00:39:37,140 --> 00:39:40,970
और फिर बातें बस वहाँ से अधिक मिलता है.

662
00:39:40,970 --> 00:39:43,580
और अगर तुम कभी किसी भाज्य एल्गोरिथ्म के एक हे लेखन,

663
00:39:43,580 --> 00:39:47,850
आप शायद यह अपने दिन नौकरी के रूप में विचार नहीं करना चाहिए.

664
00:39:47,850 --> 00:39:53,910
जब हम चल रहे बार की तुलना में यह महत्वपूर्ण है कि इन बातों को ध्यान में रखने के.

665
00:39:53,910 --> 00:39:57,760
तो अगर मैं एक एल्गोरिथ्म कि हे (एन), और किसी

666
00:39:57,760 --> 00:40:03,590
हे के एक एल्गोरिथ्म (2n) वास्तव में ये हैं asymptotically बराबर.

667
00:40:03,590 --> 00:40:06,590
तो अगर हम eleventy अरब की तरह एक बड़ी संख्या हो n कल्पना कीजिए:

668
00:40:06,590 --> 00:40:13,090
इसलिए जब हम eleventy अरब eleventy अरब की तरह कुछ + 3 की तुलना कर रहे हैं,

669
00:40:13,090 --> 00:40:17,640
अचानक कि वास्तव में तीन एक बड़ा अंतर अब और नहीं कर सकता है.

670
00:40:17,640 --> 00:40:20,980
यही कारण है कि हम इन बातों के बराबर होने के लिए विचार शुरू करने के लिए जा रहे हैं.

671
00:40:20,980 --> 00:40:24,220
इन अचरों की तरह यहाँ बातें तो इस 2 x है, या एक 3 जोड़ने,

672
00:40:24,220 --> 00:40:27,180
ये सिर्फ स्थिरांक, और इन करने के लिए छोड़ने जा रहे हैं.

673
00:40:27,180 --> 00:40:32,480
तो यही कारण है कि इन चलाने बार के सभी 3 कह रही है वे O (n) के रूप में एक ही कर रहे हैं.

674
00:40:32,480 --> 00:40:37,490
इसी तरह, अगर हम 2 अन्य चलाने बार है, चलो कहते हैं कि हे (एन + ² 2n ³), हम जोड़ सकते हैं

675
00:40:37,490 --> 00:40:42,070
+ N 7 +, और फिर हम एक और चलाने के लिए समय है कि सिर्फ हे (n ³) है.

676
00:40:42,070 --> 00:40:46,290
फिर, ये एक ही बात कर रहे हैं क्योंकि इन - ये एक ही नहीं कर रहे हैं.

677
00:40:46,290 --> 00:40:49,840
ये वही बातें कर रहे हैं, माफ करना. तो ये वही कर रहे हैं, क्योंकि

678
00:40:49,840 --> 00:40:53,090
इस n ³ इस 2n ² हावी हो रहा है.

679
00:40:53,090 --> 00:40:59,130
>> क्या है अगर हम (n ³) हे और हे की तरह बार चलाने के लिए है ही बात नहीं है (² n)

680
00:40:59,130 --> 00:41:02,820
क्योंकि इस n ³ ज्यादा इस n ² से भी बड़ा है.

681
00:41:02,820 --> 00:41:05,470
तो अगर हम exponents है, अचानक यह बात करने के लिए शुरू होता है,

682
00:41:05,470 --> 00:41:08,280
लेकिन जब हम बस कारकों के साथ काम कर रहे हैं के रूप में हम यहाँ हैं,

683
00:41:08,280 --> 00:41:12,810
तो यह बात है क्योंकि वे सिर्फ बाहर छोड़ने के लिए जा रहे हैं नहीं जा रहा है.

684
00:41:12,810 --> 00:41:16,760
चलो एल्गोरिदम के कुछ हम अब तक देखा है पर एक नज़र रखना

685
00:41:16,760 --> 00:41:19,260
और उनके चलाने के समय के बारे में बात करते हैं.

686
00:41:19,260 --> 00:41:23,850
एक सूची में एक नंबर के लिए देखने का पहला तरीका है, कि हमने देखा, रैखिक खोज थी.

687
00:41:23,850 --> 00:41:26,950
और रैखिक खोज के कार्यान्वयन सुपर सीधा है.

688
00:41:26,950 --> 00:41:30,490
हम सिर्फ एक सूची है, और हम सूची में हर एक तत्व पर देखने के लिए जा रहे हैं

689
00:41:30,490 --> 00:41:34,260
जब तक हम इस संख्या को खोजने के लिए हम देख रहे हैं.

690
00:41:34,260 --> 00:41:38,370
तो इसका मतलब है कि सबसे खराब स्थिति में, यह O (n).

691
00:41:38,370 --> 00:41:40,860
और सबसे बुरा मामले में अगर तत्व हो सकता है

692
00:41:40,860 --> 00:41:45,710
पिछले तत्व, तो रैखिक खोज का उपयोग हम हर एक तत्व को देखने के लिए है

693
00:41:45,710 --> 00:41:50,180
जब तक हम पिछले एक क्रम में पता है कि यह वास्तव में सूची में था.

694
00:41:50,180 --> 00:41:52,910
हम सिर्फ आधे रास्ते नहीं दे और सकते हैं और कहते हैं, "यह शायद वहाँ नहीं है."

695
00:41:52,910 --> 00:41:55,980
रैखिक खोज के साथ हम पूरी बात को देखने के लिए है.

696
00:41:55,980 --> 00:41:59,090
सबसे अच्छा मामले चल रहे है, दूसरे हाथ पर, निरंतर है

697
00:41:59,090 --> 00:42:04,200
क्योंकि सबसे अच्छा मामले में हम देख रहे हैं तत्व सिर्फ सूची में पहले से एक है.

698
00:42:04,200 --> 00:42:08,930
तो यह हमें वास्तव में एक कदम है, कोई फर्क नहीं पड़ता कि कितना बड़ा सूची है ले जा रहा है

699
00:42:08,930 --> 00:42:12,140
अगर हम पहले तत्व के लिए हर बार देख रहे हैं.

700
00:42:12,140 --> 00:42:15,390
>> तो जब आप खोज, याद है, यह नहीं की आवश्यकता नहीं है कि हमारी सूची हल हो.

701
00:42:15,390 --> 00:42:19,430
क्योंकि हम तो बस हर एक तत्व पर देखने जा रहे हैं, और यह वास्तव में कोई फर्क नहीं पड़ता

702
00:42:19,430 --> 00:42:23,560
किस क्रम में उन तत्वों के अंदर कर रहे हैं

703
00:42:23,560 --> 00:42:28,110
एक और अधिक बुद्धिमान खोज एल्गोरिथ्म द्विआधारी खोज की तरह कुछ है.

704
00:42:28,110 --> 00:42:31,500
याद रखें, द्विआधारी खोज के कार्यान्वयन है जब आप करने के लिए जा रहे हैं

705
00:42:31,500 --> 00:42:34,320
सूची के बीच में तलाश में रहते हैं.

706
00:42:34,320 --> 00:42:38,000
और क्योंकि हम बीच में देख रहे हैं, हम चाहते हैं कि सूची हल है

707
00:42:38,000 --> 00:42:40,580
या हम जहां मध्यम है नहीं पता है, करते हैं और हम पर देखो

708
00:42:40,580 --> 00:42:44,480
पूरी सूची में इसे खोजने के लिए, और फिर उस बिंदु पर हम सिर्फ समय बर्बाद कर रहे हैं.

709
00:42:44,480 --> 00:42:48,480
तो अगर हम एक क्रमबद्ध सूची है और हम बीच में मिल जाए, हम करने के लिए बीच की तुलना करने के लिए जा रहे हैं

710
00:42:48,480 --> 00:42:51,590
तत्व के लिए हम देख रहे हैं.

711
00:42:51,590 --> 00:42:54,640
अगर यह बहुत अधिक है, तो हम सही आधा भूल कर सकते हैं

712
00:42:54,640 --> 00:42:57,810
क्योंकि हम जानते हैं कि अगर हमारे तत्व पहले से ही बहुत अधिक है

713
00:42:57,810 --> 00:43:01,080
और इस तत्व की सही करने के लिए सब कुछ भी अधिक है,

714
00:43:01,080 --> 00:43:02,760
तो हम वहाँ अब देखने की जरूरत नहीं है.

715
00:43:02,760 --> 00:43:05,430
कहाँ दूसरे हाथ पर, यदि हमारे तत्व बहुत कम है,

716
00:43:05,430 --> 00:43:08,700
हम जानते हैं कि उस तत्व की बाईं करने के लिए सब कुछ भी बहुत कम है,

717
00:43:08,700 --> 00:43:11,390
तो यह वास्तव में वहाँ देखो समझ में नहीं पड़ता है, या तो.

718
00:43:11,390 --> 00:43:15,760
इस तरह, हर कदम के साथ और सूची के मध्य में हर समय हम देख,

719
00:43:15,760 --> 00:43:19,060
हम में आधा हमारी समस्या में कटौती करने के लिए जा रहे हैं क्योंकि अचानक हम जानते हैं

720
00:43:19,060 --> 00:43:23,040
नंबर है कि एक के लिए हम देख रहे हैं नहीं किया जा सकता है की एक पूरी गुच्छा.

721
00:43:23,040 --> 00:43:26,950
>> Pseudocode में यह कुछ इस तरह देखना होगा,

722
00:43:26,950 --> 00:43:30,990
और क्योंकि हम हर आधे ही समय में सूची में कटौती कर रहे हैं,

723
00:43:30,990 --> 00:43:34,920
हमारे सबसे ज्यादा मामले रन रैखिक से logarithmic समय कूदता है.

724
00:43:34,920 --> 00:43:39,260
तो अचानक हम लॉग में कदम क्रम में एक सूची में एक तत्व को खोजने के लिए.

725
00:43:39,260 --> 00:43:42,460
सबसे अच्छा मामले चल रहे है, हालांकि, अभी भी लगातार

726
00:43:42,460 --> 00:43:45,180
क्योंकि अब, चलो बस का कहना है कि तत्व के लिए हम देख रहे हैं

727
00:43:45,180 --> 00:43:48,380
हमेशा मूल सूची के सटीक बीच.

728
00:43:48,380 --> 00:43:52,080
तो हम बड़ा के रूप में हम चाहते हैं के रूप में हमारी सूची विकसित कर सकते हैं, लेकिन अगर तत्व के लिए हम देख रहे हैं के बीच में है,

729
00:43:52,080 --> 00:43:54,910
तो यह केवल करने के लिए हमें एक कदम उठाने जा रहा है.

730
00:43:54,910 --> 00:44:00,920
तो यही कारण है कि हम हे (लॉग एन) और (1) Ω या लगातार कर रहे हैं.

731
00:44:00,920 --> 00:44:04,510
चलो वास्तव में इस सूची पर द्विआधारी खोज चलाने.

732
00:44:04,510 --> 00:44:08,020
तो हम कहते हैं कि हम 164 तत्व के लिए देख रहे हैं.

733
00:44:08,020 --> 00:44:11,650
पहली बात हम क्या करने जा रहे हैं यह है कि इस सूची के मध्य पाते हैं.

734
00:44:11,650 --> 00:44:15,060
यह सिर्फ इतना होता है कि midpoint इन दो संख्याओं के बीच में गिर रहा है,

735
00:44:15,060 --> 00:44:18,960
तो चलो बस मनमाने ढंग से कहते हैं, हर बार midpoint 2 संख्याओं के बीच गिर जाता है,

736
00:44:18,960 --> 00:44:21,150
चलो बस ऊपर दौर.

737
00:44:21,150 --> 00:44:24,330
हम सिर्फ यकीन है कि हम इस तरह के हर कदम बनाने की जरूरत है.

738
00:44:24,330 --> 00:44:29,040
तो हम दौर के लिए जा रहे हैं, और हम कहते हैं कि 161 हमारी सूची के बीच जा रहे हैं.

739
00:44:29,040 --> 00:44:34,640
161 तो <164, और 161 के बाईं ओर हर तत्व

740
00:44:34,640 --> 00:44:39,120
भी <164 में से एक है, इसलिए हम जानते हैं कि यह करने के लिए हम सभी को मदद करने के लिए नहीं जा रहा है

741
00:44:39,120 --> 00:44:42,690
यहाँ देख शुरू तत्व है क्योंकि हम के लिए देख रहे हैं हो सकता है वहाँ नहीं कर सकते.

742
00:44:42,690 --> 00:44:47,060
तो हम क्या कर सकते है हम सिर्फ सूची की है कि पूरे बाईं आधा के बारे में भूल सकता है,

743
00:44:47,060 --> 00:44:51,700
और अब केवल 161 आगे की सही से विचार करें.

744
00:44:51,700 --> 00:44:54,050
>> तो फिर, यह midpoint की है, चलो बस ऊपर दौर.

745
00:44:54,050 --> 00:44:56,260
अब 175 बहुत बड़ी है.

746
00:44:56,260 --> 00:44:59,180
तो हम जानते हैं कि यह हमें यहाँ या यहाँ की तलाश में मदद करने के लिए नहीं जा रहा है,

747
00:44:59,180 --> 00:45:06,610
तो हम सिर्फ इतना है कि दूर फेंक कर सकते हैं, और अंततः हम 164 मारा जाएगा.

748
00:45:06,610 --> 00:45:10,560
द्विआधारी खोज पर कोई सवाल?

749
00:45:10,560 --> 00:45:14,180
चलो एक सूची के माध्यम से पहले से ही हल खोज से आगे बढ़ना

750
00:45:14,180 --> 00:45:17,660
वास्तव में किसी भी क्रम में संख्याओं की एक सूची ले

751
00:45:17,660 --> 00:45:20,960
और आरोही क्रम में है कि सूची बना रही है.

752
00:45:20,960 --> 00:45:24,060
पहली एल्गोरिथ्म हम पर देखा बुलबुला तरह बुलाया गया था.

753
00:45:24,060 --> 00:45:27,300
और इस एल्गोरिदम हमने देखा की आसान हो जाएगा.

754
00:45:27,300 --> 00:45:32,970
बुलबुला तरह का कहना है कि जब सूची के अंदर किसी भी 2 तत्वों जगह से बाहर हैं,

755
00:45:32,970 --> 00:45:36,500
जिसका अर्थ है वहाँ एक कम संख्या के बाईं ओर के लिए एक उच्च संख्या है,

756
00:45:36,500 --> 00:45:40,190
तो हम उन्हें स्वैप के लिए जा रहे हैं, क्योंकि इसका मतलब है कि सूची होगा

757
00:45:40,190 --> 00:45:42,860
"हल अधिक से पहले था.

758
00:45:42,860 --> 00:45:45,180
और हम बस के लिए इस प्रक्रिया को फिर से जारी करने जा रहे हैं और फिर

759
00:45:45,180 --> 00:45:52,100
अंततः जब तक उनके सही स्थान पर बुलबुला तत्वों तरह है और हम एक क्रमबद्ध सूची है.

760
00:45:52,100 --> 00:45:57,230
>> इस चलाने के समय हे होने जा रहा है (एन ²). क्यों?

761
00:45:57,230 --> 00:46:00,370
ठीक है, क्योंकि सबसे ज्यादा मामले में, हम हर तत्व ले जा रहे हैं, और

762
00:46:00,370 --> 00:46:04,570
हम अंत में यह सूची में हर दूसरे तत्व की तुलना करने के लिए जा रहे हैं.

763
00:46:04,570 --> 00:46:08,030
लेकिन सबसे अच्छा मामले में, हम पहले से ही एक क्रमबद्ध सूची है, बुलबुला तरह

764
00:46:08,030 --> 00:46:12,230
सिर्फ एक बार के माध्यम से जाना जा रहा है, कहते हैं, "नहीं, मैं किसी भी स्वैप नहीं बना था, इसलिए मैं काम कर रहा हूँ."

765
00:46:12,230 --> 00:46:17,410
तो हम एक सबसे अच्छा मामले Ω (एन) के समय चल रहा है.

766
00:46:17,410 --> 00:46:20,680
चलो एक सूची पर बुलबुला तरह चला.

767
00:46:20,680 --> 00:46:23,560
या 1, चलो बस कुछ pseudocode सच में जल्दी से देखो.

768
00:46:23,560 --> 00:46:28,160
हम कहते हैं कि हम ट्रैक के पाश के हर यात्रा में रखना चाहते हैं, चाहते हैं,

769
00:46:28,160 --> 00:46:32,190
या नहीं, हम किसी भी तत्व बदल का ट्रैक रखने के लिए.

770
00:46:32,190 --> 00:46:37,610
तो यह है कि के लिए कारण, हम बंद करने जा रहे हैं जब हम किसी भी तत्व नहीं बदली है.

771
00:46:37,610 --> 00:46:41,980
इसलिए हमारे पाश की शुरुआत में हम कुछ भी नहीं बदली है, तो हम कहेंगे कि गलत है.

772
00:46:41,980 --> 00:46:47,170
अब, हम सूची के माध्यम से जाने के लिए जा रहे हैं और तत्व की तुलना मैं तत्व मैं 1 +

773
00:46:47,170 --> 00:46:50,310
और यदि यह मामला है कि वहाँ एक छोटी संख्या के बाईं ओर के लिए एक बड़ी संख्या है,

774
00:46:50,310 --> 00:46:52,310
तो हम सिर्फ उन्हें स्वैप करने के लिए जा रहे हैं.

775
00:46:52,310 --> 00:46:54,490
>> और फिर हम याद है कि हम एक तत्व बदली जा रहे हैं.

776
00:46:54,490 --> 00:46:58,900
इसका मतलब है कि हम सूची के माध्यम से कम से कम 1 बार जाने की जरूरत है

777
00:46:58,900 --> 00:47:02,160
क्योंकि हालत में हम बंद कर दिया है जब पूरी सूची पहले से ही सॉर्ट किया जाता है,

778
00:47:02,160 --> 00:47:04,890
जिसका अर्थ है कि हम किसी भी स्वैप नहीं बनाया है.

779
00:47:04,890 --> 00:47:09,960
तो यही कारण है कि हमारी हालत यहाँ नीचे है जबकि कुछ तत्वों बदली किया गया है. '

780
00:47:09,960 --> 00:47:13,720
तो अब हम सिर्फ यह एक सूची पर चल रहा है पर देखो.

781
00:47:13,720 --> 00:47:16,640
मैं 5,0,1,6,4 सूची है.

782
00:47:16,640 --> 00:47:19,850
बुलबुला तरह छोड़ दिया पर सभी तरह से शुरू करने जा रहा है, और यह तुलना करने के लिए जा रहा है

783
00:47:19,850 --> 00:47:24,700
मैं तत्वों, तो 0 मैं + 1, जो 1 तत्व है.

784
00:47:24,700 --> 00:47:29,020
यह कहना है, अच्छी तरह से 5> 0 जा रहा है, लेकिन अभी 5 बाईं करने के लिए है,

785
00:47:29,020 --> 00:47:32,500
इसलिए मैं 5 और 0 स्वैप करने की जरूरत है.

786
00:47:32,500 --> 00:47:35,470
जब मैं उन्हें स्वैप, अचानक मैं यह अलग सूची मिलता है.

787
00:47:35,470 --> 00:47:38,260
5 अब> 1, तो हम उन्हें स्वैप के लिए जा रहे हैं.

788
00:47:38,260 --> 00:47:42,160
5 6> नहीं है, तो हम यहाँ कुछ भी करने की जरूरत नहीं है.

789
00:47:42,160 --> 00:47:46,690
लेकिन 6 4>, तो हम स्वैप करने की जरूरत है.

790
00:47:46,690 --> 00:47:49,740
फिर, हम पूरा करने के लिए अंत में पता चलता सूची के माध्यम से चलाने की जरूरत है

791
00:47:49,740 --> 00:47:52,330
कि इन क्रम से बाहर हैं, हम उन्हें स्वैप,

792
00:47:52,330 --> 00:47:57,120
और इस बिंदु पर हम सूची के माध्यम से 1 अधिक समय चलाने की जरूरत है

793
00:47:57,120 --> 00:48:05,390
यकीन है कि सब कुछ अपने आदेश में है, और इस बिंदु बुलबुला तरह समाप्त हो गया है.

794
00:48:05,390 --> 00:48:10,720
कुछ तत्वों को लेने और उन्हें छँटाई करने के लिए एक अलग एल्गोरिथ्म चयन छंटाई है.

795
00:48:10,720 --> 00:48:15,740
चयन छंटाई के पीछे विचार यह है कि हम करने के लिए सूची का एक क्रमबद्ध भाग बनाने जा रहे हैं

796
00:48:15,740 --> 00:48:18,150
एक समय में 1 तत्व.

797
00:48:18,150 --> 00:48:23,170
>> और जिस तरह से हम ऐसा करने जा रहे हैं सूची के बाईं ओर खंड के निर्माण से है.

798
00:48:23,170 --> 00:48:27,510
और मूल रूप से, हर - हर कदम पर, हम छोटी तत्व हम छोड़ दिया है ले जा रहे हैं

799
00:48:27,510 --> 00:48:32,310
है कि अभी तक हल नहीं किया गया है, और हम यह कि हल खंड में स्थानांतरित करने के लिए जा रहे हैं.

800
00:48:32,310 --> 00:48:35,850
इसका मतलब है कि हम लगातार न्यूनतम unsorted तत्व को खोजने की जरूरत है

801
00:48:35,850 --> 00:48:40,720
और फिर कि न्यूनतम तत्व ले और यह साथ जो कुछ भी स्वैप

802
00:48:40,720 --> 00:48:45,090
बाएँ सबसे तत्व है कि हल नहीं है.

803
00:48:45,090 --> 00:48:50,890
इस के चलाने के लिए समय हे होने जा रहा है (² n), क्योंकि मामले में सबसे खराब

804
00:48:50,890 --> 00:48:55,070
हम हर दूसरे तत्व हर एक तत्व की तुलना की जरूरत है.

805
00:48:55,070 --> 00:48:59,250
क्योंकि हम कह रहे हैं कि अगर हम सूची के बाईं छमाही में शुरू करते हैं, हम की जरूरत है

806
00:48:59,250 --> 00:49:02,970
पूरे सही खंड के माध्यम से जाने के लिए छोटी से छोटी तत्व मिल.

807
00:49:02,970 --> 00:49:05,430
और फिर, फिर से, हम पूरे सही खंड जाने के लिए और की जरूरत है

808
00:49:05,430 --> 00:49:08,210
और अधिक से अधिक और अधिक से अधिक जा रहा है कि फिर से रखने के लिए.

809
00:49:08,210 --> 00:49:11,350
N ² होने जा रहा है. हम पाश अंदर पाश के लिए किसी अन्य के लिए एक आवश्यकता के लिए जा रहे हैं

810
00:49:11,350 --> 00:49:13,350
जो n ² पता चलता है.

811
00:49:13,350 --> 00:49:16,530
सबसे अच्छा मामले सोचा, चलो कहते हैं कि हम यह एक पहले से ही क्रमबद्ध सूची दे;

812
00:49:16,530 --> 00:49:19,270
हम वास्तव में n ² की तुलना में किसी भी बेहतर नहीं करते.

813
00:49:19,270 --> 00:49:21,730
क्योंकि चयन तरह जानते हुए भी कि कोई रास्ता नहीं है

814
00:49:21,730 --> 00:49:25,540
न्यूनतम तत्व बस एक मैं हो रही हो.

815
00:49:25,540 --> 00:49:28,970
यह अभी भी यकीन है कि यह वास्तव में कम से कम करने की जरूरत है.

816
00:49:28,970 --> 00:49:31,670
>> और यकीन है कि यह न्यूनतम है, इस एल्गोरिथ्म का उपयोग केवल तरह,

817
00:49:31,670 --> 00:49:34,640
हर एक तत्व पर फिर से देखने के लिए है.

818
00:49:34,640 --> 00:49:38,420
तो सच में, अगर आप इसे देना - अगर आप चयन छंटाई पहले से ही एक क्रमबद्ध सूची दे,

819
00:49:38,420 --> 00:49:42,720
यह करने के लिए यह एक सूची है कि अभी तक हल नहीं है देने की तुलना में किसी भी बेहतर करने के लिए नहीं जा रहा है.

820
00:49:42,720 --> 00:49:46,320
वैसे, अगर यह मामला होता है कि कुछ हे (कुछ)

821
00:49:46,320 --> 00:49:50,640
और कुछ के ओमेगा, हम सिर्फ अधिक succinctly कि यह कुछ के θ कह सकते हैं.

822
00:49:50,640 --> 00:49:52,760
तो अगर आप देखते हैं कि कहीं भी आते हैं, कि है कि क्या सिर्फ मतलब है.

823
00:49:52,760 --> 00:49:57,580
>> यदि कुछ n के थीटा ², यह दोनों बड़े (² n) हे और Ω (² n) है.

824
00:49:57,580 --> 00:49:59,790
सबसे अच्छा मामले में और सबसे ज्यादा मामले तो, इससे कोई फर्क नहीं पड़ता है,

825
00:49:59,790 --> 00:50:04,400
एल्गोरिथ्म हर बार एक ही बात करने के लिए जा रहा है.

826
00:50:04,400 --> 00:50:06,610
तो यह है कि क्या चयन छंटाई के लिए pseudocode की तरह लग सकता है.

827
00:50:06,610 --> 00:50:10,630
हम मूल रूप से कहना है कि मैं सूची पुनरावृति करना चाहते करने के लिए जा रहे हैं

828
00:50:10,630 --> 00:50:15,180
से सही करने के लिए, और लूप के प्रत्येक चलना छोड़ दिया है, मैं को स्थानांतरित करने के लिए जा रहा हूँ

829
00:50:15,180 --> 00:50:19,780
सूची के इस हल भाग में न्यूनतम तत्व.

830
00:50:19,780 --> 00:50:23,260
और एक बार मैं वहाँ कुछ ले जाने के लिए, मैं कभी उस तत्व पर फिर से देखने की जरूरत है.

831
00:50:23,260 --> 00:50:28,600
क्योंकि जैसे ही मैं में सूची के बाईं ओर खंड के लिए एक तत्व स्वैप, यह हल है

832
00:50:28,600 --> 00:50:32,600
क्योंकि हम minimums उपयोग करके आरोही क्रम में सब कुछ कर रहे हैं.

833
00:50:32,600 --> 00:50:38,740
तो हम ने कहा, ठीक है, हम स्थिति में मैं कर रहे हैं, और हम तत्वों के सभी को देखने की जरूरत है

834
00:50:38,740 --> 00:50:42,260
मैं के सही क्रम में करने के लिए कम से कम मिल.

835
00:50:42,260 --> 00:50:46,150
तो इसका मतलब है कि हम i + 1 से सूची के अंत में देखना चाहता हूँ.

836
00:50:46,150 --> 00:50:51,610
और अब, अगर तत्व है कि हम वर्तमान में देख रहे हैं हमारे न्यूनतम से कम इतनी दूर है,

837
00:50:51,610 --> 00:50:54,190
जो, याद है, हम कम से कम बंद शुरू कर रहे हैं हो सकता है सिर्फ

838
00:50:54,190 --> 00:50:57,020
जो भी तत्व हम वर्तमान में कर रहे हैं, मुझे लगता है कि कम से कम है.

839
00:50:57,020 --> 00:51:00,270
अगर मैं एक तत्व है कि तुलना में छोटी है, तो मैं कहने जा रहा हूँ, ठीक है,

840
00:51:00,270 --> 00:51:02,700
ठीक है, मैं कम से कम एक नया मिल गया है.

841
00:51:02,700 --> 00:51:06,080
मुझे याद है, जहां था कि कम से कम करने के लिए जा रहा हूँ.

842
00:51:06,080 --> 00:51:09,560
>> तो अब, एक बार में मैं कि सही unsorted खंड के माध्यम से चला गया है,

843
00:51:09,560 --> 00:51:16,690
मैं कह सकता हूँ मैं तत्व है कि मैं इस स्थिति में है के साथ न्यूनतम तत्व स्वैप करने के लिए जा रहा हूँ.

844
00:51:16,690 --> 00:51:21,100
यह मेरी सूची का निर्माण करने के लिए जा रहा है, मेरे बाएं से दाएं की सूची के अनुसार क्रमबद्ध भाग,

845
00:51:21,100 --> 00:51:25,190
और हम कभी एक तत्व पर फिर से देखने की जरूरत नहीं है एक बार यह उस हिस्से में है.

846
00:51:25,190 --> 00:51:27,930
एक बार जब हम यह बदली है.

847
00:51:27,930 --> 00:51:30,260
तो चलो इस सूची में चयन तरह से चलाने के लिए.

848
00:51:30,260 --> 00:51:38,220
नीले तत्व के लिए यहाँ मैं जा रहा है, और लाल तत्व न्यूनतम तत्व होने जा रहा है.

849
00:51:38,220 --> 00:51:41,570
तो मैं सूची की बाईं पर सभी तरह से शुरू होता है, तो 5 बजे.

850
00:51:41,570 --> 00:51:44,610
अब हम न्यूनतम unsorted तत्व को खोजने की जरूरत है.

851
00:51:44,610 --> 00:51:49,480
तो हम कह 0 <5, 0 मेरी नई न्यूनतम है.

852
00:51:49,480 --> 00:51:53,820
>> लेकिन मैं वहाँ रोक नहीं है, क्योंकि भले ही हम पहचान सकते हैं कि 0 छोटी कर सकते हैं,

853
00:51:53,820 --> 00:51:59,390
हम सुनिश्चित करने के लिए सूची के हर दूसरे तत्व के माध्यम से चलाने की जरूरत है.

854
00:51:59,390 --> 00:52:01,760
1 तो बड़ा है, 6 बड़ा है, 4 बड़ा है.

855
00:52:01,760 --> 00:52:05,850
इसका मतलब है कि इन तत्वों के सभी को देखने के बाद, मैं निर्धारित किया है 0 सबसे छोटी है.

856
00:52:05,850 --> 00:52:09,800
तो मैं 5 और 0 स्वैप करने के लिए जा रहा हूँ.

857
00:52:09,800 --> 00:52:15,480
एक बार मुझे लगता है कि स्वैप, मैं एक नई सूची हासिल करने जा रहा हूँ, और मुझे पता है कि मैं जरूरत 0 कि फिर से देखने के लिए कभी नहीं

858
00:52:15,480 --> 00:52:19,380
क्योंकि एक बार मैं यह बदली है, मैं इसे हल किया है और हम कर रहे हैं.

859
00:52:19,380 --> 00:52:22,730
अब यह सिर्फ इतना होता है कि नीले तत्व फिर से 5,

860
00:52:22,730 --> 00:52:26,030
और हम 1 में देखने की जरूरत है, तो 6 और 4 के लिए है कि 1 निर्धारित

861
00:52:26,030 --> 00:52:31,520
छोटी न्यूनतम तत्व है, इसलिए हम 1 और 5 स्वैप करेंगे.

862
00:52:31,520 --> 00:52:36,890
फिर, हम को देखने की जरूरत है - 6 और 4 से 5 की तुलना,

863
00:52:36,890 --> 00:52:39,830
और हम 4 और 5 स्वैप करने के लिए जा रहे हैं, और अंत में की तुलना

864
00:52:39,830 --> 00:52:45,740
उन 2 नंबर और उन्हें स्वैप जब तक हम अपने क्रमबद्ध सूची मिलता है.

865
00:52:45,740 --> 00:52:49,730
चयन प्रकार पर कोई सवाल?

866
00:52:49,730 --> 00:52:56,420
ठीक है. चलो यहाँ पिछले विषय ले जाने के लिए, और कहा कि recursion है.

867
00:52:56,420 --> 00:52:59,810
>> Recursion, याद है, यह वास्तव में मेटा बात है, जहां एक समारोह

868
00:52:59,810 --> 00:53:02,740
बार - बार खुद को कहता है.

869
00:53:02,740 --> 00:53:05,620
तो कुछ बिंदु पर, जबकि हमारे fuction को बार - बार खुद को बुला रहा है,

870
00:53:05,620 --> 00:53:10,100
वहाँ कुछ बिंदु है जिस पर हम अपने आप को फोन बंद होने की जरूरत है.

871
00:53:10,100 --> 00:53:13,670
क्योंकि अगर हम ऐसा नहीं करते, तो हम सिर्फ करने के लिए हमेशा के लिए करने के लिए जारी करने जा रहे हैं,

872
00:53:13,670 --> 00:53:16,660
और हमारे कार्यक्रम समाप्त करने के लिए नहीं जा रहा है.

873
00:53:16,660 --> 00:53:19,200
हम इस हालत के आधार मामले कहते हैं.

874
00:53:19,200 --> 00:53:22,570
और आधार के मामले फिर से एक समारोह बुला के बजाय कहते हैं,

875
00:53:22,570 --> 00:53:25,330
मैं बस कुछ मूल्य वापस करने के लिए जा रहा हूँ.

876
00:53:25,330 --> 00:53:28,080
तो एक बार हम एक मूल्य लौटा दिया है, हम खुद को बुला बंद कर दिया है,

877
00:53:28,080 --> 00:53:32,550
और हम इतनी दूर कर दिया है कि कॉल के बाकी भी लौट सकते हैं.

878
00:53:32,550 --> 00:53:36,050
आधार के मामले के विपरीत पुनरावर्ती मामला है.

879
00:53:36,050 --> 00:53:39,050
और यह तब होता है जब हम समारोह में कहा कि हम अंदर वर्तमान में कर रहे हैं एक और फोन बनाना चाहते हैं

880
00:53:39,050 --> 00:53:44,690
और हम शायद, हालांकि हमेशा नहीं, अलग तर्क का उपयोग करना चाहते हैं.

881
00:53:44,690 --> 00:53:48,940
>> तो अगर हम च बुलाया समारोह है, और च सिर्फ 1 तर्क ले बुलाया,

882
00:53:48,940 --> 00:53:52,010
और हम बस (1) च, च (1), च (1) बुला रखने के लिए, और यह सिर्फ इतना है कि होता है

883
00:53:52,010 --> 00:53:56,510
1 तर्क पुनरावर्ती के मामले में गिर जाता है, हम अभी भी जा रहे हैं कभी नहीं करने के लिए बंद है.

884
00:53:56,510 --> 00:54:01,620
यहां तक ​​कि अगर हम एक आधार मामला है, हमें यकीन है कि अंततः हम उस आधार मामले मारा जा रहे हैं बनाने की जरूरत है.

885
00:54:01,620 --> 00:54:04,250
हम सिर्फ इस पुनरावर्ती मामले में रहने नहीं रखते.

886
00:54:04,250 --> 00:54:09,870
आम तौर पर, जब हम खुद को कहते हैं, तो हम शायद एक अलग तर्क हर बार जा रहे हैं.

887
00:54:09,870 --> 00:54:12,700
यहाँ एक बहुत आसान पुनरावर्ती समारोह है.

888
00:54:12,700 --> 00:54:15,090
तो यह एक संख्या का क्रमगुणित की गणना करेगी.

889
00:54:15,090 --> 00:54:17,790
यहाँ शीर्ष हम हमारे आधार मामला है.

890
00:54:17,790 --> 00:54:22,330
मामले में है कि n ≤ 1, हम फिर से फोन भाज्य नहीं जा रहे हैं.

891
00:54:22,330 --> 00:54:26,490
हम को रोकने के लिए जा रहे हैं, हम सिर्फ कुछ मूल्य वापस करने के लिए जा रहे हैं.

892
00:54:26,490 --> 00:54:30,170
अगर यह सच नहीं है, तो हम हमारे पुनरावर्ती मामले हिट करने के लिए जा रहे हैं.

893
00:54:30,170 --> 00:54:33,550
यहाँ सूचना है कि हम सिर्फ भाज्य (n) नहीं बुला रहे हैं, क्योंकि वह बहुत मददगार नहीं होगा.

894
00:54:33,550 --> 00:54:36,810
हम कुछ और के भाज्य कॉल करने के लिए जा रहे हैं.

895
00:54:36,810 --> 00:54:40,850
>> और इसलिए आप देखते हैं, अंत में अगर हम एक भाज्य (5) या कुछ पारित कर सकते हैं,

896
00:54:40,850 --> 00:54:45,900
हम (4) भाज्य और इतने पर कॉल करने के लिए जा रहे हैं, और अंततः हम इस आधार के मामले में मारा जा रहे हैं.

897
00:54:45,900 --> 00:54:51,730
तो यह अच्छा लग रहा है. देखते हैं क्या होता है जब हम वास्तव में इस चलाने के लिए करते हैं.

898
00:54:51,730 --> 00:54:57,840
यह हो चुकी है, और हम कहते हैं कि मुख्य एक तर्क (4) के साथ इस समारोह में कॉल करने के लिए जा रहा है.

899
00:54:57,840 --> 00:55:02,200
तो एक बार भाज्य देखता है और = 4, भाज्य ही कॉल करेगा.

900
00:55:02,200 --> 00:55:05,010
अब, अचानक, हम भाज्य (3) है.

901
00:55:05,010 --> 00:55:10,780
तो इन कार्यों बढ़ती रखने अंततः जब तक हम अपने बेस मामले मारा जा रहे हैं.

902
00:55:10,780 --> 00:55:17,830
इस बिंदु पर, इस की वापसी मूल्य वापसी (nx इस का वापसी मान) है,

903
00:55:17,830 --> 00:55:21,290
इस की वापसी मूल्य nx की वापसी मूल्य है.

904
00:55:21,290 --> 00:55:23,290
अंततः हम कुछ संख्या हिट की जरूरत है.

905
00:55:23,290 --> 00:55:26,560
यहाँ शीर्ष पर, हम 1 वापसी का कहना है.

906
00:55:26,560 --> 00:55:30,650
इसका मतलब है कि एक बार हम उस संख्या में वापसी, हम ढेर बंद इस पॉप कर सकते हैं.

907
00:55:30,650 --> 00:55:36,570
तो इस भाज्य (1) किया जाता है.

908
00:55:36,570 --> 00:55:41,190
जब 1 रिटर्न, इस भाज्य (1) रिटर्न, 1 इस वापसी.

909
00:55:41,190 --> 00:55:46,910
इस का वापसी मान, याद है, nx की वापसी मूल्य था.

910
00:55:46,910 --> 00:55:50,720
तो अचानक, इस आदमी जानता है कि मैं 2 वापस करना चाहते हैं.

911
00:55:50,720 --> 00:55:55,910
>> तो याद है, इस के मूल्य वापसी सिर्फ nx वापसी मूल्य है यहाँ.

912
00:55:55,910 --> 00:56:01,160
तो अब हम 3 x 2 कहते हैं, कर सकते हैं और अंत में, यहाँ हम कह सकते हैं

913
00:56:01,160 --> 00:56:04,010
यह सिर्फ 4 x 3 x 2 होने जा रहा है.

914
00:56:04,010 --> 00:56:09,570
और एक बार इस रिटर्न, हम मुख्य के एक पूर्णांक के अंदर करने के लिए नीचे उतरो.

915
00:56:09,570 --> 00:56:15,460
Recursion पर कोई सवाल?

916
00:56:15,460 --> 00:56:17,090
सही सभी. तो अंत में प्रश्नों के लिए और अधिक समय है,

917
00:56:17,090 --> 00:56:23,360
लेकिन अब यूसुफ शेष विषयों को कवर किया जाएगा.

918
00:56:23,360 --> 00:56:25,590
>> सभी सही [यूसुफ Ong]. तो अब है कि हम recursions के बारे में बात की है,

919
00:56:25,590 --> 00:56:27,840
चलो क्या मर्ज करते तरह है के बारे में थोड़ा सा बात.

920
00:56:27,840 --> 00:56:31,740
मर्ज तरह मूल रूप से संख्या की एक सूची छँटाई का एक और तरीका है.

921
00:56:31,740 --> 00:56:36,430
और यह कैसे काम करता है मर्ज प्रकार के साथ है, आप एक सूची है, और हम क्या है

922
00:56:36,430 --> 00:56:39,120
हम कहते हैं, चलो 2 हिस्सों में विभाजित है.

923
00:56:39,120 --> 00:56:42,750
हम पहले तरह बाईं आधे पर फिर से मर्ज चलने देंगे,

924
00:56:42,750 --> 00:56:45,040
तो हम सही आधा पर तरह मर्ज चलने देंगे,

925
00:56:45,040 --> 00:56:50,240
और कहा कि हमें अब 2 हिस्सों क्रमबद्ध हैं देता है, और अब हम उन halves एक साथ गठबंधन करने के लिए जा रहे हैं.

926
00:56:50,240 --> 00:56:55,010
यह थोड़ा मुश्किल है के लिए एक उदाहरण के बिना देखते हैं, तो हम गतियों से चलते हैं और देखेंगे कि क्या होता है.

927
00:56:55,010 --> 00:56:59,590
तो आप इस सूची के साथ शुरू करते हैं, हम इसे दो हिस्सों में विभाजित है.

928
00:56:59,590 --> 00:57:02,300
हम बाईं आधे पर तरह 1 मर्ज चलाने.

929
00:57:02,300 --> 00:57:06,660
तो यह है कि बाईं आधा है, और अब हम उन्हें इस सूची के माध्यम से फिर से चलाने के

930
00:57:06,660 --> 00:57:09,800
जो मर्ज प्रकार में पारित हो जाता है, और फिर हम देखते हैं, फिर से,

931
00:57:09,800 --> 00:57:13,270
इस सूची के बाईं ओर पर है और हम उस पर छंटाई संविलय चलाते हैं.

932
00:57:13,270 --> 00:57:15,880
अब, हम 2 नंबर की एक सूची के लिए नीचे उतरो,

933
00:57:15,880 --> 00:57:19,010
अब बाईं आधा केवल 1 तत्व लंबा है, और हम नहीं कर सकते

934
00:57:19,010 --> 00:57:23,380
एक सूची है कि आधे में केवल 1 तत्व है विभाजित, तो हम सिर्फ कहते हैं, एक बार हम 50 है,

935
00:57:23,380 --> 00:57:26,400
जो सिर्फ 1 तत्व है, यह पहले से ही हल है.

936
00:57:26,400 --> 00:57:29,860
>> एक बार जब हम उस के साथ कर रहे हैं, हम देख सकते हैं कि हम कर सकते हैं

937
00:57:29,860 --> 00:57:32,230
इस सूची के ठीक आधे पर चलते हैं,

938
00:57:32,230 --> 00:57:36,480
और 3 में भी हल किया है और तो अब है कि इस सूची के दोनों हिस्सों को हल कर रहे हैं

939
00:57:36,480 --> 00:57:39,080
हम इन नंबरों वापस एक साथ शामिल हो सकते हैं.

940
00:57:39,080 --> 00:57:45,320
इसलिए हम 50 और 3 पर देखो, 3 50 की तुलना में छोटे है, तो यह पहली बार में चला जाता है और फिर 50 अंदर आता है

941
00:57:45,320 --> 00:57:49,340
अब, जो कुछ किया है, हम वापस जाओ कि सूची और तरह यह सही आधा.

942
00:57:49,340 --> 00:57:52,440
42 यह स्वयं की संख्या है, तो यह पहले से ही हल है.

943
00:57:52,440 --> 00:57:57,850
तो अब हम इन तुलना 2 और 3 42 की तुलना में छोटी है, तो है कि पहली बार में डाल दिया जाता है,

944
00:57:57,850 --> 00:58:02,340
अब 42 में डाल दिया जाता है, और 50 के अंदर डाल दिया जाता है

945
00:58:02,340 --> 00:58:07,220
अब, कि हल है, हम सभी तरह से वापस जाने के लिए शीर्ष पर, 1337 और 15.

946
00:58:07,220 --> 00:58:14,560
ठीक है, हम अब इस सूची के बाईं आधा में देखो, 1337 के द्वारा ही है तो इसे हल है और 15 के साथ एक ही है.

947
00:58:14,560 --> 00:58:19,020
तो अब हम इन संख्या 2 गठबंधन करने के लिए कि मूल सूची, 15 <1337 सॉर्ट करने के लिए,

948
00:58:19,020 --> 00:58:23,060
तो यह पहली बार में चला जाता है, तो 1337 के अंदर चला जाता है

949
00:58:23,060 --> 00:58:26,640
और अब हम ऊपर शीर्ष मूल सूची के दोनों हिस्सों का हल.

950
00:58:26,640 --> 00:58:30,440
और हम सभी को करना है इन गठबंधन है.

951
00:58:30,440 --> 00:58:36,890
हम इस सूची की पहली संख्या 2, 3 <15 को देखो, तो यह सॉर्ट सरणी में पहली बार चला जाता है.

952
00:58:36,890 --> 00:58:44,460
<15 42, तो यह अब अंदर चला जाता है, 42 <1337, कि अंदर चला जाता है

953
00:58:44,460 --> 00:58:51,010
<50 1337, तो यह अंदर चला जाता है और लगता है कि हम सिर्फ 2 नंबर इस सूची से दूर ले गया.

954
00:58:51,010 --> 00:58:53,640
तो हम सिर्फ 2 सूचियों के बीच बारी नहीं कर रहे हैं.

955
00:58:53,640 --> 00:58:56,050
हम सिर्फ शुरुआत में देख रहे हैं, और हम तत्व ले जा रहे हैं

956
00:58:56,050 --> 00:59:00,270
और फिर यह हमारे सरणी में डाल छोटे है.

957
00:59:00,270 --> 00:59:04,080
अब हम सब halves विलय कर दिया है और हम कर रहे हैं.

958
00:59:04,080 --> 00:59:07,780
>> बारे में कोई सवाल तरह मर्ज? हाँ?

959
00:59:07,780 --> 00:59:14,190
[छात्र] यदि यह अलग समूहों में विभाजित है, वे अभी क्यों नहीं है, यह एक बार विभाजित

960
00:59:14,190 --> 00:59:19,970
और आप एक समूह में 3 और 2 है? [प्रश्न दुर्बोध के बाकी]

961
00:59:19,970 --> 00:59:24,940
कारण, तो सवाल यह है, हम सिर्फ उस दिशा में पहला कदम नहीं क्यों उन्हें मर्ज कर सकते हैं के बाद हम उन्हें दिया है?

962
00:59:24,940 --> 00:59:29,530
कारण है कि हम यह कर सकते हैं, दोनों पक्षों के बाएँ सबसे तत्वों को शुरू करने के लिए,

963
00:59:29,530 --> 00:59:33,040
और फिर छोटे से एक ले और इसे में डाल दिया है, यह है कि हम जानते हैं कि इन

964
00:59:33,040 --> 00:59:35,290
व्यक्तिगत सूची हल आदेश में हैं.

965
00:59:35,290 --> 00:59:37,290
तो अगर मैं दोनों हिस्सों के बाएँ सबसे तत्वों को देख रहा हूँ,

966
00:59:37,290 --> 00:59:40,490
मुझे पता है कि वे उन लोगों की सूची की सबसे छोटी तत्व हो जा रहे हैं.

967
00:59:40,490 --> 00:59:43,930
इसलिए मैं उन्हें इस बड़ी सूची की सबसे छोटी तत्व स्थानों में डाल सकते हैं.

968
00:59:43,930 --> 00:59:47,810
दूसरी ओर, अगर मैं वहाँ पर दूसरे स्तर में उन 2 सूची में देखो,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, +१,३३७, और 15, उन हल नहीं कर रहे हैं.

970
00:59:51,640 --> 00:59:55,770
तो अगर मैं 50 और 1337 में देखो, मैं मेरी सूची में 50 1 डाला जा रहा हूँ.

971
00:59:55,770 --> 01:00:00,130
लेकिन वह वास्तव में समझ में नहीं पड़ता है, क्योंकि उन सभी से बाहर 3 छोटी तत्व है.

972
01:00:00,130 --> 01:00:04,390
तो एक ही कारण है कि हम इस संयोजन कदम कर सकते हैं क्योंकि हमारी सूची में पहले से ही हल कर रहे हैं.

973
01:00:04,390 --> 01:00:07,010
यही वजह है कि हम करने के लिए नीचे नीचे करने के लिए सभी तरह से है

974
01:00:07,010 --> 01:00:09,800
क्योंकि जब हम सिर्फ एक ही नंबर है, तो आप यह है कि एक ही नंबर पता

975
01:00:09,800 --> 01:00:14,120
में और खुद की पहले से ही एक क्रमबद्ध सूची है.

976
01:00:14,120 --> 01:00:19,360
>> कोई सवाल? नहीं?

977
01:00:19,360 --> 01:00:24,260
जटिलता? खैर, आप देख सकते हैं कि हर कदम पर वहाँ अंत संख्या है,

978
01:00:24,260 --> 01:00:27,590
और हम आधा लॉग n बार में एक सूची में विभाजित कर सकते हैं,

979
01:00:27,590 --> 01:00:31,700
जो है जहाँ हम इस n x लॉग n जटिलता मिलता.

980
01:00:31,700 --> 01:00:34,940
और आप मर्ज प्रकार के लिए सबसे अच्छा मामले n लॉग एन देखते हैं, और यह सिर्फ इतना होता है

981
01:00:34,940 --> 01:00:39,340
कि सबसे खराब स्थिति है, या वहाँ पर Ω भी है n n लॉग.

982
01:00:39,340 --> 01:00:42,480
कुछ को ध्यान में रखना.

983
01:00:42,480 --> 01:00:45,750
पर चल रहा है, चलो कुछ सुपर बुनियादी मैं / ओ फ़ाइल पर जाने

984
01:00:45,750 --> 01:00:48,830
यदि आप हाथापाई पर देखा, तो आप देखेंगे कि हम प्रणाली के कुछ प्रकार था

985
01:00:48,830 --> 01:00:51,270
जहाँ आप एक लॉग फ़ाइल पर लिखने के लिए अगर आप कोड के माध्यम से पढ़ सकता है.

986
01:00:51,270 --> 01:00:53,730
चलो देखते हैं आप कैसे कर सकता है.

987
01:00:53,730 --> 01:00:57,450
खैर, हम fprintf है, जो बस के रूप में printf के बारे में सोच सकते हैं,

988
01:00:57,450 --> 01:01:01,720
लेकिन बस के बजाय एक फाइल करने के लिए मुद्रण, और इसलिए शुरुआत में च.

989
01:01:01,720 --> 01:01:07,570
कोड के इस यहाँ तरह है, यह क्या करता है, के रूप में आप हाथापाई में देखा हो सकता है,

990
01:01:07,570 --> 01:01:12,310
यह पंक्ति संख्या क्या कर रहे हैं द्वारा पंक्ति अपने सरणी 2 आयामी मुद्रण के माध्यम से बाहर चला जाता है.

991
01:01:12,310 --> 01:01:17,850
इस मामले में, printf अपने टर्मिनल के लिए बाहर प्रिंट या हम क्या कॉल अनुभाग के मानक उत्पादन.

992
01:01:17,850 --> 01:01:22,170
>> और अब, इस मामले में, हम सभी को करना है fprintf साथ printf की जगह है,

993
01:01:22,170 --> 01:01:26,770
यह बताओ कि क्या आप फ़ाइल मुद्रित करने के लिए करना चाहते हैं, और इस मामले में यह सिर्फ यह प्रिंट कि फाइल करने के लिए बाहर

994
01:01:26,770 --> 01:01:32,230
के बजाय यह मुद्रण अपने टर्मिनल.

995
01:01:32,230 --> 01:01:36,500
ठीक है, तो सवाल begs: हम कहाँ से फ़ाइल के इस प्रकार मिलता है, है ना?

996
01:01:36,500 --> 01:01:39,840
हम इस fprintf fuction में लॉग इन करने के लिए पारित किया है लेकिन हमें पता नहीं कहाँ से आया था.

997
01:01:39,840 --> 01:01:43,980
खैर, जल्दी कोड में हम क्या यहाँ पर इस कोड का हिस्सा था,

998
01:01:43,980 --> 01:01:48,340
जो मूल रूप से कहते हैं कि खुले फ़ाइल log.txt कॉल.

999
01:01:48,340 --> 01:01:53,220
हम के बाद क्या वह यह है कि हम यह सुनिश्चित करें कि फ़ाइल वास्तव में सफलतापूर्वक खोला है.

1000
01:01:53,220 --> 01:01:57,070
तो यह कई कारणों के लिए असफल हो सकता है, आप अपने कंप्यूटर पर पर्याप्त जगह नहीं है, उदाहरण के लिए,.

1001
01:01:57,070 --> 01:01:59,790
तो यह हमेशा महत्वपूर्ण है इससे पहले कि आप फ़ाइल के साथ कोई कार्रवाई

1002
01:01:59,790 --> 01:02:03,300
कि हम जाँच करें कि क्या कि फ़ाइल सफलतापूर्वक खोला गया.

1003
01:02:03,300 --> 01:02:09,330
तो क्या है कि एक, कि fopen के लिए एक तर्क है, ठीक है, हम कई मायनों में एक फ़ाइल को खोल सकते हैं.

1004
01:02:09,330 --> 01:02:13,510
हम क्या कर सकते हैं, हम यह w गुजरती हैं, कर सकते हैं जो फ़ाइल को अधिलेखित का मतलब है पहले से ही अगर यह बाहर निकलता है,

1005
01:02:13,510 --> 01:02:18,070
हम एक एक के पास है, जो वे फाइल के अंत करने के बजाय यह अधिभावी संलग्न कर सकते हैं,

1006
01:02:18,070 --> 01:02:22,730
या हम r निर्दिष्ट करने के लिए, जो मतलब कर सकते हैं, के रूप में केवल पढ़ने के लिए फ़ाइल को खोलने के.

1007
01:02:22,730 --> 01:02:24,890
तो अगर कार्यक्रम फ़ाइल में किसी भी परिवर्तन करने की कोशिश करता है,

1008
01:02:24,890 --> 01:02:30,140
उन पर चिल्लाओ और उन्हें यह करना नहीं है.

1009
01:02:30,140 --> 01:02:33,320
अंत में, एक बार हम फाइल के साथ कर रहे हैं, किया इस पर कार्रवाई कर रही है,

1010
01:02:33,320 --> 01:02:35,860
हमें यकीन है कि हम फ़ाइल बंद करने की जरूरत है.

1011
01:02:35,860 --> 01:02:38,830
और इसलिए अपने कार्यक्रम के अंत में, आप उन्हें फिर से पारित करने जा रहे हैं

1012
01:02:38,830 --> 01:02:42,120
इस फाइल कि आप खोला है, और बस इसे बंद.

1013
01:02:42,120 --> 01:02:44,650
तो यह कुछ महत्वपूर्ण है कि आप यकीन है कि तुम क्या करना है.

1014
01:02:44,650 --> 01:02:47,180
तो याद है आप एक फ़ाइल खोल सकते हैं, तो आप फ़ाइल के लिए लिख सकते हैं,

1015
01:02:47,180 --> 01:02:51,270
फ़ाइल में संचालन करते हैं, लेकिन फिर तुम अंत में फ़ाइल को बंद करना होगा.

1016
01:02:51,270 --> 01:02:53,270
>> बुनियादी फ़ाइल पर कोई प्रश्न मैं / हे? हाँ?

1017
01:02:53,270 --> 01:02:58,050
[छात्र सवाल है, unintelligible]

1018
01:02:58,050 --> 01:03:02,480
यहाँ ठीक है. सवाल है, जहां इस log.txt फ़ाइल प्रकट नहीं होता है?

1019
01:03:02,480 --> 01:03:07,890
वैसे, अगर आप सिर्फ यह log.txt दे, यह निष्पादन योग्य के रूप में एक ही निर्देशिका में बनाता है.

1020
01:03:07,890 --> 01:03:10,500
तो अगर you're - >> [छात्र सवाल है, unintelligible]

1021
01:03:10,500 --> 01:03:18,830
हां. उसी फ़ोल्डर में, या एक ही निर्देशिका में है, के रूप में आप यह कहते हैं.

1022
01:03:18,830 --> 01:03:21,400
अब स्मृति, ढेर, और ढेर.

1023
01:03:21,400 --> 01:03:23,400
तो कैसे स्मृति कंप्यूटर में बाहर रखी है?

1024
01:03:23,400 --> 01:03:26,270
खैर, आप यहाँ इस ब्लॉक की तरह के रूप में स्मृति की कल्पना कर सकते हैं.

1025
01:03:26,270 --> 01:03:30,260
और हम स्मृति में क्या वहाँ पर अटक ढेर और ढेर कहा जाता है कि वहाँ नीचे है.

1026
01:03:30,260 --> 01:03:34,480
और ढेर नीचे की ओर बढ़ता है और ढेर ऊपर की ओर बढ़ता है.

1027
01:03:34,480 --> 01:03:38,620
के रूप में तो टॉमी उल्लेख किया है - ओह, ठीक है, और हम इन अन्य 4 वर्ग जो मैं एक दूसरे में मिल जाएगा -

1028
01:03:38,620 --> 01:03:42,890
के रूप में टॉमी पहले कहा, आप जानते हैं कि कैसे अपने कार्यों खुद कहते हैं और एक दूसरे को फोन?

1029
01:03:42,890 --> 01:03:44,930
वे स्टैक फ्रेम का इस तरह का निर्माण.

1030
01:03:44,930 --> 01:03:47,360
वैसे, अगर मुख्य foo कॉल, foo ढेर पर डाल दिया जाता है.

1031
01:03:47,360 --> 01:03:52,430
फू कॉल बार, बार पाने के ढेर पर डाल दिया, और कहा कि के बाद ढेर पर डाल दिया जाता है.

1032
01:03:52,430 --> 01:03:57,040
और के रूप में वे वापस, वे एक बंद ढेर ले लिया हो.

1033
01:03:57,040 --> 01:04:00,140
इन स्थानों में से प्रत्येक स्मृति और क्या करना है?

1034
01:04:00,140 --> 01:04:03,110
खैर, ऊपर, जो पाठ खंड कार्यक्रम में ही शामिल हैं.

1035
01:04:03,110 --> 01:04:06,390
तो मशीन कोड, कि वहाँ है, एक बार आप अपने कार्यक्रम संकलन.

1036
01:04:06,390 --> 01:04:08,520
अगला, किसी भी वैश्विक चर initialized.

1037
01:04:08,520 --> 01:04:12,660
>> तो आप अपने प्रोग्राम में वैश्विक चर है, और आप की तरह, एक = 5 कहते हैं,

1038
01:04:12,660 --> 01:04:15,260
उस खंड में डाल दिया जाता है, और सही है कि के तहत,

1039
01:04:15,260 --> 01:04:18,990
आप किसी भी uninitialized वैश्विक डेटा है, जो सिर्फ एक int है,

1040
01:04:18,990 --> 01:04:20,990
लेकिन आप यह नहीं कह कि यह कुछ भी करने के लिए बराबर है.

1041
01:04:20,990 --> 01:04:23,870
पता है इन वैश्विक चर रहे हैं, तो वे मुख्य के बाहर हो.

1042
01:04:23,870 --> 01:04:28,560
तो यह किसी भी वैश्विक चर है कि घोषित कर रहे हैं लेकिन initialized नहीं कर रहे हैं मतलब है.

1043
01:04:28,560 --> 01:04:32,310
तो ढेर में क्या है? मेमोरी आवंटित malloc, जो हम करने के लिए एक छोटा सा में मिलेगा का उपयोग.

1044
01:04:32,310 --> 01:04:35,990
और अंत में, ढेर के साथ आप किसी भी स्थानीय चर

1045
01:04:35,990 --> 01:04:39,950
और किसी भी कार्य आप अपने मापदंडों में से किसी में कॉल कर सकते हैं.

1046
01:04:39,950 --> 01:04:43,720
आखिरी बात, तुम सच में पता करने के लिए वातावरण चर क्या करना नहीं है,

1047
01:04:43,720 --> 01:04:46,700
लेकिन जब भी आप प्रोग्राम चलाते हैं, वहाँ जुड़े कुछ की तरह है,

1048
01:04:46,700 --> 01:04:49,550
यह व्यक्ति जो कार्यक्रम दौड़ा उपयोक्तानाम है.

1049
01:04:49,550 --> 01:04:51,550
और उस के तल पर तरह की होने जा रहा है.

1050
01:04:51,550 --> 01:04:54,540
स्मृति पते, जो हेक्साडेसिमल मान रहे हैं के संदर्भ में,

1051
01:04:54,540 --> 01:04:58,170
0 में शीर्ष शुरू में मूल्यों, और वे सभी रास्ते जाने के नीचे करने के लिए नीचे.

1052
01:04:58,170 --> 01:05:00,440
इस मामले में, अगर आप 32-bit प्रणाली पर हैं,

1053
01:05:00,440 --> 01:05:05,390
नीचे में पता करने के लिए 0x होने जा रहा है, वायुसेना द्वारा पीछा किया, कि क्योंकि 32 बिट है,

1054
01:05:05,390 --> 01:05:10,890
जो 8 बाइट्स है, और इस मामले में 8 बाइट्स 8 हेक्साडेसिमल अंक से मेल खाती है.

1055
01:05:10,890 --> 01:05:20,110
तो यहाँ नीचे आप के लिए है, जैसे, 0xffffff जा रहे हैं, और वहाँ आप 0 के लिए जा रहे हैं.

1056
01:05:20,110 --> 01:05:23,660
तो क्या संकेत हैं? आप में से कुछ इस खंड में नहीं है इससे पहले कि कवर किया जा सकता है.

1057
01:05:23,660 --> 01:05:26,660
लेकिन हम इस पर व्याख्यान में जाना था, तो एक सूचक सिर्फ एक डेटा प्रकार है

1058
01:05:26,660 --> 01:05:34,030
भंडार है जो, 50 की तरह मूल्य के कुछ प्रकार के बजाय, यह स्मृति में कुछ स्थान के पते भंडार.

1059
01:05:34,030 --> 01:05:36,020
कि स्मृति की तरह [unintelligible].

1060
01:05:36,020 --> 01:05:41,120
तो इस मामले में, हम क्या है, हम एक पूर्णांक या एक int * एक सूचक है,

1061
01:05:41,120 --> 01:05:46,210
और यह 0xdeadbeef का इस हेक्साडेसिमल पता होता है.

1062
01:05:46,210 --> 01:05:50,880
>> तो हम क्या है, अब, स्मृति में कुछ स्थान पर इस सूचक अंक,

1063
01:05:50,880 --> 01:05:56,020
और वह सिर्फ एक, 50 मूल्य इस स्मृति स्थान पर है.

1064
01:05:56,020 --> 01:06:01,810
कुछ 32 बिट सिस्टम पर, सभी 32 बिट सिस्टम पर, संकेत 32 बिट या 4 बाइट्स ले.

1065
01:06:01,810 --> 01:06:06,020
लेकिन, उदाहरण के लिए, एक 64-bit प्रणाली पर, संकेत 64 बिट कर रहे हैं.

1066
01:06:06,020 --> 01:06:08,040
तो यह है कि कुछ आप को ध्यान में रखना चाहता हूँ.

1067
01:06:08,040 --> 01:06:12,310
तो एक अंत बिट प्रणाली पर एक सूचक अंत बिट लंबा है.

1068
01:06:12,310 --> 01:06:17,320
सूचक की तरह अतिरिक्त चीजों के बिना को पचाने में मुश्किल कर रहे हैं,

1069
01:06:17,320 --> 01:06:20,300
तो चलो गतिशील स्मृति आवंटन के एक उदाहरण के माध्यम से जाना.

1070
01:06:20,300 --> 01:06:25,130
क्या आप के लिए गतिशील स्मृति आवंटन करता है, या हम क्या malloc कहते हैं,

1071
01:06:25,130 --> 01:06:29,280
यह आपको सेट के बाहर डेटा के कुछ प्रकार आवंटित.

1072
01:06:29,280 --> 01:06:31,830
तो इस डेटा की तरह है और कार्यक्रम की अवधि के लिए स्थायी.

1073
01:06:31,830 --> 01:06:36,430
क्योंकि जैसा कि आप जानते हैं, यदि आप एक समारोह के अंदर एक्स, और उस समारोह रिटर्न घोषित,

1074
01:06:36,430 --> 01:06:40,910
अब आप कोई डेटा कि x में संग्रहीत किया गया था, के लिए उपयोग है.

1075
01:06:40,910 --> 01:06:44,420
संकेत हमें करना क्या है वे हमें स्मृति या दुकान मूल्यों की दुकान

1076
01:06:44,420 --> 01:06:46,840
स्मृति का एक अलग खंड, अर्थात् ढेर में.

1077
01:06:46,840 --> 01:06:49,340
अब एक बार हम समारोह के लौटने के लिए, के रूप में लंबे समय के रूप में हम एक सूचक है

1078
01:06:49,340 --> 01:06:54,960
स्मृति में उस स्थान पर है, तो हम क्या कर सकते हैं हम सिर्फ वहाँ मूल्यों पर देख सकते हैं.

1079
01:06:54,960 --> 01:06:58,020
चलो एक उदाहरण में देखें: यह हमारी स्मृति लेआउट फिर से है.

1080
01:06:58,020 --> 01:07:00,050
और हम इस समारोह है, मुख्य है.

1081
01:07:00,050 --> 01:07:06,870
यह क्या करता है - ठीक है, इतना आसान है, सही? Int x = 5, कि बस मुख्य ढेर पर एक चर है.

1082
01:07:06,870 --> 01:07:12,450
>> दूसरी ओर, अब हम एक सूचक है जो समारोह giveMeThreeInts कॉल की घोषणा.

1083
01:07:12,450 --> 01:07:16,800
और इसलिए अब हम इस समारोह में जाने के लिए और हम इसके लिए एक नया ढेर फ्रेम बनाने.

1084
01:07:16,800 --> 01:07:20,440
हालांकि, इस ढेर फ्रेम में, हम int अस्थायी * घोषित,

1085
01:07:20,440 --> 01:07:23,210
जो हमारे लिए mallocs 3 integers में.

1086
01:07:23,210 --> 01:07:25,880
तो int के आकार हमें दे कितने बाइट्स int है,

1087
01:07:25,880 --> 01:07:29,620
और malloc हमें देता है कि ढेर पर अंतरिक्ष के कई बाइट्स.

1088
01:07:29,620 --> 01:07:32,890
तो इस मामले में, हम 3 integers के लिए पर्याप्त स्थान बनाया है,

1089
01:07:32,890 --> 01:07:36,830
ढेर और जिस तरह से वहाँ है, जो कारण है कि मैं इसे उच्च ऊपर खींचा है.

1090
01:07:36,830 --> 01:07:42,900
एक बार जब हम कर रहे हैं, हम वापस यहाँ आते हैं, आप केवल जरूरत 3 ints लौटा,

1091
01:07:42,900 --> 01:07:47,000
और यह पता देता है, इस मामले में जहां कि स्मृति है.

1092
01:07:47,000 --> 01:07:51,250
और हम सूचक स्विच = सेट, और वहाँ हम सिर्फ एक सूचक है.

1093
01:07:51,250 --> 01:07:54,550
लेकिन क्या है कि समारोह रिटर्न यहाँ खड़ी है और गायब हो जाता है.

1094
01:07:54,550 --> 01:07:59,250
तो अस्थायी गायब हो जाता है, लेकिन हम अभी भी जहां के पते को बनाए रखने

1095
01:07:59,250 --> 01:08:01,850
उन 3 integers साधन के अंदर हैं.

1096
01:08:01,850 --> 01:08:06,180
इस सेट में, संकेत scoped स्थानीय स्तर पर कर रहे हैं stacked फ्रेम के लिए,

1097
01:08:06,180 --> 01:08:09,860
लेकिन स्मृति जो वे उल्लेख के ढेर में है.

1098
01:08:09,860 --> 01:08:12,190
>> क्या इसका यह मतलब है?

1099
01:08:12,190 --> 01:08:14,960
[छात्र] क्या आप इसे फिर से कह सकते हैं? >> [जोसेफ] हाँ.

1100
01:08:14,960 --> 01:08:20,270
तो अगर मैं सिर्फ एक छोटा सा वापस जाना है, तो आप देखते हैं कि अस्थायी आवंटित

1101
01:08:20,270 --> 01:08:23,500
वहाँ ढेर पर कुछ स्मृति.

1102
01:08:23,500 --> 01:08:28,680
इसलिए जब इस समारोह रिटर्न giveMeThreeInts, यहाँ इस ढेर के लिए गायब हो जा रहा है.

1103
01:08:28,680 --> 01:08:35,819
और यह चर के किसी भी, इस मामले में, यह सूचक कि stacked फ्रेम में आवंटित किया गया था.

1104
01:08:35,819 --> 01:08:39,649
यह करने के लिए गायब हो जा रहा है, लेकिन जब से हम अस्थायी लौटे

1105
01:08:39,649 --> 01:08:46,330
और हम सूचक सेट = अस्थायी, सूचक अब एक ही स्थान की स्मृति के रूप में अस्थायी था बिंदु जा रहा है.

1106
01:08:46,330 --> 01:08:50,370
तो अब, भले ही हम अस्थायी, कि स्थानीय सूचक खो देते हैं,

1107
01:08:50,370 --> 01:08:59,109
हम अभी भी यह क्या कि चर सूचक के अंदर करने के लिए इशारा कर रहा था की स्मृति पते बनाए रखने के लिए.

1108
01:08:59,109 --> 01:09:03,740
प्रश्न? यह एक भ्रामक विषय की तरह हो सकता है अगर आप इस पर खंड में नहीं चले गए हैं कर सकते हैं.

1109
01:09:03,740 --> 01:09:09,240
हम निश्चित रूप से, अपने TF करेंगे कर सकते हैं इसे खत्म हो जाना और हम निश्चित रूप से सवाल जवाब कर सकते

1110
01:09:09,240 --> 01:09:11,500
इस के लिए समीक्षा सत्र के अंत में.

1111
01:09:11,500 --> 01:09:14,220
लेकिन यह एक जटिल विषय की तरह है, और मैं अधिक उदाहरण है कि को दिखाने के लिए जा रहे हैं

1112
01:09:14,220 --> 01:09:18,790
में मदद करेगा कि स्पष्ट संकेत वास्तव में क्या कर रहे हैं.

1113
01:09:18,790 --> 01:09:22,500
>> इस मामले में, संकेत arrays के लिए बराबर हैं,

1114
01:09:22,500 --> 01:09:25,229
इसलिए मैं सिर्फ एक int सरणी के रूप में एक ही बात के रूप में इस सूचक का उपयोग कर सकते हैं.

1115
01:09:25,229 --> 01:09:29,840
तो मैं 0 में अनुक्रमण कर रहा हूँ, और 1 1 पूर्णांक बदलने,

1116
01:09:29,840 --> 01:09:39,689
2 2 पूर्णांक बदल रहा है, और 3 के लिए 3 पूर्णांक.

1117
01:09:39,689 --> 01:09:44,210
तो संकेत पर अधिक है. खैर, Binky याद करते हैं.

1118
01:09:44,210 --> 01:09:48,319
इस मामले में हम एक सूचक आवंटित है, या हम एक सूचक की घोषणा की है,

1119
01:09:48,319 --> 01:09:52,760
लेकिन शुरू में, जब मैं सिर्फ एक सूचक की घोषणा की है, यह स्मृति में कहीं भी नहीं इशारा कर रहा है.

1120
01:09:52,760 --> 01:09:54,930
यह बस के अंदर कचरा मूल्यों है.

1121
01:09:54,930 --> 01:09:56,470
तो मुझे पता नहीं है जहां यह सूचक की ओर इशारा करते है.

1122
01:09:56,470 --> 01:10:01,630
यह एक पता है जो सिर्फ 0 और 1 जहां यह शुरू में घोषित किया गया था के साथ भरा है.

1123
01:10:01,630 --> 01:10:04,810
मैं इस के साथ कुछ भी नहीं है जब तक मैं उस पर malloc कॉल कर सकते हैं

1124
01:10:04,810 --> 01:10:08,390
और तब यह मुझे ढेर पर एक छोटी सी जगह है जहां मैं मान अंदर डाल सकते हैं देता है.

1125
01:10:08,390 --> 01:10:11,980
तो फिर, मैं नहीं जानता कि क्या इस स्मृति के अंदर है.

1126
01:10:11,980 --> 01:10:16,780
पहली बात तो मुझे क्या करना है यह है कि जाँच करें कि क्या प्रणाली पर्याप्त स्मृति था

1127
01:10:16,780 --> 01:10:20,850
मुझे वापस दे पहली जगह है, जो कारण है कि मैं कर रहा हूँ कि इस जांच में 1 पूर्णांक.

1128
01:10:20,850 --> 01:10:25,020
यदि सूचक अशक्त है, इसका मतलब है कि यह करने के लिए पर्याप्त जगह है या कुछ अन्य त्रुटि हुआ नहीं था,

1129
01:10:25,020 --> 01:10:26,320
इसलिए मैं अपने कार्यक्रम के बाहर से बाहर निकलना चाहिए.

1130
01:10:26,320 --> 01:10:29,400
 लेकिन अगर यह सफल था, अब मुझे लगता है कि सूचक का उपयोग कर सकते हैं

1131
01:10:29,400 --> 01:10:35,020
और * सूचक क्या करता है यह इस प्रकार है, जहां पता है

1132
01:10:35,020 --> 01:10:38,480
कि मूल्य है, जहां है और यह 1 के बराबर सेट.

1133
01:10:38,480 --> 01:10:41,850
तो यहाँ पर, हम अगर अस्तित्व में है कि स्मृति की जाँच कर रहे हैं.

1134
01:10:41,850 --> 01:10:45,380
>> एक बार जब आप जानते हैं कि यह मौजूद है, तो आप इसे में डाल सकते हैं

1135
01:10:45,380 --> 01:10:50,460
इस मामले में 1, क्या मूल्य तुम इसे में लाना चाहते हैं.

1136
01:10:50,460 --> 01:10:53,060
एक बार जब हम इसके साथ कर रहे हैं, तो आप कि सूचक मुक्त करने की जरूरत है

1137
01:10:53,060 --> 01:10:57,160
क्योंकि हम प्रणाली है कि आप पहली जगह में कहा है कि स्मृति को वापस लाने की जरूरत है.

1138
01:10:57,160 --> 01:10:59,690
क्योंकि कंप्यूटर नहीं पता है जब हम इसके साथ कर रहे हैं.

1139
01:10:59,690 --> 01:11:02,510
इस मामले में हम स्पष्ट रूप से यह कह रहे हैं, ठीक है, हम उस स्मृति के साथ कर रहे हैं.

1140
01:11:02,510 --> 01:11:10,780
यदि कुछ अन्य प्रक्रिया की जरूरत है, कुछ अन्य कार्यक्रम की जरूरत है, आगे जाने के लिए और इसे लेने के लिए स्वतंत्र महसूस हो रहा है.

1141
01:11:10,780 --> 01:11:15,110
हम भी क्या कर सकते हैं हम सिर्फ सेट पर स्थानीय चर का पता प्राप्त कर सकते है.

1142
01:11:15,110 --> 01:11:19,080
तो int x मुख्य की खड़ी फ्रेम के अंदर है.

1143
01:11:19,080 --> 01:11:23,060
और जब हम इस एम्परसेंड का उपयोग करते हैं, तो यह और ऑपरेटर, यह क्या करता है

1144
01:11:23,060 --> 01:11:27,310
यह एक्स लेता है, और x सिर्फ स्मृति में कुछ डेटा है, लेकिन यह एक पता है.

1145
01:11:27,310 --> 01:11:33,790
यह कहीं स्थित है. तो बुला और एक्स, यह क्या करता है यह हमारे x का पता देता है.

1146
01:11:33,790 --> 01:11:38,430
ऐसा करके, हम जहाँ x स्मृति में सूचक बात कर रहे हैं.

1147
01:11:38,430 --> 01:11:41,710
अब हम सिर्फ पसंद करते है * कुछ x करते हैं, हम कर रहे हैं 5 वापस पाने के लिए जा रहा है.

1148
01:11:41,710 --> 01:11:43,820
सितारा इसे अपसंदर्भन बुलाया है.

1149
01:11:43,820 --> 01:11:46,640
आप पते का पालन करें और आप के मूल्य में संग्रहीत.

1150
01:11:51,000 --> 01:11:53,310
>> कोई सवाल? हाँ?

1151
01:11:53,310 --> 01:11:56,500
[छात्र] यदि आप 3 उठाई बात नहीं करते हैं, यह अभी भी संकलन?

1152
01:11:56,500 --> 01:11:59,490
हां. यदि आप 3-सूचक बात नहीं करते हैं, यह अभी भी संकलन करने के लिए जा रहा है,

1153
01:11:59,490 --> 01:12:02,720
लेकिन मैं तुम्हें दिखाने के लिए, एक दूसरे में क्या होता है और कर रही है कि बिना,

1154
01:12:02,720 --> 01:12:04,860
है कि हम क्या एक स्मृति रिसाव कहते हैं. तुम प्रणाली नहीं दे रहे हैं

1155
01:12:04,860 --> 01:12:07,850
अपनी स्मृति वापस करने के लिए, तो एक के बाद जबकि कार्यक्रम जमा करने के लिए जा रहा है

1156
01:12:07,850 --> 01:12:10,940
स्मृति कि यह नहीं है और यह और कुछ नहीं का उपयोग कर सकते हैं.

1157
01:12:10,940 --> 01:12:15,750
यदि आप कभी भी अपने कंप्यूटर पर 1.5 लाख किलोबाइट के साथ देखा है फ़ायरफ़ॉक्स,

1158
01:12:15,750 --> 01:12:17,840
कार्य प्रबंधक में, यह है कि क्या हो रहा है.

1159
01:12:17,840 --> 01:12:20,760
आप प्रोग्राम है कि वे नहीं संभाल रहे हैं में एक स्मृति रिसाव है.

1160
01:12:23,080 --> 01:12:26,240
तो कैसे सूचक गणित काम करता है?

1161
01:12:26,240 --> 01:12:29,480
खैर, सूचक गणित एक सरणी में तरह अनुक्रमण की तरह है.

1162
01:12:29,480 --> 01:12:36,370
इस मामले में, मैं एक सूचक है, और मुझे क्या करना है मैं पहले तत्व के लिए सूचक बिंदु बना

1163
01:12:36,370 --> 01:12:42,100
3 integers कि मैं आवंटित है की इस सरणी की.

1164
01:12:42,100 --> 01:12:46,670
तो अब मैं क्या करूँ, सितारा सूचक सूची में पहला तत्व परिवर्तन.

1165
01:12:46,670 --> 01:12:49,140
स्टार सूचक यहाँ पर एक अंक.

1166
01:12:49,140 --> 01:12:53,140
एक सूचक है, तो यहाँ पर संकेतक है यहाँ पर है, दो सूचक यहाँ पर है.

1167
01:12:53,140 --> 01:12:56,610
>> तो बस 1 जोड़ने के इस सरणी के साथ आगे बढ़ के रूप में एक ही बात है.

1168
01:12:56,610 --> 01:12:59,880
हमें क्या करना है, जब हम एक सूचक आप यहाँ पर पता मिलता है,

1169
01:12:59,880 --> 01:13:04,180
और यहाँ में मूल्य प्राप्त करने के क्रम में, आप पूरे अभिव्यक्ति से में एक सितारा

1170
01:13:04,180 --> 01:13:05,990
यह भिन्नता.

1171
01:13:05,990 --> 01:13:09,940
तो, इस मामले में, मैं 1 के लिए इस सरणी में पहला स्थान स्थापित कर रहा हूँ,

1172
01:13:09,940 --> 01:13:13,970
2 दूसरा स्थान, और 3 के लिए 3 स्थान.

1173
01:13:13,970 --> 01:13:18,180
तो क्या मैं कर रहा हूँ यहाँ मैं अपने एक सूचक मुद्रण कर रहा हूँ,

1174
01:13:18,180 --> 01:13:19,970
जो सिर्फ मुझे 2 देता है.

1175
01:13:19,970 --> 01:13:23,650
अब मैं सूचक incrementing रहा हूँ, तो सूचक एक सूचक बराबर होती है,

1176
01:13:23,650 --> 01:13:26,780
जो आगे बढ़ता रहता है.

1177
01:13:26,780 --> 01:13:30,810
और इसलिए अब अगर मैं एक सूचक मुद्रित करने के लिए, सूचक एक अब 3,

1178
01:13:30,810 --> 01:13:33,990
जो इस मामले में 3 बाहर प्रिंट.

1179
01:13:33,990 --> 01:13:36,560
और आदेश में मुफ्त कुछ, सूचक है कि मैं इसे देना

1180
01:13:36,560 --> 01:13:40,540
सरणी जो मैं malloc से वापस मिल गया की शुरुआत में इशारा किया जाना चाहिए.

1181
01:13:40,540 --> 01:13:43,430
तो, इस मामले में, अगर मैं 3 सही यहाँ कॉल करने के लिए गए थे, यह सही नहीं होगा,

1182
01:13:43,430 --> 01:13:45,070
क्योंकि यह सरणी के बीच में है.

1183
01:13:45,070 --> 01:13:48,820
मैं मूल स्थान को पाने घटाना है

1184
01:13:48,820 --> 01:13:50,420
प्रारंभिक पहले स्थान से पहले मैं इसे मुक्त कर सकते हैं.

1185
01:13:56,300 --> 01:13:58,450
तो, यहाँ एक और अधिक शामिल उदाहरण है.

1186
01:13:58,450 --> 01:14:03,360
इस मामले में, हम एक चरित्र सरणी में 7 अक्षर का आवंटन कर रहे हैं.

1187
01:14:03,360 --> 01:14:06,480
>> और इस मामले में हम क्या कर रहे हैं हम उनमें से पहले 6 पर पाशन कर रहे हैं,

1188
01:14:06,480 --> 01:14:09,900
और हम उन्हें जेड के लिए स्थापित कर रहे हैं

1189
01:14:09,900 --> 01:14:13,350
तो, int के लिए i = 0, मैं 6>, मैं + +,

1190
01:14:13,350 --> 01:14:16,220
तो, सूचक + मैं सिर्फ हमें इस मामले में दे देंगे,

1191
01:14:16,220 --> 01:14:20,860
सूचक, एक सूचक, सूचक 2, 3 सूचक, और इतने पर और आगे पाश में.

1192
01:14:20,860 --> 01:14:24,040
यह करने के लिए क्या हो रहा है यह है कि पता हो जाता है, यह dereferences मूल्य पाने के लिए,

1193
01:14:24,040 --> 01:14:27,440
और बदलाव है कि एक जेड के लिए मूल्य

1194
01:14:27,440 --> 01:14:30,350
फिर अंत में याद है कि यह एक स्ट्रिंग है, है ना?

1195
01:14:30,350 --> 01:14:33,560
सभी तार अशक्त समाप्त चरित्र के साथ समाप्त करने के लिए है.

1196
01:14:33,560 --> 01:14:38,620
तो, मुझे क्या करना है सूचक 6 में मैं अंदर अशक्त टर्मिनेटर चरित्र डाला

1197
01:14:38,620 --> 01:14:43,980
और अब मैं क्या मूल रूप से यहाँ क्या कर रहा हूँ printf एक स्ट्रिंग के लिए लागू कर रहा है?

1198
01:14:43,980 --> 01:14:46,190
>> तो, अब printf जब जब यह एक स्ट्रिंग के अंत तक पहुँच?

1199
01:14:46,190 --> 01:14:48,230
अशक्त समाप्त चरित्र हिट.

1200
01:14:48,230 --> 01:14:52,030
तो, इस मामले में, मेरे इस सरणी की शुरुआत करने के लिए मूल सूचक अंक.

1201
01:14:52,030 --> 01:14:56,410
मैं 1 चरित्र प्रिंट बाहर. मैं इसे एक से अधिक चलते हैं.

1202
01:14:56,410 --> 01:14:58,420
मुझे लगता है कि चरित्र प्रिंट बाहर. मैं इसे स्थानांतरित.

1203
01:14:58,420 --> 01:15:02,180
और मैं यह कर जब तक मैं अंत तक पहुँचने रखना.

1204
01:15:02,180 --> 01:15:07,750
और अब अंत * संकेतक भिन्नता और अशक्त समाप्त चरित्र वापस मिल जाएगा.

1205
01:15:07,750 --> 01:15:11,780
और इसलिए मेरे जबकि पाश चलाता है केवल जब कि मूल्य अशक्त समाप्त चरित्र नहीं है.

1206
01:15:11,780 --> 01:15:13,770
तो, अब मैं इस पाश से बाहर निकलें.

1207
01:15:18,780 --> 01:15:21,180
और यदि ऐसा है तो मैं इस सूचक से 6 घटाना,

1208
01:15:21,180 --> 01:15:22,860
मैं वापस शुरू करने के लिए सभी रास्ते जाओ.

1209
01:15:22,860 --> 01:15:27,880
याद है, मैं यह कर रहा हूँ क्योंकि मैं शुरू करने के लिए जाने के क्रम में यह मुक्त है.

1210
01:15:27,880 --> 01:15:30,270
>> तो, मुझे पता है कि एक बहुत कुछ था. वहाँ किसी भी सवाल?

1211
01:15:30,270 --> 01:15:31,870
कृपया, हाँ?

1212
01:15:31,870 --> 01:15:36,610
[छात्र प्रश्न unintelligible]

1213
01:15:36,610 --> 01:15:38,190
आप कह सकते हैं कि जोर से? माफ़ कीजिए.

1214
01:15:38,190 --> 01:15:44,140
[छात्र] पिछली स्लाइड सही से पहले आप सूचक मुक्त कर दिया,

1215
01:15:44,140 --> 01:15:47,300
आप वास्तव में जहां सूचक के मूल्य बदल रहा है?

1216
01:15:47,300 --> 01:15:50,370
[यूसुफ] तो, ठीक है यहाँ. >> [छात्र] ओह, ठीक है.

1217
01:15:50,370 --> 01:15:51,890
[यूसुफ] तो, मैं एक सूचक ऋण ऋण है, सही है,

1218
01:15:51,890 --> 01:15:54,140
जो बात वापस एक चलता है, और फिर मैं इसे मुक्त,

1219
01:15:54,140 --> 01:15:57,000
क्योंकि यह सूचक सरणी की शुरुआत की ओर इशारा किया है.

1220
01:15:57,000 --> 01:16:00,420
[छात्र] लेकिन यह है कि आपको लगता है कि लाइन के बाद बंद कर दिया था की जरूरत नहीं होगा.

1221
01:16:00,420 --> 01:16:03,130
तो [यूसुफ], अगर मैं इस के बाद बंद कर दिया था, यह एक स्मृति रिसाव माना किया जाएगा,

1222
01:16:03,130 --> 01:16:04,810
क्योंकि मैं मुक्त नहीं चला था.

1223
01:16:04,810 --> 01:16:11,290
[छात्र] मैं [unintelligible] पहली तीन पंक्तियों के बाद जहां आप एक सूचक [unintelligible] था.

1224
01:16:11,290 --> 01:16:13,140
[यूसुफ] उह. तो, वहाँ सवाल क्या है?

1225
01:16:13,140 --> 01:16:14,780
माफ़ कीजिए. नहीं, नहीं. जाओ, जाओ, कृपया.

1226
01:16:14,780 --> 01:16:16,870
तो [छात्र], आप संकेत के मूल्य नहीं बदल रहे हैं.

1227
01:16:16,870 --> 01:16:19,130
आप सूचक ऋण ऋण नहीं होता था.

1228
01:16:19,130 --> 01:16:19,730
[यूसुफ] हाँ, बिल्कुल.

1229
01:16:19,730 --> 01:16:21,890
तो, जब मैं एक सूचक और सूचक दो

1230
01:16:21,890 --> 01:16:24,410
मैं सूचक नहीं कर रहा हूँ एक सूचक के बराबर होती है.

1231
01:16:24,410 --> 01:16:27,260
तो, सूचक सरणी की शुरुआत में सिर्फ इशारा रहता है.

1232
01:16:27,260 --> 01:16:31,460
यह केवल जब मैं प्लस प्लस कि यह सूचक के अंदर मूल्य वापस सेट,

1233
01:16:31,460 --> 01:16:33,550
कि यह वास्तव में साथ यह बढ़ता रहता है.

1234
01:16:36,860 --> 01:16:37,780
सही सभी.

1235
01:16:40,550 --> 01:16:42,030
और सवाल?

1236
01:16:44,680 --> 01:16:47,790
>> फिर, अगर यह भारी की तरह है, इस सत्र में कवर किया जाएगा.

1237
01:16:47,790 --> 01:16:50,710
इसके बारे में अपने अध्यापन साथी से पूछो, और हम अंत में सवाल जवाब कर सकते हैं.

1238
01:16:53,510 --> 01:16:56,600
और आम तौर पर हम इस शून्य से बात करना पसंद नहीं है.

1239
01:16:56,600 --> 01:16:59,760
यह मुझे कितना मैं सरणी में ऑफसेट है का ट्रैक रखने की आवश्यकता है.

1240
01:16:59,760 --> 01:17:04,520
तो, सामान्य रूप में, यह सिर्फ कैसे काम करता है सूचक गणित समझाने.

1241
01:17:04,520 --> 01:17:07,970
लेकिन हम आम तौर पर क्या करना पसंद है हम सूचक की एक प्रतिलिपि बनाने के लिए करना है,

1242
01:17:07,970 --> 01:17:11,640
और फिर हम उस प्रतिलिपि का उपयोग जब हम चारों ओर स्ट्रिंग में आगे बढ़ रहे हैं.

1243
01:17:11,640 --> 01:17:14,660
तो, इन मामले में आप प्रति पूरे स्ट्रिंग मुद्रित करने के लिए उपयोग करते हैं,

1244
01:17:14,660 --> 01:17:19,040
लेकिन हम सूचक शून्य से 6 की तरह नहीं है या कितना हम इस में चले गए ट्रैक रखने के लिए,

1245
01:17:19,040 --> 01:17:22,700
सिर्फ इसलिए कि हम जानते हैं कि हमारे मूल बिंदु अभी भी सूची की शुरुआत करने के लिए कहा जाता है

1246
01:17:22,700 --> 01:17:25,340
और सभी कि हम इस प्रतिलिपि का बदल दिया था.

1247
01:17:25,340 --> 01:17:28,250
तो, सामान्य रूप में, अपने मूल सूचक की प्रतियां बदल.

1248
01:17:28,250 --> 01:17:32,350
की कोशिश मत करो की तरह की तरह मूल प्रतियों को बदलने नहींं.

1249
01:17:32,350 --> 01:17:35,290
अपने मूल के केवल प्रतियां को बदलने की कोशिश कर रहा है.

1250
01:17:41,540 --> 01:17:44,870
तो, तुम नोटिस जब हम printf में स्ट्रिंग पारित

1251
01:17:44,870 --> 01:17:48,990
आप इसे के सामने में एक सितारा डाल जैसे हम अन्य सभी dereferences के साथ किया था नहीं है, है ना?

1252
01:17:48,990 --> 01:17:54,180
तो, अगर तुम बाहर प्रिंट पूरे स्ट्रिंग% s की उम्मीद है एक पता है,

1253
01:17:54,180 --> 01:17:57,610
और इस मामले में एक सूचक या वर्णों की एक सरणी की तरह इस मामले में.

1254
01:17:57,610 --> 01:18:00,330
>> वर्ण, चार * arrays और एक ही बात कर रहे हैं.

1255
01:18:00,330 --> 01:18:03,690
सूचक वर्ण के लिए है, और चरित्र arrays एक ही बात कर रहे हैं.

1256
01:18:03,690 --> 01:18:05,720
और हां, तो हम सभी को करना है सूचक में पास है.

1257
01:18:05,720 --> 01:18:08,150
हम * सूचक या ऐसा कुछ की तरह पास नहीं है.

1258
01:18:13,110 --> 01:18:14,930
तो, arrays और संकेत एक ही बात कर रहे हैं.

1259
01:18:14,930 --> 01:18:19,160
जब आप एक्स की तरह कुछ कर रहे हैं यहाँ पर एक सरणी के लिए [y]

1260
01:18:19,160 --> 01:18:21,960
यह हुड के नीचे क्या कर रहा है यह कह रहा है, ठीक है, यह एक चरित्र सरणी है,

1261
01:18:21,960 --> 01:18:23,690
तो यह एक संकेत है.

1262
01:18:23,690 --> 01:18:26,510
और इसलिए x एक ही बात कर रहे हैं,

1263
01:18:26,510 --> 01:18:28,650
और इसलिए यह क्या करता है यह एक्स के लिए y कहते हैं,

1264
01:18:28,650 --> 01:18:31,820
जो स्मृति में आगे है कि ज्यादा से आगे बढ़ के रूप में एक ही बात है.

1265
01:18:31,820 --> 01:18:34,930
और अब x + y हमें पते के कुछ प्रकार देता है,

1266
01:18:34,930 --> 01:18:37,570
और हम पता भिन्नता या तीर का पालन करें

1267
01:18:37,570 --> 01:18:41,640
स्मृति में है कि जहां स्थान है और हम स्मृति में उस स्थान का मूल्य बाहर निकलना.

1268
01:18:41,640 --> 01:18:43,720
ऐसा है, तो इन दोनों वास्तव में एक ही बात कर रहे हैं.

1269
01:18:43,720 --> 01:18:45,840
यह सिर्फ एक वाक्यात्मक चीनी है.

1270
01:18:45,840 --> 01:18:48,090
वे एक ही बात करते हैं. वे एक दूसरे के लिए सिर्फ अलग syntactics हो.

1271
01:18:51,500 --> 01:18:57,590
>> तो, क्या संकेत के साथ गलत जा सकते हैं? की तरह, एक बहुत. ठीक है. तो, बुरी बातें.

1272
01:18:57,590 --> 01:19:02,410
कुछ बुरी चीजें आप कर सकते हैं अगर आपके malloc कॉल अशक्त सही रिटर्न नहीं की जाँच कर रहे हैं?

1273
01:19:02,410 --> 01:19:06,560
इस मामले में, मैं प्रणाली पूछ रहा हूँ मुझे दे कि संख्या क्या है?

1274
01:19:06,560 --> 01:19:11,200
2 4 अरब बार की तरह है, क्योंकि एक पूर्णांक के आकार 4 बाइट्स है.

1275
01:19:11,200 --> 01:19:13,810
मैं इसके लिए 8 अरब बाइट्स की तरह पूछ रहा हूँ.

1276
01:19:13,810 --> 01:19:17,270
बेशक मेरे कंप्यूटर मुझे इतना याददाश्त वापस देने के लिए सक्षम होने के लिए नहीं जा रहा है.

1277
01:19:17,270 --> 01:19:20,960
और अगर हम यह शून्य है की जाँच नहीं था, इसलिए जब हम यह वहाँ पर भिन्नता की कोशिश -

1278
01:19:20,960 --> 01:19:24,270
जहां यह जा रहा है के लिए तीर का पालन - हम कि स्मृति नहीं है.

1279
01:19:24,270 --> 01:19:27,150
यह है कि क्या हम एक शून्य सूचक dereferencing कॉल.

1280
01:19:27,150 --> 01:19:29,710
और यह अनिवार्य रूप से आप segfault का कारण बनता है.

1281
01:19:29,710 --> 01:19:31,790
यह तरीके आप segfault कर सकते हैं में से एक है.

1282
01:19:34,090 --> 01:19:38,090
अन्य बुरी बातें आप कर सकते हैं - ओह अच्छी तरह से.

1283
01:19:38,090 --> 01:19:40,650
यह एक शून्य सूचक dereferencing किया गया था. ठीक है.

1284
01:19:40,650 --> 01:19:45,160
अन्य बुरी बातें अच्छी तरह से ठीक करने के लिए, कि तुम सिर्फ वहाँ में एक जांच डाल

1285
01:19:45,160 --> 01:19:46,980
कि जाँच करता है कि सूचक अशक्त है

1286
01:19:46,980 --> 01:19:51,000
और इस कार्यक्रम से बाहर निकलें अगर ऐसा होता है कि malloc एक शून्य सूचक देता है.

1287
01:19:55,110 --> 01:19:59,850
Xkcd हास्य है. लोग अब यह समझ में. के आधार पर छाँटें.

1288
01:20:06,120 --> 01:20:09,350
>> तो स्मृति. और मैं इस पर चला गया.

1289
01:20:09,350 --> 01:20:12,000
हम एक पाश में malloc बुला रहे हैं, लेकिन हर बार हम malloc कॉल

1290
01:20:12,000 --> 01:20:14,370
हम जहां यह सूचक की ओर इशारा करते है का ट्रैक खो रहे हैं,

1291
01:20:14,370 --> 01:20:15,750
क्योंकि हम यह clobbering रहे हैं.

1292
01:20:15,750 --> 01:20:18,410
तो, malloc आरंभिक कॉल मुझे देता स्मृति यहाँ.

1293
01:20:18,410 --> 01:20:19,990
इस पर मेरी सूचक संकेत.

1294
01:20:19,990 --> 01:20:23,020
अब, मैं इसे मुक्त नहीं है, तो अब मैं malloc फिर से फोन किया.

1295
01:20:23,020 --> 01:20:26,070
अब यह खत्म अंक यहाँ. अब मेरी स्मृति यहाँ पर इशारा कर रहा है.

1296
01:20:26,070 --> 01:20:27,640
यहाँ ओर इशारा करते हुए. यहाँ ओर इशारा करते हुए.

1297
01:20:27,640 --> 01:20:31,820
लेकिन मैं यहाँ कि मैं आवंटित सभी स्मृति के पते का ट्रैक खो दिया.

1298
01:20:31,820 --> 01:20:35,100
और इसलिए अब मैं उन्हें किसी भी संदर्भ अब और नहीं है.

1299
01:20:35,100 --> 01:20:37,230
तो, मैं उन्हें इस लूप के बाहर मुक्त नहीं कर सकते हैं.

1300
01:20:37,230 --> 01:20:39,390
और इतने में आदेश कुछ इस तरह तय करने के लिए,

1301
01:20:39,390 --> 01:20:42,250
अगर आप स्मृति मुक्त करने के लिए भूल जाते हैं और आप इस स्मृति रिसाव हो,

1302
01:20:42,250 --> 01:20:45,810
आप इस लूप के अंदर स्मृति मुक्त एक बार आप इसके साथ कर रहे है.

1303
01:20:45,810 --> 01:20:51,400
खैर, यह क्या होता है. मैं जानता हूँ कि आप में से बहुत से इस से नफरत है.

1304
01:20:51,400 --> 01:20:55,270
लेकिन अब याय! आप 44,000 किलोबाइट की तरह मिलता है.

1305
01:20:55,270 --> 01:20:57,110
इसलिए, आप यह लूप के अंत में मुक्त

1306
01:20:57,110 --> 01:20:59,770
और कहा कि सिर्फ स्मृति हर समय मुक्त करने के लिए जा रहा है.

1307
01:20:59,770 --> 01:21:03,620
मूलतः, अपने कार्यक्रम स्मृति रिसाव अब और नहीं है.

1308
01:21:03,620 --> 01:21:08,150
>> और अब आप कर सकते हैं और कुछ के कुछ स्मृति मुक्त कि आप दो बार के लिए कहा है.

1309
01:21:08,150 --> 01:21:11,060
इस मामले में, आप malloc कुछ है, तो आप अपने मूल्य बदल जाते हैं.

1310
01:21:11,060 --> 01:21:13,140
आप इसे मुफ्त क्योंकि एक बार आप ने कहा कि आप इसके साथ किया गया.

1311
01:21:13,140 --> 01:21:14,940
लेकिन तब हम इसे फिर से मुक्त कर दिया.

1312
01:21:14,940 --> 01:21:16,730
यह कुछ है कि बहुत बुरा है.

1313
01:21:16,730 --> 01:21:18,820
यह शुरू में segfault नहीं जा रहा है,

1314
01:21:18,820 --> 01:21:23,350
लेकिन एक के बाद जबकि इस डबल क्या है इस भ्रष्ट अपने ढेर संरचना मुक्त

1315
01:21:23,350 --> 01:21:27,200
और आप एक छोटा सा इस बारे में और अधिक जानने के लिए अगर आप CS61 तरह एक क्लास लेने का चयन करेंगे.

1316
01:21:27,200 --> 01:21:30,000
लेकिन अनिवार्य रूप से एक के बाद जब आपके कंप्यूटर को उलझन में मिल जा रहा है

1317
01:21:30,000 --> 01:21:33,010
स्मृति स्थानों क्या कर रहे हैं और जहां जहां यह संग्रहीत किया जाता है के बारे में -

1318
01:21:33,010 --> 01:21:34,800
जहां डेटा स्मृति में संग्रहीत किया जाता है.

1319
01:21:34,800 --> 01:21:38,080
और इसलिए एक सूचक मुक्त दो बार एक बुरी बात यह है कि आप नहीं करना चाहती है.

1320
01:21:38,080 --> 01:21:41,600
>> अन्य चीजें हैं जो गलत जा सकते हैं sizeof का उपयोग नहीं कर रहा है.

1321
01:21:41,600 --> 01:21:44,460
तो, इस मामले में आप 8 बाइट्स malloc,

1322
01:21:44,460 --> 01:21:46,700
और कहा कि दो integers के रूप में एक ही बात है, है ना?

1323
01:21:46,700 --> 01:21:49,580
तो, कि पूरी तरह से सुरक्षित है, लेकिन यह क्या है?

1324
01:21:49,580 --> 01:21:52,160
ठीक है, के रूप में लुकास अलग architectures पर के बारे में बात की थी,

1325
01:21:52,160 --> 01:21:54,220
integers अलग लंबाई की हैं.

1326
01:21:54,220 --> 01:21:57,970
तो, उपकरण है कि आप का उपयोग कर रहे हैं पर, पूर्णांकों के बारे में 4 बाइट्स हैं,

1327
01:21:57,970 --> 01:22:02,370
लेकिन वे कुछ अन्य प्रणाली पर 8 बाइट्स हो सकता है या वे 16 बाइट्स हो सकता है हो सकता है.

1328
01:22:02,370 --> 01:22:05,680
तो, अगर मैं सिर्फ यहाँ पर इस नंबर का उपयोग करने के लिए,

1329
01:22:05,680 --> 01:22:07,310
इस कार्यक्रम के उपकरण पर काम कर सकते हैं,

1330
01:22:07,310 --> 01:22:10,360
लेकिन यह कुछ अन्य प्रणाली पर पर्याप्त स्मृति आवंटित करने के लिए नहीं जा रहा है.

1331
01:22:10,360 --> 01:22:14,020
इस मामले में, यह है कि क्या sizeof ऑपरेटर के लिए प्रयोग किया जाता है.

1332
01:22:14,020 --> 01:22:16,880
जब हम कहते हैं sizeof (int), यह क्या करता है

1333
01:22:16,880 --> 01:22:21,910
 यह हमें प्रणाली है कि प्रोग्राम चल रहा है पर एक पूर्णांक के आकार देता है.

1334
01:22:21,910 --> 01:22:25,490
तो, इस मामले में, sizeof (int) उपकरण की तरह कुछ पर 4 वापस आ जाएगी,

1335
01:22:25,490 --> 01:22:29,980
और अब इस वसीयत 4 2 * है, जो 8 है,

1336
01:22:29,980 --> 01:22:32,330
जो सिर्फ दो integers के लिए आवश्यक स्थान की राशि है.

1337
01:22:32,330 --> 01:22:36,710
एक अलग सिस्टम पर, अगर एक int 16 बाइट्स या 8 बाइट की तरह है,

1338
01:22:36,710 --> 01:22:39,380
यह सिर्फ पर्याप्त बाइट्स वापस करने के लिए है कि राशि की दुकान के लिए जा रहा है.

1339
01:22:41,830 --> 01:22:45,310
>> और अंत में, structs.

1340
01:22:45,310 --> 01:22:48,340
तो, अगर आप स्मृति में एक sudoku बोर्ड की दुकान चाहता था, कैसे हम इस कर सकता है?

1341
01:22:48,340 --> 01:22:51,570
आप पहली बात के लिए एक चर की तरह लगता है कि हो सकता है,

1342
01:22:51,570 --> 01:22:53,820
दूसरी बात, तीसरी बात के लिए एक चर के लिए एक चर,

1343
01:22:53,820 --> 01:22:56,420
बुरा, सही - चौथी बात के लिए एक चर?

1344
01:22:56,420 --> 01:23:00,750
तो, एक सुधार आप इस के शीर्ष पर एक 9 एक्स 9 सरणी बनाने के लिए कर सकते हैं.

1345
01:23:00,750 --> 01:23:04,480
यह ठीक है, लेकिन क्या अगर आप sudoku बोर्ड के साथ अन्य बातों सहयोगी चाहता था

1346
01:23:04,480 --> 01:23:06,490
जैसे बोर्ड की कठिनाई क्या है,

1347
01:23:06,490 --> 01:23:11,740
या, उदाहरण के लिए, अपने स्कोर क्या है, या कितना समय यह आप इस बोर्ड को हल करने के लिए ले लिया है?

1348
01:23:11,740 --> 01:23:14,970
ठीक है, तुम क्या कर सकते है आप एक struct बना सकते हैं.

1349
01:23:14,970 --> 01:23:18,910
मैं मूल रूप से कह रहा हूँ क्या मैं यहाँ पर इस संरचना को परिभाषित कर रहा हूँ,

1350
01:23:18,910 --> 01:23:23,230
और मैं एक sudoku बोर्ड है जो एक बोर्ड है कि 9 एक्स 9 के होते हैं परिभाषित कर रहा हूँ.

1351
01:23:23,230 --> 01:23:26,650
>> और यह क्या है यह स्तर के नाम करने के लिए संकेत है.

1352
01:23:26,650 --> 01:23:30,730
यह भी एक्स और वाई, जो जहां मैं सही हूँ अब निर्देशांक हैं.

1353
01:23:30,730 --> 01:23:35,980
यह भी समय [unintelligible] खर्च किया गया है, और यह कदम मैं इतनी दूर inputted है की कुल संख्या है.

1354
01:23:35,980 --> 01:23:40,010
और इसलिए इस मामले में, मैं सिर्फ एक संरचना में डेटा की एक पूरी गुच्छा समूहीकृत कर सकते हैं

1355
01:23:40,010 --> 01:23:42,790
यह अलग चर की तरह चारों ओर उड़ान की तरह होने के बजाय

1356
01:23:42,790 --> 01:23:44,540
कि मैं वास्तव में ट्रैक नहीं रखने के लिए कर सकते हैं.

1357
01:23:44,540 --> 01:23:49,720
और यह देता है हमें सिर्फ इस struct के अंदर विभिन्न बातें संदर्भित की तरह के लिए अच्छा वाक्यविन्यास है.

1358
01:23:49,720 --> 01:23:53,430
मैं सिर्फ board.board करते हैं, और मैं sudoku बोर्ड वापस मिल सकता है.

1359
01:23:53,430 --> 01:23:56,320
Board.level, मैं यह कितना कठिन है.

1360
01:23:56,320 --> 01:24:00,540
Board.x और board.y मुझे जहाँ मैं बोर्ड में हो सकता है के निर्देशांक दे.

1361
01:24:00,540 --> 01:24:04,730
और इसलिए मैं तक पहुँचने हूँ हम क्या struct में क्षेत्र कहते हैं.

1362
01:24:04,730 --> 01:24:08,840
यह sudokuBoard को परिभाषित करता है, जो मुझे लगता है कि एक प्रकार है.

1363
01:24:08,840 --> 01:24:14,800
और अब हम यहाँ हैं. मैं एक प्रकार sudokuBoard "बोर्ड" चर बुलाया है.

1364
01:24:14,800 --> 01:24:18,820
और तो अब मैं सभी क्षेत्रों है कि यहाँ पर इस संरचना का उपयोग कर सकते हैं.

1365
01:24:20,830 --> 01:24:22,450
>> Structs बारे में कोई सवाल है? हाँ?

1366
01:24:22,450 --> 01:24:25,890
Int एक्स, वाई के लिए [छात्र], आप एक लाइन पर दोनों घोषित? >> [यूसुफ] उह.

1367
01:24:25,890 --> 01:24:27,400
[छात्र] तो, तुम सिर्फ है कि उन सभी के साथ कर सकता है?

1368
01:24:27,400 --> 01:24:31,200
एक्स की तरह, y अल्पविराम बार कुल कि?

1369
01:24:31,200 --> 01:24:34,460
[यूसुफ] हाँ, आप निश्चित रूप से है कि कर सकता है, लेकिन कारण है कि मैं एक ही लाइन पर एक्स और वाई डाल -

1370
01:24:34,460 --> 01:24:36,330
और सवाल यह है कि हम सिर्फ एक ही लाइन पर यह कर सकते हैं?

1371
01:24:36,330 --> 01:24:38,600
हम सिर्फ एक ही लाइन पर क्यों नहीं है कि इन सभी के डाल दिया है

1372
01:24:38,600 --> 01:24:42,090
एक्स और वाई में एक दूसरे से जुड़े हुए हैं,

1373
01:24:42,090 --> 01:24:44,780
और यह सिर्फ stylistically अधिक सही है, एक अर्थ में,

1374
01:24:44,780 --> 01:24:46,600
क्योंकि यह एक ही लाइन पर दो बातें समूहीकरण है

1375
01:24:46,600 --> 01:24:49,340
जैसे कि तरह एक ही बात करने के लिए संबंधित हैं.

1376
01:24:49,340 --> 01:24:51,440
और मैं तो बस इन अलग अलग. यह सिर्फ एक शैली बात है.

1377
01:24:51,440 --> 01:24:53,720
यह कार्यात्मक जो भी कोई फर्क नहीं पड़ता.

1378
01:24:58,150 --> 01:24:59,270
Structs पर कोई अन्य प्रश्न?

1379
01:25:03,030 --> 01:25:06,620
आप एक struct के साथ एक Pokédex को परिभाषित कर सकते हैं.

1380
01:25:06,620 --> 01:25:11,720
एक Pokemon एक संख्या है और यह एक पत्र, एक मालिक, एक प्रकार है.

1381
01:25:11,720 --> 01:25:16,990
और फिर अगर आप पोकीमॉन की एक सरणी है, आप एक Pokédex बनाने, सही हो सकता है?

1382
01:25:16,990 --> 01:25:20,810
ठीक है, शांत,. तो, structs पर सवाल. उन structs से संबंधित हैं.

1383
01:25:20,810 --> 01:25:25,270
>> अंत में, GDB. GDB क्या है तुम करते हो? यह आपको अपने कार्यक्रम डिबग.

1384
01:25:25,270 --> 01:25:27,650
और अगर आप GDB नहीं किया है, मैं कम देख सिफारिश की जाएगी

1385
01:25:27,650 --> 01:25:31,250
और सिर्फ GDB क्या है ऊपर जा रहा है, तो आप यह कैसे के साथ काम करते हैं, कैसे आप इसे उपयोग कर सकते हैं,

1386
01:25:31,250 --> 01:25:32,900
और यह एक कार्यक्रम पर परीक्षण.

1387
01:25:32,900 --> 01:25:37,400
और इसलिए GDB क्या आपको करना है कि यह [unintelligible] अपने कार्यक्रम को थामने की मदद

1388
01:25:37,400 --> 01:25:38,920
और एक व्यावहारिक लाइन.

1389
01:25:38,920 --> 01:25:42,600
उदाहरण के लिए, मैं अपने कार्यक्रम के 3 लाइन की तरह थामने के निष्पादन के लिए चाहते हैं,

1390
01:25:42,600 --> 01:25:46,010
और जब मैं 3 लाइन पर हूँ मैं सभी मूल्यों है कि वहाँ रहे हैं मुद्रित कर सकते हैं.

1391
01:25:46,010 --> 01:25:49,710
और इसलिए हम क्या कॉल की तरह एक पंक्ति में pausing

1392
01:25:49,710 --> 01:25:52,350
हम इस कि लाइन पर एक breakpoint डाल कॉल

1393
01:25:52,350 --> 01:25:55,920
और फिर हम उस समय कार्यक्रम के राज्य में चर मुद्रित कर सकते हैं.

1394
01:25:55,920 --> 01:25:58,990
>> हम फिर से लाइन से लाइन कार्यक्रम के माध्यम से कदम कर सकते हैं.

1395
01:25:58,990 --> 01:26:03,200
और फिर हम ढेर के राज्य में समय पर देख सकते हैं.

1396
01:26:03,200 --> 01:26:08,600
और इतने में आदेश GDB, हम क्या है हम सी फाइल पर बजना कॉल का उपयोग करने के लिए,

1397
01:26:08,600 --> 01:26:11,290
लेकिन हम इसे - ggdb ध्वज पारित किया है.

1398
01:26:11,290 --> 01:26:15,850
और एक बार हम कर रहे हैं कि हम सिर्फ परिणामस्वरूप आउटपुट फाइल पर gdb चलाने.

1399
01:26:15,850 --> 01:26:18,810
और इसलिए आप इस तरह पाठ की तरह कुछ जन मिलता है,

1400
01:26:18,810 --> 01:26:21,990
लेकिन वास्तव में सब तुम्हें क्या करना है आदेश में शुरुआत में टाइप है.

1401
01:26:21,990 --> 01:26:24,250
तोड़ मुख्य मुख्य में एक breakpoint डालता है.

1402
01:26:24,250 --> 01:26:28,470
400 सूची 400 लाइन के आसपास कोड की लाइनों की सूची है.

1403
01:26:28,470 --> 01:26:31,410
और इसलिए इस मामले में आप सिर्फ चारों ओर देखने के लिए और कर सकते हैं कहते हैं, ओह,

1404
01:26:31,410 --> 01:26:34,360
मैं 397 लाइन है, जो इस लाइन में एक breakpoint सेट करना चाहते हैं,

1405
01:26:34,360 --> 01:26:37,170
और तब अपने प्रोग्राम के उस कदम में चलाता है और इसे तोड़ने के लिए जा रहा है.

1406
01:26:37,170 --> 01:26:41,120
यह वहाँ थामने के लिए जा रहा है, और तुम बाहर प्रिंट, उदाहरण के लिए कर सकते हैं, कम या अधिक के मूल्य.

1407
01:26:41,120 --> 01:26:46,410
और तो वहाँ आप को पता है की जरूरत है आदेशों की एक गुच्छा रहे हैं,

1408
01:26:46,410 --> 01:26:48,660
और इस स्लाइड शो वेबसाइट पर जाना होगा,

1409
01:26:48,660 --> 01:26:54,000
यदि ऐसा है तो आप बस इन संदर्भित करना चाहते हैं या उन्हें अपने धोखा चादरें पर डाल की तरह है, स्वतंत्र महसूस हो रहा है.

1410
01:26:54,000 --> 01:27:00,650
>> कूल. क्विज समीक्षा 0 था, और हम चारों ओर छड़ी अगर आप किसी भी सवाल है.

1411
01:27:00,650 --> 01:27:03,850
सही सभी.

1412
01:27:03,850 --> 01:27:09,030
>>  [वाहवाही]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]