1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:01,395
[संगीत बजाना]

3
00:00:01,395 --> 00:00:05,590

4
00:00:05,590 --> 00:00:07,940
>> डौग लॉयड: ठीक है तो एक सुझाव
यहां शुरू होने से पहले।

5
00:00:07,940 --> 00:00:11,660
आप वीडियो पर नहीं देखा गया है
आप तो पहले करना चाहते हो सकता संकेत दिए।

6
00:00:11,660 --> 00:00:15,860
इस वीडियो है, क्योंकि एक और
संकेत के साथ काम करने का तरीका है।

7
00:00:15,860 --> 00:00:17,574
>> तो यह बात करने के लिए जा रहा है
कुछ अवधारणाओं के बारे में

8
00:00:17,574 --> 00:00:19,490
हम में है कि कवर
वीडियो संकेत, और हम कर रहे हैं

9
00:00:19,490 --> 00:00:21,948
अब उन पर चमक के लिए जा रहा है,
वे पहले से ही कर रहे हैं, यह सोचते हैं कि

10
00:00:21,948 --> 00:00:23,090
एक तरह से समझ में आया।

11
00:00:23,090 --> 00:00:25,440
तो यह है कि सिर्फ अपने निष्पक्ष चेतावनी है
कि आप इस वीडियो को देख रहे हैं

12
00:00:25,440 --> 00:00:27,814
और आप नहीं देखा है
संकेत दिए गए वीडियो, यह हो सकता है की तरह

13
00:00:27,814 --> 00:00:29,610
अपने सिर पर एक छोटा सा उड़।

14
00:00:29,610 --> 00:00:32,080
और इसलिए यह बेहतर हो सकता है
इसी क्रम में यह देखने के लिए।

15
00:00:32,080 --> 00:00:34,710
>> इसलिए हम पहले से ही देखा है
रास्ता, संकेत के साथ काम करने के लिए

16
00:00:34,710 --> 00:00:37,810
जो हम एक घोषित है
चर, और फिर हम

17
00:00:37,810 --> 00:00:42,160
एक सूचक एक और चर घोषित
चर, कि यह करने के लिए अंक।

18
00:00:42,160 --> 00:00:44,870
इसलिए हम बनाया है एक
एक नाम के साथ चर, हम है

19
00:00:44,870 --> 00:00:48,480
एक नाम के साथ एक दूसरे चर बनाया
और हम दूसरे चर उस बिंदु

20
00:00:48,480 --> 00:00:50,220
कि पहली बार में।

21
00:00:50,220 --> 00:00:52,370
इस तरह की है एक
समस्या है, हालांकि, इसकी वजह यह

22
00:00:52,370 --> 00:00:54,650
ठीक से पता करने की आवश्यकता है
कितना स्मृति हम कर रहे हैं

23
00:00:54,650 --> 00:00:57,600
पल की जरूरत जा
हमारे कार्यक्रम संकलित किया गया है।

24
00:00:57,600 --> 00:00:58,220
>> ऐसा क्यों?

25
00:00:58,220 --> 00:01:03,338
हम नाम के लिए सक्षम होने की जरूरत है, क्योंकि या
संभव चर के सभी की पहचान

26
00:01:03,338 --> 00:01:04,129
हम मुठभेड़ हो सकता है।

27
00:01:04,129 --> 00:01:07,910
हम हो सकता है कि एक सरणी हो सकता है
जानकारी का एक बहुत धारण करने में सक्षम,

28
00:01:07,910 --> 00:01:10,110
लेकिन यह अभी भी नहीं है
पर्याप्त बिल्कुल सटीक।

29
00:01:10,110 --> 00:01:12,640
क्या हम नहीं जानते हैं, तो
क्या हम कोई विचार है

30
00:01:12,640 --> 00:01:14,370
कितना हम समय संकलन की आवश्यकता होगी?

31
00:01:14,370 --> 00:01:17,020
या फिर क्या हमारे कार्यक्रम होगा यदि
एक बहुत लंबे समय के लिए चला,

32
00:01:17,020 --> 00:01:19,810
विभिन्न उपयोगकर्ता को स्वीकार
डेटा, और हम नहीं कर सकते वास्तव में

33
00:01:19,810 --> 00:01:23,170
हम कर रहे हैं कि क्या अनुमान
1,000 इकाइयों की जरूरत के लिए जा रहे हैं?

34
00:01:23,170 --> 00:01:26,060
>> यह हम कर सकते हैं की तरह नहीं है
कमांड लाइन पर कहना

35
00:01:26,060 --> 00:01:28,040
कितने आइटम दर्ज
क्या आप की आवश्यकता होगी लगता।

36
00:01:28,040 --> 00:01:31,100
अच्छा है कि अनुमान है कि गलत क्या है?

37
00:01:31,100 --> 00:01:34,300
गतिशील स्मृति आबंटन
एक तरह से हमें रास्ता अनुमति देता है

38
00:01:34,300 --> 00:01:36,867
इस विशेष समस्या निजात पाने के लिए।

39
00:01:36,867 --> 00:01:38,700
और वैसे भी यह करता है
संकेत का उपयोग कर रहा है।

40
00:01:38,700 --> 00:01:42,140
>> हम संकेत करने के लिए उपयोग कर सकते हैं
गतिशील के लिए उपयोग हो

