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
>> ડો LLOYD: ઠીક છે, જેથી એક સૂચન
અહીં શરૂ કરતા પહેલા.

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
અમે ખરેખર વિશે વાત કરવામાં આવે છે
મેમરી જ સામાન્ય Chunk, માત્ર

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
તે કે જે તમને મેમરી આપતું નથી
તે એક નામ આપો નથી,

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
જો અમે તો શું થશે યાદ કરો
પ્રયત્ન કરો અને NULL નિર્દેશક ખોટો સંદર્ભ?

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
>> અથવા વધુ યોગ્ય
અમે પૂર્ણાંક સ્ટાર પીએક્સ કહે કરશો

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
અમે પૂર્ણાંક એક્સ પૂર્ણાંક વિચાર બરાબર કહી શકો છો.

115
00:05:17,970 --> 00:05:19,930
તે ખૂબ સરળ છે.

116
00:05:19,930 --> 00:05:24,030
અમે એક એરે બનાવવા માંગો છો તો શું
સ્ટેક પર રહેવા કે ફ્લોટ્સ એક્સ?

117
00:05:24,030 --> 00:05:28,210
એ નામ છે stack_array-- ફ્લોટ
અમારા એરે ચોરસ કૌંસ એક્સ.

118
00:05:28,210 --> 00:05:32,419
તે અમને એક એરે માટે બનાવવા માટે પડશે
સ્ટેક પર રહેવા કે ફ્લોટ્સ એક્સ ઓનલાઇન.

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
હું પકડી પૂરતી જગ્યા જરૂર
X બિંદુ કિંમતો ફ્લોટિંગ.

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
હવે ફરીથી, આ સાધન અથવા માં
IDE આ પ્રકારની કોઈપણ રીતે તમે માટે થાય છે

187
00:09:02,029 --> 00:09:04,820
તમારી પાસે જ્યારે આ રીતે થશે
તમારા કાર્યક્રમ સમાપ્ત કરવામાં આવે છે, ત્યારે

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
કે સ્ટેક પર રહે છે, તમે
પછી એક્સ મુક્ત કરવા માંગો છો નથી.

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
તેથી હું તેમજ તે લીલા જેવું રંગ છું.

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
>> પૂર્ણાંક સ્ટાર b પૂર્ણાંક 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
પૂર્ણાંક સ્ટાર b પૂર્ણાંક 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
b સરનામું સમાવે
મેમરી કે બ્લોક.

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
તેથી અમે પૂર્ણાંક સ્ટાર b બરાબર કહે છે ત્યારે
પૂર્ણાંક malloc માપ, જમણી ત્યાં છે,

243
00:11:29,760 --> 00:11:33,490
આ પર પોપ કે તીર
ત્યાં જમણી બાજુ, કે સમગ્ર બાબત

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
અથવા, વધુ diagrammatically મૂકી
એમ કરવા માટે નિર્દેશ કરે છે.

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
>> એક પોઇન્ટેડ કે જે બી તો કરશે
એક ચિન્હ b બરાબર કરવામાં આવી છે.

260
00:12:25,280 --> 00:12:28,150
પરંતુ તેના બદલે માત્ર એક b બરાબર
અર્થ એ થાય કે અને બી હવે છે

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
સ્ટાર b એમ બરાબર વત્તા 2, યાદ
અમારા પોઇન્ટર વિડિઓ શું સ્ટાર b થાય છે.

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
હું બી મુક્ત ત્યારે શું થાય?

278
00:13:16,490 --> 00:13:18,800
હું મુક્ત અર્થ શું કહ્યું યાદ રાખો.

279
00:13:18,800 --> 00:13:21,920
હું બી મુક્ત જ્યારે હું શું કહી રહ્યો છું?

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