1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [6 વિભાગ] [વધુ સાનુકૂળ]

2
00:00:01,000 --> 00:00:04,000
[રોબ બોડેન] [હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,000 --> 00:00:09,000
[આ CS50 છે.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> અમે પ્રશ્નો અમારા વિભાગમાં વડા કરી શકે છે.

5
00:00:11,000 --> 00:00:17,000
હું પહેલા જગ્યા માટે URL મોકલ્યો.

6
00:00:17,000 --> 00:00:22,000
પ્રશ્નો ના વિભાગની શરૂઆતમાં કહે-

7
00:00:22,000 --> 00:00:26,000
દેખીતી રીતે હું સંપૂર્ણપણે અત્યંત સરળ પ્રશ્ન unsick-નથી છું

8
00:00:26,000 --> 00:00:28,000
માત્ર શું valgrind છે?

9
00:00:28,000 --> 00:00:30,000
Valgrind શું થાય છે?

10
00:00:30,000 --> 00:00:34,000
કોઈને કહેવું valgrind શું કરે છે કરવા માંગો છો?

11
00:00:34,000 --> 00:00:36,000
[વિદ્યાર્થી] ચકાસે મેમરી લીક્સ.

12
00:00:36,000 --> 00:00:41,000
અરે વાહ, valgrind સામાન્ય મેમરી ચેકર છે.

13
00:00:41,000 --> 00:00:44,000
તે, અંતે, તમને કહે છે જો તમે કોઈપણ મેમરી લીક્સ હોય છે,

14
00:00:44,000 --> 00:00:49,000
જે મોટે ભાગે આપણે શું કારણ માટે ઉપયોગ કરી રહ્યા છો તો તમે કરવા માંગો છો

15
00:00:49,000 --> 00:00:54,000
સમસ્યા સમૂહ અથવા તમે કરવા માંગો છો જો સારો દેખાવ

16
00:00:54,000 --> 00:00:59,000
મોટા બોર્ડ પર મેળવવા માટે, તમારે કોઈ મેમરી લીક્સ બિલકુલ જરૂર પડે છે,

17
00:00:59,000 --> 00:01:01,000
અને કદાચ તમને મેમરી છિદ્ર કે જે તમે શોધી શકો છો,

18
00:01:01,000 --> 00:01:04,000
પણ ધ્યાન રાખો કે તમે જ્યારે ફાઈલ ખોલવા

19
00:01:04,000 --> 00:01:07,000
અને જો તમે તેને બંધ કરો નહિં, કે જે મેમરી છિદ્ર છે.

20
00:01:07,000 --> 00:01:10,000
>> ઘણા લોકો અમુક નોડ માટે જોઈ રહ્યા હોય કે જે તેઓ મુક્ત કરી રહ્યાં છો

21
00:01:10,000 --> 00:01:15,000
ખરેખર, જ્યારે તેઓ ખૂબ પ્રથમ પગલું માં શબ્દકોશ બંધ ન હતી.

22
00:01:15,000 --> 00:01:19,000
તે તમને કહે છે જો તમે કોઈપણ અમાન્ય છે વાંચે અથવા લખે છે,

23
00:01:19,000 --> 00:01:22,000
જેનો અર્થ છે કે જો તમે પ્રયાસ કરો અને કિંમત સેટ

24
00:01:22,000 --> 00:01:26,000
કે ઢગલો ઓવરને બહાર છે અને તે seg દોષ ન થાય

25
00:01:26,000 --> 00:01:30,000
પરંતુ valgrind તે કેચ, કારણ કે તમે ખરેખર નથી ત્યાં લેખિત જોઈએ,

26
00:01:30,000 --> 00:01:33,000
અને જેથી તમે ચોક્કસપણે તે ક્યાં તો કોઇ નથી કરીશું.

27
00:01:33,000 --> 00:01:38,000
તમે કેવી રીતે ઉપયોગ કરી શકું valgrind?

28
00:01:38,000 --> 00:01:42,000
તમે કેવી રીતે ઉપયોગ કરી શકું valgrind?

29
00:01:42,000 --> 00:01:45,000
>> તે એક સામાન્ય પ્રશ્ન છે

30
00:01:45,000 --> 00:01:49,000
પ્રકારની તેને ચલાવવા અને આઉટપુટ જુઓ.

31
00:01:49,000 --> 00:01:51,000
આઉટપુટ વખત ઘણો જબરજસ્ત છે.

32
00:01:51,000 --> 00:01:54,000
ત્યાં પણ મજા ભૂલો જ્યાં જો તમને કેટલાક ભયંકર ખોટું વસ્તુ છે

33
00:01:54,000 --> 00:01:59,000
લુપ માં બની રહ્યું છે, પછી તે આખરે કહે, "કરશે વે ઘણા ભૂલો.

34
00:01:59,000 --> 00:02:03,000
હું હવે ગણતરી રોકવા જાઉં છું. "

35
00:02:03,000 --> 00:02:08,000
તે વાસ્તવમાં શાબ્દિક આઉટપુટ કે જે તમે પાર્સ હોય છે.

36
00:02:08,000 --> 00:02:13,000
અંતે, તે તમને કોઈપણ મેમરી લીક્સ કે તમારી પાસે કહેશે,

37
00:02:13,000 --> 00:02:16,000
કેટલા બ્લોક્સ, કે જે ઉપયોગી થઈ શકે છે કારણ કે

38
00:02:16,000 --> 00:02:20,000
જો તે એક બ્લોક unfreed છે, પછી તે સામાન્ય રીતે સરળતાથી શોધી

39
00:02:20,000 --> 00:02:23,000
1,000 કરતાં બ્લોક્સ unfreed.

40
00:02:23,000 --> 00:02:26,000
1,000 unfreed બ્લોકો કદાચ અર્થ છે કે તમે નથી ખાલી કરી રહ્યાં છો

41
00:02:26,000 --> 00:02:30,000
તમારી સાથે લિંક યોગ્ય અથવા કંઈક યાદીઓ છે.

42
00:02:30,000 --> 00:02:32,000
કે valgrind છે.

43
00:02:32,000 --> 00:02:35,000
>> હવે અમે પ્રશ્નો અમારી કલમ છે,

44
00:02:35,000 --> 00:02:38,000
જે તમે ડાઉનલોડ કરવા માટે જરૂર નથી.

45
00:02:38,000 --> 00:02:41,000
તમે મારા નામ પર ક્લિક કરો અને તેમને જગ્યા માં લઈ શકો છો.

46
00:02:41,000 --> 00:02:44,000
હવે મને પર ક્લિક કરો.

47
00:02:44,000 --> 00:02:46,000
1 પુનરાવર્તન સ્ટેક છે, કે જે અમે પ્રથમ કરી રહ્યા હશે.

48
00:02:46,000 --> 00:02:55,000
2 પુનરાવર્તન કતાર પ્રયત્ન કરશે, અને 3 પુનરાવર્તન આ singly યાદીની લિંક થશે.

49
00:02:55,000 --> 00:02:58,000
અમારા સ્ટેક સાથે બંધ શરૂ કરી રહ્યા છીએ.

50
00:02:58,000 --> 00:03:02,000
કારણ કે તે અહીં કહે છે, સ્ટેક સૌથી આધારભૂત છે,

51
00:03:02,000 --> 00:03:07,000
કમ્પ્યુટર વિજ્ઞાનના મૂળભૂત માહિતી માળખાં.

52
00:03:07,000 --> 00:03:11,000
ખૂબ અજમાયશી ઉદાહરણ છે

53
00:03:11,000 --> 00:03:13,000
ડાઇનિંગ હોલ માં ટ્રે ને સ્ટેક.

54
00:03:13,000 --> 00:03:16,000
તે વાસ્તવમાં છે જ્યારે તમે એક સ્ટેક રહી રજૂ કરવામાં આવ્યા છે,

55
00:03:16,000 --> 00:03:20,000
કોઈને કહેવું, રહ્યું છે "ઓહ ટ્રે એક સ્ટેક જેમ."

56
00:03:20,000 --> 00:03:22,000
તમે ટ્રે ગંજી છે.

57
00:03:22,000 --> 00:03:24,000
પછી તમે ટ્રે ખેંચી જવા જ્યારે,

58
00:03:24,000 --> 00:03:31,000
પ્રથમ ટ્રે કે જેને ખેંચવામાં રહ્યું છે કે છેલ્લા એક કે સ્ટેક પર મૂકવામાં આવ્યું હતું.

59
00:03:31,000 --> 00:03:34,000
તે પણ જેવા સ્ટેક અહીં કહે છે

60
00:03:34,000 --> 00:03:37,000
અમે મેમરીનો સેગમેન્ટમાં સ્ટેક કહેવાય છે.

61
00:03:37,000 --> 00:03:40,000
અને તે સ્ટેક શા માટે કહેવાય છે?

62
00:03:40,000 --> 00:03:42,000
>> કારણ કે સ્ટેક માહિતી બંધારણ જેમ,

63
00:03:42,000 --> 00:03:46,000
તે કોઈ રન નોંધાયો નહીં અને પૉપ સ્ટેક પર સ્ટેક ફ્રેમ્સ,

64
00:03:46,000 --> 00:03:53,000
જ્યાં સ્ટેક ફ્રેમ્સ કાર્ય ચોક્કસ કોલ જેવા છે.

65
00:03:53,000 --> 00:03:57,000
અને સ્ટેક જેમ, તમે હંમેશા પાછા પડશે

66
00:03:57,000 --> 00:04:03,000
એક કાર્ય કૉલ પહેલાં તમે નીચા સ્ટેક ફ્રેમ્સ માં ફરીથી મેળવી શકો છો.

67
00:04:03,000 --> 00:04:08,000
તમે મુખ્ય કૉલ foo કોલ બાર અને બાર મુખ્ય સીધું વળતર ન હોઈ શકે છે.

68
00:04:08,000 --> 00:04:14,000
તે હંમેશા માટે યોગ્ય દબાણ અને ધાણી સ્ટેક અનુસરો મળ્યું છે.

69
00:04:14,000 --> 00:04:18,000
બે ઓપરેશન જેમ હું જણાવ્યું હતું કે, દબાણ અને પોપ છે.

70
00:04:18,000 --> 00:04:20,000
તે સાર્વત્રિક શરતો હોય છે.

71
00:04:20,000 --> 00:04:26,000
તમે અને કોઈ બાબત શું રન ટાઇમ સ્ટેકનું દ્રષ્ટિએ પુશ પૉપ ખબર હોવી જોઇએ.

72
00:04:26,000 --> 00:04:28,000
અમે જોશો ક્યુને અલગ પ્રકારની હોય છે.

73
00:04:28,000 --> 00:04:32,000
તે ખરેખર એક સાર્વત્રિક શબ્દ નથી, પરંતુ દબાણ અને પોપ રન ટાઇમ સ્ટેકનું માટે સાર્વત્રિક હોય છે.

74
00:04:32,000 --> 00:04:34,000
Push ને માત્ર સ્ટેક પર મૂકવામાં આવે છે.

75
00:04:34,000 --> 00:04:37,000
પૉપ છે બંધ સ્ટેક લો.

76
00:04:37,000 --> 00:04:43,000
અને અમે અહીં જોવા અમારા typedef સ્ટ્રક્ટ સ્ટેક હોય છે,

77
00:04:43,000 --> 00:04:46,000
તેથી અમે ઘરનાં પરચૂરણ કામો ** શબ્દમાળાઓ ધરાવે છે.

78
00:04:46,000 --> 00:04:51,000
શું વિચાર કોઈપણ ** દ્વારા ભયભીત.

79
00:04:51,000 --> 00:04:54,000
આ અંત શબ્દમાળાઓ ઝાકઝમાળ છે રહ્યું છે

80
00:04:54,000 --> 00:04:58,000
અથવા પોઇંટરો એક અક્ષરો એરે, જ્યાં

81
00:04:58,000 --> 00:05:00,000
અક્ષરો પોઇંટરો માટે શબ્દમાળાઓ હોય છે.

82
00:05:00,000 --> 00:05:05,000
તે શબ્દમાળાઓ પ્રયત્ન નથી, પરંતુ અહીં, તેઓ શબ્દમાળાઓ પ્રયત્ન રહ્યા છીએ.

83
00:05:05,000 --> 00:05:08,000
>> અમે શબ્દમાળાઓ ઝાકઝમાળ છે.

84
00:05:08,000 --> 00:05:14,000
અમે એક માપ છે, જે દર્શાવે છે કે કેટલી તત્વો સ્ટેક પર હાલમાં છે,

85
00:05:14,000 --> 00:05:19,000
અને પછી અમે ક્ષમતા, કે જે કેટલા તત્વો સ્ટેક પર હોઇ શકે છે.

86
00:05:19,000 --> 00:05:22,000
આ ક્ષમતા બોલ 1 કરતા વધુ કંઈક તરીકે શરૂ થવું જોઈએ,

87
00:05:22,000 --> 00:05:27,000
પરંતુ માપ 0 તરીકે બોલ શરૂ થઈ રહ્યું છે.

88
00:05:27,000 --> 00:05:36,000
હવે, ત્યાં મૂળભૂત રીતે ત્રણ અલગ અલગ રીતે તમે એક સ્ટેક વિચાર કરી શકો છો.

89
00:05:36,000 --> 00:05:39,000
સારું, કદાચ વધુ, પરંતુ બે મુખ્ય માર્ગો છે

90
00:05:39,000 --> 00:05:43,000
તમે તેને અમલમાં ઝાકઝમાળ મદદથી કરી શકો છો, અથવા તમે તેને અમલમાં એક કડી થયેલ યાદી વાપરી રહ્યા હોય.

91
00:05:43,000 --> 00:05:48,000
લિંક કરેલા યાદીઓ પ્રકારની છે માંથી રન ટાઇમ સ્ટેકનું બનાવવા તુચ્છ.

92
00:05:48,000 --> 00:05:51,000
તે ખૂબ જ સરળ છે સંલગ્ન યાદીમાં સ્ટેક કરો,

93
00:05:51,000 --> 00:05:55,000
અહીં, અમે સ્ટેક કરો એરે મદદથી જઈ રહ્યાં છો,

94
00:05:55,000 --> 00:05:59,000
અને પછી એરે વાપરી રહ્યા હોય, ત્યાં પણ બે રીતે તમે એના વિશે વિચારો શકે છે.

95
00:05:59,000 --> 00:06:01,000
પહેલાં, જ્યારે હું જણાવ્યું હતું કે, અમે સ્ટેક માટે ક્ષમતા હોય છે,

96
00:06:01,000 --> 00:06:04,000
તેથી અમે સ્ટેક પર એક તત્વ ફિટ થઈ શકે છે.

97
00:06:04,000 --> 00:06:09,000
>> એક રીતે બની શકે છે તેમ તેમ તમે 10 તત્વો દબાવો, તો પછી તમે પૂર્ણ કરી લો ટૂંક છે.

98
00:06:09,000 --> 00:06:13,000
તમને ખબર છે કે ત્યાં એક વિશ્વમાં 10 વસ્તુઓ બંધાયેલ ઉપલા છે

99
00:06:13,000 --> 00:06:16,000
કે તમે 10 કરતાં વધુ વસ્તુઓ તમારી સ્ટેક પર ક્યારેય પડશે,

100
00:06:16,000 --> 00:06:20,000
જે કિસ્સામાં તમે તમારા સ્ટેક માપ પર બંધાયેલ ઉપર કરી શકે છે.

101
00:06:20,000 --> 00:06:23,000
અથવા તમે કરી શકે છે તમારા સ્ટેક અનબાઉન્ડેડ શકાય છે,

102
00:06:23,000 --> 00:06:27,000
પરંતુ જો તમે એક એરે કરી રહ્યા છીએ, કે અર્થ એ થાય કે દરેક એક સમયે તમે 10 તત્વો દબાવો,

103
00:06:27,000 --> 00:06:29,000
પછી તમે 20 તત્વો વધવા છે જઈ રહ્યાં છો, અને જ્યારે તમે 20 તત્વો દબાવો,

104
00:06:29,000 --> 00:06:33,000
તમે 30 તત્વો અથવા 40 તત્વો તમારા એરે વધવા હોય રહ્યા છીએ.

105
00:06:33,000 --> 00:06:37,000
તમે ક્ષમતા, કે જે અમે શું કરીએ અહીં જઈ રહ્યાં છો વધારો કરવાની જરૂર જઈ રહ્યાં છો.

106
00:06:37,000 --> 00:06:40,000
દરેક એક સમય આપણે સ્ટેક મહત્તમ કદ સુધી પહોંચે છે,

107
00:06:40,000 --> 00:06:46,000
જ્યારે આપણે કંઈક બીજું દબાણ, અમે કરવા માટે ક્ષમતા વધારવા જરૂર જઈ રહ્યાં છો.

108
00:06:46,000 --> 00:06:50,000
અહીં, અમે દબાણ bool પુશ (કોલસો * str) તરીકે જાહેર કર્યું હતું.

109
00:06:50,000 --> 00:06:54,000
ચાર * str શબ્દમાળા કે અમે સ્ટેક પર દબાણ કરવામાં આવે છે,

110
00:06:54,000 --> 00:06:58,000
અને bool માત્ર કહે છે કે શું આપણે સફળ અથવા નિષ્ફળ ગયું.

111
00:06:58,000 --> 00:07:00,000
>> અમે કેવી રીતે નિષ્ફળ કરી શકે છે?

112
00:07:00,000 --> 00:07:04,000
માત્ર એક જ સંજોગોમાં કે તમે વિચાર કરી શકો છો શું છે

113
00:07:04,000 --> 00:07:07,000
જ્યાં અમે ખોટા પરત કરવાની જરૂર છે?

114
00:07:07,000 --> 00:07:09,000
યાહ.

115
00:07:09,000 --> 00:07:12,000
[વિદ્યાર્થી] જો તે સંપૂર્ણ છે અને અમે બંધાયેલી અમલીકરણ ઉપયોગ કરી રહ્યાં છો.

116
00:07:12,000 --> 00:07:17,000
અરે વાહ, તેથી અમે કેવી રીતે વ્યાખ્યાયિત-તેમણે જવાબ આપ્યો નથી

117
00:07:17,000 --> 00:07:23,000
જો તે સંપૂર્ણ છે અને અમે બાઉન્ડેડ અમલીકરણ ઉપયોગ કરી રહ્યાં છો.

118
00:07:23,000 --> 00:07:26,000
ત્યાર બાદ અમે ચોક્કસપણે ખોટી આપશે.

119
00:07:26,000 --> 00:07:31,000
જલદી અમે એરે માં 10 વસ્તુઓ દબાવો, અમે 11 બેસી શકતા નથી, તેથી અમે ખોટા આવો.

120
00:07:31,000 --> 00:07:32,000
જો તે અનબાઉન્ડેડ છે? યાહ.

121
00:07:32,000 --> 00:07:38,000
જો તમે કોઈ કારણસર એરે નથી વધારી શકે છે.

122
00:07:38,000 --> 00:07:43,000
અરે વાહ, જેથી મેમરી મર્યાદિત સ્ત્રોત છે,

123
00:07:43,000 --> 00:07:51,000
અને છેવટે, જો અમે સ્ટેક પર ઉપર અને ઉપર ફરી દબાણ વસ્તુઓ રાખવા માટે,

124
00:07:51,000 --> 00:07:54,000
અમે પ્રયાસ અને એક મોટી એરે ફાળવવા માટે ફિટ જઈ રહ્યાં છો

125
00:07:54,000 --> 00:07:59,000
મોટા ક્ષમતા, અને malloc અથવા જે અમે ઉપયોગ કરી રહ્યાં છો ખોટા પાછા જઈ રહ્યું છે.

126
00:07:59,000 --> 00:08:02,000
વેલ, malloc નલ આપશે.

127
00:08:02,000 --> 00:08:05,000
>> યાદ રાખો, દરેક એક સમય તમે ક્યારેય malloc કૉલ, તમે એ જોવા માટે ચકાસણી થવી જોઈએ જો તે

128
00:08:05,000 --> 00:08:12,000
નલ આપે છે અથવા અન્ય કે જે ચોકસાઈ કપાત છે.

129
00:08:12,000 --> 00:08:17,000
કારણ કે આપણે એક અમાપ સ્ટેક માંગો છો,

130
00:08:17,000 --> 00:08:21,000
માત્ર એક જ કેસ અમે ખોટા પાછો જઈ રહ્યાં છો છે જો અમે પ્રયાસ

131
00:08:21,000 --> 00:08:26,000
ક્ષમતા અને malloc વધારો અથવા જે ખોટા આપે છે.

132
00:08:26,000 --> 00:08:30,000
પછી પોપ કોઈ દલીલો લે છે,

133
00:08:30,000 --> 00:08:37,000
અને તે શબ્દમાળા કે સ્ટેક ટોચ પર છે આપે છે.

134
00:08:37,000 --> 00:08:41,000
ગમે તાજેતરમાં સ્ટેક પર દબાણ આવ્યું હતું પોપ શું પરત આવે છે,

135
00:08:41,000 --> 00:08:44,000
અને તે પણ તે સ્ટેક દૂર કરે છે.

136
00:08:44,000 --> 00:08:50,000
નોટિસ અને તે નલ આપે છે જો ત્યાં સ્ટેક પર કંઈ નથી.

137
00:08:50,000 --> 00:08:53,000
તે હંમેશા શક્ય છે કે સ્ટેક ખાલી છે.

138
00:08:53,000 --> 00:08:55,000
જાવા, જો કે તમે, અથવા અન્ય ભાષાઓ માટે ઉપયોગ કરી રહ્યાં છો,

139
00:08:55,000 --> 00:09:01,000
એક ખાલી સ્ટેક માંથી પૉપ પ્રયાસ કરી અપવાદ અથવા કંઈક થઇ શકે છે.

140
00:09:01,000 --> 00:09:09,000
>> પરંતુ સી, નલ કિસ્સાઓ કેવી રીતે અમે આ સમસ્યા હેન્ડલ ઘણાં પ્રકારની છે.

141
00:09:09,000 --> 00:09:13,000
નલ પરત કેવી રીતે અમે મહત્વપૂર્ણ રીતે સ્ટેક ખાલી હતી રહ્યા છીએ.

142
00:09:13,000 --> 00:09:16,000
અમે કોડ કે જે તમારા સ્ટેક કાર્યક્ષમતા ચકાસવા કરશે પ્રદાન કરેલો,

143
00:09:16,000 --> 00:09:19,000
દબાણ અને પૉપ અમલ.

144
00:09:19,000 --> 00:09:23,000
આ કોડ ઘણો હશે નહિં.

145
00:09:23,000 --> 00:09:40,000
હું ખરેખર કરશે, પહેલા અમે તે કરવા માટે, હિંટ, સંકેતની-

146
00:09:40,000 --> 00:09:44,000
જો તમે તેને જોઇ ન હોય, malloc માત્ર એક જ કાર્ય નથી

147
00:09:44,000 --> 00:09:47,000
કે તમારા માટે ઢગલો પર મેમરી ફાળવે છે.

148
00:09:47,000 --> 00:09:51,000
ત્યાં alloc વિધેયો એક કુટુંબ છે.

149
00:09:51,000 --> 00:09:53,000
પ્રથમ malloc છે, જે તમે ઉપયોગ કરી રહ્યાં છો છે.

150
00:09:53,000 --> 00:09:56,000
તો પછી ત્યાં calloc છે, કે જે malloc તરીકે જ વાત કરે છે,

151
00:09:56,000 --> 00:09:59,000
પરંતુ તે બધું તમારા માટે બહાર શૂન્ય કરશે.

152
00:09:59,000 --> 00:10:04,000
જો તમે ક્યારેય કંઈક mallocing પછી કર્યું બધું સેટ કરવા માગે છે null

153
00:10:04,000 --> 00:10:06,000
તમે હમણાં જ લખવા ના બદલે પ્રથમ સ્થાને હોવા જોઈએ calloc ઉપયોગ

154
00:10:06,000 --> 00:10:09,000
બહાર મેમરી સમગ્ર બ્લોક શૂન્ય લૂપ માટે.

155
00:10:09,000 --> 00:10:15,000
>> Realloc malloc જેવું છે અને ખાસ કિસ્સાઓમાં ઘણો છે,

156
00:10:15,000 --> 00:10:19,000
પરંતુ મૂળભૂત રીતે realloc શું કરે છે

157
00:10:19,000 --> 00:10:24,000
તે નિર્દેશક જે પહેલેથી ફાળવણી કરવામાં આવી હતી લઈ જાય છે.

158
00:10:24,000 --> 00:10:27,000
Realloc કાર્ય તમે ધ્યાન અહીં ભરવા શકાય માંગો છો.

159
00:10:27,000 --> 00:10:31,000
તે એક નિર્દેશક જે પહેલેથી malloc કરી હતી પરત કરવામાં લે છે.

160
00:10:31,000 --> 00:10:35,000
હવે કહો કે તમે malloc થી 10 બાઇટ્સ એક નિર્દેશક વિનંતી છે.

161
00:10:35,000 --> 00:10:38,000
ત્યાર બાદ તમે સમજો છો કે તમને 20 બાઇટ્સ માગતા હતા,

162
00:10:38,000 --> 00:10:42,000
જેથી તમે 20 બાઇટ્સ સાથે નિર્દેશક પર realloc કહી,

163
00:10:42,000 --> 00:10:47,000
અને realloc તમારા માટે આપોઆપ બધું પર નકલ થશે.

164
00:10:47,000 --> 00:10:51,000
જો તમે હમણાં malloc ફરીથી કહેવાય છે, જેમ હું 10 બાઇટ્સ એક બ્લોક છે.

165
00:10:51,000 --> 00:10:53,000
હવે હું 20 બાઇટ્સ એક બ્લોક જરૂર છે,

166
00:10:53,000 --> 00:10:58,000
જેથી હું 20 બાઇટ્સ malloc જો, પછી હું જાતે પર પ્રથમ વસ્તુ ના 10 બાઇટ્સ નકલ હોય છે

167
00:10:58,000 --> 00:11:01,000
બીજી વસ્તુ માં અને તે પછી પ્રથમ વસ્તુ મફત.

168
00:11:01,000 --> 00:11:04,000
Realloc તમારા માટે કે હેન્ડલ કરશે.

169
00:11:04,000 --> 00:11:11,000
>> નોટિસ સહી કરવા માટે રદબાતલ * પ્રયત્ન રહ્યું છે,

170
00:11:11,000 --> 00:11:15,000
જે ફક્ત મેમરી બ્લોક માટે છે નિર્દેશક પરત,

171
00:11:15,000 --> 00:11:17,000
પછી રદબાતલ * ptr.

172
00:11:17,000 --> 00:11:22,000
તમે રદબાતલ * એક સામાન્ય નિર્દેશક તરીકે વિચાર કરી શકો છો.

173
00:11:22,000 --> 00:11:27,000
સામાન્ય રીતે, ખાલીપણુ * સાથે તમે ક્યારેય ડીલ

174
00:11:27,000 --> 00:11:30,000
પરંતુ malloc એક રદબાતલ * પરત આવે છે, અને પછી તેને જેમ ઉપયોગ

175
00:11:30,000 --> 00:11:34,000
આ ખરેખર એક કોલસો બનાવો * પ્રયત્ન રહ્યું છે.

176
00:11:34,000 --> 00:11:37,000
અગાઉના રદબાતલ * કે malloc દ્વારા કરવામાં ફર્યા હતા

177
00:11:37,000 --> 00:11:41,000
હવે realloc પસાર કરી જવાનું, અને પછી કદ

178
00:11:41,000 --> 00:11:49,000
બાઇટ્સ તમે ફાળવણી કરવા માંગો છો નવા નંબર છે, તેથી તમારા નવા ક્ષમતા છે.

179
00:11:49,000 --> 00:11:57,000
હું તમને એક દંપતી મિનિટ આપો પડશે અને તે અમારી જગ્યા કામ કરે છે.

180
00:11:57,000 --> 00:12:02,000
1 પૂનરાવર્તન સાથે શરૂ કરો.

181
00:12:16,000 --> 00:12:21,000
હું તમને માટે પૂરતી દબાણ અમલ સમય વિશે પછી આસ્થાપૂર્વક બંધ થશે,

182
00:12:21,000 --> 00:12:24,000
અને પછી હું તમને બીજા પોપ કરવું વિરામ આપવા પડશે.

183
00:12:24,000 --> 00:12:27,000
પરંતુ તે ખરેખર છે કે ખૂબ કોડ તમામ નથી.

184
00:12:27,000 --> 00:12:35,000
સૌથી કોડ કદાચ વિસ્તરતા સામગ્રી છે, ક્ષમતા વિસ્તરણ કર્યું હતું.

185
00:12:35,000 --> 00:12:39,000
ઠીક છે, કોઈ સંપૂર્ણપણે થઈ દબાણ,

186
00:12:39,000 --> 00:12:47,000
પરંતુ જ્યાં સુધી તમને લાગે છે કે તમે સાચો માર્ગ પર કરશો, તે સારી છે.

187
00:12:47,000 --> 00:12:53,000
>> શું કોઇને કોઇ કોડ તેઓ મને અપ ખેંચીને સાથે આરામદાયક લાગે છે?

188
00:12:53,000 --> 00:12:59,000
અરે વાહ, હું, પરંતુ તે કોઈપણ કોઈપણ કોડ મેં ખેંચી શકે છે થશે?

189
00:12:59,000 --> 00:13:05,000
ઠીક છે, તમે શરૂ કરવા માટે, તેને સાચવી શકો છો, ગમે છે?

190
00:13:05,000 --> 00:13:09,000
હું હંમેશા તે પગલું ભૂલી જાવ.

191
00:13:09,000 --> 00:13:15,000
ઠીક છે, પુશ અંતે looking,

192
00:13:15,000 --> 00:13:18,000
તમે તમારા કોડ સમજાવવા માંગો છો?

193
00:13:18,000 --> 00:13:24,000
[વિદ્યાર્થી] ફર્સ્ટ બધી, હું કદ વધારો થયો છે.

194
00:13:24,000 --> 00:13:28,000
હું માનું મારે જે રીતે હોવું જોઈએ, હું કદ વધારો થયો હતો,

195
00:13:28,000 --> 00:13:31,000
અને હું એ જોવા કે તે ક્ષમતા કરતાં ઓછી છે.

196
00:13:31,000 --> 00:13:36,000
અને જો તે ક્ષમતા કરતાં ઓછી છે, હું એરે કે અમે પહેલાથી જ હોય ​​ઉમેરો.

197
00:13:36,000 --> 00:13:42,000
અને જો તેમાં તે નથી, હું 2 દ્વારા ક્ષમતા મલ્ટીપ્લાય,

198
00:13:42,000 --> 00:13:50,000
અને હું કંઇક કરવા માટે શબ્દમાળાઓ એરે હવે reallocate મોટી ક્ષમતા માપ સાથે.

199
00:13:50,000 --> 00:13:55,000
અને પછી જો કે નિષ્ફળ જાય, તો હું વપરાશકર્તા કહેવું અને ખોટા પાછા ફરવા માટે,

200
00:13:55,000 --> 00:14:04,000
અને જો તે દંડ છે, પછી હું નવી જગ્યા શબ્દમાળા મૂકે છે.

201
00:14:04,000 --> 00:14:07,000
>> [રોબ બી] આ પણ નોંધ્યું છે કે અમે એક સરસ bitwise ઓપરેટર અંહિ વપરાય

202
00:14:07,000 --> 00:14:09,000
માટે 2 દ્વારા વધવું.

203
00:14:09,000 --> 00:14:11,000
યાદ રાખો, ડાબી પાળી હંમેશા 2 દ્વારા ગુણાકાર કરી રહ્યું છે.

204
00:14:11,000 --> 00:14:15,000
અધિકાર પાળી 2 દ્વારા લાંબા તરીકે વહેંચવામાં આવે છે કારણ કે તમે યાદ રાખો કે એનો અર્થ

205
00:14:15,000 --> 00:14:18,000
એક 2 દ્વારા વિભાજી પૂર્ણાંક તરીકે 2 દ્વારા વહેંચાય છે.

206
00:14:18,000 --> 00:14:20,000
તે અહીં અથવા ત્યાં 1 ટૂંકાવીને શકે છે.

207
00:14:20,000 --> 00:14:26,000
પરંતુ 1 દ્વારા છોડી પાળી હંમેશા 2 દ્વારા ગુણાકાર કરી રહ્યું છે,

208
00:14:26,000 --> 00:14:32,000
તમે પૂર્ણાંક સીમાડાં ઓવરફ્લો સિવાય, અને પછી તેને રહેશે નહીં.

209
00:14:32,000 --> 00:14:34,000
એક બાજુ ટિપ્પણી.

210
00:14:34,000 --> 00:14:39,000
હું શું-માટે આ કોઈપણ રીતે બિલકુલ કોડિંગ બદલી ન રહ્યું છે ગમે,

211
00:14:39,000 --> 00:14:48,000
પરંતુ હું આ કંઈક કરવું ગમશે.

212
00:14:48,000 --> 00:14:51,000
તે વાસ્તવમાં તેને સહેજ લાંબા સમય સુધી કરી રહ્યા છે.

213
00:15:04,000 --> 00:15:08,000
કદાચ આ સંપૂર્ણ આ બતાવવા કેસ નથી,

214
00:15:08,000 --> 00:15:14,000
પરંતુ હું સેગમેન્ટમાં કરવા માંગો તેનો આ બ્લોકમાં

215
00:15:14,000 --> 00:15:17,000
ઠીક, જો આ જો આવું થાય, તો પછી હું કંઈક કરવા જાઉં છું,

216
00:15:17,000 --> 00:15:19,000
અને પછી કાર્ય કરવામાં આવે છે.

217
00:15:19,000 --> 00:15:22,000
હું પછી મારી આંખોમાં કામગીરી નીચે બધી રીતે સ્ક્રોલ જરૂર નથી

218
00:15:22,000 --> 00:15:25,000
શું બીજું બાદ આવું થાય છે.

219
00:15:25,000 --> 00:15:27,000
તે જો આ જો આવું થાય, તો પછી હું ફક્ત આવો.

220
00:15:27,000 --> 00:15:30,000
તે પણ આ બધું બહાર ના સરસ વધારાના લાભ ધરાવે છે

221
00:15:30,000 --> 00:15:33,000
હવે એક વાર છોડી ખસેડાયેલો.

222
00:15:33,000 --> 00:15:40,000
હું લાંબા સમય સુધી-જો તમે ક્યારેય હાસ્યજનક રીતે લાંબા લીટીઓ નજીક જરૂર છે,

223
00:15:40,000 --> 00:15:45,000
પછી તે 4 બાઇટ્સ મદદ, અને વધુ ડાબેરી કંઈક છે,

224
00:15:45,000 --> 00:15:48,000
ઓછા ભરાઈ ગયાં તમને લાગે જો ગમે-ઠીક, હું યાદ છે

225
00:15:48,000 --> 00:15:53,000
હું લૂપ માટે એક બીજું અંદર અંદર એક જ્યારે લૂપ હાલમાં છું.

226
00:15:53,000 --> 00:15:58,000
તમે ગમે ત્યાં આ વળતર તુરંત જ કરી શકે છે, હું પ્રકારની જેમ.

227
00:15:58,000 --> 00:16:05,000
તે તદ્દન વૈકલ્પિક છે અને કોઈપણ રીતે થવાની ધારણા છે.

228
00:16:05,000 --> 00:16:12,000
>> [વિદ્યાર્થી] ત્યાં કદ હોવું જોઇએ - આ નિષ્ફળ શરત છે?

229
00:16:12,000 --> 00:16:19,000
આ નિષ્ફળ અહીં શરત અમે realloc નિષ્ફળ છે, તેથી હા.

230
00:16:19,000 --> 00:16:22,000
આ નિષ્ફળ સ્થિતિ કેવી રીતે કદાચ નોટિસ,

231
00:16:22,000 --> 00:16:26,000
પછી અમે મફત સામગ્રી સિવાય, અમે હંમેશા નિષ્ફળ જઈ રહ્યાં છો

232
00:16:26,000 --> 00:16:29,000
કોઈ બાબત કેટલી વખત અમે કંઈક દબાણ કરવાનો પ્રયાસ કરો.

233
00:16:29,000 --> 00:16:32,000
જો અમે દબાણ રાખવા, અમે incrementing માપ રાખવું,

234
00:16:32,000 --> 00:16:36,000
તેમ છતાં અમે કોઇ સ્ટેક પર ન મૂકવા આવે છે.

235
00:16:36,000 --> 00:16:39,000
સામાન્ય રીતે આપણે ત્યાં સુધી કદ નથી વધારતી નથી

236
00:16:39,000 --> 00:16:43,000
પછી અમે સફળતાપૂર્વક સ્ટેક પર છે તે મૂકે છે.

237
00:16:43,000 --> 00:16:50,000
અમે તે કરવા માટે, કહેવું હો, ક્યાં અહીં અને અહીં.

238
00:16:50,000 --> 00:16:56,000
અને પછી તેની જગ્યાએ કહેતા ≤ ક્ષમતા s.size છે, આ ક્ષમતા કરતાં ઓછી છે,

239
00:16:56,000 --> 00:17:01,000
માત્ર કારણ કે અમે આવ્યા, જ્યાં બધું હતું.

240
00:17:01,000 --> 00:17:07,000
>> અને યાદ રાખો, માત્ર જગ્યા કે અમે કદાચ ખોટા પરત કરી શકે છે

241
00:17:07,000 --> 00:17:14,000
અહીં છે, જ્યાં realloc નલ પાછો ફર્યો,

242
00:17:14,000 --> 00:17:19,000
અને જો તમે પ્રમાણભૂત ભૂલ યાદ થાય છે,

243
00:17:19,000 --> 00:17:22,000
કદાચ તમને આ કેસ વિચારણા જ્યાં તમે પ્રમાણભૂત ભૂલ છાપી શકો છો,

244
00:17:22,000 --> 00:17:26,000
માત્ર ધોરણ બહાર સીધી છાપવા બદલે જેથી fprintf stderr.

245
00:17:26,000 --> 00:17:31,000
ફરીથી, કે અપેક્ષા નથી, પરંતુ જો તે એક ભૂલ છે,

246
00:17:31,000 --> 00:17:41,000
printf લખો, પછી તમે તેને પ્રમાણભૂત બહાર બદલે પ્રમાણભૂત ભૂલ છાપવાનો શકો છો.

247
00:17:41,000 --> 00:17:44,000
>> કોઈપણ જે કંઈપણ નોંધ છે? હા.

248
00:17:44,000 --> 00:17:47,000
[વિદ્યાર્થી] એ તમને [અશ્રાવ્ય] પર જાઓ શકું?

249
00:17:47,000 --> 00:17:55,000
[રોબ બી] હા, તેનો વાસ્તવિક binariness અથવા માત્ર તે શું?

250
00:17:55,000 --> 00:17:57,000
[વિદ્યાર્થી] તેથી તમે તેને 2 દ્વારા મલ્ટીપ્લાય?

251
00:17:57,000 --> 00:17:59,000
[રોબ બી] અરે વાહ, મૂળભૂત રીતે.

252
00:17:59,000 --> 00:18:11,000
દ્વિસંગી જમીન, અમે હંમેશા અંકો અમારી સમૂહ છે.

253
00:18:11,000 --> 00:18:22,000
1 દ્વારા આ ડાબી સ્થળાંતર મૂળભૂત તેને જમણી બાજુ પર અહીં દાખલ.

254
00:18:22,000 --> 00:18:25,000
પાછા આ, માત્ર દ્વિસંગી કે બધું યાદ

255
00:18:25,000 --> 00:18:28,000
2 ની શક્તિ છે, તેથી આ 0 થી 2 રજૂ કરે છે,

256
00:18:28,000 --> 00:18:30,000
1 આ 2, આ 2 માટે 2.

257
00:18:30,000 --> 00:18:33,000
જમણી બાજુએ એક 0 હવે દાખલ કરીને, અમે હમણાં જ બધું પાળી પર.

258
00:18:33,000 --> 00:18:38,000
શું 0 ને 2 હવે 1 હોય છે માટે 2, 2 2 માટે છે.

259
00:18:38,000 --> 00:18:41,000
જમણી બાજુ કે અમે શામેલ

260
00:18:41,000 --> 00:18:44,000
છે જરૂરી માટે 0 હશે,

261
00:18:44,000 --> 00:18:46,000
જે અર્થમાં બનાવે છે.

262
00:18:46,000 --> 00:18:49,000
જો તમે ક્યારેય 2 દ્વારા એક સંખ્યાના ગુણાંકમાં હોય, તો તે અપ વિચિત્ર અંત નથી ચાલી રહ્યું છે,

263
00:18:49,000 --> 00:18:54,000
તેથી 0 સ્થળ માટે 2 0 હોવો જોઈએ,

264
00:18:54,000 --> 00:18:59,000
અને આ છે જે હું અડધી પહેલા અંગે ચેતવણી આપી હતી કે જો તમે પાળી થાય નથી

265
00:18:59,000 --> 00:19:01,000
પૂર્ણાંક માં બિટ્સ સંખ્યા ઉપરાંત,

266
00:19:01,000 --> 00:19:04,000
તો પછી આ 1 થી અંત બોલ જઈને રહ્યું છે.

267
00:19:04,000 --> 00:19:10,000
કે માત્ર એ જ ચિંતા છે જો તમે ખરેખર મોટી ક્ષમતા સાથે વ્યવહાર કરવામાં થાય છે.

268
00:19:10,000 --> 00:19:15,000
પરંતુ તે સમયે, પછી તમે વસ્તુઓ અબજો ઝાકઝમાળ સાથે કામ કરીએ છીએ,

269
00:19:15,000 --> 00:19:25,000
જે મેમરીમાં રીતે ફિટ ન શકે.

270
00:19:25,000 --> 00:19:31,000
>> હવે અમે પોપ, કે જે વધુ સરળ છે મેળવી શકો છો.

271
00:19:31,000 --> 00:19:36,000
તમે તેને નથી જો તમે આખું ટોળું પૉપ થાય માંગો શકે છે,

272
00:19:36,000 --> 00:19:38,000
અને હવે તમે અડધા ક્ષમતા પર ફરીથી છો.

273
00:19:38,000 --> 00:19:42,000
તમે મેમરીનો જથ્થો તમારી પાસે સંકોચો realloc શકે છે,

274
00:19:42,000 --> 00:19:47,000
પરંતુ તમે તે અંગે ચિંતા કરવાની જરૂર નથી, તેથી માત્ર realloc કેસ પ્રયત્ન રહ્યું છે

275
00:19:47,000 --> 00:19:50,000
મેમરી વધતી ઘટાડાથી મેમરી ક્યારેય,

276
00:19:50,000 --> 00:19:59,000
જે પોપ સુપર સરળ બનાવવા જઈ રહ્યું છે.

277
00:19:59,000 --> 00:20:02,000
હવે ક્યુને, કે જે રન ટાઇમ સ્ટેકનું જેવો હોવો જવું છે,

278
00:20:02,000 --> 00:20:06,000
પરંતુ ક્રમમાં છે કે જે તમને વસ્તુઓ બહાર લઇ જવા માટે વિપરીત છે.

279
00:20:06,000 --> 00:20:10,000
એક કતાર ઓફ અજમાયશી ઉદાહરણ એક વાક્ય છે,

280
00:20:10,000 --> 00:20:12,000
તેથી હું માનું જો તમે ઇંગલિશ હતા, મેં કહ્યું હોત

281
00:20:12,000 --> 00:20:17,000
એક કતાર એક અજમાયશી ઉદાહરણ એક કતાર છે.

282
00:20:17,000 --> 00:20:22,000
તેથી લીટી જેમ, જો તમે લીટી માં પ્રથમ વ્યક્તિ છો,

283
00:20:22,000 --> 00:20:24,000
તમે વાક્ય બહાર પ્રથમ વ્યક્તિ પ્રયત્ન અપેક્ષા.

284
00:20:24,000 --> 00:20:31,000
જો તમે વાક્ય છેલ્લા વ્યક્તિ છો, તો તમે છેલ્લા સેવા વ્યક્તિ હશે આવે છે.

285
00:20:31,000 --> 00:20:35,000
અમે તે FIFO પેટર્ન કૉલ, જ્યારે સ્ટેક LIFO પેટર્ન હતી.

286
00:20:35,000 --> 00:20:40,000
તે શબ્દો ખૂબ સાર્વત્રિક હોય છે.

287
00:20:40,000 --> 00:20:46,000
>> રન ટાઇમ સ્ટેકનું જેમ અને એરે વિપરીત, ક્યુને ખાસ મધ્યમાં તત્વો ઍક્સેસ મંજૂરી આપતા નથી.

288
00:20:46,000 --> 00:20:50,000
અહીં, સ્ટેક, અમે દબાણ અને પોપ હોય છે.

289
00:20:50,000 --> 00:20:54,000
અહીં, અમે તેમને કહેવાય એન્ક્યૂ અને dequeue છે થાય છે.

290
00:20:54,000 --> 00:20:58,000
હું પણ સાંભળ્યું ન હોય તેમને પાળી અને unshift કહેવાય છે.

291
00:20:58,000 --> 00:21:02,000
હું સાંભળી કર્યું છે લોકો કહે છે દબાણ અને પોપ પણ ક્યુને લાગુ પડે છે.

292
00:21:02,000 --> 00:21:05,000
હું સાંભળ્યું દાખલ કરો, દૂર કરવા,

293
00:21:05,000 --> 00:21:11,000
તેથી દબાણ અને પૉપ, જો તમે રન ટાઇમ સ્ટેકનું વિશે વાત કરે છે, તો તમે દબાણ છે અને ધાણી.

294
00:21:11,000 --> 00:21:16,000
જો તમે ક્યુને વિશે વાત કરી રહ્યાં છો, તમે જે શબ્દોના તમે ઉપયોગ કરવા માંગો છો લઇ શકે

295
00:21:16,000 --> 00:21:23,000
નિવેશ અને દૂર કરવા માટે, અને ત્યાં તે કહેવાય કરીશું પર કોઈ સર્વસંમતિ છે.

296
00:21:23,000 --> 00:21:27,000
પરંતુ અહીં, અમે એન્ક્યૂ અને dequeue છે.

297
00:21:27,000 --> 00:21:37,000
હવે, સ્ટ્રક્ટ લગભગ સ્ટેક સ્ટ્રક્ટ સમાન દેખાય છે.

298
00:21:37,000 --> 00:21:40,000
પરંતુ અમે વડા સાચવી રાખે છે.

299
00:21:40,000 --> 00:21:44,000
હું માનું તે અહીં કહે છે, પરંતુ અમે માથામાં શા માટે જરૂરી છે?

300
00:21:53,000 --> 00:21:57,000
આ પ્રોટોટાઇપ મૂળભૂત પર દબાણ અને પૉપ સમાન છે.

301
00:21:57,000 --> 00:21:59,000
તમે તેના દબાણ અને પોપ તરીકે વિચાર કરી શકો છો.

302
00:21:59,000 --> 00:22:08,000
માત્ર એટલો જ તફાવત છે પોપ નિર્વાચન બદલે છેલ્લા ના હોય, તો તે છે પ્રથમ ફર્યા હતા.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, અથવા કંઈક.

304
00:22:12,000 --> 00:22:14,000
અને અહીં શરૂઆત છે.

305
00:22:14,000 --> 00:22:17,000
અમારા કતાર સંપૂર્ણપણે પૂર્ણ છે, તેથી તેમાં ચાર તત્વો છે.

306
00:22:17,000 --> 00:22:21,000
અમારા કતાર ઓવરને હાલમાં 2,

307
00:22:21,000 --> 00:22:24,000
અને હવે અમે કંઈક બીજું દાખલ જાઓ.

308
00:22:24,000 --> 00:22:29,000
>> જ્યારે અમે સ્ટેક આવૃત્તિ માટે કે કંઈક બીજું, અમે શું કર્યું સામેલ કરવા માંગો છો

309
00:22:29,000 --> 00:22:36,000
તો અમે મેમરી અમારા બ્લોક વિસ્તારી.

310
00:22:36,000 --> 00:22:40,000
આ સાથે સમસ્યા શું છે?

311
00:22:40,000 --> 00:22:45,000
[વિદ્યાર્થી] તમે 2 ખસેડો.

312
00:22:45,000 --> 00:22:51,000
હું શું કતાર ઓવરને વિશે પહેલાં જણાવ્યું હતું કે,

313
00:22:51,000 --> 00:22:57,000
આ 1 અંતે અર્થમાં કે અમે શરૂ નથી,

314
00:22:57,000 --> 00:23:01,000
તો પછી અમે 1 dequeue કરવા માંગો છો, dequeue પછી 3, પછી 4 dequeue,

315
00:23:01,000 --> 00:23:05,000
dequeue પછી 2, પછી આ એક dequeue.

316
00:23:05,000 --> 00:23:08,000
અમે realloc હવે ઉપયોગ કરી શકતા નથી,

317
00:23:08,000 --> 00:23:11,000
અથવા ખૂબ જ ઓછામાં ઓછા કરવા માટે, તમને અલગ રીતે realloc ઉપયોગ કરે છે.

318
00:23:11,000 --> 00:23:15,000
પરંતુ તમે કદાચ માત્ર realloc ઉપયોગ કરવો ન જોઈએ.

319
00:23:15,000 --> 00:23:18,000
તમે જાતે તમારી મેમરી નકલ હોય જતાં હોય છે.

320
00:23:18,000 --> 00:23:21,000
>> ત્યાં બે મેમરી નકલ વિધેયો છે.

321
00:23:21,000 --> 00:23:25,000
ત્યાં memcopy અને memmove છે.

322
00:23:25,000 --> 00:23:29,000
હું હાલમાં મદદ પાનાંઓ વાંચી રહ્યો છું તે જોવા માટે એક કે જે તમે ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો.

323
00:23:29,000 --> 00:23:35,000
ઠીક છે, memcopy, આ તફાવત એ છે

324
00:23:35,000 --> 00:23:38,000
કે memcopy અને memmove, એક કેસ યોગ્ય રીતે સંભાળે છે

325
00:23:38,000 --> 00:23:41,000
તમે જ્યાં પ્રદેશ કે પ્રદેશ ઓવરલેપ થાય છે માં નકલ કરી રહ્યા છીએ

326
00:23:41,000 --> 00:23:46,000
તમે નકલ કરી રહ્યા છો.

327
00:23:46,000 --> 00:23:50,000
Memcopy તે હેન્ડલ નથી. Memmove કરે છે.

328
00:23:50,000 --> 00:23:59,000
તમે જેમ સમસ્યા વિચાર કરી શકો છો

329
00:23:59,000 --> 00:24:09,000
ચાલો કહે હું આ વ્યક્તિ નકલ કરવા માંગો છો,

330
00:24:09,000 --> 00:24:13,000
આ બોલ વ્યક્તિ માટે આ ચાર.

331
00:24:13,000 --> 00:24:16,000
અંતે, એરે શું જેવો હવો જોઈએ

332
00:24:16,000 --> 00:24:26,000
પછી નકલ 2, 1, 2, 1, 3, 4, અને પછી ઓવરને અંતે કેટલાક સામગ્રી છે.

333
00:24:26,000 --> 00:24:29,000
પરંતુ આ ક્રમ કે જેમાં આપણે ખરેખર નકલ પર આધારિત છે,

334
00:24:29,000 --> 00:24:32,000
જો આપણે એ હકીકત છે કે આ વિસ્તારમાં અમે માં નકલ કરી રહ્યા છો તેવું વિચારતા નથી કારણ કે

335
00:24:32,000 --> 00:24:35,000
ઓવરલેપ એક અમે માંથી નકલ કરી રહ્યા છો,

336
00:24:35,000 --> 00:24:46,000
તો પછી અમે પ્રારંભ જેવા અહીં, કદાચ સ્થળ અમે જવા માગતા માં 2 નકલ,

337
00:24:46,000 --> 00:24:52,000
પછી અમારી પોઇંટરો આગળ વધો.

338
00:24:52,000 --> 00:24:56,000
>> હવે અમે અહીં અને અહીં જઈ રહ્યાં છો, અને હવે અમે સાથે નકલ કરવા માંગો છો

339
00:24:56,000 --> 00:25:04,000
આ વ્યક્તિ પર આ વ્યક્તિ અને અમારા પોઇંટરો આગળ વધો.

340
00:25:04,000 --> 00:25:07,000
અમે અંત મેળવવાની જઈ રહ્યાં છો શું 2 છે, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
તેના બદલે યોગ્ય 2 ના, 1, 2, 1, 3, 4 કારણ કે

342
00:25:10,000 --> 00:25:15,000
1 2, મૂળ 3, 4 overrode.

343
00:25:15,000 --> 00:25:19,000
Memmove કે યોગ્ય રીતે સંભાળે છે.

344
00:25:19,000 --> 00:25:23,000
આ કિસ્સામાં, મૂળભૂત રીતે માત્ર હંમેશા memmove ઉપયોગ

345
00:25:23,000 --> 00:25:26,000
કારણ કે તે યોગ્ય રીતે સંભાળે છે.

346
00:25:26,000 --> 00:25:29,000
તે સામાન્ય રીતે કોઈ પણ ખરાબ નથી કરવા નથી.

347
00:25:29,000 --> 00:25:32,000
આ વિચાર શરૂઆતથી શરૂ અને આ રીતે નકલ બદલે છે

348
00:25:32,000 --> 00:25:35,000
જેમ અમે અહીં આપી હતી, તે અંતથી શરૂ થાય છે અને નકલ કરે છે,

349
00:25:35,000 --> 00:25:38,000
અને તે કિસ્સામાં, તમે એક સમસ્યા ક્યારેય હોઈ શકે છે.

350
00:25:38,000 --> 00:25:40,000
ત્યાં કોઈ પ્રભાવ ગુમાવી છે.

351
00:25:40,000 --> 00:25:47,000
હંમેશા memmove વાપરો. ચિંતા ક્યારેય memcopy વિશે.

352
00:25:47,000 --> 00:25:51,000
અને તે છે જ્યાં તમે અલગ memmove હોય રહ્યા છીએ

353
00:25:51,000 --> 00:26:01,000
આવરિત-આસપાસ તમારી કતાર ના ભાગ.

354
00:26:01,000 --> 00:26:04,000
કોઈ ચિંતાઓ જો નહિં સંપૂર્ણપણે થાય છે.

355
00:26:04,000 --> 00:26:10,000
આ વધુ સ્ટેક, પુશ પૉપ, અને કરતાં મુશ્કેલ છે.

356
00:26:10,000 --> 00:26:15,000
>> કોઈપણ કોઈપણ કોડ આપણે સાથે કામ કરી શકે છે છે?

357
00:26:15,000 --> 00:26:21,000
પણ સંપૂર્ણપણે અપૂર્ણ જો?

358
00:26:21,000 --> 00:26:23,000
[વિદ્યાર્થી] અરે વાહ, તેને સંપૂર્ણપણે અપૂર્ણ છે, જોકે.

359
00:26:23,000 --> 00:26:27,000
સંપૂર્ણપણે અપૂર્ણ સુધી દંડ છે કારણકે આપણે-કરી શકો છો પુનરાવર્તન સાચવવા માંગો છો?

360
00:26:27,000 --> 00:26:32,000
હું કે દરેક એક સમય ભૂલી જાવ.

361
00:26:32,000 --> 00:26:39,000
ઠીક છે, શું રાખવાની થાય છે જ્યારે અમે વસ્તુઓ માપ બદલવા જરૂર છે.

362
00:26:39,000 --> 00:26:42,000
સંપૂર્ણપણે પુન: માપ અવગણો.

363
00:26:42,000 --> 00:26:49,000
આ કોડ સમજાવો.

364
00:26:49,000 --> 00:26:54,000
હું સૌ પ્રથમ ચકાસણી છું જો કદ તમામ પ્રથમ નકલ કરતાં ઓછી હોય

365
00:26:54,000 --> 00:27:01,000
અને પછી તે પછી, હું દાખલ હું + + વડા માપ લે છે,

366
00:27:01,000 --> 00:27:05,000
અને મને ખાતરી છે કે તે એરે ક્ષમતા આસપાસ આવરણમાં બનાવવા માટે,

367
00:27:05,000 --> 00:27:08,000
અને મને તે સ્થાને નવા શબ્દમાળા દાખલ કરો.

368
00:27:08,000 --> 00:27:12,000
પછી હું કદ વધારો અને સાચું આવો.

369
00:27:12,000 --> 00:27:22,000
>> [રોબ બી] આ ચોક્કસપણે એક તે કિસ્સાઓ છે કે જ્યાં તમે મોડ ઉપયોગ કરવા માંગો છો જઈ રહ્યાં છો છે.

370
00:27:22,000 --> 00:27:25,000
કેસ કોઈપણ પ્રકારનું જ્યાં તમે આસપાસ રેપિંગ છે, જો તમે આસપાસ રેપિંગ વિચારો,

371
00:27:25,000 --> 00:27:29,000
તાત્કાલિક વિચાર મોડ પ્રયત્ન કરીશું.

372
00:27:29,000 --> 00:27:36,000
એક ઝડપી ઓપ્ટિમાઇઝેશન તરીકે / તમારો કોડ એક વાક્ય ટૂંકા બનાવે છે,

373
00:27:36,000 --> 00:27:42,000
તમે નોંધ્યું છે કે લીટી તરત જ એક આ બાદ

374
00:27:42,000 --> 00:27:53,000
માત્ર માપ છે + +, જેથી તમે મર્જ કરો કે આ લીટી માં, કદ + +.

375
00:27:53,000 --> 00:27:58,000
હવે નીચે અહીં, અમે કેસ હોય છે

376
00:27:58,000 --> 00:28:01,000
અમે પૂરતી મેમરી જ્યાં નથી,

377
00:28:01,000 --> 00:28:05,000
તેથી અમે 2 કરીને અમારી ક્ષમતા વધી રહી છે.

378
00:28:05,000 --> 00:28:09,000
હું માનું તમે જ સમસ્યા અહીં હોઇ શકે છે, પરંતુ અમે તે હવે અવગણી શકો છો,

379
00:28:09,000 --> 00:28:13,000
જ્યાં જો તમે તમારી ક્ષમતા વધારવા નિષ્ફળ થયેલ છે,

380
00:28:13,000 --> 00:28:18,000
તો પછી તમારે માટે 2 દ્વારા તમારી ક્ષમતા ફરીથી ઘટાડો કરવા માંગો છો જઈ રહ્યાં છો.

381
00:28:18,000 --> 00:28:24,000
અન્ય ટૂંકી નોંધ છે જેમ તમે શું કરી શકો છો + + =,

382
00:28:24,000 --> 00:28:30,000
તમે પણ << = કરી શકો છો.

383
00:28:30,000 --> 00:28:43,000
લગભગ કંઈપણ પહેલા સમકક્ષ જઈ શકે છે, + = | =, અને = << =.

384
00:28:43,000 --> 00:28:52,000
ચાર * નવી અમારા મેમરી નવા બ્લોક છે.

385
00:28:52,000 --> 00:28:55,000
ઓહ, અહીં બનાવ્યા.

386
00:28:55,000 --> 00:29:02,000
>> લોકો શું અમારી મેમરી નવા બ્લોક પ્રકાર વિશે શું વિચારો છો?

387
00:29:02,000 --> 00:29:06,000
[વિદ્યાર્થી] તે ચાર રચે છે ** પ્રયત્ન કરીશું.

388
00:29:06,000 --> 00:29:12,000
અમારા સ્ટ્રક્ટ પાછા અહીં વિચારી,

389
00:29:12,000 --> 00:29:14,000
શબ્દમાળાઓ છે, આપણે શું reallocating છે.

390
00:29:14,000 --> 00:29:21,000
અમે કતાર માં તત્વો માટે એક આખી નવી ગતિશીલ બનાવવા સંગ્રહ કરવામાં આવે છે.

391
00:29:21,000 --> 00:29:25,000
અમે તમારી શબ્દમાળાઓ માટે સોંપણી કરી રહ્યા છીએ શું છે, આપણે શું હમણાં mallocing કરી રહ્યાં છો,

392
00:29:25,000 --> 00:29:30,000
અને તેથી નવા ચાર રચે છે ** પ્રયત્ન રહ્યું છે.

393
00:29:30,000 --> 00:29:34,000
તે શબ્દમાળાઓ ઝાકઝમાળ જ હશે.

394
00:29:34,000 --> 00:29:38,000
પછી કેસ કે જે હેઠળ અમે ખોટા પાછા જઈ રહ્યાં છો શું છે?

395
00:29:38,000 --> 00:29:41,000
[વિદ્યાર્થી] અમે ઘરનાં પરચૂરણ કામો * કરી જોઈએ?

396
00:29:41,000 --> 00:29:44,000
[રોબ બી] હા, સારી કોલ.

397
00:29:44,000 --> 00:29:46,000
[વિદ્યાર્થી] શું હતી?

398
00:29:46,000 --> 00:29:49,000
[રોબ બી] અમે ઘરનાં પરચૂરણ કામો * કદ નથી કારણ કે અમે કોઈ ઇચ્છતા લાંબા

399
00:29:49,000 --> 00:29:53,000
આ ખરેખર ખૂબ મોટી સમસ્યા છે કારણકે sizeof (કોલસો) 1 કરશે.

400
00:29:53,000 --> 00:29:55,000
Sizeof ઘરનાં પરચૂરણ કામો * માટે 4 હોઇ રહ્યું છે,

401
00:29:55,000 --> 00:29:58,000
તેથી જ્યારે તમે ints સાથે કામ કરીએ છીએ ઘણો,

402
00:29:58,000 --> 00:30:01,000
તમે તેને દૂર વિચાર કરતા હોય છે કારણ કે અને પૂર્ણાંક * ના પૂર્ણાંક કદ માપ

403
00:30:01,000 --> 00:30:04,000
સિસ્ટમ 32-bit એ જ વસ્તુ હોઈ જવું છે.

404
00:30:04,000 --> 00:30:09,000
પરંતુ અહીં, (કોલસો) sizeof અને sizeof (કોલસો *) હવે આ જ વાત હશે આવે છે.

405
00:30:09,000 --> 00:30:15,000
>> આ સંજોગોમાં જ્યાં અમે ખોટા પરત શું છે?

406
00:30:15,000 --> 00:30:17,000
[વિદ્યાર્થી] નવી નલ છે.

407
00:30:17,000 --> 00:30:23,000
અરે વાહ, જો નવું નલ છે, અમે ખોટા પાછા ફરવા માટે,

408
00:30:23,000 --> 00:30:34,000
અને હું નીચે ફેંકવું જાઉં છું અહીં-

409
00:30:34,000 --> 00:30:37,000
[વિદ્યાર્થી] [અશ્રાવ્ય]

410
00:30:37,000 --> 00:30:39,000
[રોબ બી] અરે વાહ, આ દંડ છે.

411
00:30:39,000 --> 00:30:46,000
તમે ક્યાં તો 2 વખત ક્ષમતા અથવા ક્ષમતા 1 પાળી છે અને પછી માત્ર તે સેટ નીચે અહીં અથવા જે કરી શકે.

412
00:30:46,000 --> 00:30:52,000
અમે તે કરી કારણ કે અમે તેને હતી પડશે.

413
00:30:52,000 --> 00:30:56,000
>> = 1 ક્ષમતા.

414
00:30:56,000 --> 00:31:08,000
અને તમે જે 1 સ્થળને ગુમાવ્યા ચિંતા ક્યારેય જઈ રહ્યાં છો

415
00:31:08,000 --> 00:31:12,000
કારણ કે તમે છોડી 1 દ્વારા કર્યું, જેથી તે 1 સ્થળ જરૂરી 0 છે,

416
00:31:12,000 --> 00:31:16,000
તેથી યોગ્ય 1 દ્વારા સ્થળાંતર, તો તમે હજુ પણ દંડ પ્રયત્ન રહ્યા છીએ.

417
00:31:16,000 --> 00:31:19,000
[વિદ્યાર્થી] શું તમે વળતર તે પહેલાં શું જરૂર છે?

418
00:31:19,000 --> 00:31:29,000
[રોબ બી] હા, આ સંપૂર્ણપણે કોઈ અર્થ બનાવે છે.

419
00:31:29,000 --> 00:31:36,000
>> હવે ધારે અમે અંત ઓવરને સાચી પરત જઈ રહ્યાં છો.

420
00:31:36,000 --> 00:31:39,000
જે રીતે અમે આ memmoves કરવા જઈ રહ્યાં છો,

421
00:31:39,000 --> 00:31:45,000
અમે કેવી રીતે અમે તેમને આમ સાથે ખૂબ કાળજી રાખો જરૂર છે.

422
00:31:45,000 --> 00:31:50,000
શું કોઇને કેવી રીતે અમે તેમને આમ કરવા માટે કોઈ સૂચનો છે?

423
00:32:17,000 --> 00:32:21,000
અહીં અમારા પ્રારંભ છે.

424
00:32:21,000 --> 00:32:28,000
ખચીત, અમે શરૂઆતમાં ફરીથી શરૂ કરવા માંગો છો

425
00:32:28,000 --> 00:32:35,000
અને ત્યાંથી માં નકલ વસ્તુઓ, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
કે જે તમને કેવી રીતે કરવું?

427
00:32:41,000 --> 00:32:52,000
પ્રથમ, હું memmove માટે મદદ પાનું અંતે ફરી જોવા મળે છે.

428
00:32:52,000 --> 00:32:57,000
Memmove, દલીલો ક્રમ હંમેશા મહત્વનો છે.

429
00:32:57,000 --> 00:33:01,000
અમે અમારા ગંતવ્ય પ્રથમ કરવા માંગો છો, સ્રોત બીજું, કદ ત્રીજા સ્થાને છે.

430
00:33:01,000 --> 00:33:06,000
ત્યાં કયા વિધેયો સ્રોત અને અંતિમ મુકામ વિપરીત ઘણો છે.

431
00:33:06,000 --> 00:33:11,000
ગંતવ્ય સ્ત્રોત માટે સુસંગત અંશે હોઇ શકે છે.

432
00:33:17,000 --> 00:33:21,000
ચાલ, તે શું પરત આવે છે?

433
00:33:21,000 --> 00:33:27,000
તે ગંતવ્ય માટે કારણ ગમે છે કે જે તમને શકો છો માટે એક નિર્દેશક, આપે છે.

434
00:33:27,000 --> 00:33:32,000
હું ચિત્ર તે વાંચી શકો છો, પરંતુ અમે અમારી ગંતવ્ય માં ખસેડવા માંગો છો.

435
00:33:32,000 --> 00:33:35,000
>> અમારા ગંતવ્ય શું જવાનું છે આવશે?

436
00:33:35,000 --> 00:33:37,000
[વિદ્યાર્થી] ન્યુ.

437
00:33:37,000 --> 00:33:39,000
[રોબ બી] હા, અને જ્યાં અમે માંથી નકલ કરવામાં આવે છે?

438
00:33:39,000 --> 00:33:43,000
પ્રથમ વસ્તુ અમે નકલ કરવામાં આવે છે 1 આ, 3, 4 છે.

439
00:33:43,000 --> 00:33:50,000
શું એ આ 1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
1 આ સરનામું શું છે?

441
00:33:55,000 --> 00:33:58,000
1 કે સરનામું શું છે?

442
00:33:58,000 --> 00:34:01,000
[વિદ્યાર્થી] [અશ્રાવ્ય]

443
00:34:01,000 --> 00:34:03,000
[રોબ બી] હેડ + + પ્રથમ તત્વ ની સરનામું.

444
00:34:03,000 --> 00:34:05,000
અમે એરે પ્રથમ તત્વ કેવી રીતે મેળવી શકું?

445
00:34:05,000 --> 00:34:10,000
[વિદ્યાર્થી] કતારમાં.

446
00:34:10,000 --> 00:34:15,000
[રોબ બી] હા q.strings.

447
00:34:15,000 --> 00:34:20,000
યાદ રાખો, અહીં, અમારા વડા 1 છે.

448
00:34:20,000 --> 00:34:24,000
તે રફૂ કરવું. મેં હમણાં જ લાગે તે જાદુઇ-

449
00:34:24,000 --> 00:34:29,000
અહીં, અમારા વડા 1 છે. હું મારી રંગ પણ બદલી જાઉં છું.

450
00:34:29,000 --> 00:34:36,000
અને અહીં શબ્દમાળાઓ છે.

451
00:34:36,000 --> 00:34:41,000
આ, અમે તો લખી અમે ઉપર અહીં કર્યું શકો છો

452
00:34:41,000 --> 00:34:43,000
સાથે + + હેડ q.strings.

453
00:34:43,000 --> 00:34:51,000
ઘણા લોકો પણ તે લખી અને q.strings [વડા].

454
00:34:51,000 --> 00:34:55,000
આ ખરેખર કોઈ પણ ઓછા કાર્યક્ષમ નથી.

455
00:34:55,000 --> 00:34:58,000
તમે તેને લાગે કારણકે તમે તેને dereferencing છે અને પછી એ સરનામું મેળવવામાં શકે છે,

456
00:34:58,000 --> 00:35:04,000
પરંતુ કમ્પાઇલર તેને આપણે શું પહેલાં અનુવાદ રહ્યું છે રીતે, q.strings વડા +.

457
00:35:04,000 --> 00:35:06,000
ક્યાં માર્ગ તમે તેને લાગે કરવા માંગો છો.

458
00:35:06,000 --> 00:35:11,000
>> અને કેટલા બાઇટ્સ અમે નકલ કરવા માંગો છો?

459
00:35:11,000 --> 00:35:15,000
[વિદ્યાર્થી] ક્ષમતા - વડા.

460
00:35:15,000 --> 00:35:18,000
ક્ષમતા - વડા.

461
00:35:18,000 --> 00:35:21,000
અને પછી તમે હંમેશા એક ઉદાહરણ લખી શકે છે

462
00:35:21,000 --> 00:35:23,000
બહાર આકૃતિ જો કે અધિકાર છે.

463
00:35:23,000 --> 00:35:26,000
[વિદ્યાર્થી] તે પછી 2 દ્વારા વિભાજી કરવાની જરૂર છે.

464
00:35:26,000 --> 00:35:30,000
અરે વાહ, જેથી હું ધારી અમે કદ ઉપયોગ કરી શકે છે.

465
00:35:30,000 --> 00:35:35,000
અમે હજુ પણ માપ છે સુખાકારી

466
00:35:35,000 --> 00:35:39,000
માપ ઉપયોગ કરીને, અમે 4 થી સમાન કદ ધરાવે છે.

467
00:35:39,000 --> 00:35:42,000
અમારા કદ 4 છે. અમારા વડા 1 છે.

468
00:35:42,000 --> 00:35:46,000
અમે આ 3 તત્વો નકલ કરવા માંગો છો.

469
00:35:46,000 --> 00:35:54,000
કે જે સેનીટી કે કદ તપાસો - વડા યોગ્ય રીતે 3 હોય છે.

470
00:35:54,000 --> 00:35:58,000
અને અહીં પાછા આવતા, જેમ કે અમારી પહેલાં જણાવ્યું હતું કે,

471
00:35:58,000 --> 00:36:00,000
જો અમે ક્ષમતા ઉપયોગ થાય છે, તે પછી અમે 2 દ્વારા વિભાજીત હોય છો

472
00:36:00,000 --> 00:36:04,000
કારણ કે અમે પહેલાથી જ અમારી ક્ષમતા ઉગાડવામાં છે, જેથી તેના બદલે, અમે કદ ઉપયોગ જઈ રહ્યાં છો.

473
00:36:11,000 --> 00:36:13,000
કે જે તે ભાગ નકલો.

474
00:36:13,000 --> 00:36:18,000
હવે, અમે અન્ય ભાગ, ભાગ છે, જે પ્રારંભના બાકી છે નકલ કરવાની જરૂર છે.

475
00:36:18,000 --> 00:36:28,000
>> કે સ્થિતિ શું માં memmove ચાલી રહ્યું છે?

476
00:36:28,000 --> 00:36:32,000
[વિદ્યાર્થી] પ્લસ કદ - વડા.

477
00:36:32,000 --> 00:36:38,000
હા, તેથી અમે પહેલાથી જ કદ નકલ કરેલ છે - વડા બાઇટ્સ,

478
00:36:38,000 --> 00:36:43,000
અને તેથી જ્યાં અમે બાકીના બાઇટ્સ નકલ કરવા માંગો છો, નવું છે

479
00:36:43,000 --> 00:36:48,000
અને પછી કદ બાદ-ઉપરાંત બાઇટ્સ સંખ્યા અમે પહેલાંથી સાઇન નકલ કરી છે

480
00:36:48,000 --> 00:36:52,000
અને પછી જ્યાં અમે માંથી નકલ કરવામાં આવે છે?

481
00:36:52,000 --> 00:36:54,000
[વિદ્યાર્થી] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[રોબ બી] હા q.strings.

483
00:36:56,000 --> 00:37:02,000
અમે ક્યાં તો અને q.strings. [0] શકે

484
00:37:02,000 --> 00:37:05,000
આ નોંધપાત્ર રીતે ઓછું આ કરતાં સામાન્ય છે.

485
00:37:05,000 --> 00:37:14,000
જો તે માત્ર 0 જ હશે, તો પછી તમારે q.strings જુઓ વલણ ધરાવે પડશે.

486
00:37:14,000 --> 00:37:16,000
કે જ્યાં અમે માંથી નકલ કરી રહ્યા છો.

487
00:37:16,000 --> 00:37:18,000
કેટલી બાઇટ્સ અમે નકલ કરશો બાકી છે? >> [10 વિદ્યાર્થી].

488
00:37:18,000 --> 00:37:20,000
અધિકાર.

489
00:37:20,000 --> 00:37:25,000
[વિદ્યાર્થી] અમે 5 વધવું હોય નહિં - 10 ગણો બાઇટ્સ અથવા કંઈક કદ?

490
00:37:25,000 --> 00:37:30,000
અરે વાહ, તેથી આ જ્યાં-શું બરાબર અમે નકલ કરવામાં આવે છે?

491
00:37:30,000 --> 00:37:32,000
[વિદ્યાર્થી] [અશ્રાવ્ય]

492
00:37:32,000 --> 00:37:34,000
આ વસ્તુ અમે નકલ કરી રહ્યા છીએ પ્રકાર શું છે?

493
00:37:34,000 --> 00:37:36,000
[વિદ્યાર્થી] [અશ્રાવ્ય]

494
00:37:36,000 --> 00:37:41,000
અરે વાહ, આ ઘરનાં પરચૂરણ કામો * ઓ કે અમે નકલ કરી રહ્યાં છીએ તેથી, અમે જ્યાં તે આવતા નથી જાણતા નથી.

495
00:37:41,000 --> 00:37:47,000
વેલ, જ્યાં તેઓ પોઇન્ટ કરી રહ્યાં છો, તો શબ્દમાળાઓ જેમ, અમે અંત તે કતાર પર દબાણ

496
00:37:47,000 --> 00:37:49,000
અથવા કતાર પર enqueuing.

497
00:37:49,000 --> 00:37:51,000
જ્યાં તે આવતા હોય છે, અમે કોઇ વિચાર છે.

498
00:37:51,000 --> 00:37:56,000
અમે માત્ર કોલસો બનાવો * પોતાને ઓ ટ્રૅક રાખવા જરૂર છે.

499
00:37:56,000 --> 00:38:00,000
વડા બાઇટ્સ - અમે કદ નકલ કરવા નથી માંગતા.

500
00:38:00,000 --> 00:38:03,000
વડા ઘરનાં પરચૂરણ કામો * s, - અમે કદ નકલ કરવા માંગો છો

501
00:38:03,000 --> 00:38:11,000
તેથી અમે sizeof (કોલસો *) દ્વારા આ મલ્ટીપ્લાય રહ્યા છીએ.

502
00:38:11,000 --> 00:38:17,000
જ નીચે અહીં, હેડ * sizeof (કોલસો *).

503
00:38:17,000 --> 00:38:24,000
>> [વિદ્યાર્થી] શું આશરે [અશ્રાવ્ય]

504
00:38:24,000 --> 00:38:26,000
આ અહીં અધિકાર?

505
00:38:26,000 --> 00:38:28,000
[વિદ્યાર્થી] ના, કે નીચે, કદ - વડા.

506
00:38:28,000 --> 00:38:30,000
આ અહીં અધિકાર [રોબ બી]

507
00:38:30,000 --> 00:38:32,000
પોઇન્ટર અંકગણિત.

508
00:38:32,000 --> 00:38:35,000
કેવી રીતે નિર્દેશક અંકગણિત કામ જઈને છે

509
00:38:35,000 --> 00:38:40,000
તે આપોઆપ પ્રકાર કે અમે સાથે કામ કરીએ છીએ માપ દ્વારા multiplies.

510
00:38:40,000 --> 00:38:46,000
માત્ર અહીં માંગો, નવી + (કદ - વડા)

511
00:38:46,000 --> 00:38:56,000
બરાબર અને નવા [- વડા કદ] સમકક્ષ છે

512
00:38:56,000 --> 00:39:00,000
ત્યાં સુધી અમે તે યોગ્ય રીતે કામ કરવા માટે અપેક્ષા,

513
00:39:00,000 --> 00:39:04,000
જો ત્યારથી અમે પૂર્ણાંક એરે સાથે વ્યવહાર કરી રહ્યાં છો, તો પછી અમે પૂર્ણાંક દ્વારા ઇન્ડેક્સ નથી

514
00:39:04,000 --> 00:39:07,000
અથવા જો તે 5 કદ અને તમે 4 થી તત્વ કરવા માંગો છો, તો પછી અમે માં અનુક્રમણિકા

515
00:39:07,000 --> 00:39:10,000
પૂર્ણાંક એરે. [4]

516
00:39:10,000 --> 00:39:14,000
તમે don't [4] પૂર્ણાંક ઓફ * માપ.

517
00:39:14,000 --> 00:39:21,000
કે તે આપોઆપ સંભાળે છે, અને આ કિસ્સામાં

518
00:39:21,000 --> 00:39:29,000
શાબ્દિક સમકક્ષ છે, જેથી કૌંસ વાક્યરચના

519
00:39:29,000 --> 00:39:34,000
છે માત્ર આ કન્વર્ટ કરી જલદી તમે કમ્પાઇલ જઈ રહી છે.

520
00:39:34,000 --> 00:39:38,000
કે કંઈક તમે કે કાળજી રાખો જરૂર છે

521
00:39:38,000 --> 00:39:42,000
જ્યારે તમે કદ ઉમેરીને છે - વડા

522
00:39:42,000 --> 00:39:45,000
તમે નથી એક બાઈટ ઉમેરી રહ્યા છે.

523
00:39:45,000 --> 00:39:53,000
તમે એક કોલસો બનાવો * ઉમેરી રહ્યાં છીએ, જે એક બાઇટ્સ અથવા જે પ્રયત્ન કરી શકો છો.

524
00:39:53,000 --> 00:39:56,000
>> અન્ય પ્રશ્નો છે?

525
00:39:56,000 --> 00:40:04,000
ઠીક છે, dequeue સરળ હોઈ રહ્યું છે.

526
00:40:04,000 --> 00:40:11,000
હું તમને અમલ મિનિટ આપવા પડશે.

527
00:40:11,000 --> 00:40:18,000
ઓહ, અને મને લાગ્યું કે આ તે જ પરિસ્થિતિ છે જ્યાં

528
00:40:18,000 --> 00:40:21,000
શું એન્ક્યૂ કિસ્સામાં, જો આપણે નલ enqueuing કરી રહ્યાં છો,

529
00:40:21,000 --> 00:40:24,000
કદાચ અમે તેને હેન્ડલ કરવા માંગો છો, તો કદાચ અમે નથી.

530
00:40:24,000 --> 00:40:27,000
અમે તેને ફરીથી નથી અહીં, પણ અમારી સ્ટેક કેસ તરીકે જ.

531
00:40:27,000 --> 00:40:34,000
જો અમે નલ એન્ક્યૂ, તો અમે તેને અવગણી શકો છો.

532
00:40:34,000 --> 00:40:40,000
કોઈપણ અમુક કોડ મેં ખેંચી શકે છે?

533
00:40:40,000 --> 00:40:45,000
[વિદ્યાર્થી] હું માત્ર dequeue છે.

534
00:40:45,000 --> 00:40:56,000
સંસ્કરણ 2 જે ઠીક છે.

535
00:40:56,000 --> 00:40:59,000
તમે તે સમજાવવા માટે કરવા માંગો છો?

536
00:40:59,000 --> 00:41:01,000
[વિદ્યાર્થી] પ્રથમ, તમે ખાતરી કરો કે ત્યાં કતાર માં કશુંક

537
00:41:01,000 --> 00:41:07,000
અને તે માપ નીચે 1 દ્વારા રહ્યું છે.

538
00:41:07,000 --> 00:41:11,000
તમે તે જરૂર છે, અને તે પછી તમે વડા પાછા

539
00:41:11,000 --> 00:41:13,000
અને પછી 1 અપ વડા ખસેડો.

540
00:41:13,000 --> 00:41:19,000
ઠીક છે, તેથી એક ખૂણામાં કેસ અમે ધ્યાનમાં હોય છે. યાહ.

541
00:41:19,000 --> 00:41:24,000
[વિદ્યાર્થી] જો તમારા માથા છેલ્લા તત્વ છે,

542
00:41:24,000 --> 00:41:26,000
પછી તમે વડા ઍરેની બહાર નિર્દેશ કરવા નથી માંગતા.

543
00:41:26,000 --> 00:41:29,000
>> અરે વાહ, જેથી વડા તરીકે ટૂંક સમયમાં અમારા એરે ઓવરને બનાવ્યા,

544
00:41:29,000 --> 00:41:35,000
જ્યારે અમે dequeue, અમારા વડા 0 થી લઈ modded કરીશું.

545
00:41:35,000 --> 00:41:40,000
કમનસીબે, અમે તે એક પગલું ન કરી શકો છો.

546
00:41:40,000 --> 00:41:44,000
હું જે રીતે હું કદાચ ઠીક છે હો અનુમાન

547
00:41:44,000 --> 00:41:52,000
આ ચાર રચે છે * પ્રયત્ન રહ્યું છે, આપણે શું પરત કરી રહ્યાં છો,

548
00:41:52,000 --> 00:41:55,000
ગમે તમારા ચલ નામ થવા માંગે છે.

549
00:41:55,000 --> 00:42:02,000
પછી અમે અમારી ક્ષમતા દ્વારા વડા mod માંગો છો

550
00:42:02,000 --> 00:42:10,000
અને પછી Ret આવો.

551
00:42:10,000 --> 00:42:14,000
લોકો અહીં ઘણો તેઓ શું કરી શકે છે

552
00:42:14,000 --> 00:42:19,000
આ you'll કિસ્સામાં જુઓ લોકો આમ જો વડા

553
00:42:19,000 --> 00:42:29,000
ક્ષમતા કરતાં વધારે હોય છે, હેડ કરવું - ક્ષમતા.

554
00:42:29,000 --> 00:42:36,000
અને તે માત્ર મોડ શું છે આસપાસ કામ કરી રહ્યા છે.

555
00:42:36,000 --> 00:42:41,000
વડા મોડ = ક્ષમતા ખૂબ ક્લીનર છે

556
00:42:41,000 --> 00:42:51,000
ક્ષમતા -. જો વડા ક્ષમતા વડા કરતાં વધુ આસપાસ વીંટવાનું ઓફ

557
00:42:51,000 --> 00:42:56,000
>> પ્રશ્નો?

558
00:42:56,000 --> 00:43:02,000
ઠીક છે, છેલ્લા વસ્તુ અમે બાકી અમારી સંલગ્ન યાદી છે.

559
00:43:02,000 --> 00:43:07,000
તમે લિંક કરેલા યાદી વર્તન કેટલાક કરવા માટે વપરાઈ શકે જો તમે કર્યું

560
00:43:07,000 --> 00:43:11,000
તમારા હેશ કોષ્ટકોમાં યાદીઓ સાથે કડી થયેલ છે, જો તમે હેશ ટેબલ હતી.

561
00:43:11,000 --> 00:43:15,000
હું ભારપૂર્વક હેશ ટેબલ કરી ભલામણ કરીએ છીએ.

562
00:43:15,000 --> 00:43:17,000
તમે પહેલેથી જ એક trie કરી શકો છો,

563
00:43:17,000 --> 00:43:23,000
પરંતુ પ્રયત્નોમાં વધુ મુશ્કેલ હોય છે.

564
00:43:23,000 --> 00:43:27,000
સિદ્ધાંત, તેઓ asymptotically છો વધુ સારા.

565
00:43:27,000 --> 00:43:30,000
પરંતુ માત્ર મોટા બોર્ડ પર નજર,

566
00:43:30,000 --> 00:43:35,000
કરવાનો પ્રયાસ કરે છે અને આમ વધુ સારી રીતે ક્યારેય, અને તેઓ વધુ મેમરી લે છે.

567
00:43:35,000 --> 00:43:43,000
બધું વિશે વધુ કામ માટે વધુ ખરાબ હોવા અંત થાય છે પ્રયાસ કરે છે.

568
00:43:43,000 --> 00:43:49,000
તે ડેવિડ Malan ઉકેલ શું હંમેશા

569
00:43:49,000 --> 00:43:56,000
છે તે હંમેશા તેના trie ઉકેલ પોસ્ટ્સ, અને ચાલો જોવા જ્યાં તેઓ હાલમાં છે.

570
00:43:56,000 --> 00:44:00,000
તેઓ શું હેઠળ હતી, ડેવિડ જ?

571
00:44:00,000 --> 00:44:06,000
તેમણે 18 # જેથી, તે ઘણું જ ખરાબ નથી,

572
00:44:06,000 --> 00:44:09,000
અને તે માટે એક શ્રેષ્ઠ જ હશે કરવાનો પ્રયાસ કરે છે તમે વિચાર કરી શકો છો

573
00:44:09,000 --> 00:44:17,000
અથવા એક શ્રેષ્ઠ એક trie ઓફ પ્રયાસ કરે છે.

574
00:44:17,000 --> 00:44:23,000
તે તેના મૂળ ઉકેલ છે પણ નથી?

575
00:44:23,000 --> 00:44:29,000
મને લાગે છે કે trie ઉકેલો માટે રેમ વપરાશ આ શ્રેણીમાં વધુ હોય છે.

576
00:44:29,000 --> 00:44:33,000
>> એકદમ ટોચ પર નીચે જાઓ, અને રેમ વપરાશ એક અંકો છે.

577
00:44:33,000 --> 00:44:36,000
નીચે તરફ નીચે જાઓ, અને પછી તમે જોયા કરવાનો પ્રયાસ કરે છે શરૂ

578
00:44:36,000 --> 00:44:41,000
, કે જ્યાં તમે સંપૂર્ણપણે વ્યાપક રેમ વપરાશ વિચાર

579
00:44:41,000 --> 00:44:45,000
અને પ્રયત્નોમાં વધુ મુશ્કેલ હોય છે.

580
00:44:45,000 --> 00:44:53,000
પરંતુ એક શૈક્ષણિક અનુભવ વર્થ સંપૂર્ણપણે જો તમે એક ન.

581
00:44:53,000 --> 00:44:56,000
છેલ્લા વસ્તુ અમારા સંલગ્ન યાદી છે,

582
00:44:56,000 --> 00:45:04,000
અને આ ત્રણ વસ્તુઓ, રન ટાઇમ સ્ટેકનું, ક્યુને, અને સંલગ્ન યાદીઓ,

583
00:45:04,000 --> 00:45:09,000
ભવિષ્યના કોઈપણ વસ્તુ તમે ક્યારેય કમ્પ્યૂટર સાયન્સ કરવું

584
00:45:09,000 --> 00:45:12,000
ધારે તમે આ બાબતો સાથે પારિવારિકતા હશે.

585
00:45:12,000 --> 00:45:19,000
તેઓ એ જ બધું માટે મૂળભૂત છે.

586
00:45:19,000 --> 00:45:25,000
>> યાદીઓ લિંક કરેલા છે, અને અહીં આપણે એક singly કડી થયેલ યાદી અમારી અમલીકરણ પ્રયત્ન છે રહ્યું છે.

587
00:45:25,000 --> 00:45:34,000
શું singly કડી થયેલ નથી અર્થ તરીકે સમયમાં બમણું કડી થયેલ વિરોધ? હા.

588
00:45:34,000 --> 00:45:37,000
[વિદ્યાર્થી] તે માત્ર આગામી નિર્દેશક તેના બદલે પોઇંટરો નિર્દેશ,

589
00:45:37,000 --> 00:45:39,000
તેને અને તે પછી એક પૂર્વવર્તી એક જેવા હોય છે.

590
00:45:39,000 --> 00:45:44,000
અરે વાહ, તેથી ચિત્ર બંધારણમાં માં, હું શું માત્ર કરી?

591
00:45:44,000 --> 00:45:48,000
હું બે વસ્તુઓ હોય છે. હું ચિત્ર અને ચિત્ર હોય છે.

592
00:45:48,000 --> 00:45:51,000
ચિત્ર બંધારણ, અમારા singly કડી થયેલ યાદીઓ,

593
00:45:51,000 --> 00:45:57,000
ખચીત, અમે અમારી યાદી વડા માટે નિર્દેશક અમુક પ્રકારના હોય છે,

594
00:45:57,000 --> 00:46:02,000
અને પછી અમારી યાદી અંદર, અમે માત્ર પોઇન્ટર હોય છે,

595
00:46:02,000 --> 00:46:05,000
અને કદાચ આ પોઇન્ટ null છે.

596
00:46:05,000 --> 00:46:08,000
તે તમારી singly યાદીની લિંક લાક્ષણિક ચિત્ર બની રહ્યું છે.

597
00:46:08,000 --> 00:46:14,000
એક સમયમાં બમણું કડી થયેલ યાદી છે, તમે પાછળની જઈ શકે છે.

598
00:46:14,000 --> 00:46:19,000
જો હું તમને યાદીમાં કોઇ નોડ આપો, પછી તમે જરૂરી મેળવી શકો છો

599
00:46:19,000 --> 00:46:23,000
અન્ય કોઇ નોડ યાદીમાં જો તે સમયમાં બમણું કડી થયેલ યાદી છે.

600
00:46:23,000 --> 00:46:27,000
પરંતુ જો હું તમને યાદીમાં ત્રીજા નોડ વિચાર અને તે singly કડી થયેલ યાદી છે,

601
00:46:27,000 --> 00:46:30,000
કોઈ રીતે તમે ક્યારેય પ્રથમ અને બીજા ગાંઠો મેળવવા જઈ રહ્યાં છો.

602
00:46:30,000 --> 00:46:34,000
અને ત્યાં લાભો અને detriments, અને એક સ્પષ્ટ એક છે

603
00:46:34,000 --> 00:46:42,000
છે તમે વધુ કદ લે છે, અને તમે જ્યાં આ વસ્તુઓ હવે પોઇન્ટ છે ટ્રેક રાખવો પડે છે.

604
00:46:42,000 --> 00:46:49,000
પરંતુ અમે માત્ર singly કડી થયેલ કાળજી.

605
00:46:49,000 --> 00:46:53,000
>> થોડા વસ્તુઓ અમે અમલ કરવા માટે હોય રહ્યા છીએ.

606
00:46:53,000 --> 00:47:00,000
તમારા typedef સ્ટ્રક્ટ નોડ, પૂર્ણાંક હું: સ્ટ્રક્ટ નોડ * આગામી; નોડ.

607
00:47:00,000 --> 00:47:09,000
કે typedef તમારા મનમાં માં સળગાવી જોઇએ.

608
00:47:09,000 --> 00:47:14,000
1 ક્વિઝ એક કડી થયેલ યાદી નોડ એક typedef આપવા માંગો જોઈએ,

609
00:47:14,000 --> 00:47:18,000
અને તમે તરત જ કે નીચે બેદરકારીપૂર્વક કરવાનો પ્રયત્ન કરીશું

610
00:47:18,000 --> 00:47:22,000
વિના પણ તે વિશે વિચારવાનો.

611
00:47:22,000 --> 00:47:27,000
હું થોડા પ્રશ્નો ધારી, અમે અહીં સ્ટ્રક્ટ શા માટે જરૂરી છે?

612
00:47:27,000 --> 00:47:32,000
અમે નોડ * કહી ન શકે કેમ?

613
00:47:32,000 --> 00:47:35,000
[વિદ્યાર્થી] [અશ્રાવ્ય]

614
00:47:35,000 --> 00:47:38,000
યાહ.

615
00:47:38,000 --> 00:47:44,000
આ જ વસ્તુ છે કે એક વસ્તુ તરીકે નોડ વ્યાખ્યાયિત

616
00:47:44,000 --> 00:47:47,000
પોતે typedef છે.

617
00:47:47,000 --> 00:47:55,000
પરંતુ આ મુદ્દે, જ્યારે અમે આ સ્ટ્રક્ટ નોડ વ્યાખ્યા દ્વારા પદચ્છેદન પ્રકારની છો

618
00:47:55,000 --> 00:48:01,000
અમે અમારા typedef હજી સમાપ્ત નથી છે, કે જેથી કારણ કે typedef નથી સમાપ્ત થઈ ગઈ છે,

619
00:48:01,000 --> 00:48:05,000
નોડ અસ્તિત્વમાં નથી.

620
00:48:05,000 --> 00:48:12,000
પરંતુ સ્ટ્રક્ટ નોડ કરે છે, અને અહીં, આ નોડ

621
00:48:12,000 --> 00:48:14,000
આ પણ બીજું કશું કહેવાય કરી શકાય છે.

622
00:48:14,000 --> 00:48:16,000
આ n એ કહી શકાય.

623
00:48:16,000 --> 00:48:19,000
તે સંલગ્ન યાદી નોડ કહી શકાય.

624
00:48:19,000 --> 00:48:21,000
તે કશું કહી શકાય.

625
00:48:21,000 --> 00:48:26,000
પરંતુ આ સ્ટ્રક્ટ નોડ માટે આ સ્ટ્રક્ટ નોડ તરીકે આ જ વાત કહી શકાય જરૂર છે.

626
00:48:26,000 --> 00:48:29,000
, તમે શું કહી આ પણ અહીં છે

627
00:48:29,000 --> 00:48:32,000
અને જેથી પણ પ્રશ્ન બીજા બિંદુ જવાબ

628
00:48:32,000 --> 00:48:37,000
જે શા માટે એક વખત જ્યારે તમે સ્ટ્ર્ક્ટ્સ અને સ્ટ્ર્ક્ટ્સ ઓફ typedefs જુએ લોટ,

629
00:48:37,000 --> 00:48:42,000
તમે અનામી સ્ટ્ર્ક્ટ્સ જોવા જ્યાં તમે હમણાં typedef સ્ટ્રક્ટ જોશો પડશે,

630
00:48:42,000 --> 00:48:47,000
સ્ટ્રક્ટ, શબ્દકોશ, અથવા ગમે અમલીકરણ.

631
00:48:47,000 --> 00:48:51,000
>> અહીં અમે શા માટે નોડ કહેવું જરૂરી છે?

632
00:48:51,000 --> 00:48:54,000
તે એક અનામી સ્ટ્રક્ટ કેમ ન હોઈ શકે?

633
00:48:54,000 --> 00:48:56,000
તે લગભગ એ જ જવાબ છે.

634
00:48:56,000 --> 00:48:58,000
[વિદ્યાર્થી] તમે સ્ટ્રક્ટ અંદર તે સંદર્ભ લો કરવાની જરૂર છે.

635
00:48:58,000 --> 00:49:04,000
અરે વાહ, આ સ્ટ્રક્ટ અંદર, તો તમે સ્ટ્રક્ટ પોતે નો સંદર્ભ લો કરવાની જરૂર છે.

636
00:49:04,000 --> 00:49:10,000
જો તમે સ્ટ્રક્ટ એક નામ આપતા નથી, જો તે એક અનામી સ્ટ્રક્ટ છે, તો તમે તેને ઉલ્લેખ કરી શકે છે.

637
00:49:10,000 --> 00:49:17,000
અને છેલ્લા પરંતુ ઓછામાં ઓછા-આ તમામ પ્રયત્ન કરીશું નથી અંશે સરળ,

638
00:49:17,000 --> 00:49:20,000
અને તેઓ તમને ખ્યાલ મદદ જો તમે આ લખી રહ્યાં નીચે કરીશું

639
00:49:20,000 --> 00:49:24,000
કે તમે કંઇક ખોટું કરી રહ્યા છીએ જો વસ્તુઓ આ પ્રકારના અર્થમાં બનાવતા નથી.

640
00:49:24,000 --> 00:49:28,000
છેલ્લું નથી, પરંતુ ઓછામાં ઓછા, આ શા માટે સ્ટ્રક્ટ નોડ * પ્રયત્ન નથી?

641
00:49:28,000 --> 00:49:34,000
તે માત્ર શા માટે નોડ નથી સ્ટ્રક્ટ શકાય આગામી?

642
00:49:34,000 --> 00:49:37,000
[વિદ્યાર્થી] પછીના સ્ટ્રક્ટ માટે પોઇન્ટર.

643
00:49:37,000 --> 00:49:39,000
કે સ્વાભાવિકપણે અમે શું કરવા માંગો છો.

644
00:49:39,000 --> 00:49:42,000
શા સ્ટ્રક્ટ આગામી નોડ પ્રયત્ન ક્યારેય શકે છે?

645
00:49:42,000 --> 00:49:50,000
તે સ્ટ્રક્ટ * આગામી નોડ પ્રયત્ન શા માટે છે? યાહ.

646
00:49:50,000 --> 00:49:53,000
[વિદ્યાર્થી] તે અનંત લૂપ જેવું છે.

647
00:49:53,000 --> 00:49:55,000
યાહ.

648
00:49:55,000 --> 00:49:57,000
[વિદ્યાર્થી] તે બધા એક જ હશે.

649
00:49:57,000 --> 00:50:02,000
અરે વાહ, માત્ર અમે કેવી રીતે આકાર અથવા કંઈક થશે લાગે છે.

650
00:50:02,000 --> 00:50:08,000
એક સ્ટ્રક્ટ કદ મૂળભૂત + અથવા - કેટલાક અહીં અથવા ત્યાં પેટર્ન.

651
00:50:08,000 --> 00:50:15,000
તે વાસ્તવમાં માટે સ્ટ્રક્ટ માં વસ્તુઓ માપ સરવાળા જ હશે.

652
00:50:15,000 --> 00:50:18,000
આ અહીં અધિકાર કંઈપણ ફેરફાર કર્યા વિના, માપ સરળ હોઈ રહ્યું છે.

653
00:50:18,000 --> 00:50:24,000
સ્ટ્રક્ટ નોડ કદ માટે હું આગામી ઓફ + + કદ માપ પ્રયત્ન રહ્યું છે.

654
00:50:24,000 --> 00:50:27,000
I ની માપ 4 હોઇ રહ્યું છે. આગામી કદ માટે 4 હોઇ રહ્યું છે.

655
00:50:27,000 --> 00:50:30,000
સ્ટ્રક્ટ નોડ કદ થી 8 પ્રયત્ન રહ્યું છે.

656
00:50:30,000 --> 00:50:34,000
જો અમે * નથી, sizeof વિચારી,

657
00:50:34,000 --> 00:50:37,000
પછી sizeof (i) માટે 4 હોઇ રહ્યું છે.

658
00:50:37,000 --> 00:50:43,000
સ્ટ્રક્ટ નોડ કદ આગામી માટે i ની કદ સ્ટ્રક્ટ આગામી ગાંઠની + + કદ પ્રયત્ન રહ્યું છે

659
00:50:43,000 --> 00:50:46,000
હું સ્ટ્રક્ટ આગામી ગાંઠની + + + + કદ માપ.

660
00:50:46,000 --> 00:50:55,000
તે ગાંઠો એક અનંત રિકર્ઝન હશે.

661
00:50:55,000 --> 00:51:00,000
આ શા માટે આ કેવી રીતે વસ્તુઓ માટે હોય છે.

662
00:51:00,000 --> 00:51:03,000
>> ફરીથી, ચોક્કસપણે કે યાદ,

663
00:51:03,000 --> 00:51:06,000
અથવા ઓછામાં ઓછું તેને પર્યાપ્ત સમજો કે તમે કરવાનો પ્રયત્ન કરી શકો છો

664
00:51:06,000 --> 00:51:12,000
તે શું જેવો હવો જોઈએ મારફતે કારણ છે.

665
00:51:12,000 --> 00:51:14,000
આ વસ્તુઓ અમે અમલ કરવા માંગો છો જઈ રહ્યાં છો.

666
00:51:14,000 --> 00:51:18,000
જો લંબાઈ યાદી-

667
00:51:18,000 --> 00:51:21,000
તમે ઠગ અને આસપાસ ચાલુ રાખી શકે

668
00:51:21,000 --> 00:51:24,000
વૈશ્વિક લંબાઈ અથવા કંઈક છે, પરંતુ અમે તે નથી જઈ રહ્યાં છો.

669
00:51:24,000 --> 00:51:28,000
અમે યાદી લંબાઈ ગણતરી રહ્યા છીએ.

670
00:51:28,000 --> 00:51:34,000
અમે સમાવે છે તેથી, જે શોધ જેવી મૂળભૂત છે,

671
00:51:34,000 --> 00:51:41,000
તેથી અમે પૂર્ણાંકો એક કડી થયેલ યાદી જોવા માટે જો આ પૂર્ણાંક સંકળાયેલા યાદીમાં છે.

672
00:51:41,000 --> 00:51:44,000
અંત થાય યાદીમાં શરૂઆતમાં દાખલ રહ્યું છે.

673
00:51:44,000 --> 00:51:46,000
ઉમેરો કરવા માટે ઓવરને અંતે દાખલ રહ્યું છે.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted યાદીમાં માં સોર્ટ સ્થિતિ દાખલ રહ્યું છે.

675
00:51:53,000 --> 00:52:01,000
ના Insert_sorted પ્રકારની ધારે છે કે તમે ઉપયોગમાં અથવા ક્યારેય અંત ખરાબ રીતે જોડો.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted જ્યારે તમે insert_sorted-અમલ કરી રહ્યા છીએ

677
00:52:09,000 --> 00:52:13,000
ચાલો આપણે કહેવું કડી થયેલ યાદી છે.

678
00:52:13,000 --> 00:52:18,000
આ તે શું હાલમાં જેમ, 2, 4, 5 જુએ છે.

679
00:52:18,000 --> 00:52:24,000
હું 3 દાખલ કરો, જેથી લાંબા તરીકે યાદી પોતે પહેલેથી સૉર્ટ થાય છે માંગો છો,

680
00:52:24,000 --> 00:52:27,000
તે સરળ છે શોધવા જ્યાં 3 અનુસરે છે.

681
00:52:27,000 --> 00:52:29,000
હું 2 શરુ થાય છે.

682
00:52:29,000 --> 00:52:32,000
ઠીક, 3 2 કરતા વધારે હોય છે, જેથી હું જવા રાખવા માંગો છો.

683
00:52:32,000 --> 00:52:35,000
ઓહ, 4 ખૂબ મોટી છે, તેથી મને ખબર 3 થી 2 અને 4 વચ્ચે જઈ રહ્યું છે,

684
00:52:35,000 --> 00:52:39,000
અને હું પોઇંટરો અને તે તમામ સામગ્રી ઠીક છે.

685
00:52:39,000 --> 00:52:43,000
પરંતુ જો આપણે સખત insert_sorted ઉપયોગ નથી કર્યો,

686
00:52:43,000 --> 00:52:50,000
ગમે ચાલો માત્ર કહે હું 6 ઉમેરવું,

687
00:52:50,000 --> 00:52:55,000
પછી મારા સંલગ્ન યાદી આ બની રહ્યું છે.

688
00:52:55,000 --> 00:53:01,000
તે હવે કોઈ અર્થ બનાવે છે, જેથી insert_sorted માટે, તમે માત્ર ધારણ કરી શકે છે

689
00:53:01,000 --> 00:53:04,000
કે યાદી છટણી કરવામાં આવે છે, તેમ છતાં કામગીરી અસ્તિત્વમાં

690
00:53:04,000 --> 00:53:09,000
જે તેને અલગ કરવામાં આવે નથી કારણ શકે છે, અને એ છે કે તે છે.

691
00:53:09,000 --> 00:53:20,000
મદદરૂપ insert-જેથી શોધો તે મુખ્ય બાબતો માટે અમલમાં છે જઈ રહ્યાં છો છે.

692
00:53:20,000 --> 00:53:24,000
>> હવે, એક મિનિટ લાગી લંબાઈ કરવું અને સમાવે છે,

693
00:53:24,000 --> 00:53:30,000
અને તે પ્રમાણમાં ઝડપી પ્રયત્ન કરીશું.

694
00:53:41,000 --> 00:53:48,000
બંધ કરવાનો સમય નજીક છે, તેથી લંબાઈ કોઈને માટે કશું હોય અથવા સમાવે છે?

695
00:53:48,000 --> 00:53:50,000
તેઓ લગભગ સમાન હોવું રહ્યા છીએ.

696
00:53:50,000 --> 00:53:57,000
[વિદ્યાર્થી] લંબાઈ.

697
00:53:57,000 --> 00:54:01,000
ચાલો જોવા માટે, પુનરાવર્તન.

698
00:54:01,000 --> 00:54:04,000
ઠીક છે.

699
00:54:12,000 --> 00:54:15,000
તમે તે સમજાવવા માટે કરવા માંગો છો?

700
00:54:15,000 --> 00:54:21,000
[વિદ્યાર્થી] હું માત્ર એક નિર્દેશક નોડ બનાવવા અને તેને પ્રથમ, જે આપણા વૈશ્વિક ચલ છે આરંભ કરવા માટે,

701
00:54:21,000 --> 00:54:27,000
અને પછી હું જોવા માટે જો તે નલ જેથી હું seg દોષ ન મળી શકે અને 0 આપશે જો કે કેસ છે તપાસો.

702
00:54:27,000 --> 00:54:34,000
નહિંતર, મારફતે લૂપ હું, પૂર્ણાંક અંદર રાખવામાં આવેલ

703
00:54:34,000 --> 00:54:38,000
કેટલી વખત હું યાદી આગળના તત્વ ઍક્સેસ કરી છે

704
00:54:38,000 --> 00:54:43,000
અને તે જ પગાર - વધારો કામગીરી પણ છે કે જે વાસ્તવિક તત્વ ઍક્સેસ કરવા માટે,

705
00:54:43,000 --> 00:54:47,000
અને પછી હું સતત ચેક જો તે નલ છે તે જોવા માટે બનાવવા માટે,

706
00:54:47,000 --> 00:54:56,000
અને જો તે નલ, તે પછી aborts અને માત્ર તત્વો હું ઍક્સેસ કરી છે સંખ્યા આપે છે.

707
00:54:56,000 --> 00:55:01,000
>> [રોબ બી] કોઈને પણ બાબતની કોઈ પણ ટિપ્પણી છે?

708
00:55:01,000 --> 00:55:06,000
આ દેખાય છે દંડ ચોકસાઈ જાગરૂક.

709
00:55:06,000 --> 00:55:10,000
[વિદ્યાર્થી] મને નથી લાગતું કે તમે == નોડ નલ જરૂર છે.

710
00:55:10,000 --> 00:55:13,000
અરે વાહ, તેથી જો નોડ == નલ વળતર 0.

711
00:55:13,000 --> 00:55:18,000
પરંતુ જો નોડ == નલ પછી આ ઓહ, ત્યાં ચોકસાઈ મુદ્દો છે.

712
00:55:18,000 --> 00:55:23,000
તે ફક્ત તમે મને પરત કરી રહ્યાં છો, પરંતુ તેને અવકાશ માં હમણાં નથી.

713
00:55:23,000 --> 00:55:30,000
તમે હમણાં જ પૂર્ણાંક હું જરૂર છે, તેથી હું = 0.

714
00:55:30,000 --> 00:55:34,000
પરંતુ જો નોડ નલ હોય, તો પછી હું હજુ પણ 0 પ્રયત્ન રહ્યું છે,

715
00:55:34,000 --> 00:55:39,000
અને અમે 0 પાછા જઈ રહ્યાં છો, જેથી આ કેસ સરખા છે.

716
00:55:39,000 --> 00:55:48,000
અન્ય સામાન્ય વસ્તુ જાહેરાત રાખે છે

717
00:55:48,000 --> 00:55:51,000
લૂપ માટે ની ગાંઠની અંદર છે.

718
00:55:51,000 --> 00:55:54,000
તમે કહેવું તદ્દન શકે છે, નં.

719
00:55:54,000 --> 00:55:56,000
ચાલો તેને આ તરીકે રાખો.

720
00:55:56,000 --> 00:55:59,000
હું કદાચ પૂર્ણાંક હું = 0 અહીં મૂકો છો,

721
00:55:59,000 --> 00:56:05,000
પછી નોડ * નોડ = અહીં પ્રથમ છે.

722
00:56:05,000 --> 00:56:11,000
અને આ સંભવિત છે કદાચ આ છૂટકારો હવે કેવી રીતે મેળવી શકો છો.

723
00:56:11,000 --> 00:56:14,000
આ સંભવિત છે હું કેવી રીતે તે હોય શકે છે.

724
00:56:14,000 --> 00:56:21,000
તમે આ જેવા તેના પર પણ જોઈ શકે છે.

725
00:56:21,000 --> 00:56:25,000
લૂપ માળખું માટે અહીં આ

726
00:56:25,000 --> 00:56:30,000
લગભગ પૂર્ણાંક હું = 0 માટે તમે કુદરતી પ્રયત્ન કરીશું

727
00:56:30,000 --> 00:56:33,000
મને એરેને લંબાઈ કરતા ઓછી છે મને + +.

728
00:56:33,000 --> 00:56:38,000
જો કે આવી જ રીતે તમે એક એરે પર ફરી વળવું, આ કેવી રીતે તમે એક કડી થયેલ યાદી પર ફરી વળવું.

729
00:56:38,000 --> 00:56:45,000
>> આ અમુક બિંદુએ બીજા પ્રકૃતિ પ્રયત્ન કરીશું.

730
00:56:45,000 --> 00:56:50,000
મન કે સાથે, આ માટે લગભગ સમાન વસ્તુ હોઈ રહ્યું છે.

731
00:56:50,000 --> 00:56:57,000
તમે ઉપર સંકળાયેલી યાદી પર ફરી વળવું માંગો છો જઈ રહ્યાં છો.

732
00:56:57,000 --> 00:57:02,000
આ નોડ હું કોઈ વિચાર શું કિંમત કહેવાય છે. જો

733
00:57:02,000 --> 00:57:04,000
હું નોડ.

734
00:57:04,000 --> 00:57:15,000
જો કે ગાંઠ પર મૂલ્ય = હું સાચું પરત, અને તે છે.

735
00:57:15,000 --> 00:57:18,000
નોંધ કરો કે માત્ર એક જ રસ્તો અમે ક્યારેય ખોટા પાછા

736
00:57:18,000 --> 00:57:23,000
જો અમે સમગ્ર યાદીની લિંક પર ફરી વળવું અને પરત સાચું નથી,

737
00:57:23,000 --> 00:57:29,000
જેથી આ શું કરે છે.

738
00:57:29,000 --> 00:57:36,000
તરીકે બાજુ નોંધ-અમે કદાચ ઉમેરો અથવા ઉમેરવું મળશે નહીં.

739
00:57:36,000 --> 00:57:39,000
>> ઝડપી છેલ્લા નોંધ.

740
00:57:39,000 --> 00:57:52,000
જો તમે સ્ટેટિક કીવર્ડ જુઓ, તેથી આપણે સ્થિર પૂર્ણાંક ગણતરી = 0 કહેવું,

741
00:57:52,000 --> 00:57:56,000
તો પછી અમે ગણતરી કરી + +, તમે મૂળભૂત વૈશ્વિક ચલ કારણ કે તે વિચાર કરી શકો છો,

742
00:57:56,000 --> 00:58:00,000
ભલે હું હમણાં જ કહ્યું હતું કે આ કેવી રીતે અમે લંબાઈ અમલ જઈ રહ્યાં છો નથી.

743
00:58:00,000 --> 00:58:06,000
હું આ કરી રહ્યો છું અહીં, અને પછી + + ગણતરી.

744
00:58:06,000 --> 00:58:11,000
કોઈપણ રીતે આપણે સંલગ્ન યાદી અમે અમારી ગણતરી incrementing આવે નોડ દાખલ કરી શકો છો.

745
00:58:11,000 --> 00:58:15,000
આ બિંદુ છે સ્ટેટિક કીવર્ડ શું અર્થ થાય છે.

746
00:58:15,000 --> 00:58:20,000
જો હું માત્ર પૂર્ણાંક ગણતરી હતી = 0 છે કે જે નિયમિત જૂના વૈશ્વિક ચલ હશે.

747
00:58:20,000 --> 00:58:25,000
સ્થિર પૂર્ણાંક ગણતરી અર્થ એ છે કે તે આ ફાઈલ માટે વૈશ્વિક ચલ છે.

748
00:58:25,000 --> 00:58:28,000
તેને કેટલીક અન્ય ફાઇલ માટે અશક્ય છે,

749
00:58:28,000 --> 00:58:34,000
5 pset લાગે માંગો, જો તમે શરૂ કર્યું છે.

750
00:58:34,000 --> 00:58:39,000
તમે બંને speller.c હોય છે, અને તમે dictionary.c હોય છે,

751
00:58:39,000 --> 00:58:42,000
અને જો તમે માત્ર એક વૈશ્વિક વસ્તુ જાહેર, પછી speller.c પણ

752
00:58:42,000 --> 00:58:45,000
dictionary.c અને ઊલટું માં વાપરી શકાય છે.

753
00:58:45,000 --> 00:58:48,000
વૈશ્વિક ચલો કોઇપણ સી. ફાઈલ દ્વારા સુલભ છે,

754
00:58:48,000 --> 00:58:54,000
પરંતુ સ્થિર ચલો માત્ર ફાઈલ પોતે અંદર સુલભ છે,

755
00:58:54,000 --> 00:59:01,000
જેથી અંદર સ્પેલચેકરરૂપરેખાંંકિતકરો અથવા dictionary.c ની અંદર છે,

756
00:59:01,000 --> 00:59:06,000
આ કેવી રીતે હું મારા એરે માપ માટે મારી ચલ જાહેર કરશે પ્રકારની છે

757
00:59:06,000 --> 00:59:10,000
અથવા શબ્દકોશ શબ્દો મારા નંબર માપ.

758
00:59:10,000 --> 00:59:15,000
ત્યારથી હું એક વૈશ્વિક ચલ જાહેર કે જે કોઇ પણ ઍક્સેસ નથી માંગતા,

759
00:59:15,000 --> 00:59:18,000
હું ખરેખર માત્ર મારા પોતાના હેતુ માટે તે વિશે કાળજી.

760
00:59:18,000 --> 00:59:21,000
>> આ વિશે સારી વસ્તુ પણ સમગ્ર નામ ટક્કર સામગ્રી છે.

761
00:59:21,000 --> 00:59:27,000
જો કોઇ અન્ય ફાઇલ માટે એક વૈશ્વિક ગણતરી કહેવાય ચલ ઉપયોગ કરવાનો પ્રયાસ કરે છે, વસ્તુઓ ખૂબ, ખૂબ ખોટું જાય છે,

762
00:59:27,000 --> 00:59:33,000
તેથી આ સરસ રીતે વસ્તુઓ સલામત રાખે છે, અને માત્ર તમે તેને ઍક્સેસ કરી શકો છો,

763
00:59:33,000 --> 00:59:38,000
અને કોઈ એક, અને જો કોઈએ વૈશ્વિક ગણતરી કહેવાય ચલ ઘોષણા કરી શકાય છે

764
00:59:38,000 --> 00:59:43,000
પછી તેને તમારા સ્થિર ગણતરી કહેવાય ચલ સાથે દખલ કરશે.

765
00:59:43,000 --> 00:59:47,000
કે સ્થિર શું છે. એ એક ફાઈલ વૈશ્વિક ચલ છે.

766
00:59:47,000 --> 00:59:52,000
>> બાબતની પ્રશ્નો?

767
00:59:52,000 --> 00:59:59,000
બધા સમૂહ. બાય.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]