41
00:01:42,140 --> 00:01:45,710
है कि आवंटित स्मृति, स्मृति
अपने कार्यक्रम के रूप में आवंटित चल रहा है।

42
00:01:45,710 --> 00:01:48,290
यह संकलन समय पर आवंटित नहीं कर रहा है।

43
00:01:48,290 --> 00:01:51,570
जब आप गतिशील आवंटित
स्मृति यह एक पूल से आता है

44
00:01:51,570 --> 00:01:53,795
स्मृति के ढेर के रूप में जाना जाता है।

45
00:01:53,795 --> 00:01:56,420
हमने इससे पहले सभी स्मृति
पाठ्यक्रम में साथ काम कर रहा

46
00:01:56,420 --> 00:01:59,920
एक पूल से आ गया है
स्मृति के ढेर के रूप में जाना जाता है।

47
00:01:59,920 --> 00:02:02,470
एक अच्छा तरीका है आम तौर पर करने के लिए
mind-- और इस नियम में रखना

48
00:02:02,470 --> 00:02:04,720
हमेशा सच नहीं होता है
लेकिन बहुत ज्यादा लगभग

49
00:02:04,720 --> 00:02:09,940
हमेशा true-- किसी भी है कि रखती है
बार जब आप एक चर नाम दे

50
00:02:09,940 --> 00:02:12,090
शायद ढेर पर रहता है।

51
00:02:12,090 --> 00:02:14,650
और किसी भी समय आप नहीं करते
एक चर एक नाम देना,

52
00:02:14,650 --> 00:02:19,160
आप गतिशील स्मृति के साथ क्या कर सकते हैं जो
आवंटन, यह ढेर पर रहता है।

53
00:02:19,160 --> 00:02:22,190
>> अब मैं एक तरह से इस के रूप में प्रस्तुत कर रहा हूँ
स्मृति के इन दो पूल है कि अगर वहाँ।

54
00:02:22,190 --> 00:02:24,740
लेकिन अगर आप यह देखा हो सकता है
आम तौर पर है, जो आरेख,

55
00:02:24,740 --> 00:02:27,290
का प्रतिनिधित्व
क्या स्मृति की तरह लग रहा है

56
00:02:27,290 --> 00:02:30,373
और हम सब के बारे में देखभाल करने के लिए नहीं जा रहे हैं
ऊपर और नीचे सामान।

57
00:02:30,373 --> 00:02:33,580
क्या हम देखभाल के बारे में यह हिस्सा है
यहां बीच, ढेर और ढेर।

58
00:02:33,580 --> 00:02:35,570
आप से देख सकते हैं
इस चित्र में देख रहे हैं,

59
00:02:35,570 --> 00:02:38,390
ये वास्तव में दो नहीं हैं
स्मृति के अलग-अलग पूल।

60
00:02:38,390 --> 00:02:42,757
यह स्मृति का एक साझा पूल है
जहां आप इस दृश्य में, शुरू

61
00:02:42,757 --> 00:02:44,590
आप नीचे से शुरू
और भरना शुरू

62
00:02:44,590 --> 00:02:48,040
ढेर के साथ नीचे, और आप से
शीर्ष पर शुरू और भरना शुरू

63
00:02:48,040 --> 00:02:50,072
ढेर के साथ ऊपर से नीचे।

64
00:02:50,072 --> 00:02:51,780
लेकिन यह सच है
एक ही पूल, यह सिर्फ है

65
00:02:51,780 --> 00:02:56,050
अलग अलग स्थानों, विभिन्न स्थानों
स्मृति में आवंटित किए जा रहे हैं कि।

66
00:02:56,050 --> 00:02:59,060
और आप से बाहर चला सकते हैं
या तो होने से स्मृति

67
00:02:59,060 --> 00:03:01,240
ढेर सभी रास्ते जाओ
नीचे करने के लिए, या

68
00:03:01,240 --> 00:03:05,440
ढेर, शीर्ष करने के लिए सभी रास्ते जाओ
या ढेर और ढेर होने

69
00:03:05,440 --> 00:03:06,740
एक दूसरे के खिलाफ पूरा।

70
00:03:06,740 --> 00:03:09,500
उन की सभी शर्तों को हो सकता है
कि अपने कार्यक्रम का कारण

71
00:03:09,500 --> 00:03:11,030
स्मृति से बाहर चलाने के लिए।

72
00:03:11,030 --> 00:03:11,952
इसलिए इस बात का ध्यान रखें।

73
00:03:11,952 --> 00:03:13,660
हम के बारे में बात करते हैं
ढेर और ढेर

74
00:03:13,660 --> 00:03:17,880
हम वास्तव में के बारे में बात कर रहे हैं
स्मृति का एक ही सामान्य हिस्सा है, बस

75
00:03:17,880 --> 00:03:21,930
कि स्मृति के विभिन्न भागों।

76
00:03:21,930 --> 00:03:24,910
>> तो हम गतिशील कैसे मिलता है
पहली जगह में स्मृति आवंटित?

77
00:03:24,910 --> 00:03:27,740
हमारे कार्यक्रम प्राप्त करता है कैसे
यह चल रहा है के रूप में स्मृति?

78
00:03:27,740 --> 00:03:32,660
खैर सी नामक एक समारोह में प्रदान
malloc, स्मृति संभाजक, जो

79
00:03:32,660 --> 00:03:36,810
आप के लिए एक फोन करना है, और आप में पारित
कितने आप चाहते हैं कि स्मृति के बाइट्स।

80
00:03:36,810 --> 00:03:39,940
अपने कार्यक्रम चल रहा है, तो अगर
और आप एक पूर्णांक क्रम चाहते हैं,

81
00:03:39,940 --> 00:03:46,040
आप में से चार बाइट्स Mallock सकता है
स्मृति, malloc चार कोष्ठक।

82
00:03:46,040 --> 00:03:48,540
>> Mallock के माध्यम से जाना होगा
ढेर के माध्यम से देख,

83
00:03:48,540 --> 00:03:50,750
हम गतिशील रहे हैं, क्योंकि
स्मृति का आवंटन

84
00:03:50,750 --> 00:03:53,500
और यह आप के लिए वापस आ जाएगी
कि स्मृति के लिए एक सूचक।

85
00:03:53,500 --> 00:03:56,180
यह आपको लगता है कि memory-- देना नहीं है
यह एक नाम देना नहीं है,

86
00:03:56,180 --> 00:03:57,950
यह आप इसे करने के लिए एक संकेत देता है।

87
00:03:57,950 --> 00:04:00,780
फिर मैंने कहा क्यों और इसलिए है कि
यह शायद करने के लिए महत्वपूर्ण है कि

88
00:04:00,780 --> 00:04:03,770
संकेत दिए गए वीडियो देख चुके हैं
हम इस में बहुत दूर पाने से पहले।

89
00:04:03,770 --> 00:04:05,940
तो malloc जा रहा है
एक सूचक तुम वापस दे।

90
00:04:05,940 --> 00:04:08,950
>> Mallock आप किसी भी नहीं दे सकते हैं
स्मृति आप बाहर चला गया है, क्योंकि

91
00:04:08,950 --> 00:04:10,645
यह एक शून्य सूचक तुम वापस दे देंगे।

92
00:04:10,645 --> 00:04:15,282
आप हम क्या होता है अगर याद है
कोशिश करते हैं और एक शून्य सूचक भिन्नता?

93
00:04:15,282 --> 00:04:17,019
हम सही, एक SEG गलती पीड़ित हैं?

94
00:04:17,019 --> 00:04:18,060
यही कारण है कि शायद अच्छा नहीं है।

95
00:04:18,060 --> 00:04:21,579
>> तो हर बार जब आप एक फोन करना
हमेशा, हमेशा आप malloc के लिए

96
00:04:21,579 --> 00:04:25,270
जांच की जरूरत है या नहीं,
यह तुम वापस रिक्त है दिया सूचक।

97
00:04:25,270 --> 00:04:28,800
अगर ऐसा है, तो आप अपने कार्यक्रम को समाप्त करने की जरूरत है
आप भिन्नता कोशिश करते हैं और क्योंकि अगर

98
00:04:28,800 --> 00:04:31,360
आप जा रहे हैं शून्य सूचक
विखंडन दोष पीड़ित करने के लिए

99
00:04:31,360 --> 00:04:34,380
और अपने कार्यक्रम है
वैसे भी दुर्घटना के लिए जा रहा है।

100
00:04:34,380 --> 00:04:37,190
तो कैसे स्थिर रुप से हम करते हैं
एक पूर्णांक प्राप्त?

101
00:04:37,190 --> 00:04:37,730
>> पूर्णांक एक्स।

102
00:04:37,730 --> 00:04:40,010
हम शायद किया है कि
समय का एक गुच्छा, है ना?

103
00:04:40,010 --> 00:04:43,480
यह कहा जाता है एक चर बनाता है
ढेर पर रहता है कि एक्स।

104
00:04:43,480 --> 00:04:46,190
कैसे हम गतिशील एक पूर्णांक प्राप्त करते हैं?

105
00:04:46,190 --> 00:04:50,010
इंटरनैशनल स्टार पिक्सल malloc 4 के बराबर होती है।

106
00:04:50,010 --> 00:04:53,050
>> या अधिक उचित
हम int स्टार पिक्सल कह सकता हूँ

107
00:04:53,050 --> 00:04:57,680
, पूर्णांक के malloc आकार के बराबर होती है
बस कुछ कम फेंकने के लिए

108
00:04:57,680 --> 00:04:59,740
हमारे कार्यक्रम के आसपास जादुई संख्या।

109
00:04:59,740 --> 00:05:04,140
यह हमारे लिए प्राप्त करने के लिए जा रहा है
ढेर से स्मृति के चार बाइट्स,

110
00:05:04,140 --> 00:05:06,720
और सूचक हम मिल
इसे वापस करने के लिए पिक्सल कहा जाता है।

111
00:05:06,720 --> 00:05:08,430
और फिर हम है बस के रूप में
हम पहले किया

112
00:05:08,430 --> 00:05:13,966
कर सकते हैं पिक्सल भिन्नता को
कि स्मृति का उपयोग।

113
00:05:13,966 --> 00:05:15,590
हम कैसे उपयोगकर्ता से एक पूर्णांक प्राप्त करते हैं?

114
00:05:15,590 --> 00:05:17,970
हम int x पूर्णांक मिल के बराबर होती है कह सकते हैं।

115
00:05:17,970 --> 00:05:19,930
यही कारण है कि बहुत सीधा है।

116
00:05:19,930 --> 00:05:24,030
हम एक सरणी बनाने के लिए चाहते हैं, तो क्या
के ढेर पर रहते हैं कि मंगाई x?

117
00:05:24,030 --> 00:05:28,210
उस नाम है stack_array-- फ्लोट
हमारे array-- वर्ग कोष्ठक एक्स की।

118
00:05:28,210 --> 00:05:32,419
यही कारण है कि हमें एक सरणी के लिए पैदा करेगा
के ढेर पर रहते हैं कि मंगाई x।

119
00:05:32,419 --> 00:05:34,960
हम मंगाई की एक सरणी बना सकते हैं
वह भी, ढेर पर रहता है।

120
00:05:34,960 --> 00:05:37,330
वाक्य रचना एक लग सकता है
अधिक बोझिल थोड़ा

121
00:05:37,330 --> 00:05:41,740
लेकिन हम नाव कह सकते हैं
स्टार heap_array के बराबर होती है

122
00:05:41,740 --> 00:05:44,360
malloc एक्स बार नाव के आकार।

123
00:05:44,360 --> 00:05:48,160
मैं पकड़ करने के लिए पर्याप्त कमरे की जरूरत
एक्स चल बिन्दु मूल्यों।

124
00:05:48,160 --> 00:05:51,560
तो मैं 100 की जरूरत है कहना
तैरता है, या 1,000 मंगाई।

125
00:05:51,560 --> 00:05:54,810
तो उस मामले में यह होगा
100 मंगाई के लिए 400 बाइट्स,

126
00:05:54,810 --> 00:05:59,080
या 1,000 मंगाई के लिए 4,000 बाइट्स,
प्रत्येक नाव तक ले जाता है क्योंकि

127
00:05:59,080 --> 00:06:01,230
अंतरिक्ष के चार बाइट्स।

128
00:06:01,230 --> 00:06:05,110
>> यह करने के बाद मैं उपयोग कर सकते हैं
heap_array पर वर्ग कोष्ठक सिंटेक्स।

129
00:06:05,110 --> 00:06:08,970
बस मैं stack_array पर होगा के रूप में, मैं
व्यक्तिगत रूप से उसके तत्वों का उपयोग कर सकते हैं

130
00:06:08,970 --> 00:06:11,590
का उपयोग कर heap_array शून्य, heap_array है।

131
00:06:11,590 --> 00:06:15,800
लेकिन हम ऐसा कर सकते हैं कारण याद
क्योंकि सी में एक सरणी के नाम

132
00:06:15,800 --> 00:06:19,990
वास्तव में करने के लिए एक सूचक है
उस सरणी का पहला तत्व।

133
00:06:19,990 --> 00:06:23,480
हम एक घोषणा कर रहे हैं कि इस तथ्य तो
यहां ढेर पर तैरता की सरणी

134
00:06:23,480 --> 00:06:24,810
वास्तव में थोड़ा भ्रामक है।

135
00:06:24,810 --> 00:06:27,600
हम वास्तव में कर रहे हैं
वहाँ कोड की दूसरी पंक्ति

136
00:06:27,600 --> 00:06:32,360
यह भी का एक हिस्सा के लिए एक सूचक बनाने
हम तो साथ कुछ काम करना है कि स्मृति।

137
00:06:32,360 --> 00:06:35,620
>> यहाँ बड़ी समस्या के साथ है
गतिशील हालांकि स्मृति आवंटित,

138
00:06:35,620 --> 00:06:38,360
यह सच है और इस वजह से है
कुछ अच्छी आदतें विकसित करने के लिए महत्वपूर्ण

139
00:06:38,360 --> 00:06:39,800
जब आप इसके साथ काम कर रहे हैं।

140
00:06:39,800 --> 00:06:43,060
स्थिर रुप से घोषित विपरीत
स्मृति, अपनी स्मृति

141
00:06:43,060 --> 00:06:46,790
स्वचालित रूप से करने के लिए नहीं लौटा है
अपने कार्य किया जाता है जब सिस्टम।

142
00:06:46,790 --> 00:06:49,280
हम मुख्य है, और यदि हां
मुख्य एक समारोह कॉल

143
00:06:49,280 --> 00:06:53,860
च, खत्म च यह जब कर रहा है जो कुछ भी
और कार्यक्रम के नियंत्रण के लिए रिटर्न

144
00:06:53,860 --> 00:06:58,810
पीठ, मुख्य करने के लिए सभी स्मृति की
इस्तेमाल किया है कि च वापस दे दिया जाता है।

145
00:06:58,810 --> 00:07:01,250
यह फिर से इस्तेमाल किया जा सकता
कुछ अन्य प्रोग्राम के द्वारा,

146
00:07:01,250 --> 00:07:04,250
या कुछ अन्य समारोह है कि
मुख्य में बाद में बुलाया जाता है।

147
00:07:04,250 --> 00:07:06,970
यह फिर से एक ही है कि स्मृति से अधिक उपयोग कर सकते हैं।

148
00:07:06,970 --> 00:07:09,620
>> यदि आप गतिशील
हालांकि स्मृति का आवंटन

149
00:07:09,620 --> 00:07:14,380
आप स्पष्ट रूप से बताने के लिए है
आप इसके साथ कर रहे हैं कि प्रणाली।

150
00:07:14,380 --> 00:07:18,370
यह जो कर सकता है, यह आप के लिए पर पकड़ लेंगे
आप बाहर चलने के लिए एक समस्या के लिए नेतृत्व

151
00:07:18,370 --> 00:07:19,290
स्मृति की।

152
00:07:19,290 --> 00:07:22,179
और वास्तव में हम कभी कभी का उल्लेख
एक स्मृति रिसाव के रूप में यह करने के लिए।

153
00:07:22,179 --> 00:07:24,970
और कभी कभी इन स्मृति लीक
वास्तव में वास्तव में विनाशकारी हो सकता है

154
00:07:24,970 --> 00:07:27,020
प्रणाली के प्रदर्शन के लिए।

155
00:07:27,020 --> 00:07:31,120
>> यदि आप एक लगातार इंटरनेट उपयोगकर्ता हैं
आप कुछ वेब ब्राउज़र का उपयोग हो सकता है

156
00:07:31,120 --> 00:07:35,630
और मैं यहाँ नाम का नाम नहीं होगा, लेकिन
कुछ वेब ब्राउज़र वहाँ से बाहर हैं

157
00:07:35,630 --> 00:07:39,150
वास्तव में रखने के लिए कुख्यात रहे हैं कि
तय नहीं मिलता है कि स्मृति लीक।

158
00:07:39,150 --> 00:07:44,570
और आप अपने ब्राउज़र खुला छोड़ दें
समय की एक बहुत ही लंबी अवधि के लिए, दिन

159
00:07:44,570 --> 00:07:48,060
और दिनों या हफ्तों के लिए, आप कभी कभी
अपने सिस्टम सूचना है कि हो सकता है

160
00:07:48,060 --> 00:07:49,790
वास्तव में धीरे-धीरे, वास्तव में चल रहा है।

161
00:07:49,790 --> 00:07:54,640
और उस के लिए कारण यह है कि
ब्राउज़र, स्मृति आवंटित की गई है

162
00:07:54,640 --> 00:07:57,320
लेकिन उसके बाद सिस्टम नहीं बताया
कि यह इसके साथ हो चुका है।

163
00:07:57,320 --> 00:08:01,000
और इतना है कि कम स्मृति के पत्तों
अपने अन्य कार्यक्रमों के सभी के लिए उपलब्ध

164
00:08:01,000 --> 00:08:04,480
आप कर रहे हैं, क्योंकि साझा करने के लिए
कि वेब ब्राउज़र leaking--

165
00:08:04,480 --> 00:08:06,755
कार्यक्रम स्मृति लीक कर रहा है।

166
00:08:06,755 --> 00:08:08,880
हम वापस स्मृति दे कर कैसे
हम इसके साथ कर रहे है?

167
00:08:08,880 --> 00:08:10,838
खैर सौभाग्य से यह एक है
यह करने के लिए बहुत ही आसान तरीका।

168
00:08:10,838 --> 00:08:11,710
हम सिर्फ यह मुक्त।

169
00:08:11,710 --> 00:08:15,020
मुक्त नामक एक समारोह नहीं है,
यह स्मृति के लिए एक सूचक को स्वीकार करता है

170
00:08:15,020 --> 00:08:16,010
और हम जाने के लिए अच्छे हैं।

171
00:08:16,010 --> 00:08:18,310
>> तो चलो हम में हैं, हम कहते हैं
हमारे कार्यक्रम के बीच,

172
00:08:18,310 --> 00:08:21,970
हम 50 अक्षर malloc करना चाहते हैं।

173
00:08:21,970 --> 00:08:25,710
हम कर सकते हैं कि एक सरणी malloc करना चाहते हैं
50 अक्षर धारण करने में सक्षम।

174
00:08:25,710 --> 00:08:29,109
और हम वापस करने के लिए एक सूचक मिलता है जब
कि, कि सूचक के नाम शब्द है।

175
00:08:29,109 --> 00:08:30,900
हम हम कर रहे हैं जो कुछ भी
शब्द के साथ क्या करने जा रहे हैं,

176
00:08:30,900 --> 00:08:33,440
और फिर हम कर रहे हैं जब
हम सिर्फ यह मुक्त किया।

177
00:08:33,440 --> 00:08:37,460
और अब हम उन 50 लौट आए हैं
वापस व्यवस्था करने के लिए स्मृति के बाइट्स।

178
00:08:37,460 --> 00:08:40,147
कुछ अन्य समारोह के लिए उन्हें इस्तेमाल कर सकते हैं।

179
00:08:40,147 --> 00:08:43,480
हम एक पीड़ित के बारे में चिंता करने की जरूरत नहीं है
स्मृति रिसाव हम शब्द को मुक्त किया है।

180
00:08:43,480 --> 00:08:46,639
हम वापस स्मृति दिया है,
इसलिए हम उसके साथ काम कर रहे हैं।

181
00:08:46,639 --> 00:08:48,430
तो तीन हैं
कि ऐसा करना चाहिए सुनहरा नियम

182
00:08:48,430 --> 00:08:51,700
आप कर रहे हैं, जब भी ध्यान में रखा जाना
गतिशील स्मृति आवंटन

183
00:08:51,700 --> 00:08:52,990
malloc साथ।

184
00:08:52,990 --> 00:08:56,480
स्मृति के प्रत्येक ब्लॉक कि
आप malloc मुक्त कर दिया जाना चाहिए

185
00:08:56,480 --> 00:08:58,430
अपने कार्यक्रम से पहले पूरा चल रहा है।

186
00:08:58,430 --> 00:09:02,029
अब फिर से, उपकरण में या में
आईडीई इस तरह की वैसे भी आप के लिए होता है

187
00:09:02,029 --> 00:09:04,820
you-- जब यह वैसे भी कुछ नहीं होगा
अपने कार्यक्रम समाप्त हो जाता है जब,

188
00:09:04,820 --> 00:09:06,880
सभी स्मृति में जारी किया जाएगा।

189
00:09:06,880 --> 00:09:10,750
लेकिन यह आम तौर पर अच्छा कोडिंग है
अभ्यास हमेशा के लिए, जब आप कर रहे,

190
00:09:10,750 --> 00:09:13,810
आप mallocd है क्या मुक्त।

191
00:09:13,810 --> 00:09:16,690
>> उस ने कहा, केवल बातें है कि
आप mallocd मुक्त किया जाना चाहिए है।

192
00:09:16,690 --> 00:09:19,880
आप स्थिर रुप से घोषणा एक
पूर्णांक, पूर्णांक एक्स सेमी कॉलन,

193
00:09:19,880 --> 00:09:23,500
कि ढेर पर रहता है, तो आप
तब x मुक्त करने के लिए नहीं करना चाहती।

194
00:09:23,500 --> 00:09:25,970
तुम हो तो यह है कि केवल बातें
mallocd मुक्त किया जाना चाहिए।

195
00:09:25,970 --> 00:09:28,960
>> और अंत में, दो बार नहीं मुक्त कुछ करो।

196
00:09:28,960 --> 00:09:31,170
यही कारण है कि करने के लिए नेतृत्व कर सकते हैं
एक और अजीब स्थिति है।

197
00:09:31,170 --> 00:09:33,530
आप है कि इतना सब कुछ
mallocd मुक्त किया गया है।

198
00:09:33,530 --> 00:09:36,000
आप है कि केवल बातें
malloc मुक्त किया जाना चाहिए।

199
00:09:36,000 --> 00:09:38,730
और दो बार नहीं मुक्त कुछ करो।

200
00:09:38,730 --> 00:09:43,660
>> तो चलो यहाँ एक उदाहरण के माध्यम से चलते हैं
कुछ गतिशील आवंटित क्या की

201
00:09:43,660 --> 00:09:46,122
स्मृति मिश्रित तरह लग सकता है
कुछ स्थिर स्मृति के साथ में।

202
00:09:46,122 --> 00:09:47,080
यहाँ क्या हो सकता है?

203
00:09:47,080 --> 00:09:48,913
आप का पालन कर सकते हैं देखें
साथ में और क्या लगता है

204
00:09:48,913 --> 00:09:51,720
हम जाने के रूप में होने जा रहा
कोड के इन सभी लाइनों के माध्यम से।

205
00:09:51,720 --> 00:09:53,980
>> इसलिए हम पूर्णांक मीटर कहते हैं।

206
00:09:53,980 --> 00:09:54,840
यहाँ क्या होता है?

207
00:09:54,840 --> 00:09:56,339
वैसे यह बहुत सीधा है।

208
00:09:56,339 --> 00:09:59,650
मैं एम नामक एक पूर्णांक चर पैदा करते हैं।

209
00:09:59,650 --> 00:10:01,400
मैं इसे हरी रंग
कि रंग है, क्योंकि

210
00:10:01,400 --> 00:10:03,730
मैं बात कर रहा हूँ, जब कि मैं का उपयोग
के बारे में पूर्णांक चर।

211
00:10:03,730 --> 00:10:05,160
यह एक बॉक्स है।

212
00:10:05,160 --> 00:10:08,400
यह आप कर सकते मीटर कहा जाता है, और है
इसके अंदर दुकान पूर्णांकों।

213
00:10:08,400 --> 00:10:12,400
>> मैं तो एक पूर्णांक स्टार क्या कहते हैं?

214
00:10:12,400 --> 00:10:13,530
अच्छा है कि बहुत समान है।

215
00:10:13,530 --> 00:10:15,780
मैं एक बॉक्स एक बुलाया पैदा कर रहा हूँ।

216
00:10:15,780 --> 00:10:19,100
इसे धारण पूर्णांक के लिए सक्षम है
सितारों, पूर्णांकों को संकेत दिए।

217
00:10:19,100 --> 00:10:21,570
इसलिए मुझे लगता है के रूप में अच्छी तरह से इसे हरी-ish रंग कर रहा हूँ।

218
00:10:21,570 --> 00:10:24,140
>> मुझे लगता है यह कुछ है पता
एक पूर्णांक के साथ क्या करना,

219
00:10:24,140 --> 00:10:25,852
लेकिन यह कोई पूर्णांक नहीं ही है।

220
00:10:25,852 --> 00:10:27,310
लेकिन यह बहुत ज्यादा एक ही विचार है।

221
00:10:27,310 --> 00:10:28,101
मैं एक बॉक्स बना लिया है।

222
00:10:28,101 --> 00:10:30,070
ये सही दोनों
अब ढेर पर रहते हैं।

223
00:10:30,070 --> 00:10:32,520
मैं उन दोनों को नाम दिए गए हैं।

224
00:10:32,520 --> 00:10:36,750
>> पूर्णांक स्टार ख पूर्णांक के malloc आकार के बराबर होती है।

225
00:10:36,750 --> 00:10:38,560
यह एक थोड़ा मुश्किल हो सकता है।

226
00:10:38,560 --> 00:10:44,110
एक दूसरा ले लो और आप के बारे में क्या लगता है
इस चित्र पर होने की उम्मीद है।

227
00:10:44,110 --> 00:10:50,210
पूर्णांक स्टार ख पूर्णांक के malloc आकार के बराबर होती है।

228
00:10:50,210 --> 00:10:51,940
>> वैसे यह सिर्फ एक बॉक्स नहीं बना है।

229
00:10:51,940 --> 00:10:53,800
यह वास्तव में दो बक्से पैदा करता है।

230
00:10:53,800 --> 00:10:58,670
और यह यह भी स्थापित करता है, संबंधों
एक रिश्ते में एक बिंदु।

231
00:10:58,670 --> 00:11:02,240
हम एक ब्लॉक आवंटित किया है
ढेर पर स्मृति की।

232
00:11:02,240 --> 00:11:05,940
नोटिस शीर्ष सही बॉक्स कि
एक नाम नहीं है।

233
00:11:05,940 --> 00:11:06,760
>> हम यह mallocd।

234
00:11:06,760 --> 00:11:08,050
यह ढेर पर मौजूद है।

235
00:11:08,050 --> 00:11:10,090
लेकिन बी एक नाम है।

236
00:11:10,090 --> 00:11:11,950
यह बी नामक एक सूचक चर है।

237
00:11:11,950 --> 00:11:13,910
यही कारण है कि ढेर पर रहता है।

238
00:11:13,910 --> 00:11:18,250
>> तो यह स्मृति का एक टुकड़ा है
कि एक दूसरे के लिए अंक।

239
00:11:18,250 --> 00:11:21,840
ख पता होता है
स्मृति की है कि ब्लॉक की।

240
00:11:21,840 --> 00:11:23,757
यह अन्यथा एक नाम नहीं है।

241
00:11:23,757 --> 00:11:24,590
लेकिन यह इसके लिए अंक।

242
00:11:24,590 --> 00:11:29,760
इसलिए हम पूर्णांक स्टार ख के बराबर होती है जब कहते हैं
पूर्णांक के malloc आकार, सही है कि वहाँ,

243
00:11:29,760 --> 00:11:33,490
पर popped कि कि तीर
वहाँ दाईं ओर, कि पूरी बात,

244
00:11:33,490 --> 00:11:36,740
मैं यह प्रकट होगा
फिर, क्या होता है।

245
00:11:36,740 --> 00:11:39,341
कि सब के सब में क्या होता है
कोड की है कि एकल लाइन।

246
00:11:39,341 --> 00:11:41,340
अब हम थोड़ा अधिक मिलेगा
फिर से सीधा।

247
00:11:41,340 --> 00:11:43,330
एक एम्परसेंड मीटर के बराबर होती है।

248
00:11:43,330 --> 00:11:46,280
आप क्या एक याद करो
एम्परसेंड मीटर है के बराबर होती है?

249
00:11:46,280 --> 00:11:48,920
अच्छा है कि एक मीटर का पता हो जाता है।

250
00:11:48,920 --> 00:11:54,150
या, और अधिक रेखचित्र डाल
मीटर करने के लिए एक अंक।

251
00:11:54,150 --> 00:11:56,360
>> एक बी के बराबर होती है।

252
00:11:56,360 --> 00:11:57,560
ठीक है तो यहाँ एक और एक है।

253
00:11:57,560 --> 00:11:59,230
एक ख के बराबर होती है।

254
00:11:59,230 --> 00:12:02,260
क्या होने जा रहा है
आरेख इस समय के लिए?

255
00:12:02,260 --> 00:12:04,330
>> अच्छा है कि याद
असाइनमेंट ऑपरेटर काम करता है

256
00:12:04,330 --> 00:12:08,960
पर मूल्य बताए द्वारा
सही बाईं तरफ के मूल्य के लिए।

257
00:12:08,960 --> 00:12:14,820
मीटर करने के लिए इतनी के बजाय एक ओर इशारा करते हुए, एक अब
बी अंक है कि एक ही जगह पर बताते हैं।

258
00:12:14,820 --> 00:12:18,900
एक, एक बी बिंदु नहीं है
जहां बी अंक बताते हैं।

259
00:12:18,900 --> 00:12:25,280
>> एक उठाई कि ख के लिए तो होगा
एक एम्परसेंड ख के बराबर होती है किया गया है।

260
00:12:25,280 --> 00:12:28,150
लेकिन बजाय एक बस ख के बराबर होती है
इसका मतलब है कि और ख अब कर रहे हैं

261
00:12:28,150 --> 00:12:31,770
, एक ही पते पर क्योंकि इशारा करते हुए
ख के अंदर सिर्फ एक पता है।

262
00:12:31,770 --> 00:12:35,004
और अब एक के अंदर एक ही पता है।

263
00:12:35,004 --> 00:12:37,170
मीटर शायद, 10 के बराबर होती है
सबसे सरल बात

264
00:12:37,170 --> 00:12:38,690
हम एक छोटा सा में किया है।

265
00:12:38,690 --> 00:12:40,460
बॉक्स में 10 रखो।

266
00:12:40,460 --> 00:12:45,640
स्टार ख मीटर के बराबर होती है प्लस 2 से याद करते हैं
हमारे संकेत वीडियो क्या स्टार ख का मतलब है।

267
00:12:45,640 --> 00:12:50,230
हम भिन्नता ख और डाल करने के लिए जा रहे हैं
कि स्मृति स्थान में कुछ मूल्य।

268
00:12:50,230 --> 00:12:51,860
इस मामले में 12।

269
00:12:51,860 --> 00:12:55,300
>> इसलिए जब हम में से एक बिंदु भिन्नता
हम सिर्फ तीर नीचे की यात्रा को याद करते हैं।

270
00:12:55,300 --> 00:12:58,205
या दूसरे शब्दों में कहें, हम
कि स्मृति पता करने के लिए जाना

271
00:12:58,205 --> 00:12:59,580
और हम इसे किसी तरह से हेरफेर।

272
00:12:59,580 --> 00:13:00,830
हम वहाँ में कुछ मान रखा।

273
00:13:00,830 --> 00:13:03,960
इस मामले स्टार ख में
मीटर के बराबर होती है प्लस 2 बस है

274
00:13:03,960 --> 00:13:08,230
चर के लिए जाना है, ख द्वारा उठाई
स्मृति के लिए जाना है, ख द्वारा उठाई

275
00:13:08,230 --> 00:13:11,750
और 12, वहाँ में मीटर प्लस 2 डाल दिया।

276
00:13:11,750 --> 00:13:14,970
>> अब मैं ख मुक्त।

277
00:13:14,970 --> 00:13:16,490
मैं b मुक्त तो क्या होता है?

278
00:13:16,490 --> 00:13:18,800
मैं मुक्त साधन क्या कहा याद रखें।

279
00:13:18,800 --> 00:13:21,920
मैं b मुक्त जब मैं क्या कह रहा हूँ?

280
00:13:21,920 --> 00:13:23,410
>> मैं उसके साथ काम कर रहा हूँ, है ना?

281
00:13:23,410 --> 00:13:25,702
मैं अनिवार्य स्मृति छोड़ देना।

282
00:13:25,702 --> 00:13:26,910
मैं इस प्रणाली के लिए इसे वापस दे।

283
00:13:26,910 --> 00:13:33,010
मैं यह अब और नहीं है की जरूरत नहीं
क्या मैं ठीक है, उन्हें बता रहा हूँ?

284
00:13:33,010 --> 00:13:37,390
>> अब मैं कहना है कि अगर स्टार एक
11 आप शायद कर सकते हैं के बराबर होती है

285
00:13:37,390 --> 00:13:40,460
पहले से ही खराब है कि कुछ बताने
ठीक है, यहाँ होने जा रहा है?

286
00:13:40,460 --> 00:13:44,160
और मुझे लगता है मुझे लगता है कि शायद कोशिश की यदि वास्तव में
विखंडन दोष भुगतना होगा।

287
00:13:44,160 --> 00:13:47,140
क्योंकि अब, हालांकि
स्मृति के पहले से है कि हिस्सा

288
00:13:47,140 --> 00:13:50,220
मैं था कि कुछ
इस बिंदु पर करने के लिए उपयोग,

289
00:13:50,220 --> 00:13:54,590
अब मैं स्मृति पहुँचने हूँ कि
मुझे का उपयोग करने के लिए कानूनी नहीं है।

290
00:13:54,590 --> 00:13:57,330
>> और जैसा कि हम शायद होगा
हम स्मृति का उपयोग करते हैं, तो याद

291
00:13:57,330 --> 00:14:00,000
हम स्पर्श करने की अपेक्षा नहीं कर रहे हैं कि,
कि सबसे आम कारण है

292
00:14:00,000 --> 00:14:01,860
एक विभाजन की
गलती। और तो मेरे कार्यक्रम

293
00:14:01,860 --> 00:14:05,170
मैं ऐसा करने की कोशिश करता है, तो दुर्घटना होगा।

294
00:14:05,170 --> 00:14:09,910
तो फिर यह अच्छा पाने के लिए एक अच्छा विचार है
अभ्यास और अच्छी आदतों जमा हुआ

295
00:14:09,910 --> 00:14:12,920
malloc और नि: शुल्क के साथ काम करते हैं,
इसलिए यदि आप विभाजन पीड़ित नहीं है कि

296
00:14:12,920 --> 00:14:15,310
आप का उपयोग करें, और उस दोष
आपके गतिशील आवंटित

297
00:14:15,310 --> 00:14:17,370
स्मृति जिम्मेदारी से।

298
00:14:17,370 --> 00:14:20,300
>> मैं डौग लॉयड हूँ इस CS50 है।

299
00:14:20,300 --> 00:14:21,947