1
00:00:00,000 --> 00:00:02,310
[Powered by Google Translate] [4 અઠવાડિયું ચાલુ રાખ્યું,]

2
00:00:02,310 --> 00:00:04,240
[ડેવિડ જે Malan - હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,240 --> 00:00:07,290
[આ CS50 છે. - CS50.TV]

4
00:00:07,290 --> 00:00:11,290
>> આ CS50 છે, અને આ 4 અઠવાડિયાના અંત છે.

5
00:00:11,290 --> 00:00:14,030
કેટલાક સારા સમાચાર છે અને કેટલાક ખરાબ સમાચાર તેથી.

6
00:00:14,030 --> 00:00:26,240
સોમવાર પર કોઈ વ્યાખ્યાન આગામી સપ્તાહ, કોઈ સમસ્યા સુયોજિત કરો. [વિદ્યાર્થીઓ આનંદદાયક]

7
00:00:26,240 --> 00:00:28,680
તમે કરવા માગો જ્યાં આ રહ્યું છે જઈ રહ્યાં છો.

8
00:00:28,680 --> 00:00:31,590
પરંતુ અમે આ છે આગલા બુધવારે બદલે નથી,

9
00:00:31,590 --> 00:00:37,740
અને ત્યાં પાઠ્યક્રમ 1 શુક્રવાર વ્યાખ્યાન દીઠ પણ આગામી શુક્રવાર કે જેથી અમે ટ્રેક પર રહી શકો છો.

10
00:00:37,740 --> 00:00:40,580
પરંતુ બધું સામાન્ય તરીકે ફિલ્માંકન થશે, તેથી ચિંતા ન કરો.

11
00:00:40,580 --> 00:00:44,100
>> અને સંબંધમાં 0 ક્વિઝ અમે શું સપ્તાહની અંત કરીશ

12
00:00:44,100 --> 00:00:47,140
એ કોર્સ હોમપેજ cs50.net સમજૂતી પર પોસ્ટ

13
00:00:47,140 --> 00:00:50,160
અપેક્ષાઓ સૉર્ટ કરો શું તમે જ્યારે તે પ્રથમ ક્વિઝ આવે હોવી જોઇએ.

14
00:00:50,160 --> 00:00:55,100
સામાન્ય રીતે, તે ઘણીબધી પસંદગી, સાચું-ખોટા, ટૂંકા જવાબ, ટૂંકી કોડિંગ સમસ્યાઓ હશે.

15
00:00:55,100 --> 00:00:57,360
તમે સમકક્ષ અમલ અપેક્ષા નથી જઈ રહ્યાં છો

16
00:00:57,360 --> 00:01:00,030
એક સમસ્યા છે કે તમે એક pset પર જોવા કરશે, જેના માટે તમે કમ્પ્યુટર છે

17
00:01:00,030 --> 00:01:03,240
ડીબગર અને એક જેવા છે, પરંતુ ત્યાં નાના કોડિંગ સમસ્યાઓ હશે.

18
00:01:03,240 --> 00:01:06,900
>> અને ખરેખર, શ્રેષ્ઠ CS50 શું અંગેની ક્વિઝ એક અર્થમાં વિચાર માર્ગદર્શિકા જેવા છે

19
00:01:06,900 --> 00:01:09,180
છે cs50.net પર જવા માટે, કડી ક્વેસ્ચન જાઓ,

20
00:01:09,180 --> 00:01:11,920
અને તમે ભૂતકાળમાં ઘણા વર્ષો ક્વેસ્ચન મૂલ્યનું જોઈ શકો છો.

21
00:01:11,920 --> 00:01:16,600
જસ્ટ ખ્યાલ છે કે અભ્યાસક્રમ હંમેશા વર્ષોમાં જ નથી કરવામાં આવ્યો છે.

22
00:01:16,600 --> 00:01:18,510
ક્યારેક અમે કેટલીકવાર સબ્ટ્રેક્ટ, ઉમેરો,

23
00:01:18,510 --> 00:01:20,670
તેથી જો તમે એક જેઓ જૂની અંગેની ક્વિઝ પર અમુક વિષય જુઓ

24
00:01:20,670 --> 00:01:25,380
કે તમે કોઈ વિચાર તે શું વાત છે, તો એ ક્યાં છે કે અમે તેને આવરી લીધા ન હતા

25
00:01:25,380 --> 00:01:27,210
અથવા તે અમે તેને આવરી લીધા ન હતા.

26
00:01:27,210 --> 00:01:31,110
પરંતુ સમીક્ષાઓ સ્વરૂપ, આ રવિવાર, સોમવાર, મંગળવાર અને

27
00:01:31,110 --> 00:01:34,770
તેમજ અભ્યાસક્રમ વ્યાપી રવિવાર રાત્રે સમીક્ષા સત્ર તરીકે -

28
00:01:34,770 --> 00:01:37,500
સમય અને સ્થાન માટે આ કોર્સ હોમપેજ પર જાહેરાત કરી -

29
00:01:37,500 --> 00:01:40,120
તમે બધા માટે એક એ કોર્સ શિક્ષણ ફેલો સાથે સમીક્ષા કરવાની તક મળે છે

30
00:01:40,120 --> 00:01:44,830
આ વર્ષ માટે બન્ને વિભાગમાં અને એક સંપૂર્ણ વર્ગ તરીકે, સામગ્રી,

31
00:01:44,830 --> 00:01:48,400
અને તે સામાન્ય તરીકે ફિલ્માંકન કરવામાં આવશે છે.

32
00:01:48,400 --> 00:01:53,380
>> અધિકાર છે. જેથી વધુ હેરાનગતિ વિના, પાસ પર એક ટિપ્પણી / નિષ્ફળ અને ઉમેરો / છોડો.

33
00:01:53,380 --> 00:01:57,980
તમે મારી નોંધ કરી છે છેલ્લા રાત્રે જોઈ શકે છે, અને આ ખરેખર માત્ર કેટલીક વધારાની આશ્ચાસન છે

34
00:01:57,980 --> 00:02:01,250
કે જો તમે ખાસ કરીને ઓછી આરામદાયક અથવા વચ્ચે ક્યાંક તે વચ્ચે છે

35
00:02:01,250 --> 00:02:04,870
અને તમે તમારા માથા પર ફક્ત થોડો અનુભવ કરી રહ્યાં છો,

36
00:02:04,870 --> 00:02:08,430
સમજો કે ખરેખર છે એકદમ સામાન્ય, અને ત્યાં તેની જગ્યાએ પૂરતી આધાર માળખું છે,

37
00:02:08,430 --> 00:02:13,530
એક જે ઓફિસ કલાકો મારું ઇમેઇલ છેલ્લા રાત્રે દીઠ બધી વધુ સુધારવા પર ઉદ્દેશ હતા,

38
00:02:13,530 --> 00:02:16,520
અને ખૂબ પ્રતીતિ થઈ કે પાસ જેવા વિકલ્પ / આના જેવો વર્ગ માટે નિષ્ફળ

39
00:02:16,520 --> 00:02:21,540
ખરેખર આ જેવા કોર્સ ધાર બોલ લઇ તંત્ર તરીકે રાખવાનો છે,

40
00:02:21,540 --> 00:02:24,200
જેથી ફરીથી જો તમે તે 10, 15, 20 કલાક ગાળ્યા કરી રહ્યાં છો

41
00:02:24,200 --> 00:02:28,160
માત્ર કેટલાક pset વિચાર કામ કરવાનો અને તમે જાણો છો કે તમે જે રીતે 90-95% ત્યાં હોવ

42
00:02:28,160 --> 00:02:32,100
પરંતુ તમે કેટલાક ધુત્કારી કાઢવું ​​ભૂલ શોધી, એક પાસ / માં કરી શકો છો મોડેલ કે પ્રકારની છે ઠીક નિષ્ફળ જાય છે.

43
00:02:32,100 --> 00:02:36,230
>> આ વિચાર છે કે જે તે પદ્ધતિ સાથે તમે પછી તમારી અન્ય psets પર ધ્યાન કેન્દ્રિત જઈ શકે છે

44
00:02:36,230 --> 00:02:39,530
અથવા ઊંઘ અથવા જે તે એ છે કે તમે પર ધ્યાન કેન્દ્રિત કરવા માંગો છો.

45
00:02:39,530 --> 00:02:43,390
જેથી ખ્યાલ છે કે તમે આ આગામી મંગળવાર સુધી હોય - ટેકનિકલી 5 સોમવાર,

46
00:02:43,390 --> 00:02:50,840
પરંતુ તે એક રજા છે, તેથી આ આગામી મંગળવાર - માટે પાસ સ્વિચ / ક્રમિક અથવા ઊલટું માટે નિષ્ફળ જાય છે.

47
00:02:50,840 --> 00:02:54,450
અને જો તમે કરાડ પર ખરેખર છો છે અને એકસાથે ડ્રોપ વિચારી,

48
00:02:54,450 --> 00:02:56,440
મને વ્યાખ્યાન બાદ પકડી અથવા મને નોંધ ડ્રોપ કરો.

49
00:02:56,440 --> 00:02:59,990
અમે ઓછામાં ઓછા ચેટ માટે પ્રેમ પહેલાં તમે રામરામ બિડ છો.

50
00:02:59,990 --> 00:03:03,470
અધિકાર છે. તેથી અમે છેલ્લા સમય બોલ તાલીમ વ્હીલ્સ લેતી શરૂ કર્યું.

51
00:03:03,470 --> 00:03:06,030
ખાસ કરીને, અમે શબ્દમાળા પર ધ્યાન કેન્દ્રિત કર્યું.

52
00:03:06,030 --> 00:03:09,740
શબ્દમાળા જે કશુંક CS50 પુસ્તકાલય જાહેર કરવામાં આવ્યું છે તે છે,

53
00:03:09,740 --> 00:03:14,340
ખાસ કરીને તે cs50.h તરીકે ઓળખાતી ફાઈલ માં જે અમે આ અઠવાડિયે અને આગામી જોવા શરૂ કરી શકશો.

54
00:03:14,340 --> 00:03:17,250
પરંતુ શબ્દમાળા ખરેખર કંઇક એક સરળીકરણ છે

55
00:03:17,250 --> 00:03:20,980
કે એક વધુ arcanely ઘરનાં પરચૂરણ કામો * તરીકે વર્ણવવામાં થોડું છે.

56
00:03:20,980 --> 00:03:24,090
ચાર અમે સાથે પરિચિત છો. તે માત્ર એક જ અક્ષર છે.

57
00:03:24,090 --> 00:03:28,010
પરંતુ સોમવાર તરીકે * શું સૂચિત? >> [વિદ્યાર્થી] એક નિર્દેશક.

58
00:03:28,010 --> 00:03:31,290
એક નિર્દેશક. અને નિર્દેશક શું છે? >> [વિદ્યાર્થી] એક સરનામું.

59
00:03:31,290 --> 00:03:33,420
>> તે સરનામું, મેમરીમાં સ્થાન જેવું છે.

60
00:03:33,420 --> 00:03:35,910
એક સરનામું અથવા સ્થાન અથવા મેમરી શું છે?

61
00:03:35,910 --> 00:03:40,290
ફરીથી, અમારા બધા એક જહાજની નાની હોડી અથવા RAM ના 2 ગીગાબાઇટ્સ સાથે લેપટોપ આ દિવસોમાં મોટા ભાગે હોય છે,

62
00:03:40,290 --> 00:03:44,160
અને તેનો અર્થ એ કે તમે એક અબજ અથવા 2 અબજ મેમરી વર્થ બાઇટ્સ હોય છે.

63
00:03:44,160 --> 00:03:46,240
અને તે ખરેખર તે શું શારીરિક જેવો દેખાય છે તો કોઈ વાંધો નથી,

64
00:03:46,240 --> 00:03:51,220
પરંતુ વિશ્વાસ લઇ કે તમે બધી વ્યક્તિગત બાઇટ્સ કે તમારા પોતાના લેપટોપ છે સંખ્યા કરી શકો છો -

65
00:03:51,220 --> 00:03:54,580
આ 0 બાઇટ છે, આ 1 બાઇટ છે, આ બાઇટ છે અબજ 2 -

66
00:03:54,580 --> 00:03:56,100
અને તે બરાબર એક કોમ્પ્યુટર શું કરે છે.

67
00:03:56,100 --> 00:04:00,030
જ્યારે તમે એક પાત્ર માટે જગ્યા ફાળવો, ઉદાહરણ તરીકે,

68
00:04:00,030 --> 00:04:02,480
તે દેખીતી રીતે કરવા માટે તમારા કમ્પ્યુટરની મેમરી ક્યાંક રહેતા હોય છે,

69
00:04:02,480 --> 00:04:05,860
અને કદાચ તે બાઇટ 12345 નંબર પર છે,

70
00:04:05,860 --> 00:04:08,470
અને જે ક્યાંક તમારા કમ્પ્યુટરની મેમરી માં અહીં છે.

71
00:04:08,470 --> 00:04:12,630
અને તે પાત્રની પછી સરનામા 12345 છે.

72
00:04:12,630 --> 00:04:16,140
>> હવે, 0 મારફતે હવે આમ અત્યાર સુધી સપ્તાહમાં, અમે ખરેખર નથી સંભાળ છે

73
00:04:16,140 --> 00:04:19,170
મેમરી વસ્તુઓ કારણ કે અમે સામાન્ય રીતે પ્રતીકો વાપરો કે જ્યાં સંગ્રહાય છે,

74
00:04:19,170 --> 00:04:22,540
ચલો, અને એરે ખરેખર અમારી માહિતી પર વિચાર.

75
00:04:22,540 --> 00:04:24,950
પરંતુ સોમવાર અને તમામ વધુ આજે તરીકે, તમે હવે હોય રહ્યા છીએ

76
00:04:24,950 --> 00:04:27,710
લેખન કાર્યક્રમો સાથે તમામ વધુ અર્થસભર ક્ષમતાઓ

77
00:04:27,710 --> 00:04:31,330
ખરેખર એક કમ્પ્યુટર મેમરી ચાલાકી જોકે તમે જોઈ ફિટ,

78
00:04:31,330 --> 00:04:33,720
બંને સારા હેતુઓ અને ખરાબ માટે

79
00:04:33,720 --> 00:04:39,620
ભૂલો આ સામગ્રી શીખવાની આ બિંદુ પર ખૂબ સામાન્ય પરિણામ છે.

80
00:04:39,620 --> 00:04:42,460
પરંતુ તે શું ખરેખર તેને એક કોલસો બનાવો * પ્રયત્ન અર્થ આ છે?

81
00:04:42,460 --> 00:04:46,140
ચાલો આગળ પાછળ જવા માટે - અને અમે પાછા Binky આવવા તરીકે આજે વચન પડશે.

82
00:04:46,140 --> 00:04:48,670
ચાલો એક સરળ ઉદાહરણ અહીં જાઓ.

83
00:04:48,670 --> 00:04:53,060
મને compare.c તરીકે આ ફાઈલ સંગ્રહો, અને દો મને માત્ર કેટલાક નમૂના કોડ અહીં વિચાર

84
00:04:53,060 --> 00:05:00,490
જેથી stdio.h સમાવેશ દો, મને પણ મારી જાતે આપી સમાવેશ થાય છે cs50.h. હું ત્યાં ઝૂમ પડશે.

85
00:05:00,490 --> 00:05:05,850
દો મને મુખ્ય પૂર્ણાંક, મુખ્ય (રદબાતલ) લખવાનું શરૂ કરો, અને હવે હું આ કંઈક કરવા માંગો છો:

86
00:05:05,850 --> 00:05:13,520
printf ("મને શબ્દમાળા આપો:") અને તે પછી હું ઉપયોગ કરશે શબ્દમાળા ઓ GetString નહીં

87
00:05:13,520 --> 00:05:16,750
વપરાશકર્તા માંથી શબ્દમાળા મેળવવા માટે, તે પછી હું એક બીજા માટે વપરાશકર્તા પૂછવા જાઉં છું.

88
00:05:16,750 --> 00:05:21,870
("મને અન્ય શબ્દમાળા આપો:") અને હું તેમને કે વિચાર GetString દ્વારા પૂછવા જાઉં છું.

89
00:05:21,870 --> 00:05:27,020
હું તે કહી કારણ કે ટી ​​આવે પછી ઓ અને ઓ શબ્દમાળા માટે એક સરસ નામ છે જો તે સારુ સામાન્ય કરીશું.

90
00:05:27,020 --> 00:05:30,030
તેથી GetString, અને હવે હું માત્ર એક સેનીટી ચેક કરવા માંગો છો અને હું કહેવા જાઉં છું

91
00:05:30,030 --> 00:05:39,770
જો (ઓ ટી ==) પછી હું માત્ર વપરાશકર્તા printf જણાવવું ("! તમે એક જ વસ્તુ \ n લખ્યો") જાઉં છું;

92
00:05:39,770 --> 00:05:45,520
બીજું હું બહાર જેમ ("તમે લખેલા કંઈક અલગ \! n") કંઇક છાપવા જાઉં છું

93
00:05:45,520 --> 00:05:48,460
અથવા ગમે તે સજા થશે. જેથી કંઈક.

94
00:05:48,460 --> 00:05:52,200
પછી હંમેશની જેમ, હું 0 જે ફક્ત સૂચવે કશું ખરાબ થયું કે પાછા પડશે,

95
00:05:52,200 --> 00:05:54,400
અને હું આગળ વધો અને સંકલન અને આ પ્રોગ્રામ રન જાઉં છું.

96
00:05:54,400 --> 00:05:56,540
>> પરંતુ સોમવારે અમે આ કાર્યક્રમ ચાલી હતી,

97
00:05:56,540 --> 00:06:00,420
અને ખરેખર જણાવ્યું હતું કે હેલો હેલો નથી અને ગુડબાય ગુડબાય નથી.

98
00:06:00,420 --> 00:06:03,140
આ વર્તણૂક આપણે જોયું થોડું આ જેવી વધારે હતી.

99
00:06:03,140 --> 00:06:11,450
મને મારી સ્રોત ડિરેક્ટરીમાં જાઓ, અહીં ઝૂમ, અને ચાલો તુલના કરો.

100
00:06:11,450 --> 00:06:14,570
ઠીક કમ્પાઇલ કરેલ છે. મને સ્કોર સરખામણી કરી. મને શબ્દમાળા આપો: હેલો.

101
00:06:14,570 --> 00:06:16,300
મને અન્ય શબ્દમાળા આપો: હેલો.

102
00:06:16,300 --> 00:06:18,000
તમે કંઇક અલગ લખ્યો!

103
00:06:18,000 --> 00:06:22,650
વેલ દો, મને 50 50, જેવી સરળ કંઈક પ્રયાસ કરો. તમે કંઇક અલગ લખ્યો!

104
00:06:22,650 --> 00:06:25,740
હાય, હાય. તેથી સ્પષ્ટ રીતે, કંઈક અહીં રહ્યું છે.

105
00:06:25,740 --> 00:06:28,440
પરંતુ શા માટે માટે સમજૂતી હતી?

106
00:06:28,440 --> 00:06:33,850
દેખીતી રીતે, 12 લીટી સંપૂર્ણપણે નિષ્ક્રિય છે.

107
00:06:34,300 --> 00:06:39,430
મૂળભૂત અહીં સમસ્યા શું છે? યાહ. >> [વિદ્યાર્થી] તે સરનામાં સરખામણી છે.

108
00:06:39,430 --> 00:06:41,850
અરે વાહ, બરાબર. તે વાસ્તવમાં સરનામાંઓ તુલના છે

109
00:06:41,850 --> 00:06:44,580
જેમાં હેલો હેલો અને સંગ્રહિત થાય છે.

110
00:06:44,580 --> 00:06:48,290
તે અક્ષરો હેલ્લો ન સરખામણી છે અને ફરી ફરી,

111
00:06:48,290 --> 00:06:52,370
કારણ કે ખરેખર શું થયું છે, આ બધા સમય અમે GetString નો ઉપયોગ કરી રહ્યો -

112
00:06:52,370 --> 00:06:56,130
આ વર્ગમાં વપરાતું કાળું પાટિયું ફરી અમારી કોમ્પ્યુટર મેમરી છે,

113
00:06:56,130 --> 00:07:00,100
અને ચાલો કહે હું ચલ ઓ જાહેર કર્યા પછી GetString કૉલ કરો.

114
00:07:00,100 --> 00:07:01,930
મારી યાદદાસ્ત શું લાગતું નથી?

115
00:07:01,930 --> 00:07:07,070
ચાલો આપખુદ કહે છે કે ઓ આ જેવો દેખાય છે. તે એક ચોરસ છે.

116
00:07:07,070 --> 00:07:09,040
અને ખૂબ ખૂબ કોઈપણ સમયે હું સ્ક્રીન પર મેમરી એક ભાગ ખેંચવામાં કર્યા છે

117
00:07:09,040 --> 00:07:12,860
જો તે 32 બીટ છે હું આ જેવા ચોરસ કરવામાં ચિત્રકામ કરેલા ઉપકરણ કારણ કે ખરેખર,

118
00:07:12,860 --> 00:07:17,380
એક નિર્દેશક, એક સરનામું, 32 બિટ્સ છે. તે પૂર્ણાંક તરીકે જ છે.

119
00:07:17,380 --> 00:07:19,420
તે કમ્પ્યુટર સિસ્ટમ પર આધારિત હોઈ શકે છે.

120
00:07:19,420 --> 00:07:24,630
તમે જે લોકો ડાઘ એ હકીકત છે કે જે તમારા Mac અથવા પીસી 64 બિટ્સ સાથે પરિચિત હોય છે,

121
00:07:24,630 --> 00:07:28,120
કે જે વાસ્તવમાં સૂચવે છે કે જે તમારા કમ્પ્યુટરને 64-bit પોઇંટરો ઉપયોગ કરે છે,

122
00:07:28,120 --> 00:07:33,730
64-bit સરનામાંઓ, અને તેનું upsides વચ્ચે તમારા કમ્પ્યુટર્સ છે

123
00:07:33,730 --> 00:07:35,560
yesteryear કરતાં ખૂબ વધુ RAM હોય શકે છે.

124
00:07:35,560 --> 00:07:39,240
લાંબા વાર્તા ટૂંકા, એ દિવસે પાછા જ્યારે કમ્પ્યુટર્સ માત્ર 32 બિટ્સ ઉપયોગ

125
00:07:39,240 --> 00:07:42,740
માટે સરનામાં પ્રતિનિધિત્વ કરે છે, બાઇટ્સ મોટામાં નંબર તમે પ્રતિનિધિત્વ કરી શકે છે

126
00:07:42,740 --> 00:07:46,280
તે કિસ્સામાં હતું શું જો તમે 32 બિટ્સ છે?

127
00:07:46,280 --> 00:07:49,590
4 તેથી અબજ, જમણે, કારણ કે 2 32 બિલિયન 4 છે.

128
00:07:49,590 --> 00:07:51,370
આ નંબર કોર્સ કરવામાં રિકરિંગ છે.

129
00:07:51,370 --> 00:07:55,240
>> તેથી જો તમે માત્ર 32 બિટ્સ હોય, સૌથી વધુ સંખ્યામાં તમે ગણતરી કરી શકે છે 4 આશરે અબજ.

130
00:07:55,240 --> 00:07:58,750
પરંતુ તે થોડા વર્ષો પહેલા સુધી કોમ્પ્યુટર્સ એક મૂળભૂત મર્યાદા હતી

131
00:07:58,750 --> 00:08:01,180
જો તમે માત્ર 4 બિલિયન તરીકે ઉચ્ચ ગણતરી કરી શકે છે કારણ કે,

132
00:08:01,180 --> 00:08:05,270
જો તમે RAM ની 8 ગીગાબાઇટ્સ અથવા તો RAM ના 5 ગીગાબાઇટ્સ ખરીદી વાંધો નથી;

133
00:08:05,270 --> 00:08:07,780
તમે જે ઉચ્ચ ગણતરી છે, તેથી તેને નકામી થઇ હતી.

134
00:08:07,780 --> 00:08:11,430
તમે ફક્ત તમારા કમ્પ્યુટરની મેમરી પ્રથમ 3 અથવા 4 ગીગાબાઇટ્સ ઍક્સેસ કરી શકે છે.

135
00:08:11,430 --> 00:08:14,410
આ એક મુદ્દો ઓછી હવે, અને તમે MacBook પ્રો અને Dells ખરીદી શકો છો

136
00:08:14,410 --> 00:08:17,680
RAM ની 8 ગીગાબાઇટ્સ અથવા વધુ પણ આ દિવસોમાં સાથે.

137
00:08:17,680 --> 00:08:24,100
પરંતુ જો હું આ કાર્યક્રમમાં તદ્દન ખાલી નિર્દેશક ફાળવો, એક નિર્દેશક ઓ કહેવાય છે,

138
00:08:24,100 --> 00:08:28,370
આ જેવા સ્ક્રીન પર જોવા કારણ કે ખરેખર અમે પાછા છાલ આ સ્તર કરવાની જરૂર પડી શકે છે.

139
00:08:28,370 --> 00:08:33,520
હું કહેતા શબ્દમાળા રાખવા, પરંતુ સોમવાર તરીકે, શબ્દમાળા ખરેખર ઘરનાં પરચૂરણ કામો * છે,

140
00:08:33,520 --> 00:08:35,590
કેટલાક પાત્રની સરનામું.

141
00:08:35,590 --> 00:08:39,280
તેથી આપણે કે તાલીમ વ્હીલ બોલ લેવા છતાં પણ આપણે હવે માટે GetString ઉપયોગ ચાલુ રાખવા પડશે.

142
00:08:39,280 --> 00:08:42,600
તેથી હું ઓ જાહેર કર્યું છે, અને આ મેમરી એક ભાગ, 32 બિટ્સ છે.

143
00:08:42,600 --> 00:08:47,370
શું મૂળભૂત દ્વારા મેમરી અહીં છે? >> [અશ્રાવ્ય વિદ્યાર્થી જવાબ]

144
00:08:47,370 --> 00:08:50,040
કે શું છે? >> [વિદ્યાર્થી] ગાર્બેજ. >> ગાર્બેજ. બરાબર.

145
00:08:50,040 --> 00:08:54,610
જો તમે પ્રોગ્રામર એક ચલ એક મૂલ્ય નથી મૂકી નથી, કોણ જાણે તે શું છે?

146
00:08:54,610 --> 00:08:57,990
ક્યારેક તમે નસીબદાર વિચાર અને તેને 0 છે, કે જે સરસ, સ્વચ્છ મૂળભૂત કિંમત પ્રકારની છે,

147
00:08:57,990 --> 00:09:00,310
પરંતુ અમે જોયું સોમવાર, ક્યારેક તે સંપૂર્ણપણે નકામુ છે,

148
00:09:00,310 --> 00:09:04,130
કેટલાક ખરેખર મોટી સકારાત્મક કે નકારાત્મક સંખ્યા છે કે જ્યાં તરફથી આવ્યા હતા?

149
00:09:05,350 --> 00:09:07,010
યાહ. >> [વિદ્યાર્થી] પહેલાં આ કાર્ય કરે છે. >> યાહ.

150
00:09:07,010 --> 00:09:10,170
>> ઘણીવાર કાર્ય કે જે પહેલાં કારણ કે યાદ કહેવાય મળ્યો,

151
00:09:10,170 --> 00:09:13,920
જેમ તમે મેમરી કાર્યો કૉલ, તેઓ નીચે થી વધુ અને વધુ જગ્યા લેવા અપ

152
00:09:13,920 --> 00:09:17,040
અને તરીકે કાર્ય વળતર જલદી છે, કે જે મેમરી ફરીથી નહીં

153
00:09:17,040 --> 00:09:20,890
આગામી વ્યક્તિ કે કહેવાય નહીં દ્વારા, જે તમારી મેમરી સમાન સ્લાઇસ વાપરી રહ્યા છે.

154
00:09:20,890 --> 00:09:23,450
અને જો તમે ડાબી ત્યાં કચરો, અગાઉના કિંમતો કરેલા,

155
00:09:23,450 --> 00:09:28,190
અમે કેટલીક કિંમત કર્યા ત્યારે ખરેખર આપણે કંઈ પણ ત્યાં મૂકી છે કારણ ઓ ભૂલથી શકે છે.

156
00:09:28,190 --> 00:09:30,960
તેથી આ બિંદુ પર અમારી રેમ આ જેવો દેખાય છે.

157
00:09:30,960 --> 00:09:36,030
હવે 7 લીટીના બાજુ જમણી બાજુ આપણે GetString કૉલ કરી રહ્યાં છો,

158
00:09:36,030 --> 00:09:40,150
જે અમે અઠવાડિયા માટે થઈ હવે કરવાનું છે, પરંતુ ખરેખર શું કરવાનું GetString છે?

159
00:09:40,150 --> 00:09:43,350
આ CS50 સ્ટાફ દ્વારા લખવામાં GetString થોડો બુદ્ધિશાળી છે

160
00:09:43,350 --> 00:09:46,500
કે જલદી વપરાશકર્તા શરૂ થાય લખીને કીઓ અને હિટ દાખલ કરો,

161
00:09:46,500 --> 00:09:50,010
GetString બહાર આધાર કેટલા કીસ્ટ્રોક વપરાશકર્તા હિટ હતી,

162
00:09:50,010 --> 00:09:53,360
કેટલા અક્ષરો હું માટે રેમ ફાળવણી કરવાની જરૂર નથી.

163
00:09:53,360 --> 00:09:55,660
અને જ્યાં કે રેમ આવે છે, જેઓ જાણે છે?

164
00:09:55,660 --> 00:09:58,930
તે તમારા કમ્પ્યુટર 2 ગીગાબાઇટ્સ અથવા મેમરી whatnot ક્યાંક છે.

165
00:09:58,930 --> 00:10:05,200
દો પરંતુ ધારો કે કમ્પ્યૂટર હેલ્લો શબ્દ માટે જગ્યા અહીં જોવા મળે છે.

166
00:10:05,200 --> 00:10:08,710
શબ્દ હું લખ્યો H-ઇ એલ એલ-O હતી.

167
00:10:08,710 --> 00:10:13,510
અને જો આપણે અક્ષરો ક્રમ તરીકે આ ડ્રો, અમે તેને આ જેવા દોરે.

168
00:10:13,510 --> 00:10:17,860
પણ હું 1 વધારાના વસ્તુ કરવાની જરૂર છે. શું સી કોઈપણ શબ્દમાળા ઓવરને અંતે અનુલક્ષે છે?

169
00:10:17,860 --> 00:10:20,710
આ નલ પાત્ર, જે અમે 0 \ તરીકે લખી.

170
00:10:20,710 --> 00:10:23,980
તે ટેકનિકલી નંબર 0 છે, પરંતુ બેકસ્લેશ તમામ સ્પષ્ટ કરે છે

171
00:10:23,980 --> 00:10:28,150
કે આ અર્થ 0 નંબર, પૂર્ણાંક 0 છે;

172
00:10:28,150 --> 00:10:32,440
તે, ઉદાહરણ તરીકે, 0 ક્વોટ-અવતરણ ચિહ્નો પૂરાં કરવાં કે તમે કીબોર્ડ લખો શકે છે માટે નથી.

173
00:10:32,440 --> 00:10:33,940
તેથી આ હેલ્લો છે.

174
00:10:33,940 --> 00:10:36,350
>> અને આપણે જે સોમવારે કહ્યું નહોતું કે GetString જેમ કાર્ય

175
00:10:36,350 --> 00:10:39,580
છે ખરેખર આ બધા અઠવાડિયા પરત?

176
00:10:39,580 --> 00:10:43,960
તે સે દીઠ શબ્દમાળા પાછા ન કારણ કે તે ખરેખર નથી જેનો અર્થ નથી છે છે

177
00:10:43,960 --> 00:10:47,710
કારણ કે શબ્દમાળાઓ અસ્તિત્વમાં નથી. તેઓ CS50 પુસ્તકાલય એક ફેબ્રિકેશન જેવું છો.

178
00:10:47,710 --> 00:10:51,300
શું ખરેખર એક સ્ટ્રિંગ છે, વધુ તકનિકી? >> [વિદ્યાર્થી] તે પ્રથમ અક્ષર છે.

179
00:10:51,300 --> 00:10:55,950
બરાબર. તે તદ્દન સરળ પ્રથમ અક્ષર ની સરનામા છે કે જે વપરાશકર્તા સાઇન લખ્યો

180
00:10:55,950 --> 00:11:02,810
તેથી જો મારા શબ્દ હેલો તે બાઇટ નંબર 123 પર અને પછી બાઇટ 124 નંબર પર થાય,

181
00:11:02,810 --> 00:11:08,320
125, 126, અને તેથી આગળ, જો હું 0 થી હમણાં પર મારી બાઇટ્સ નંબર,

182
00:11:08,320 --> 00:11:12,650
ખરેખર GetString પરત છે શું શાબ્દિક સંખ્યા 123 છે.

183
00:11:12,650 --> 00:11:19,270
તેથી નહીં s માં મૂકી શું નંબર 123, નથી અક્ષર એચ શબ્દ છે હેલો,

184
00:11:19,270 --> 00:11:23,130
તદ્દન ખાલી સરનામા કે હું હેલો પ્રથમ અક્ષર શોધી શકો છો.

185
00:11:23,130 --> 00:11:26,500
પરંતુ તે પર્યાપ્ત નથી લાગતું નથી. હું તમને એક શબ્દમાળા માટે પૂછ્યું છે, પાત્ર નથી.

186
00:11:26,500 --> 00:11:32,970
તેથી અમે અથવા કોમ્પ્યુટર કેવી રીતે જાણી શકું ELLO પ્રકારની એચ સાથે આવે છે કે?

187
00:11:35,760 --> 00:11:37,460
કરારની સૉર્ટ અમારી પાસે શું છે? યાહ.

188
00:11:37,460 --> 00:11:40,100
[વિદ્યાર્થી] તે પોતે કહેવાની કેટલીક વધુ અક્ષરો શોધવા માટે રાખે છે. ચોક્કસ. >>

189
00:11:40,100 --> 00:11:44,570
>> આ સંમેલનમાં માનવ કમ્પ્યુટર જેમાં જ્યારે તમે શબ્દમાળાઓ સાથે વ્યવહાર કરવામાં આવે છે છે,

190
00:11:44,570 --> 00:11:49,410
અન્યથા ઘરનાં પરચૂરણ કામો તારા તરીકે હવે ઓળખાય છે, તમે ખાલી બહાર આકૃતિ હોય છે

191
00:11:49,410 --> 00:11:54,350
જ્યાં જીવન માં દરેક શબ્દમાળા ઓવરને ખરેખર માત્ર લૂપ માટે એક સાથે ઉપર વારો છે,

192
00:11:54,350 --> 00:11:57,820
જ્યારે લૂપ, ગમે છે, કે જેથી જ્યારે તમે શબ્દમાળા ઓવરને શોધવા

193
00:11:57,820 --> 00:12:02,160
હવે તમે તે અટકળ બાંધવી શકે છે, ઓહ, સમગ્ર શબ્દ હેલો હતી.

194
00:12:02,160 --> 00:12:04,820
પહેલાં પ્રોગ્રામિંગ અનુભવ સાથે તમે તે જાવા ખબર પડી શકે છે

195
00:12:04,820 --> 00:12:09,880
તમે હમણાં જ ફોન કરો. લંબાઈ શકે છે અને અન્ય ભાષાઓમાં તમે લંબાઈ અથવા સમાન કૉલ કરી શકો છો.

196
00:12:09,880 --> 00:12:14,060
કે કારણ કે ભાષાઓ ઘણો છે, ખાસ કરીને વસ્તુઓ ભાષાઓ પદાર્થ આધારિત કહે છે,

197
00:12:14,060 --> 00:12:18,580
કંઈક લંબાઈ પોતે માહિતી ના ભાગ ની સમાઇ અંદર પ્રકારની છે,

198
00:12:18,580 --> 00:12:24,000
ખૂબ અમે સમાઇ ID અને નામો અને સોમવારે એક વિદ્યાર્થી ની અંદર ગૃહો ગમે છે.

199
00:12:24,000 --> 00:12:28,700
પરંતુ સી ઘણા નીચા સ્તરે છે. ત્યાં કોઈ વસ્તુઓ અથવા વર્ગો છે, જો તમે તે શરતો સાંભળ્યું કર્યું છે તે પહેલાં.

200
00:12:28,700 --> 00:12:31,490
તમારી પાસે ખરેખર મેમરી સરનામાંઓ છે.

201
00:12:31,490 --> 00:12:35,540
તેથી આ રસપ્રદ માહિતી માળખાં પ્રતિનિધિત્વ રીતે જૂના જમાનાનું જેવું છે.

202
00:12:35,540 --> 00:12:38,760
તમે પ્રથમ અક્ષર ની સરનામા જેવી શરૂઆતની કિંમત હોય છે

203
00:12:38,760 --> 00:12:42,340
અને પછી માત્ર કેટલાક મનસ્વી સંમેલન કે દરેકને અનુસરો સંમત થાય છે.

204
00:12:42,340 --> 00:12:46,420
આમ કેવી રીતે શબ્દમાળા લંબાઈ અમલમાં મૂકાયેલ છે, અમે દરખાસ્ત મુકી ન હતી?

205
00:12:46,420 --> 00:12:51,360
Strlen, strlen, કે જે તમને કેટલાક હવે થોડા વખત ઉપયોગ કર્યો છે. તે ખૂબ સરળ અધિકાર છે?

206
00:12:51,360 --> 00:12:53,060
તે કોડ 2 રેખાઓ જેવું છે.

207
00:12:53,060 --> 00:12:56,140
તે ખરેખર ખૂબ અમુક પ્રકારની એક માટે લૂપ છે વધારાની સ્થાનિક ચલ સાથે કદાચ.

208
00:12:56,140 --> 00:13:00,540
પરંતુ strlen માત્ર એક નિર્દેશક લો અને પછી શરૂ 0 \ શોધી છે.

209
00:13:00,540 --> 00:13:05,190
>> અને જલદી તેને શોધે છે, તે પગલાંઓ કે જેઓ શબ્દમાળા લેવામાં આવ્યું છે તે કુલ સંખ્યા પાછા આવી શકો છો.

210
00:13:05,190 --> 00:13:07,150
તેથી અમે આ અટકળ બાંધવી શું આગામી પર કોઈ રન નોંધાયો નહીં કરી શકે છે.

211
00:13:07,150 --> 00:13:11,850
પછી ધારો હું ટી જાહેર હું 10 લીટી માં કર્યું છે.

212
00:13:11,850 --> 00:13:14,280
આ અમુક કચરો કિંમત છે. કોણ પ્રથમ જાણે?

213
00:13:14,280 --> 00:13:18,490
પરંતુ 10 વાક્ય બાજુ જમણી બાજુ પર હું ફરીથી GetString કૉલ છું.

214
00:13:18,490 --> 00:13:20,050
કોણ જાણે જ્યાં આ થાય?

215
00:13:20,050 --> 00:13:23,830
ચાલો આપખુદ કહે છે કે ઓપરેટિંગ સિસ્ટમ પર અહીં માર્ગ માટે જગ્યા મળી નથી.

216
00:13:23,830 --> 00:13:28,610
હું સાંયોગિક H-ઇ એલ એલ ઓ લખો ફરીથી થાય છે,

217
00:13:28,610 --> 00:13:31,260
અને તેથી અમે ચિત્ર આ પ્રકારના જ ડ્રો કરી શકો છો.

218
00:13:31,260 --> 00:13:34,290
પરંતુ હકીકત એ છે કે હું સ્થપાયો આ ચિત્ર કરેલા ઇરાદાપૂર્વકની છે

219
00:13:34,290 --> 00:13:37,720
કારણ કે આ એક કરતાં અલગ હેલ્લો છે.

220
00:13:37,720 --> 00:13:43,920
અહીં આ 456 સ્થાન હોઇ શકે છે, આ 457 છે, અને તેથી આગળ.

221
00:13:43,920 --> 00:13:47,170
તેથી શું જ્યાં પ્રશ્ન ચિહ્ન વાર હતી મૂકવા નહીં?

222
00:13:47,170 --> 00:13:50,190
આ 456 કેસ છે.

223
00:13:50,190 --> 00:13:53,540
અમે આ નંબર ચૂંટવું કરી રહ્યાં છો આપખુદ આજે પછી કારણ કે ખરેખર

224
00:13:53,540 --> 00:13:57,110
અમે કાંઇ ના સરનામા શું છે તે અંગે ખૂબ જ કાળજી નથી જઈ રહ્યાં છો.

225
00:13:57,110 --> 00:14:02,690
બધા અમે વિશે કાળજી છે કે અમે હેલો જેવા માહિતી અમુક ભાગ ના સરનામા આકૃતિ કરી શકો છો.

226
00:14:02,690 --> 00:14:07,100
>> તેથી ખરેખર મોટા ભાગના લોકો શું કમ્પ્યૂટર સાયન્સ કરવા જ્યારે મેમરી સરનામાંઓ વિશે વાત

227
00:14:07,100 --> 00:14:10,210
અને પોઇંટરો વિશે ખાસ વાત,

228
00:14:10,210 --> 00:14:14,220
કોણ રાખે છે જ્યાં આ સામગ્રી ખરેખર છે, - બદલે બહાર figuring 123 સંતાપ

229
00:14:14,220 --> 00:14:17,440
અમે જરા પણ ખબર છે કે તે અમુક સંખ્યાત્મક સરનામાં પર છે -

230
00:14:17,440 --> 00:14:22,180
અમે વિશ્વ સરળ અને માત્ર કહે છે કે ઓ કે અક્ષર પોઇન્ટ છે

231
00:14:22,180 --> 00:14:25,080
અને ટી કે અક્ષર પોઇન્ટ છે.

232
00:14:25,080 --> 00:14:27,430
અને હકીકત એ છે કે તે એક તીર છે તદ્દન ઇરાદાપૂર્વક છે

233
00:14:27,430 --> 00:14:31,610
કારણ કે શાબ્દિક હવે ઓ એચ અને ટી તરફ સંકેત છે અન્ય એચ તરફ સંકેત છે

234
00:14:31,610 --> 00:14:34,720
કારણ કે આ દિવસે ઓવરને અંતે, તે વાંધો સરનામું શું છે નથી કરતું નથી,

235
00:14:34,720 --> 00:14:40,240
પરંતુ તે બાબત કે અમે કોડ કેટલાક ભાગ સાથે તે સરનામા વ્યક્ત કરવાની ક્ષમતા હોય છે.

236
00:14:40,240 --> 00:14:42,730
અમે ખરેખર આ સરનામાં ચાલાકીથી છે હજુ સુધી

237
00:14:42,730 --> 00:14:47,770
તેથી અમે જોશો જ્યાં અમે વચ્ચે નાખવું અને સૉર્ટ ઓફ પોઇન્ટર સાથે વસ્તુઓ કરી શકો છો,

238
00:14:47,770 --> 00:14:52,030
પરંતુ હવે લીટી માટે 12 શાબ્દિક શું કિંમતો અમે સરખામણી કરી રહ્યા હોય

239
00:14:52,030 --> 00:14:55,500
અનુસાર 12 લીટી માં આ વાર્તા માટે?

240
00:14:56,570 --> 00:15:01,290
અમે કહી રહ્યાં 123 456 માટે સમાન સમાન છે? અને તે ચોક્કસપણે કેસ નથી.

241
00:15:01,290 --> 00:15:05,320
અને પણ ખ્યાલ પ્રમાણે, આ નિર્દેશક ચોક્કસપણે આ જ નથી

242
00:15:05,320 --> 00:15:09,500
કારણ કે તમે બે વાર GetString કહેવાય છે, અને GetString માટે હોંશિયાર સુપર નથી પ્રયાસ કરતું નથી,

243
00:15:09,500 --> 00:15:12,470
તે ખ્યાલ નથી પ્રયાસ કરતું નથી, ઓહ, તમે હેલો 5 મિનિટ પહેલા લખ્યો;

244
00:15:12,470 --> 00:15:15,090
દો મને તમે જ નિર્દેશક આપો હું તમને પહેલાં આપ્યું,

245
00:15:15,090 --> 00:15:18,450
તે માત્ર મેમરી એક નવી ભાગ દરેક વખતે તમે તેને કહી ફાળવે છે.

246
00:15:18,450 --> 00:15:20,350
>> કેવી રીતે અમે આ સમસ્યા ઠીક કરું?

247
00:15:20,350 --> 00:15:24,270
ઊંચા સ્તર જો હું હેલો હેલો અને શબ્દમાળાઓ તુલના કરવા માંગો છો -

248
00:15:24,270 --> 00:15:28,680
હું પોઇંટરો વિશે કાળજી નથી - કેવી રીતે હું પ્રશ્નનો જવાબ જઈ નથી,

249
00:15:28,680 --> 00:15:31,980
તેણે વપરાશકર્તા એ જ વસ્તુ લખ્યું છે? શું જરૂરી અહીં છે? યાહ.

250
00:15:31,980 --> 00:15:35,200
[વિદ્યાર્થી] કાર્ય વાપરો. >> હું બોક્સ એક કાર્ય બહાર વાપરી શકો છો.

251
00:15:35,200 --> 00:15:38,170
હું strcmp, ઓ ટી-r-c-m-p કહેવાય વિધેય વાપરી શકે છે,

252
00:15:38,170 --> 00:15:41,190
ફક્ત કહેતા શબ્દમાળા સરખાવવા ઓફ સંક્ષિપ્ત આવૃત્તિ.

253
00:15:41,190 --> 00:15:45,070
અને જો આપણે જાય, દાખલા તરીકે, 2 તુલના, જે આજે handouts વચ્ચે હોય છે,

254
00:15:45,070 --> 00:15:46,690
હું કે બરાબર નથી.

255
00:15:46,690 --> 00:15:51,750
હું નીચે પર 26 જેથી અથવા બાકીનું બધું રેખા 1 એ જ રાખવામાં આવે છે,

256
00:15:51,750 --> 00:15:54,360
અને હવે નોટિસ આ ભાગ માત્ર થોડો ફેરફાર આવ્યો છે.

257
00:15:54,360 --> 00:15:57,690
ચાલો એક ક્ષણ માટે 28 લીટી અવગણો અને આ એક માત્ર ભાર મૂકે છે.

258
00:15:57,690 --> 00:16:00,410
અમે શું સોમવારે કહ્યું નહોતું કે str સરખાવો કરે છે?

259
00:16:00,410 --> 00:16:05,200
આ કિસ્સામાં 2 પોઇન્ટર, ઓ અને ટી લેવાની પ્રક્રિયા સંભાળે છે,

260
00:16:05,200 --> 00:16:08,480
પ્રકારના વર્ચ્યુઅલ તે 2 અક્ષરો પર તેની આંગળી મૂકી,

261
00:16:08,480 --> 00:16:11,530
અને તે કરવું જ પડશે કે શું એક વખતે કે લૂપ માટે લૂપ એક કંઈક છે,

262
00:16:11,530 --> 00:16:16,050
અને તે કહે છે કે આ છે એ જ? જો આમ હોય, તો તે આંગળીઓ અથવા આગળ પોઇંટરો ખસે છે.

263
00:16:16,050 --> 00:16:17,970
આ છે એક જ, આ જ, આ જ,

264
00:16:17,970 --> 00:16:22,710
આ જ રીતે, આ જ? Ooh અને, હું બંને ઓ અને ટી અંતે શબ્દમાળા ઓવરને અંતે છું.

265
00:16:22,710 --> 00:16:26,780
હું કોઇ પણ વિરોધાભાસ મળ્યા નથી. હા, આ શબ્દમાળાઓ જ છે.

266
00:16:26,780 --> 00:16:31,940
અને શું str વળતર તુલના નથી જો 2 શબ્દમાળાઓ સમાન હોય છે દેખીતી રીતે? શૂન્ય.

267
00:16:31,940 --> 00:16:35,900
0 તેથી આ કિસ્સામાં સારી છે કારણ કે જો તે -1 અથવા +1 આપે,

268
00:16:35,900 --> 00:16:40,560
કે અર્થ એ થાય કે ઓ માત્ર ટી મૂળાક્ષરોની પહેલાં અથવા ટી પછી આવો બને છે.

269
00:16:40,560 --> 00:16:43,760
અને શા માટે છે કે જે ઉપયોગી હોઈ કાર્ય છે કે જે તમને કહે છે કે શબ્દમાળા પહેલા આવે પડશે

270
00:16:43,760 --> 00:16:46,720
કે પછી એક શબ્દકોશ?

271
00:16:46,720 --> 00:16:48,740
[વિદ્યાર્થી] શોધી રહ્યું છે. >> શોધી અને સૉર્ટ.

272
00:16:48,740 --> 00:16:51,730
>> તેથી તમે બાઈનરી શોધ અથવા બબલ સૉર્ટ કરવા જેવી વસ્તુઓ અથવા સૉર્ટ મર્જ કરી શકો છો

273
00:16:51,730 --> 00:16:53,230
જ્યાં તમે વસ્તુઓ સરખાવવા છે.

274
00:16:53,230 --> 00:16:56,420
આમ અત્યાર સુધીમાં અમે કેટલાક ખૂણા કાપવામાં પ્રકારની કરેલા અને માત્ર સૉર્ટ વિશે વાત કરી

275
00:16:56,420 --> 00:16:59,430
નંબરો સંદર્ભમાં કારણ કે તે સરસ અને સરળ છે તે વિશે વાત,

276
00:16:59,430 --> 00:17:02,430
પરંતુ તમે ચોક્કસપણે શબ્દમાળાઓ સફરજન, અને કેળાના તુલના કરી શકો છો,

277
00:17:02,430 --> 00:17:05,349
જો સફરજન માટે કેળાના પહેલા આવે છે, તેવી જ રીતે ઓળખવામાં આવે છે કારણ કે,

278
00:17:05,349 --> 00:17:09,319
તમે આસપાસ શબ્દમાળાઓ ખસેડી શકો છો રોબ જેમ જ મેમરીમાં કર્યું વિડિઓ માં મર્જ સૉર્ટ સાથે

279
00:17:09,319 --> 00:17:15,880
અને અમે પસંદગી સૉર્ટ કરો, નિવેશ સૉર્ટ કરો, અને પરપોટો સૉર્ટ સાથે સ્ટેજ પર અહીં કર્યું હતું.

280
00:17:15,880 --> 00:17:18,710
તેથી બીજું જ્યાં અમે આ સમય લાગી શકે છે? ચાલો આ પ્રયાસ કરો.

281
00:17:18,710 --> 00:17:23,980
ચાલો જેવું એક ક્ષણ માટે તે પાઠ ભૂલી જાઓ અને હવે પ્રયાસ અને નીચેના કરવું 1.c નકલ કરો.

282
00:17:23,980 --> 00:17:26,800
21 લીટી માં હું પ્રિન્ટ કંઈક કહી રહ્યો છું,

283
00:17:26,800 --> 00:17:28,520
પછી હું વપરાશકર્તા તરફથી એક શબ્દમાળા મેળવવામાં છું,

284
00:17:28,520 --> 00:17:30,690
પછી હું આ ચકાસણી છું.

285
00:17:30,690 --> 00:17:33,620
અમે ખરેખર આ આદત માં મેળવેલ છે હજુ સુધી, પરંતુ આપણે હવે આ નથી.

286
00:17:33,620 --> 00:17:40,990
ની ખરેખર દો પાછળ આ સ્તર છાલ. આ ખરેખર કામની પાળી * છે. આ વ્યક્તિ ખરેખર ઘરનાં પરચૂરણ કામો * છે.

287
00:17:40,990 --> 00:17:45,690
તેથી તે શું ઓ == NULL જો ચકાસણી કરી અર્થ છે?

288
00:17:45,690 --> 00:17:48,380
તે તારણ છે કે જ્યારે તમે GetString જેમ કાર્ય કૉલ

289
00:17:48,380 --> 00:17:51,540
અથવા વધુ સામાન્ય રીતે ફક્ત કમ્પ્યુટર તમને અમુક મેમરી આપવા માટે,

290
00:17:51,540 --> 00:17:53,030
કંઈક ખોટું થાય તો કરી શકે છે.

291
00:17:53,030 --> 00:17:56,630
તમે ઉન્મત્ત પ્રયત્ન અને મેમરીની ટેરાબાઈટ માટે કોમ્પ્યુટર પૂછી શકે છે

292
00:17:56,630 --> 00:18:01,780
મેમરી બાઇટ્સ કે જે ફક્ત કોમ્પ્યુટર અસ્તિત્વમાં નથી ટ્રિલિયન માટે પુછે છે,

293
00:18:01,780 --> 00:18:05,130
પરંતુ GetString અને અન્ય કાર્યો તમે yelling કેટલાક માર્ગ જરૂર

294
00:18:05,130 --> 00:18:06,820
જો તમે ખૂબ માટે પૂછ્યું છે.

295
00:18:06,820 --> 00:18:10,450
અને જે રીતે GetString કરે છે જો તમે વધુ મેમરી માટે પૂછ્યું છે

296
00:18:10,450 --> 00:18:14,250
કરતાં કમ્પ્યુટર માં ઉપલબ્ધ છે, જો તે સુપર, સુપર ઓછી સંભાવના છે

297
00:18:14,250 --> 00:18:17,730
કારણ કે અમને કંઈ એક ટ્રિલિયન અક્ષરો લખો અને પછી Enter હિટ જતાં હોય છે,

298
00:18:17,730 --> 00:18:21,980
પરંતુ ઓછી સંભાવના છે, છતાં તેને હોઈ શકે છે, હું હજુ પણ તે માટે ફક્ત કેસ તપાસ કરવા માંગો છો,

299
00:18:21,980 --> 00:18:26,120
અને ખાસ કિંમત GetString, જવાબ, અને અન્ય કાર્યો વળતર કે

300
00:18:26,120 --> 00:18:30,630
જો કંઈક ખોટું ગયું તમામ કેપ્સ માં NULL છે.

301
00:18:30,630 --> 00:18:36,520
>> અને શું NULL છે? NULL જ એક નિર્દેશક પ્રતિનિધિત્વ થાય છે. તે મેમરી સરનામા 0 છે.

302
00:18:36,520 --> 00:18:40,800
વિશ્વ કે આપખુદ નિર્ણય લીધો, જો આ મારા કમ્પ્યુટર મેમરી છે -? તમે શું જાણો છો -

303
00:18:40,800 --> 00:18:46,260
અમે ફક્ત દરેક કમ્પ્યુટર મેમરી 1 બાઇટ ચોરી જઈ રહ્યાં છો, અને આ 0 સ્થાન છે.

304
00:18:46,260 --> 00:18:49,560
અમે તેને NULL એક ઉપનામ આપવા જઈ રહ્યાં છો, અને અમે વચન જઈ રહ્યાં છો

305
00:18:49,560 --> 00:18:52,660
કે અમે ખરેખર વાસ્તવિક માહિતી ત્યાં ક્યારેય મુકીશું

306
00:18:52,660 --> 00:18:56,770
કારણ કે અમે માત્ર આપખુદ એક ખાસ મૂલ્ય 0, ઉર્ફ NULL જરૂર છે,

307
00:18:56,770 --> 00:19:00,230
તેથી અમે વપરાશકર્તાઓ કિકિયારી જો કંઈક ખોટું કરી શકો છો.

308
00:19:00,230 --> 00:19:03,590
અન્યથા તમને ખબર નથી શકે 0 અર્થ કંઈક અહીં મૂકો

309
00:19:03,590 --> 00:19:05,490
અથવા તેને એવો નથી કંઈક ખોટું થયું?

310
00:19:05,490 --> 00:19:09,190
અમે બધા સંમત છે કે NULL અર્થ કંઇ પરત કરવામાં આવી હતી,

311
00:19:09,190 --> 00:19:11,700
કોઈ વાસ્તવિક સરનામા પરત ફર્યા હતા.

312
00:19:11,700 --> 00:19:15,210
હવે, અહીં હું ફક્ત મારા હું માનવ સંમેલન અપનાવવા છું મુખ્ય માંથી 1 પાછા

313
00:19:15,210 --> 00:19:17,040
જો કંઈક ખોટું.

314
00:19:17,040 --> 00:19:20,650
કે કારણ મુખ્ય વળતર સંમેલનમાં 0 જો સારા પરત છે,

315
00:19:20,650 --> 00:19:22,990
1 અથવા અમુક જો ખરાબ અન્ય મૂલ્ય.

316
00:19:22,990 --> 00:19:28,200
પરંતુ GetString અને કોઈપણ કાર્ય કે મેમરી NULL વળતર માં સોદા જો કંઈક ખરાબ જાય છે.

317
00:19:28,200 --> 00:19:33,480
>> ઠીક છે. તેથી દુર્ભાગ્યે, 27 લીટી, એ છતાં સુપર સરળ, સંપૂર્ણ શબ્દમાળા નકલ નિષ્ફળ જાય છે.

318
00:19:33,480 --> 00:19:35,740
શા માટે? અમે જોઈ શકો છો આ અનુસરે છે.

319
00:19:35,740 --> 00:19:40,120
હું 27 લીટી દાવો કરી રહ્યો છું ને એક નકલ કરી અને તે કહે છે.

320
00:19:40,120 --> 00:19:45,790
તેથી હું 2 આ સમય શબ્દમાળાઓ માટે વપરાશકર્તા નથી જણાવી રહ્યો છું; હું ફક્ત ઓ માં કિંમત કહી રહ્યો છું

321
00:19:45,790 --> 00:19:47,870
ટી માં પણ મૂકવામાં આવવો જોઈએ.

322
00:19:47,870 --> 00:19:52,890
તેથી હવે માત્ર નિદર્શન માટે તૂટેલા આ કેવી રીતે થાય છે, રેખા, 29 આગળ હું શું કરી રહ્યો છું?

323
00:19:52,890 --> 00:19:56,980
પ્રથમ હું જો ટી લંબાઈ 0 કરતાં મોટો છે ચકાસણી છું.

324
00:19:56,980 --> 00:19:59,330
કેટલાક ત્યાં શબ્દમાળા છે. વપરાશકર્તા સાઇન કંઈક લખ્યો

325
00:19:59,330 --> 00:20:03,410
32 કરવાનું લાઇન, દેખીતી રીતે શું છે?

326
00:20:03,410 --> 00:20:08,910
[અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] >> અધિકાર. તમે પ્રકારની તે હું શું કહ્યું કે તે કરવાનું છે માંથી અટકળ બાંધવી કરી શકો છો.

327
00:20:08,910 --> 00:20:13,200
પરંતુ ટેકનિકલ રીતે, આ શું કરે છે? ટી [0] શું પ્રતિનિધિત્વ?

328
00:20:13,200 --> 00:20:15,140
[વિદ્યાર્થી] આ zeroth પાત્ર. >> [Malan] આ zeroth પાત્ર.

329
00:20:15,140 --> 00:20:19,620
અથવા, માનવ જેવી વધુ ટી પ્રથમ અક્ષર, ગમે તે, એચ કદાચ આ કિસ્સામાં.

330
00:20:19,620 --> 00:20:24,990
અને toupper કરે તે શું કહે છે. તે ના zeroth અક્ષર અક્ષરે અને તેને બદલે છે.

331
00:20:24,990 --> 00:20:28,430
તેથી આ અર્થ એ થાય ટી ના zeroth અક્ષર લઇ કરવા માટે, તેને મોટા,

332
00:20:28,430 --> 00:20:30,320
અને તે જ સ્થાન પર પાછા મૂકો.

333
00:20:30,320 --> 00:20:35,540
તેથી જો હું લોઅરકેસ માં હેલો લખો, આ મૂડી એચ માટે લોઅરકેસ ક બદલવો જોઈએ

334
00:20:35,540 --> 00:20:41,400
પરંતુ સમસ્યા એ છે કે લીટીઓ માં 35 અને 36 હું શું વિશે છું અમને ઓ અને t માટે છાપે છે.

335
00:20:41,400 --> 00:20:43,120
અને તમારા જાડો શું છે?

336
00:20:43,120 --> 00:20:47,250
હું શું ખરેખર છું એ જોવા માટે તો હું બધા લોઅરકેસ માં હેલો માં લખ્યો ચાલે?

337
00:20:47,250 --> 00:20:52,280
શું મુદ્રિત કરો ચાલી રહ્યું છે? >> [અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] >> કે શું છે?

338
00:20:52,280 --> 00:20:58,360
[વિદ્યાર્થી] મોટા એચ અને બાકીના નાના. >> આ મોટા એચ અને બાકીના નાના જેના માટે, અથવા ઓ ટી?

339
00:20:58,360 --> 00:21:03,170
બંને [વિદ્યાર્થી]. >> બંને. બરાબર. તેથી આપણે શું થઈ રહ્યું છે તે અહીં.

340
00:21:03,170 --> 00:21:08,380
>> મને આગળ વધો અને આ કમ્પાઇલ. આ copy1 છે, તેથી copy1 બનાવે છે. અધિકાર છે.

341
00:21:08,380 --> 00:21:14,840
સાઇન ઝૂમ દો મને આગળ વધો અને copy1 ચલાવવા માટે, દાખલ કરો, કંઈક કહો: હેલ્લો લોઅરકેસ છે.

342
00:21:14,840 --> 00:21:19,570
તે નકલ મૂડીગત, પરંતુ તે દેખીતી રીતે મૂળ તેમજ મૂડીગત,

343
00:21:19,570 --> 00:21:22,070
કારણ કે શું હવે આ વાર્તામાં શું થાય છે?

344
00:21:22,070 --> 00:21:27,030
27 લીટી માં હું વાસ્તવમાં શબ્દમાળા નકલ છો તેમ લાગતું નથી,

345
00:21:27,030 --> 00:21:30,450
પરંતુ છતાં પણ તમે તર્ક આશા હતી હોઈ શકે છે કે આ કેસ માટે,

346
00:21:30,450 --> 00:21:33,680
જો તમે આ ચિત્ર વિશે વિચારો, શું ખરેખર હું કર્યું છે?

347
00:21:33,680 --> 00:21:35,410
ચિત્ર અડધા જ છે.

348
00:21:35,410 --> 00:21:39,390
તેથી આપણે સમય પાછા રોલ છે કે જેથી ટી હજુ સુધી વાર્તામાં અસ્તિત્વમાં નથી.

349
00:21:39,390 --> 00:21:43,160
એસ વાર્તા માં હાજર હોય, પરંતુ આપણે હેલ્લો આ સમય લોઅરકેસ.

350
00:21:43,160 --> 00:21:46,710
તેથી દો મને ઠીક હું શું ખરેખર સાઇન લખ્યો

351
00:21:46,710 --> 00:21:51,280
આ અહીં કિસ્સામાં અમે-h ઈ-l-l-o હોય છે.

352
00:21:51,280 --> 00:21:58,050
અમે તેના અક્ષરો અનુક્રમ તરીકે દોરવા પડશે, મારા વિભાજક રેખાઓ અહીં મૂકો અને મારી \ 0.

353
00:21:58,050 --> 00:22:05,980
તેથી આ છે જ્યાં અમે 24-ઇશ મારફતે તરીકે રેખા 1 જલદી છે આપી, અથવા લાગી છે, ચલાવવામાં.

354
00:22:05,980 --> 00:22:07,800
આ મારો મેમરી ચિત્ર છે.

355
00:22:07,800 --> 00:22:10,800
હું જ્યારે 27 વાક્ય વિચાર, શું થાય છે?

356
00:22:10,800 --> 00:22:14,730
પહેલાંની જેમ, હું એક નિર્દેશક, કે જે હું આ ચોરસ તરીકે ડ્રો કરીશું.

357
00:22:14,730 --> 00:22:19,740
તે કહેવાય છે. અને મૂળભૂત દ્વારા તેની કિંમત શું છે? કોણ જાણે? કેટલાક કચરો મૂલ્ય.

358
00:22:19,740 --> 00:22:22,060
>> તેથી હું તારીજ કરીશું કે દૂર પ્રશ્ન ચિહ્ન તરીકે.

359
00:22:22,060 --> 00:22:27,670
અને જલદી 27 લીટીના બાજુ જમણી બાજુ ચલાવે છે, હું શું કરું છું ટી ની અંદર મૂકવા?

360
00:22:27,670 --> 00:22:30,770
આ જ વસ્તુ છે કે s માં છે.

361
00:22:30,770 --> 00:22:34,120
તેથી જો આપણે એક ક્ષણ માટે તીર આ બેધ્યાનપણું દૂર કરો અને અમે કહીએ છીએ,

362
00:22:34,120 --> 00:22:40,330
ઓહ, આ મેમરી લોડ 123 સરનામું છે, જ્યારે તમે કહી ટી ઓ, અર્ધવિરામ નહીં,

363
00:22:40,330 --> 00:22:42,700
તમે શાબ્દિક 123 રહ્યાં છો અહીં મૂકી.

364
00:22:42,700 --> 00:22:45,200
હવે જો આપણે પ્રકારની ચિત્રો સાથે અમારી વિશ્વ ફરીથી સરળ,

365
00:22:45,200 --> 00:22:48,750
તમે ખરેખર કર્યું છે શું ફક્ત તમારા વિશ્વમાં બીજા તીર ઉમેરી

366
00:22:48,750 --> 00:22:52,910
કે ટી ​​એ જ ચોક્કસ શબ્દમાળાને પોઇન્ટ છે.

367
00:22:52,910 --> 00:22:59,730
તેથી જ્યારે 31 લીટી અને 32 માં હું ખરેખર [0] ટી બદલવા વિશે જાય છે,

368
00:22:59,730 --> 00:23:05,580
ટી શું છે [0] દેખીતી રીતે હવે પર્યાય? ઓ [0]

369
00:23:05,580 --> 00:23:07,030
જેથી તે ચાલી રહ્યું છે તે તમામ.

370
00:23:07,030 --> 00:23:09,900
અને પણ આ પ્રકારની છતાં લાગે છે થોડું નીચું સ્તર અને arcane

371
00:23:09,900 --> 00:23:12,760
અને આ પ્રકારની કદાચ તર્ક આ માત્ર કામ કર્યું છે કરીશું જેવા લાગે છે -

372
00:23:12,760 --> 00:23:15,410
હું વસ્તુઓ નકલો પહેલા કર્યા અને તે માત્ર કામ કર્યું -

373
00:23:15,410 --> 00:23:18,590
જો તમે ખરેખર એક શબ્દમાળા ખરેખર શું છે તે વિશે વિચારો, તે ચાર રચે છે * છે.

374
00:23:18,590 --> 00:23:21,700
વેલ, તે શું છે? કેટલાક પાત્રની સરનામા છે.

375
00:23:21,700 --> 00:23:24,930
પછી કદાચ તે વધુ અર્થપૂર્ણ બને કે જ્યારે તમે કંઈક પ્રયાસ કરો

376
00:23:24,930 --> 00:23:29,220
સુપર મોટે ભાગે આ જેવા સરળ, બધા તમે નકલ કરી રહ્યા છીએ મેમરી સરનામું છે.

377
00:23:29,220 --> 00:23:32,530
તમે ખરેખર શબ્દમાળા પોતે સાથે કંઈ નથી કરી રહ્યા.

378
00:23:32,530 --> 00:23:37,500
તેથી જો તમે કોઈ વિચાર છે કે તમે કેવી રીતે કોડ આ સમસ્યા હલ થશે,

379
00:23:37,500 --> 00:23:45,080
ઉચ્ચ સ્તર, સરળ, અમે શું કરવું જોઇએ કરવા માટે s ની ખરી નકલ ટા બનાવવા દેખીતી રીતે?

380
00:23:46,670 --> 00:23:48,820
યાહ. >> [વિદ્યાર્થી] તે એક નવું સ્થાન આપો? ચોક્કસ. >>

381
00:23:48,820 --> 00:23:50,800
>> અમે ટી એક નવા સ્થાન આપવા જરૂર છે.

382
00:23:50,800 --> 00:23:55,230
અમે કોઈક વિશ્વ કે જેમાં અમે મેમરી એક નવી ભાગ વિચાર બનાવવાની જરૂર છે,

383
00:23:55,230 --> 00:24:00,090
જે સ્પષ્ટતા ખાતર માત્ર હું આ એક નીચે જમણી ડ્રો, પરંતુ પડશે તે ત્યાં હોવી જરૂરી નથી.

384
00:24:00,090 --> 00:24:04,880
પરંતુ તે સમાન કદ પ્રયત્ન કરવાની જરૂર છે, જેથી હું જ જગ્યાએ આ લંબરૂપ રેખાઓ દોરવા પડશે.

385
00:24:04,880 --> 00:24:09,720
તે દંડ છે જો આ તમામ કચરો શરૂઆતમાં છે. કોણ જાણે શું ત્યાં હતો?

386
00:24:09,720 --> 00:24:13,850
પરંતુ પગલું 1 માટે મને ખૂબ મેમરી આપી હોય રહ્યું છે હું જરૂર

387
00:24:13,850 --> 00:24:18,630
હેલો એક નકલ ફિટ, પછી બહાર આકૃતિ કેવી રીતે ક નકલ કરવા માટે અહીં, અહીં ઇ,

388
00:24:18,630 --> 00:24:20,390
અહીં અને તેથી આગળ l.

389
00:24:20,390 --> 00:24:24,880
પરંતુ આ પહેલેથી જ થોડો સ્પષ્ટ લાગે છે પણ જો વિગતો હજી પણ કેટલીક છે અમૂર્ત કરીશું.

390
00:24:24,880 --> 00:24:28,690
આ આ શબ્દમાળા નકલ કરો, તે લૂપ અથવા જ્યારે લૂપ માટે માત્ર એક છે

391
00:24:28,690 --> 00:24:31,580
અથવા કંઈક કે જેની સાથે તમે બધી વધુ પરિચિત બનવા દીધું છે.

392
00:24:31,580 --> 00:24:35,970
તેથી આપણે આ પ્રયાસ કરો. મને copy2.c માં જાઓ.

393
00:24:35,970 --> 00:24:43,270
Copy2.c અમે 27 લાઇન સિવાય લગભગ આ જ કાર્યક્રમ છે.

394
00:24:43,270 --> 00:24:47,260
તે થોડો જટિલ લાગે છે, પરંતુ જો આપણે તેને તોડી નીચે ભાગ દ્વારા ટુકડો,

395
00:24:47,260 --> 00:24:48,950
બાજુ ડાબી બાજુની જ છે.

396
00:24:48,950 --> 00:24:52,790
ચાર * ટી મેમરી આ વસ્તુ બનાવે છે, પ્રશ્ન ચિહ્ન સાથે જોકે

397
00:24:52,790 --> 00:24:54,680
કારણ કે અમે કોઈ વિચાર છે શું મૂળભૂત રીતે ત્યાં છે.

398
00:24:54,680 --> 00:24:57,920
બાજુ જમણી બાજુ આપણે હવે એક નવી કાર્ય malloc, રજૂઆત કરી રહ્યાં છો,

399
00:24:57,920 --> 00:25:00,640
માટે મેમરીને ફાળવવા, મને મેમરી આપવા માટે,

400
00:25:00,640 --> 00:25:06,900
અને તે દેખીતી રીતે કેટલા દલીલો કેટલા કૌંસ અંદર વસ્તુઓ? લે છે

401
00:25:09,660 --> 00:25:12,130
હું 1 અને 2 ના murmurings સાંભળ્યું છે, પરંતુ તે ફક્ત 1 છે.

402
00:25:12,130 --> 00:25:15,320
ત્યાં કોઈ અલ્પવિરામ, જેનો અર્થ છે કે ત્યાં માત્ર કૌંસ અંદર 1 વાત છે છે.

403
00:25:15,320 --> 00:25:17,720
તેમ છતાં ત્યાં અન્ય કૌંસ છે દો, મને પ્રકાશિત

404
00:25:17,720 --> 00:25:21,460
શું બાહ્યતમ કૌંસ ની અંદર છે, અને તે આ અભિવ્યક્તિ છે:

405
00:25:21,460 --> 00:25:25,880
(Strlen (ઓ) + 1) * sizeof (કોલસો).

406
00:25:25,880 --> 00:25:29,190
તેથી જો આપણે ખરેખર આ મારફતે લાગે, આ કહેતા છે મને ઓ લંબાઈ આપે છે.

407
00:25:29,190 --> 00:25:34,440
હું શા માટે છું, છતાંય, લંબાઈ પર 1 ઉમેરીને? >> [અશ્રાવ્ય વિદ્યાર્થી જવાબ]

408
00:25:34,440 --> 00:25:40,200
બરાબર. અમે આ વ્યક્તિ માટે પૂંછડી પર જગ્યા, છઠ્ઠું અક્ષર કે કોઈ ઇંગલિશ અર્થ હોય છે જરૂર

409
00:25:40,200 --> 00:25:42,250
પરંતુ ખાસ કાર્યક્રમ વિષયક અર્થ નથી.

410
00:25:42,250 --> 00:25:46,800
>> તેથી અમે તે માટે એક + 1 જરૂર છે કારણ કે strlen વળતર લંબાઈ માનવ અપેક્ષા,

411
00:25:46,800 --> 00:25:50,890
હેલ્લો અથવા 5, તો તે તમને વધારાની નલ અક્ષર નથી આપતું નથી.

412
00:25:50,890 --> 00:25:52,980
તેથી હું જાતે 1 + સાથે આ ઉમેરો.

413
00:25:52,980 --> 00:25:56,060
અને પછી આ * કદ (કોલસો), અમે આ પહેલાં જોઈ હોય તો.

414
00:25:56,060 --> 00:25:57,480
આ ટેકનિકલી કાર્ય નથી.

415
00:25:57,480 --> 00:26:04,150
તે એક ખાસ કીવર્ડ કે જે હમણાં જ તમને જણાવે છે કે માપ શું કમ્પ્યૂટર પર અમુક માહિતી પ્રકાર છે છે

416
00:26:04,150 --> 00:26:06,980
વાસ્તવમાં કારણ કે, અમને કેટલાક 32-bit કમ્પ્યુટર્સ હોય છે.

417
00:26:06,980 --> 00:26:10,900
હું ઘરે એક સુંદર જૂના કમ્પ્યુટર ધરાવે છે, અને તે માત્ર 32 બિટ્સ વાપરે પોઇંટરો પ્રતિનિધિત્વ કરે છે.

418
00:26:10,900 --> 00:26:13,900
અને તેથી જો હું માહિતી પ્રકાર કદ હતી, તે 32 બિટ્સ હોઈ શકે છે.

419
00:26:13,900 --> 00:26:18,300
પરંતુ જો હું મારી નવી ફેન્સી કોમ્પ્યુટર ઉપયોગ કરું છું, હું પાછા 64 બિટ્સની કિંમત વિચાર કરી શકે છે

420
00:26:18,300 --> 00:26:20,510
એક સરનામું કંઈક છે.

421
00:26:20,510 --> 00:26:25,400
તેથી આ કિસ્સામાં, માત્ર સુપર સુરક્ષિત કરવા માટે, અમે હાર્ડ કોડ કંઈક નથી જઈ રહ્યાં છો -

422
00:26:25,400 --> 00:26:28,740
સાથે સાથે, શું આપણે શું અત્યાર સુધી કહ્યું હતું કે કર્યું છે અનુસાર ઘરનાં પરચૂરણ કામો નું માપ છે?

423
00:26:28,740 --> 00:26:34,450
અમે ખૂબ ખૂબ મૌખિક જણાવ્યું છે કે તે 1 બાઇટ છે, અને એ કે બોર્ડ સમગ્ર ઘટનાએ સાચું છે.

424
00:26:34,450 --> 00:26:37,000
પરંતુ ફરીથી, ધારણાઓ માટે ખરાબ હોય છે.

425
00:26:37,000 --> 00:26:40,850
તેઓ બગડેલ સોફ્ટવેર દોરી જો લોકો રીતે તમે નથી ઇરાદો નહોતો તમારા સોફ્ટવેર વાપરો.

426
00:26:40,850 --> 00:26:44,750
તેથી લેટ્સ અમૂર્ત હિસ્સો આ દૂર અને માત્ર વધારે સામાન્ય કહેવું

427
00:26:44,750 --> 00:26:46,830
હું મેમરી આ અનેક ટુકડા જરૂર

428
00:26:46,830 --> 00:26:50,210
અને મેમરી દરેક ભાગ, એક અક્ષર માપ સમકક્ષ હોવા જોઈએ,

429
00:26:50,210 --> 00:26:54,870
જે 1 આ કેસ માટે સમાન હકીકત છે, પરંતુ તેને લખવાનું વધુ સામાન્ય રીત છે.

430
00:26:54,870 --> 00:27:00,460
તેથી જો શબ્દ હેલ્લો છે, કેટલા બાઇટ્સ malloc દેખીતી રીતે નથી હેલ્લો માટે ફાળવવા?

431
00:27:00,460 --> 00:27:04,980
છ [વિદ્યાર્થી]. છ. >> બરાબર ઘણા અમે સ્ક્રીન પર પ્રશ્ન ગુણ હોય છે.

432
00:27:04,980 --> 00:27:07,800
અને પછી લેવાનો હવે GetString તમારા સમજ પર આધારિત અનુમાન

433
00:27:07,800 --> 00:27:12,790
malloc શું કદાચ આપે? >> [વિદ્યાર્થી] એક સરનામું.

434
00:27:12,790 --> 00:27:17,020
શું એક સરનામું? મેમરી પ્રથમ ભાગ છે.

435
00:27:17,020 --> 00:27:20,670
>> અમે કોઇ વિચાર શું છે ત્યાં હોય છે કારણ કે અમુક અન્ય કાર્ય

436
00:27:20,670 --> 00:27:23,010
કરવામાં આ મેમરી હોઈ શકે છે અગાઉ મદદથી.

437
00:27:23,010 --> 00:27:28,380
પરંતુ malloc, GetString જેમ, મેમરી પ્રથમ બાઇટ ની સરનામા આપે છે

438
00:27:28,380 --> 00:27:30,540
કે તે કોરે તમારા માટે સેટ છે.

439
00:27:30,540 --> 00:27:38,380
જોકે, તે કરતું નથી આ શું ખાલી એક બેકસ્લેશ નલ પાત્ર સાથે ભરો છે

440
00:27:38,380 --> 00:27:43,030
કારણ કે તે વળે બહાર તમે malloc વાપરવા માટે કંઈપણ ફાળવી શકો છો: ints, શબ્દમાળાઓ એરે,

441
00:27:43,030 --> 00:27:45,700
ફ્લોટ્સ, વિદ્યાર્થી માળખાં.

442
00:27:45,700 --> 00:27:47,750
તમે malloc સંપૂર્ણપણે સામાન્ય ઉપયોગ કરી શકો છો.

443
00:27:47,750 --> 00:27:51,470
તે કાળજી નથી અથવા તે જાણવા માટે તમે શું મેમરી માટે allocating કરી રહ્યાં નથી.

444
00:27:51,470 --> 00:27:55,810
તેથી તે malloc માટે ધૃષ્ટ હોઈ \ 0 મૂકવામાં આવશે

445
00:27:55,810 --> 00:27:58,340
મેમરી દરેક ભાગ ઓવરને અંતે તે તમને આપી દીધો છે

446
00:27:58,340 --> 00:28:02,620
કારણ કે આ \ 0 વસ્તુ માત્ર શબ્દમાળાઓ માટે એક પરંપરા છે.

447
00:28:02,620 --> 00:28:06,310
તે ints માટે વપરાયેલ નથી છે, જે તેને ફ્લોટ્સ માટે વપરાયેલ નથી છે, તે વિદ્યાર્થીઓ માટે વપરાયેલ નથી છે.

448
00:28:06,310 --> 00:28:11,730
અને તેથી malloc સાથે gotcha છે કે બોજ પર તમે સંપૂર્ણપણે પ્રોગ્રામર છે

449
00:28:11,730 --> 00:28:16,790
યાદ કેટલા બાઇટ્સ તમે ફાળવવામાં અને લૂપ માટે નથી ક્યારેય ઉપયોગ

450
00:28:16,790 --> 00:28:21,570
અથવા જ્યારે લૂપ અને મેમરીનો ભાગ તમે આપવામાં આવી છે તેના સીમા ભૂતકાળ જાઓ.

451
00:28:21,570 --> 00:28:23,540
બીજી રીતે મૂકો, જલદી તમે મેમરીને ફાળવવા,

452
00:28:23,540 --> 00:28:28,510
તમે ઓપરેટિંગ સિસ્ટમ કહી શકાતું નથી, ઓહ, જે રીતે દ્વારા, મેમરી એક ભાગ મોટી આ કેવી રીતે થયું?

453
00:28:28,510 --> 00:28:32,080
તે તમે સંપૂર્ણ કરવા માટે યાદ રાખો કે જો તમે કિંમત જરૂર છે.

454
00:28:32,080 --> 00:28:34,330
>> તેથી આપણે કેવી રીતે હું આ મેમરીનો ઉપયોગ પ્રક્રિયા કરો.

455
00:28:34,330 --> 00:28:38,430
28 લીટી અને 29 માં હું આ શા માટે કરી રહ્યો છું?

456
00:28:39,850 --> 00:28:42,260
જસ્ટ કુલ સેનીટી ચેક.

457
00:28:42,260 --> 00:28:45,110
જસ્ટ કિસ્સામાં કંઈક ખોટું થયું હતું, હું મેમરી કેટલાક ઉન્મત્ત રકમ માટે પૂછો

458
00:28:45,110 --> 00:28:48,690
અથવા હું ઘણા વસ્તુઓ કમ્પ્યુટર પર ચાલી રહ્યું છે કે માત્ર પૂરતી મેમરી નથી,

459
00:28:48,690 --> 00:28:51,780
આવું જ કંઇક, હું ઓછામાં ઓછા કરવા માટે નલ ચકાસવા માટે કરવા માંગો છો.

460
00:28:51,780 --> 00:28:55,260
વાસ્તવમાં, મોટા ભાગના કમ્પ્યૂટરો તમે ભ્રમ આપશે કે દરેક કાર્યક્રમ

461
00:28:55,260 --> 00:28:57,080
તમારી RAM ના સમગ્ર ઉપયોગ કરી શકો છો,

462
00:28:57,080 --> 00:29:00,740
પણ તેથી, કેટલાક ઉન્મત્ત લાંબા કદાચ શબ્દમાળા માં વપરાશકર્તા પ્રકારો જો કે, તેઓ એક ખરાબ વ્યક્તિ છો

463
00:29:00,740 --> 00:29:03,440
અને તેઓ વાસ્તવમાં તેને તમારા કાર્યક્રમ અથવા ચૂંથવું ભાંગી પ્રયાસ કરી રહ્યા છો,

464
00:29:03,440 --> 00:29:07,300
તમે ઓછામાં ઓછું malloc પરત કિંમત તપાસ કરવા માંગો છો અને શું તે નલ સમકક્ષ હોય છે.

465
00:29:07,300 --> 00:29:11,630
અને જો તે, ચાલો ફક્ત હમણાં બહાર નીકળવા કારણ કે મને ખબર નથી કે તે શું છે તે કિસ્સામાં શું કરવું.

466
00:29:11,630 --> 00:29:13,950
હું શબ્દમાળા કેવી રીતે નકલ કરશો? ત્યાં થોડા આવું રીતે છે.

467
00:29:13,950 --> 00:29:18,850
ત્યાં છે str સી કાર્યો નકલ કરો, પરંતુ તે સુપર સરળ અમારા માટે આ રસ્તો જૂના જમાનાનું શું કરવું.

468
00:29:18,850 --> 00:29:23,110
>> પ્રથમ દો મને બહાર આકૃતિ ઓ લંબાઈ શું છે.

469
00:29:23,110 --> 00:29:26,930
હું લૂપ આ જોખમમાં મૂકી શકે છે પરંતુ તેના બદલે હું હમણાં જ તે મૂકવામાં બહાર સ્પષ્ટતા માટે અહીં.

470
00:29:26,930 --> 00:29:30,610
તેથી n એ હવે મૂળ શબ્દમાળા લંબાઈ, જે દેખીતી રીતે છે 5 સંગ્રહ કરે છે.

471
00:29:30,610 --> 00:29:35,290
પછી મારા માટે લુપમાં હું 0 થી વારો છું n સુધી,

472
00:29:35,290 --> 00:29:40,940
અને હું દરેક ઇટરેશન પર મૂકી રહ્યો છું ઓ [i] ટી ની અંદર [i].

473
00:29:40,940 --> 00:29:45,060
તેથી કે હું શું મારા 2 પહેલાં શબ્દમાળાઓ નિર્દેશ કરતી આંગળીઓ સાથે ગર્ભિત.

474
00:29:45,060 --> 00:29:49,260
તરીકે લૂપ માટે આ જેવા iterates, હું અહીં માં ક નકલ કરી જાઉં છું,

475
00:29:49,260 --> 00:29:52,890
અહીં, અહીં પ્રવેશ l માં ઈ કારણ કે આ ઓ છે, આ ટી છે.

476
00:29:52,890 --> 00:29:58,770
અને પછી છેલ્લે, 35 લીટી માં હું આ શા માટે કરી રહ્યો છું?

477
00:29:58,770 --> 00:30:03,770
હું ખાતરી કરવા માટે કે હું શબ્દમાળા ટી અંત છું કરવાની જરૂર છે.

478
00:30:03,770 --> 00:30:06,170
અને હું આ રીતે કર્યું માટે સુપર સ્પષ્ટ છે.

479
00:30:06,170 --> 00:30:09,510
પરંતુ પ્રસ્તાવ, કોઈ જો તમે કરી શકે, આમ એક અલગ રીત.

480
00:30:09,510 --> 00:30:13,930
હું ખરેખર 35 લીટી કરવાની જરૂર નથી. ત્યાં બીજી આવું રીત છે.

481
00:30:13,930 --> 00:30:18,880
યાહ. >> [અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] >> કહો તે મોટેથી.

482
00:30:18,880 --> 00:30:20,960
[વિદ્યાર્થી] ઓછી કરતાં અથવા સમાન. ચોક્કસ. >>

483
00:30:20,960 --> 00:30:24,450
અમે હમણાં જ કરતાં ઓછા અથવા n એ, કે જે સામાન્ય રીતે ખરાબ રહી છે સમકક્ષ કહી શકે છે

484
00:30:24,450 --> 00:30:28,190
લગભગ હંમેશા જ્યારે અમે આ વસ્તુ અમે ગણતરી કરી રહ્યા છીએ એક સમાન સુધી જાઓ કારણ કે

485
00:30:28,190 --> 00:30:30,000
અમે પગલાં 1 ખૂબ દૂર જાય છે.

486
00:30:30,000 --> 00:30:32,170
પરંતુ યાદ રાખો, કેટલા બાઇટ્સ અમે ફાળવી હતી?

487
00:30:32,170 --> 00:30:37,210
અમે strlen s ની ફાળવણી, 6 ની કુલ 5 તેથી + 1.

488
00:30:37,210 --> 00:30:39,980
તેથી આ કિસ્સામાં અમે આ કંઈક કરી શકે

489
00:30:39,980 --> 00:30:46,450
જેથી અમે પણ માત્ર હેલ્લો એ \ 0 ખૂબ ઓવરને અંતે નકલ કરી રહ્યા છો.

490
00:30:46,450 --> 00:30:49,860
વૈકલ્પિક રીતે, અમે str નકલ કહેવાય વિધેય વાપરી, strcpy શકે છે,

491
00:30:49,860 --> 00:30:51,700
પરંતુ લગભગ તરીકે ખૂબ મજા નહિં હોય.

492
00:30:51,700 --> 00:30:54,000
પરંતુ તે બધા તેને હૂડ નીચે કરે છે.

493
00:30:54,000 --> 00:30:56,050
પછી છેલ્લે, અમે પહેલાની જેમ જ વસ્તુ નથી.

494
00:30:56,050 --> 00:31:01,620
હું ટી ઉઠાવે છે અને પછી હું દાવો છે કે મૂળ આ અને નકલ કે જેમ દેખાય જેવો દેખાય છે.

495
00:31:01,620 --> 00:31:08,570
તેથી આપણે આ પ્રયાસ કરો. મને અહીં જાઓ. Copy2 બનાવો. અમે ઝૂમ અને copy2 સ્કોર પડશે.

496
00:31:08,570 --> 00:31:13,840
હું લોઅરકેસ માં હેલો લખો માંગવાનો, અને ખરેખર હું મૂળ તરીકે હેલ્લો લોઅરકેસ વિચાર

497
00:31:13,840 --> 00:31:16,930
પરંતુ નકલ માટે હેલો મૂડી.

498
00:31:16,930 --> 00:31:20,300
પરંતુ હું હજી સુધી પૂર્ણ છું. હું 1 છેલ્લા વસ્તુ અહીં કરવાની જરૂર છે.

499
00:31:20,300 --> 00:31:28,000
46 અને 47 સ્પષ્ટ મેમરી મુક્ત છે, પરંતુ ખરેખર શું અર્થ છે?

500
00:31:28,000 --> 00:31:33,250
હું શું, કરી રહ્યો છું તેમ તમે વિચારો દ્વારા, 46 લીટી અને 47 લાઇન ફોન?

501
00:31:33,250 --> 00:31:38,900
અસર શું છે કે નથી? યાહ.

502
00:31:38,900 --> 00:31:43,140
[અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] ચોક્કસ. >>

503
00:31:43,140 --> 00:31:46,380
>> તમે માત્ર ઓપરેટિંગ સિસ્ટમ કહેવાની છે હેય, આ મેમરી માટે આભાર.

504
00:31:46,380 --> 00:31:48,320
તમે હવે તેને બીજા કોઈને માટે વાપરી શકો છો.

505
00:31:48,320 --> 00:31:50,790
અને અહીં કચરો કિંમતો સંપૂર્ણ ઉદાહરણ છે.

506
00:31:50,790 --> 00:31:55,430
હું ફક્ત આ મેમરી ઉપયોગ કર્યો છે ડાઉન 2 સ્થળોએ શબ્દ લખી હેલ્લો,

507
00:31:55,430 --> 00:31:57,490
અહીં, અહીં, અહીં અહીં, અને.

508
00:31:57,490 --> 00:32:00,910
તેથી આ 0-h ઈ-l-l-o-\ છે.

509
00:32:00,910 --> 00:32:06,960
પરંતુ પછી હું 46 લીટી અને 47 લાઇન કહી, અને તમને ખબર શું ચિત્ર દ્રષ્ટિએ ત્યાં શું થાય છે?

510
00:32:06,960 --> 00:32:10,010
ખરેખર રાહ, આ ચિત્ર જૂના એક છે.

511
00:32:10,010 --> 00:32:12,550
એકવાર અમે નકલ કરવા માટે, આ વ્યક્તિ ખરેખર અહીં પોઇન્ટ છે,

512
00:32:12,550 --> 00:32:16,110
તેથી આપણે જે નંબરો દૂર કરો અને માત્ર અમૂર્ત દૂર અમારા તીરો તરીકે ફરીથી.

513
00:32:16,110 --> 00:32:19,370
શું આ ચિત્ર બને છે જ્યારે હું મફત કૉલ?

514
00:32:19,370 --> 00:32:22,750
[અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] પણ નથી. >>

515
00:32:22,750 --> 00:32:29,510
જો હું અને ઓ ટી પર મફત ફોન કરો - એક યુક્તિ પ્રશ્ન પ્રકારની - આ ચિત્ર બધું બદલી શકતું નથી

516
00:32:29,510 --> 00:32:33,880
ઓ ફોન અને ફોન કારણ કે ટી ​​માત્ર ઓપરેટિંગ સિસ્ટમ કહે છે,

517
00:32:33,880 --> 00:32:39,010
હેય, તો તમે આ મેમરી ફરીથી ઉપયોગ કરી શકે છે, પરંતુ તે આ null માટે બદલી શકતું નથી

518
00:32:39,010 --> 00:32:41,840
અથવા અમુક વિશિષ્ટ અક્ષર, તો તે આ બદલી શકતું નથી,

519
00:32:41,840 --> 00:32:47,350
તે ક અથવા ઈ અથવા અથવા અન્ય કંઈપણ ક્યાં તો સ્થાને l અથવા ઓ l ફેરફાર થતો નથી.

520
00:32:47,350 --> 00:32:51,610
ચિત્ર દ્રષ્ટિએ, જલદી તમે મફત, કંઇ ફેરફાર કરો.

521
00:32:51,610 --> 00:32:56,570
અને તેમાં કચરો કિંમતો મૂળ આવેલું છે કારણ કે જો હું પાછળથી આ કાર્યક્રમ માં

522
00:32:56,570 --> 00:33:01,010
GetString અથવા malloc અથવા કંઈક વધુ મેમરી માટે ઓપરેટિંગ સિસ્ટમ પૂછો કે

523
00:33:01,010 --> 00:33:04,900
અને ઓપરેટિંગ સિસ્ટમ કહે છે, ખાતરી કરો કે, હું મેમરી 12 બાઇટ્સ માત્ર મુક્ત હોય,

524
00:33:04,900 --> 00:33:08,080
આ વાપરવા માટે, તમે શું સોંપવામાં આવશે જવું છે?

525
00:33:08,080 --> 00:33:10,830
તમે મેમરી એક ભાગ છે કે અમે સામાન્ય રીતે દોરે કરશે સોંપી શકાય જઈ રહ્યાં છો

526
00:33:10,830 --> 00:33:13,700
પ્રશ્ન ચિહ્ન સાથે છે, પરંતુ તે પ્રશ્ન ચિહ્ન શું છે?

527
00:33:13,700 --> 00:33:17,000
તેઓ-h ઈ-l-l-o,-h ઈ-l-l-o પ્રયત્ન થાય છે.

528
00:33:17,000 --> 00:33:20,940
આ અમારી નવી કચરો કિંમતો જલદી તમે કે મેમરી મુક્ત છે.

529
00:33:20,940 --> 00:33:22,750
>> ત્યાં એક વાસ્તવિક વિશ્વમાં સૂચિતાર્થ અહીં પણ છે.

530
00:33:22,750 --> 00:33:24,720
આ રેમ સાથે શું થાય છે, પરંતુ તમારા કમ્પ્યુટર્સ

531
00:33:24,720 --> 00:33:26,720
વાસ્તવમાં ડિસ્ક સાથે જ વાત કરે છે.

532
00:33:26,720 --> 00:33:30,620
અમે આ અંગે ખાસ કરીને ભવિષ્યના સમસ્યા સમૂહ છે કે જે વિદેશી પર ધ્યાન કેન્દ્રિત કરે છે સાથે વાત કરશે.

533
00:33:30,620 --> 00:33:36,170
પરંતુ શું ખરેખર થાય છે જો તમે તમારા ડેસ્કટોપ પર કેટલાક સંવેદનશીલ નાણાકીય ફાઈલ છે

534
00:33:36,170 --> 00:33:39,600
અથવા અમુક ઉપરછલ્લા JPEG તમે અને તે તમારી ટ્રૅશમાં માં ખેંચો

535
00:33:39,600 --> 00:33:44,390
શું થાય છે જ્યારે તમે તે ટ્રૅશ કે રીસાઇકલ બિન માં ખેંચો?

536
00:33:44,390 --> 00:33:47,240
તમે જાણતા હતા કે હું શેના વિશે વાત કરી હતી. [અટ્ટહાસ્ય]

537
00:33:47,240 --> 00:33:52,370
શું થાય છે જ્યારે તમે તમારા રીસાઇકલ બિન અથવા કચરો કરી શકો છો કે જે પ્રવેશ પુરાવા ખેંચી કર્યું છે?

538
00:33:52,370 --> 00:33:55,920
[અશ્રાવ્ય વિદ્યાર્થી જવાબ]

539
00:33:55,920 --> 00:33:58,000
વેલ, તેથી સાવચેત. શું થાય છે જ્યારે તમે આ કરી?

540
00:33:58,000 --> 00:34:01,030
ટૂંકા જવાબ કશું છે અધિકાર?

541
00:34:01,030 --> 00:34:04,790
સ્કેચી અથવા સંવેદનશીલ ફાઈલ હજુ હમણાં જ છે ત્યાં ક્યાંક બેસીને તમારી હાર્ડ ડ્રાઈવ પર.

542
00:34:04,790 --> 00:34:07,940
અમને મોટા ભાગના ઓછામાં ઓછા કઠિન કે તમે તમારા કચરો ખાલી કરવાની જરૂર શીખી છે

543
00:34:07,940 --> 00:34:10,429
અથવા તમારા રીસાઇકલ બિન ખરેખર ફાઈલો કાઢી છે.

544
00:34:10,429 --> 00:34:13,440
અને ખરેખર, જ્યારે તમે યોગ્ય ક્લિક કરો અથવા તમારું ટ્રૅશ પર ક્લિક કરી શકો છો નિયંત્રિત

545
00:34:13,440 --> 00:34:15,580
અથવા ફાઈલ, કચરાપેટી અથવા જે પસંદ કરો

546
00:34:15,580 --> 00:34:21,420
અને તમે ખરેખર ખાલી ટ્રૅશમાં કરી શકો છો અથવા રીસાઇકલ બિન, શું ખરેખર આ ચિત્ર પછી શું થાય છે?

547
00:34:22,810 --> 00:34:25,969
વધુ કંઈ નથી. તેથી કશું ખરેખર ડિસ્ક પર થાય છે.

548
00:34:25,969 --> 00:34:30,880
>> અને જો આપણે માત્ર કામચલાઉ વિષયાંતર કરવું અને લખી - I'll ફક્ત આ પાછળ વાપરે છે.

549
00:34:30,880 --> 00:34:34,639
તેથી હવે વાર્તા રેમ, કે જે જ્યાં કાર્યક્રમો અસ્તિત્વ ધરાવે ફેરફાર છે

550
00:34:34,639 --> 00:34:39,250
જ્યારે તમે તેમને ચલાવી રહ્યા છો ડિસ્ક, જે છે, જ્યાં તેઓ લાંબા ગાળાના સંગ્રહાય છે

551
00:34:39,250 --> 00:34:42,920
પણ જ્યારે શક્તિ બહાર હવે માટે, આ બોલ - અને આપણે ભવિષ્યમાં ફરી આ આવવું પડશે -

552
00:34:42,920 --> 00:34:46,380
ચાલો ફક્ત ડોળ કરવો કે આ તમારા કમ્પ્યુટરની હાર્ડ ડ્રાઈવ અંદર પ્રતિનિધિત્વ

553
00:34:46,380 --> 00:34:50,110
કારણ કે આ દિવસે પાછા તેઓ પરિપત્ર ડિસ્ક પ્રયત્ન ફ્લોપી ડિસ્ક જેવી જ ઉપયોગ થાય છે.

554
00:34:50,110 --> 00:34:55,130
તેથી જો તમે અમુક સંવેદનશીલ એક્સેલ ફાઈલ હોય છે, તે મેમરી આ ભાગ લઇ શકે છે

555
00:34:55,130 --> 00:34:59,770
તમારા કમ્પ્યુટર ડિસ્ક પર, અને હું માત્ર એક જ મનસ્વી 1 સે અને 0s ચિત્રકામ છું.

556
00:34:59,770 --> 00:35:03,970
જ્યારે તમે તમારી ટ્રૅશમાં કે ફાઇલ ખેંચો અથવા બિન રિસાયકલ કરી શકો છો,

557
00:35:03,970 --> 00:35:07,750
શાબ્દિક કંઇ બને છે કારણ કે એપલ અને માઈક્રોસોફ્ટ માત્ર નિર્ણય કર્યો છે

558
00:35:07,750 --> 00:35:10,450
ટ્રૅશમાંથી કરી શકો છો અને રીસાઇકલ બિન ખરેખર માત્ર એક કામચલાઉ પ્લેસહોલ્ડર છે.

559
00:35:10,450 --> 00:35:14,710
કદાચ છેવટે એ OS તમારા માટે તે ખાલી કરશે, પરંતુ સામાન્ય રીતે, તે કંઇ કરતું નથી,

560
00:35:14,710 --> 00:35:17,090
ઓછામાં ઓછું ત્યાં સુધી તમે ખરેખર જગ્યા પર છો.

561
00:35:17,090 --> 00:35:20,870
>> જોકે, જ્યારે તમે ખાલી કચરો અથવા ખાલી રીસાઇકલ બિન જાઓ

562
00:35:20,870 --> 00:35:23,460
એ જ રીતે, કશું આ ચિત્ર માટે થાય છે.

563
00:35:23,460 --> 00:35:28,590
બધા આવું થાય તમારા કમ્પ્યુટર પર અન્ય જગ્યાઓને છે, ત્યાં ટેબલ કેટલાક પ્રકાર છે.

564
00:35:28,590 --> 00:35:35,400
તે થોડો ખાણિયાઓને છેતરે છે શીટ કે કહે છે કે, ચાલો, કહો resume.doc જેવા પ્રકારની છે,

565
00:35:35,400 --> 00:35:40,920
તેથી માઈક્રોસોફ્ટ વર્ડ તમારી હાર્ડ ડિસ્ક પર 123 સ્થાન પર લાઇવ ઉપયોગ ફાઈલ તમારા છોડો,

566
00:35:40,920 --> 00:35:43,710
માં નથી અને મેમરી નથી RAM, પરંતુ તમારી હાર્ડ ડિસ્ક પર,

567
00:35:43,710 --> 00:35:49,050
અને તમારા 456 અંતે ઉપરછલ્લા JPEG જીવન છે, અને તમારા એક્સેલ ફાઈલ 789 પર અથવા ત્યાં રહે છે.

568
00:35:49,050 --> 00:35:53,640
જ્યારે તમે વાસ્તવમાં કચરો અથવા રીસાઇકલ બિન ખાલી દ્વારા ફાઈલો કાઢી નાંખો,

569
00:35:53,640 --> 00:35:59,530
આ ચિત્ર ફેરફાર થતો નથી. આ 0s અને તમારી હાર્ડ ડ્રાઈવ પર 1 સે ગમે ત્યાં થતી નથી.

570
00:35:59,530 --> 00:36:03,930
પરંતુ આ ટેબલ, પ્રકારની આ થોડું ડેટાબેઝ, ફેરફાર કરે છે.

571
00:36:03,930 --> 00:36:08,750
જ્યારે તમે તમારા રેઝ્યૂમે કાઢી, એ છતાં પણ આ ફાઈલને અમુક અર્થમાં કાઢી નાખવામાં આવે છે,

572
00:36:08,750 --> 00:36:12,790
પરંતુ તમામ કોમ્પ્યુટર જ્યાં કે વસ્તુ તમારી હાર્ડ ડ્રાઈવ પર જીવે છે ભૂલી ગયા નથી.

573
00:36:12,790 --> 00:36:17,870
આ 0s અને 1 સે કે જે તમારી ફરીથી શરૂ કરો અથવા આ અન્ય કોઈપણ ફાઈલો કંપોઝ હજુ અકબંધ.

574
00:36:17,870 --> 00:36:21,960
>> તેથી જો તમે આ આકસ્મિક હતી, ત્યાં હજી પણ સંભાવના બિન શૂન્ય છે

575
00:36:21,960 --> 00:36:25,800
જો કે તમે તમારી માહિતી પુનઃપ્રાપ્ત નોર્ટન ઉપયોગિતાઓને અથવા અમુક વ્યવસાયિક સોફ્ટવેર વાપરી રહ્યા હોય

576
00:36:25,800 --> 00:36:29,810
જીવન માં જેના હેતુ માટે 0s અને 1 સે કે પ્રકારના અનાથ કરવામાં આવી શોધે છે,

577
00:36:29,810 --> 00:36:33,300
અહીં ભૂલી ગયા પરંતુ અહીં છોડી, કે જેથી તમે તમારી માહિતી પાછા મેળવી શકો છો.

578
00:36:33,300 --> 00:36:38,410
અથવા પોલીસ અથવા એફબીઆઇ સાથે ફોરેન્સિક તપાસકર્તાઓને ખરેખર હાર્ડ ડ્રાઈવ લેશે

579
00:36:38,410 --> 00:36:42,550
અને ખરેખર 0s અને 1 સે કે JPEGs જેવા દેખાવ, એક્સેલ ફાઇલો જેવા દેખાવ પેટર્ન જોવા માટે,

580
00:36:42,550 --> 00:36:46,400
અને તેમને કે માર્ગ તો પણ કોમ્પ્યુટર તેમને ભૂલી ગઇ છે ત્યાં પુનઃપ્રાપ્ત.

581
00:36:46,400 --> 00:36:49,820
જેથી માત્ર ખરેખર રસ્તો માહિતી કાઢી, કારણ કે અમે ભવિષ્યમાં ચર્ચા કરીશું,

582
00:36:49,820 --> 00:36:54,190
માટે સખત મહેનત અથવા ફાઈલ અથવા હાર્ડ ડિસ્ક નાશ છે -

583
00:36:54,190 --> 00:36:56,540
તમે ખરેખર 0s અને 1 સે છૂટકારો ન મળી શકે

584
00:36:56,540 --> 00:36:59,440
કારણ કે અન્યથા તમે gigabyte હાર્ડ ડ્રાઈવ સાથે શરૂ છો

585
00:36:59,440 --> 00:37:02,380
અને તમે મેગાબાઇટ હાર્ડ ડ્રાઈવ સાથે અંત જો તમે સતત કાઢવા માટે કરવામાં આવી હતી હો,

586
00:37:02,380 --> 00:37:04,380
શાબ્દિક 0s, અને 1 સે.

587
00:37:04,380 --> 00:37:06,310
તેથી જો તમે ખરેખર તમારા ટ્રેક આવરી ઇચ્છતા થશે

588
00:37:06,310 --> 00:37:10,510
અને મૂળભૂત સમસ્યા એ છે કે હજુ 0s અને ડિસ્ક પર 1 સે?

589
00:37:10,510 --> 00:37:14,930
હું gesticulating કે તમે ભૌતિક ઉપકરણ તૂટી શકે કોઈને જુઓ. કે કામ કરશે.

590
00:37:14,930 --> 00:37:19,600
[અટ્ટહાસ્ય] પરંતુ જો કે એક ખર્ચાળ ઉકેલ પ્રકારની છે, શું વધુ વાજબી હશે?

591
00:37:19,600 --> 00:37:23,270
યાહ. >> [વિદ્યાર્થી] તેઓને ઉપરલખો. >> તેમને શું ઉપરલખો? >> [વિદ્યાર્થી] અન્ય માહિતી.

592
00:37:23,270 --> 00:37:29,070
અન્ય માહિતી. તમે હમણાં જ 0s અથવા 1 સે અથવા બધા 0s, બધા 1 સે સાથે તમારી ડિસ્ક પર ફરીથી લખી શકો છો.

593
00:37:29,070 --> 00:37:31,230
>> અને તે ખરેખર છે સોફ્ટવેર કેટલાક શું કરે છે.

594
00:37:31,230 --> 00:37:33,570
તમે સોફ્ટવેર ખરીદી અથવા પણ કરી શકો છો મફત સોફ્ટવેર મેળવવા,

595
00:37:33,570 --> 00:37:36,610
અને પણ મેક ઓએસ માટે આ દિવસ બાંધવામાં, ઓછી Windows માં, જેથી

596
00:37:36,610 --> 00:37:38,660
માટે સુરક્ષિત રીતે ભૂંસી ક્ષમતા છે.

597
00:37:38,660 --> 00:37:41,960
ખરેખર, જો તમે આજે બધા રન ઘરમાં માંગો છો જો તમે મેક હોય છે અને આ કરવા માટે,

598
00:37:41,960 --> 00:37:45,740
જો તમને મળેલું તમારા ટ્રૅશમાં કેટલાક સામગ્રી, તો તમે સુરક્ષિત કચરાપેટી કરી શકો છો કરી શકો છો,

599
00:37:45,740 --> 00:37:47,610
જે બરાબર છે કે કરે છે.

600
00:37:47,610 --> 00:37:53,350
માત્ર ભૂંસી અંહિની ફાઈલો બદલે, તે 0s અને 1 સે અહીં ભૂંસી નથી,

601
00:37:53,350 --> 00:38:01,240
તેના બદલે, તે માત્ર તેમને તમામ બદલે, ઉદાહરણ માટે 0s અને ડોટ, કોઈ, કોઈ છે.

602
00:38:01,240 --> 00:38:05,330
તેથી તમારી ભાવિ psets ઓફ ખરેખર ઈરાદાપૂર્વક માહિતી પુનઃપ્રાપ્ત થશે -

603
00:38:05,330 --> 00:38:08,430
ફોટોગ્રાફ્સ છે કે અમે લોકો, સ્થાનો, કેમ્પસ પર અને વસ્તુઓ ભર્યું છે

604
00:38:08,430 --> 00:38:12,810
જેના માટે અમે ડિજીટલ કેમેરા મેમરી કાર્ડ એક ફોરેન્સિક ઇમેજ બનાવવા પડશે,

605
00:38:12,810 --> 00:38:17,120
જે ચોક્કસ જ વિચાર છે - અને તમે ખરેખર શોધવા પડકાર શકાય પડશે

606
00:38:17,120 --> 00:38:20,160
આ દાખલાની તમારી હાર્ડ ડ્રાઈવ પર JPEGs પ્રતિનિધિત્વ કરે છે,

607
00:38:20,160 --> 00:38:23,610
કે ભૂતપૂર્વ વિદ્યાર્થી ઇમેઇલ જેમના જેમ જ હું થોડા અઠવાડિયા પહેલા વાંચી હતી

608
00:38:23,610 --> 00:38:25,860
તેમની બહેન ફોટોગ્રાફ્સ પુનઃપ્રાપ્ત.

609
00:38:25,860 --> 00:38:30,300
અમે વિરામ 5-મિનિટ શા માટે ન લો અહીં, અને અમે મેમરી પર વધુ સાથે નવી ટુકડી બનાવવી પડશે.

610
00:38:33,030 --> 00:38:38,610
અહીં જ્યાં વસ્તુઓ થોડો મન-બેન્ડિંગ વિચાર છે, પરંતુ આ એક ખૂબ શક્તિશાળી પગલું છે

611
00:38:38,610 --> 00:38:40,480
આ તમામ વધુ સમજવા તરફ.

612
00:38:40,480 --> 00:38:42,900
અહીં pointers.c કહેવાય કાર્યક્રમ છે.

613
00:38:42,900 --> 00:38:45,430
તે આજે નમૂનો કોડ વચ્ચે છે.

614
00:38:45,430 --> 00:38:51,280
નોંધ કરો કે પ્રથમ થોડા રેખાઓ, 19 22 દ્વારા તમામ અમે કરી રહ્યા છીએ GetString કંઈક છે

615
00:38:51,280 --> 00:38:54,460
અને એક સરનામું પરત, તે s માં સંગ્રહિત.

616
00:38:54,460 --> 00:38:58,380
3 પણ pset માટે અત્યારથી જો તમે કરવા માંગો છો પરંતુ 4 pset અને

617
00:38:58,380 --> 00:39:01,030
તમે તમારી જાતને બોલ આ તાલીમ વ્હીલ્સ લેવા જ્યાં શરૂ કરી શકો છો,

618
00:39:01,030 --> 00:39:04,030
ત્યાં કોઈ ડોળ કરવો કે શબ્દમાળાઓ હવે અસ્તિત્વમાં કારણ છે.

619
00:39:04,030 --> 00:39:07,030
તે ચોક્કસપણે છે માત્ર કોલસો બનાવો * કહેતા શરૂ કરવું ઠીક છે.

620
00:39:07,030 --> 00:39:12,610
>> એક અલગ તરીકે, ઓનલાઇન સંદર્ભો અને પુસ્તકો તમે ઘણી વખત સ્ટાર ચલ માટે આગામી જોઈ શકો છો.

621
00:39:12,610 --> 00:39:15,600
તમે પણ તે બંને બાજુઓ આસપાસ જગ્યાઓ જોઇ શકશે.

622
00:39:15,600 --> 00:39:17,680
તે બધા વિધેયાત્મક રીતે યોગ્ય છે.

623
00:39:17,680 --> 00:39:21,180
હવે માટે, જોકે, અમે આ અભિગમ પર પ્રમાણિત સુપર સ્પષ્ટ બનાવવા પડશે

624
00:39:21,180 --> 00:39:24,000
કે ઘરનાં પરચૂરણ કામો * અક્ષર નિર્દેશક કહેતા જેવું છે.

625
00:39:24,000 --> 00:39:25,680
કે માહિતી પ્રકાર છે.

626
00:39:25,680 --> 00:39:28,730
અને પછી ચલની નામ ઓ આ કિસ્સામાં છે.

627
00:39:28,730 --> 00:39:31,180
તેથી અમે શબ્દમાળા મેળવેલ કરી છે અને અમે તેને ઓ કહેવાય કર્યું છે.

628
00:39:31,180 --> 00:39:35,180
અને પછી નીચે અહીં નોંધ્યું છે કે હું ખરેખર છેતરપિંડી કરવામાં થોડો કરી રહ્યો છું.

629
00:39:35,180 --> 00:39:39,080
આ નિર્દેશક અંકગણિત, જે સુપર સરળ જેવું છે કહેવામાં આવે છે.

630
00:39:39,080 --> 00:39:41,790
તે માત્ર અર્થ એ થાય ઉમેરો અને પોઇંટરો નંબરો સબ્ટ્રેક્ટ.

631
00:39:41,790 --> 00:39:43,660
પરંતુ આ ખરેખર કામ કરે છે.

632
00:39:43,660 --> 00:39:49,170
આ કાર્યક્રમ દેખીતી રીતે જ s શબ્દમાળા અંતિમ પરિણામ કે આવા લાઇન દીઠ 1 અક્ષર છાપે છે -

633
00:39:49,170 --> 00:39:54,920
તેથી અમે જ્યાં આ રહ્યું છે બગાડી, પોઇંટરો કરી શકે છે, પોઇંટરો ચલાવો, દો મને સાઇન ઝૂમ

634
00:39:54,920 --> 00:39:58,940
હવે મને હેલો અને પ્રકાર દાખલ કંઈક લખો દો

635
00:39:58,940 --> 00:40:01,080
અને તે લીટી દીઠ 1 અક્ષર છાપે છે.

636
00:40:01,080 --> 00:40:04,730
ઉપર પહેલા બીજા સુધી, અમે ચોરસ કૌંસ નોટેશનમાં સાથે આ કરી શકે છે.

637
00:40:04,730 --> 00:40:09,760
અમે લૂપ માટે હોય છે અને અમે s ની printf કરવા માગો છો [i] અને અમે તે ફરીથી અને ફરીથી અને ફરીથી કરવા માંગો છો

638
00:40:09,760 --> 00:40:11,950
દરેક લીટીના અંતે બેકસ્લેશ n સાથે.

639
00:40:11,950 --> 00:40:16,800
પરંતુ આ કાર્યક્રમ અલગ છે. આ કાર્યક્રમ વાપરી છે, શાબ્દિક અર્થ, અંકગણિત.

640
00:40:16,800 --> 00:40:18,860
તેથી શું અહીં ચાલી રહ્યું છે?

641
00:40:18,860 --> 00:40:24,720
સૌ પ્રથમ, પહેલાં આ લૂપ પણ ચલાવે છે, જે, માત્ર સ્પષ્ટ છે, ઓ ખરેખર છે?

642
00:40:24,720 --> 00:40:27,270
એસ છે? >> [વિદ્યાર્થી] એક સરનામું. >> એક સરનામું.

643
00:40:27,270 --> 00:40:32,980
>> અને તેનો સરનામા હેલ્લો કિસ્સામાં, છે, કે શબ્દ પ્રથમ અક્ષર છે, કે જે ક છે.

644
00:40:32,980 --> 00:40:37,370
તેથી ઓ આ ચોક્કસ ઉદાહરણ છે, ક ની સરનામું.

645
00:40:37,370 --> 00:40:41,850
તેથી તે શું ઓ કરવું એનો અર્થ એ નથી હું +?

646
00:40:41,850 --> 00:40:46,280
વેલ, હું આ 0 અંતે લૂપ માટે શરૂ થાય છે. અમે તે ઘણી વખત કર્યું છે.

647
00:40:46,280 --> 00:40:49,760
હું શબ્દમાળા લંબાઈ સુધી જાય છે, દેખીતી રીતે જઈ રહ્યું છે.

648
00:40:49,760 --> 00:40:53,950
તેથી આ લૂપ પ્રથમ પુનરાવૃત્તિ પર, હું ચોક્કસપણે 0 છે.

649
00:40:53,950 --> 00:41:01,740
તેથી આ સમીકરણ કહી રહ્યાં છે ઓ આઇ + + - બદલે, ઓ +0- કે દેખીતી રીતે છે ફક્ત ઓ.

650
00:41:01,740 --> 00:41:04,320
તેથી * શું અહીં છે ઓ?

651
00:41:04,320 --> 00:41:08,530
હવે અમે એક થોડા અલગ રીતે તારો ઉપયોગ કરી રહ્યાં છો.

652
00:41:08,530 --> 00:41:13,080
મને આગળ વધો અને ટી છૂટકારો મેળવવા કારણ કે અમે ટી અને ઓ નકલો વિશે વાત કરી લીધું.

653
00:41:13,080 --> 00:41:15,540
હવે અમે માત્ર એક ઓ સંડોવતા કથા કહેશે કરવા માંગો છો.

654
00:41:15,540 --> 00:41:20,090
અને તેથી આ ક્ષણે, પ્રકાર શબ્દમાળા કર્યા બાદ, અમારા વિશ્વ લાગે તદ્દન જેમ તે પહેલા કર્યું

655
00:41:20,090 --> 00:41:26,630
ફક્ત ઓ ક ની સરનામા સ્ટોર અને વધુ સામાન્ય શબ્દમાળા નિર્દેશ કરતી હેલ્લો સાથે.

656
00:41:26,630 --> 00:41:33,170
જો હું હવે * જેવી લીટી કરવું (ઓ + + આઇ) ની આ આઉટ કરવાનો પ્રયાસ કરો દો.

657
00:41:33,170 --> 00:41:40,140
તેથી * (ઓ આઇ +). મને આ સરળ છે કારણ કે આ 0 છે, તેથી આ * (+0 ઓ) છે.

658
00:41:40,140 --> 00:41:43,790
વેલ, એક મિનિટ રાહ જુઓ. વધુ સરળ બનાવે છે. આ * (ઓ) છે.

659
00:41:43,790 --> 00:41:47,020
ઠીક છે, હવે કૌંસ મૂર્ખ પ્રકારની છે, તેથી હવે માત્ર કરવા * ઓ દો.

660
00:41:47,020 --> 00:41:50,540
તેથી આ લૂપ છે, કે જે વાક્ય કે પ્રકાશિત છે, 26 ના પ્રથમ પુનરાવૃત્તિ માં,

661
00:41:50,540 --> 00:41:53,650
ખૂબ ખૂબ આ છાપવા માટે સમકક્ષ હોય છે.

662
00:41:53,650 --> 00:41:56,040
* ઓ ની માહિતી પ્રકાર શું છે?

663
00:41:56,040 --> 00:42:00,770
આ સંદર્ભમાં, કારણ કે, તારા માટે જ s પોતે આગામી બને છે,

664
00:42:00,770 --> 00:42:04,930
પરંતુ વધુ ખાસ રીતે, કારણ કે અમે લાંબા સમય સુધી ઓ જાહેર કરવામાં આવે છે,

665
00:42:04,930 --> 00:42:09,730
અમે ચલ કંઈ પણ બનાવી રહ્યાં છો, ત્યાં 26 લીટી માં ઘરનાં પરચૂરણ કામો * કોઇ ઉલ્લેખ છે,

666
00:42:09,730 --> 00:42:14,280
ત્યાં મુખ્ય શબ્દ શબ્દમાળા કોઈ ઉલ્લેખ છે, અમે માત્ર એક ઓ કહેવાય ચલ વાપરી રહ્યા હોય,

667
00:42:14,280 --> 00:42:19,650
તે તારણ હવે તારો થોડા અલગ છે, અને દેખીતી રીતે એ તો સ્પષ્ટ છે કે, જેનો અર્થ ચિંતામાં મૂકી દે.

668
00:42:19,650 --> 00:42:26,590
* અહીં ઓ અર્થ છે ઓ માં સરનામા અને પ્રિન્ટ પર જાઓ ગમે ત્યાં હોય છે.

669
00:42:26,590 --> 00:42:33,750
* ઓ, તેથી ઓ અહીં છે - આનાથી સૉર્ટ વસ્તુઓ અને સીડી જેવા, તીર અનુસરો - અહીં.

670
00:42:33,750 --> 00:42:35,850
તેથી આ * ઓ છે.

671
00:42:35,850 --> 00:42:39,060
>> તેથી 26 લીટી કે લૂપ પ્રથમ પુનરાવૃત્તિ શું મુદ્રિત નહીં?

672
00:42:39,060 --> 00:42:42,170
હું% C, કે જે અક્ષર માટે પ્લેસહોલ્ડર છે છાપો,

673
00:42:42,170 --> 00:42:48,520
પછી નવી લાઇન માટે \ n. * (ઓ આઇ +) છે જ્યાં i 0 માત્ર છે અને આ.

674
00:42:48,520 --> 00:42:53,670
તેથી શું કામની પાળી હું% C માટે નથી માં મૂકી? એચ

675
00:42:53,670 --> 00:42:56,900
તમે કદાચ જ્યાં આ રહ્યું છે જોઈ શકે છે - આ લૂપની આગળના ઇટરેશન -

676
00:42:56,900 --> 00:43:01,350
આગામી પુનરાવૃત્તિ હું 1 ચોક્કસપણે છે, જેથી આ અર્થ +1 ને,

677
00:43:01,350 --> 00:43:05,580
અને પછી હવે હું કૌંસ કરવાની જરૂર નથી કારણ કે હવે તારો કહેવું જોઇએ છે

678
00:43:05,580 --> 00:43:08,620
મેમરી સરનામા +1 s પર જાઓ.

679
00:43:08,620 --> 00:43:14,170
ઓ શું છે? ચાલો સમય પાછા રોલ અને કહેવું આ તીર હવે ખરેખર અમને કોઇ તરફેણ કરી છે.

680
00:43:14,170 --> 00:43:18,450
વધુ ખાસ દો કહે છે કે આ સંખ્યા 123 સ્ટોર કરે છે

681
00:43:18,450 --> 00:43:25,110
કારણ કે આ શબ્દમાળાને શરૂઆત હેલ્લો, આ 123 સરનામા છે, આ 124 છે, અને તેથી આગળ.

682
00:43:25,110 --> 00:43:30,550
તેથી બીજા પુનરાવૃત્તિ જ્યારે હું +1 ને કહી રહ્યો છું પર, કે +1 ને 123 કહેતા જેવું છે,

683
00:43:30,550 --> 00:43:35,340
અન્યથા 124 તરીકે ઓળખાય છે, જેથી શું કામની પાળી બીજા પુનરાવૃત્તિ પર મુદ્રિત નહીં?

684
00:43:35,340 --> 00:43:37,850
મેમરી 124 સરનામાં પર ઇ.

685
00:43:37,850 --> 00:43:44,440
પછી ફરીથી + 125, 126, 127, અને આ લૂપ thankfully સ્ટોપ્સ પહેલાં આપણે અહીં

686
00:43:44,440 --> 00:43:49,040
કારણ કે હું strlen ઉપયોગ કરું છું, તે સુનિશ્ચિત કરવા માટે હું ખૂબ ઊંચા ગણતરી કરવામાં આવી નથી કરો.

687
00:43:49,040 --> 00:43:50,810
જેથી પણ તે છે.

688
00:43:50,810 --> 00:43:55,000
ફરીથી, આ છે જેમ છતાં અમે એક સપ્તાહ અગાઉ કર્યું હતું.

689
00:43:55,000 --> 00:43:59,200
મને તે વાક્ય પર નીચે લખી હોવા છતાં પણ અમે બન્ને કરવા નહિં માંગો.

690
00:43:59,200 --> 00:44:02,500
આ સમાન હવે આ.

691
00:44:02,500 --> 00:44:08,310
>> તેથી ભલે ઓ એક સ્ટ્રિંગ છે, કારણ કે અમે અઠવાડિયા માટે કર્યું છે કે તે ફોન, ઓ ખરેખર એક કોલસો બનાવો * છે.

692
00:44:08,310 --> 00:44:13,270
તેથી જો આપણે સુપર ગુદા પ્રયત્ન કરવા માંગો છો, તે ખરેખર યોગ્ય કરવા માટે ચોક્કસ અક્ષર લખવા

693
00:44:13,270 --> 00:44:17,490
આ ઇથ આ આંકડાકીય સરનામાં અને આ તારો ઓપરેટર મદદથી સ્થાન પર,

694
00:44:17,490 --> 00:44:20,470
પરંતુ પ્રમાણિકપણે, આ માત્ર ખૂબ જ સ્વચ્છ છે. તેથી આ ખરાબ નથી.

695
00:44:20,470 --> 00:44:26,720
કોઈ કારણ 27 વાક્ય અહીં કરવાથી રોકવા માટે, પરંતુ 26 વિધેયાત્મક છે જ,

696
00:44:26,720 --> 00:44:31,570
અને તે વિધેયાત્મક રીતે બરાબર કારણો છે કે અમે આમ દૂર કરવામાં ચર્ચા કર્યા છે માટે તે જ છે.

697
00:44:31,570 --> 00:44:33,650
અને છેલ્લે, 29 માત્ર સારી પ્રથા છે.

698
00:44:33,650 --> 00:44:38,420
S ની મફત કૉલ અર્થ એ છે કે હવે તમે પાછા મેમરી કે GetString તમે આપેલો આપીને કરી રહ્યાં છો

699
00:44:38,420 --> 00:44:41,630
કારણ કે ફરીથી, સોમવાર તરીકે હું તમારો ઉલ્લેખ કર્યો છે, અઠવાડિયા માટે GetString

700
00:44:41,630 --> 00:44:44,180
તમારી કોડ એક ભૂલ રજૂઆત કરવામાં આવી છે.

701
00:44:44,180 --> 00:44:46,490
અઠવાડિયા માટે તમારો કોડ મેમરી લીક્સ ધરાવે છે

702
00:44:46,490 --> 00:44:49,970
તમે કરી છે જેમાં કરવામાં મેમરી માટે GetString પૂછવા પરંતુ તમે તેને ક્યારેય કર્યો છે પાછા આપ્યા.

703
00:44:49,970 --> 00:44:53,410
અને તે ઇરાદાપૂર્વક અમને દ્વારા કરવામાં આવી હતી pedagogically પસંદ

704
00:44:53,410 --> 00:44:55,880
કારણ કે તે ફક્ત ખૂબ પર શરૂઆતમાં વિશે વિચારો.

705
00:44:55,880 --> 00:44:57,710
પરંતુ હવે અમે વધુ સમપ્રમાણતા જરૂર છે.

706
00:44:57,710 --> 00:45:00,830
જો તમે મેમરી માટે કમ્પ્યૂટર પૂછો, જેમ GetString કેસ છે,

707
00:45:00,830 --> 00:45:02,820
તરીકે કેસ દેખીતી રીતે છે malloc માટે,

708
00:45:02,820 --> 00:45:07,970
તમે હવે pset 4 આગળ પણ મફત આવા મેમરી કરવું જ જોઈએ.

709
00:45:07,970 --> 00:45:11,650
આ પૂર્ણાંક n એ કહેતા અલગ છે નોટિસ.

710
00:45:11,650 --> 00:45:15,040
તમે આ મુક્ત કરવાની જરૂર નથી કારણ કે તમે GetString નથી કહી નહોતી નથી

711
00:45:15,040 --> 00:45:16,890
અને તમે malloc નથી કહી ન હતી.

712
00:45:16,890 --> 00:45:20,610
>> અને જો તમે GetInt તરીકે ઓળખાતા અમે આખરે જોશો,

713
00:45:20,610 --> 00:45:25,520
GetInt તમારા માટે મેમરી નથી ફાળવી કારણ કે તમે ખરેખર આસપાસ પૂર્ણાંકો પસાર કરી શકે નથી

714
00:45:25,520 --> 00:45:29,430
અને ફ્લોટ્સ અને અક્ષરો માત્ર રસ્તો અમે અઠવાડિયા સુધી આમ કર્યું છે.

715
00:45:29,430 --> 00:45:33,960
સ્ટ્રીંગ્સ, જોકે, ખાસ છે કારણ કે ખરેખર તેઓ ઘણા અક્ષરો એકબીજા સાથે જોડાણ છો.

716
00:45:33,960 --> 00:45:37,450
જેથી તેઓ માત્ર અક્ષરો અને ફ્લોટ્સ અને ints અલગ છો અને ગમે છે.

717
00:45:37,450 --> 00:45:39,980
પરંતુ અમે પાછા તે પહેલાં લાંબા થવું પડશે.

718
00:45:39,980 --> 00:45:44,920
પોઇન્ટર આ શરૂઆત પર કોઈપણ પછી પ્રશ્ન છે? યાહ.

719
00:45:44,920 --> 00:45:49,690
[અશ્રાવ્ય વિદ્યાર્થી પ્રશ્ન]

720
00:45:49,690 --> 00:45:51,440
આહ, ખૂબ જ સારો પ્રશ્ન.

721
00:45:51,440 --> 00:45:55,790
એક અમુક વસ્તુઓ સી ખરેખર તમારા માટે કરે છે, જે અનુકૂળ છે,

722
00:45:55,790 --> 00:46:00,110
છે તે તમારા માટે બહાર આધાર કદ શું માહિતી પ્રકાર છે

723
00:46:00,110 --> 00:46:03,060
અને પછી તમે ગુણાકાર તે પ્રકારના કરે છે.

724
00:46:03,060 --> 00:46:06,610
આ અક્ષરો કિસ્સામાં અપ્રસ્તુત છે કારણ કે લગભગ હંમેશા ઘરનાં પરચૂરણ કામો 1 બાઇટ છે,

725
00:46:06,610 --> 00:46:08,150
તેથી આ કાર્ય કરે છે.

726
00:46:08,150 --> 00:46:11,220
પરંતુ ચર્ચા ભલા માટે, જો તમે વાસ્તવમાં પૂર્ણાંકો છાપવા હતા

727
00:46:11,220 --> 00:46:15,500
અને તમે અમુક કિંમત ઓ કે પૂર્ણાંક નિર્દેશ કરતી હતી છાપવાનો પ્રયાસ કરતી હતી,

728
00:46:15,500 --> 00:46:20,720
તમે જેમ જ 4 +, નથી જરૂર * હું હમણાં જ કારણ કે પૂર્ણાંક 4 બાઇટ્સ આવે છે.

729
00:46:20,720 --> 00:46:25,780
પોઇન્ટર અંકગણિત અર્થ એ થાય કે સી અને કમ્પાઇલર તમે બધા ગણિત નથી.

730
00:46:25,780 --> 00:46:29,190
બધા તમે કાળજી પાસે માનવ અર્થમાં જેવું માં ગણતરી છે. યાહ.

731
00:46:29,190 --> 00:46:35,200
[વિદ્યાર્થી] જો તમે અંદર લૂપ માટે શબ્દમાળા જાહેર, તો તમે તેને પાછળથી મુક્ત છે?

732
00:46:35,200 --> 00:46:36,760
પ્રશ્ન સારું.

733
00:46:36,760 --> 00:46:41,390
>> જો તમે એક લૂપ માટે શબ્દમાળા અંદર જાહેર તમે પછીથી તેને મુક્ત કરવાની જરૂર છે?

734
00:46:41,390 --> 00:46:47,520
તમે માત્ર મુક્ત મેમરી માટે જરૂર છે કે જે તમને GetString સાથે અથવા malloc સાથે ફાળવો.

735
00:46:47,520 --> 00:46:53,110
તેથી જો તમે હમણાં જ કહેવું કંઈક ગમે - દો મને સર્પાકાર કૌંસ હવે મૂકવા કે જેથી તમામ કોડ સંબંધિત હોય છે.

736
00:46:53,110 --> 00:46:58,580
જો તમે buggily જોકે, આ કંઈક હતી, ચાર * ટી ઓ =,

737
00:46:58,580 --> 00:47:03,450
તમે મફત ટન કરવાની જરૂર નથી કારણ કે ટી ​​malloc અથવા GetString કોઇ ઉલ્લેખ સમાવેશ કરવામાં આવ્યો ન નથી.

738
00:47:03,450 --> 00:47:08,960
તેનાથી વિપરીત જો તમે આ કર્યું, GetString, પછી હા, તમે મફત ટી માટે જરૂર છે.

739
00:47:08,960 --> 00:47:14,350
અને હકીકતમાં, તમારા જ છે કે શું આ તક લૂપ અંદર હવે અવકાશ જ મુદ્દા માટે છે

740
00:47:14,350 --> 00:47:16,060
કે અમે ભૂતકાળમાં ચર્ચા કરી છે.

741
00:47:16,060 --> 00:47:18,830
અન્યથા તમે મેમરી allocating શકાય છો, મેમરી allocating, મેમરી allocating,

742
00:47:18,830 --> 00:47:21,230
અને કાર્યક્રમ ઓવરને અંતે કારણ કે તમે તે લૂપની બહાર છો,

743
00:47:21,230 --> 00:47:24,240
ટી અસ્તિત્વમાં નથી, પરંતુ તમે જે ઓપરેટિંગ સિસ્ટમ કહેવામાં ક્યારેય

744
00:47:24,240 --> 00:47:26,750
કે જે તમને મેમરી હવે જરૂર ન હતી.

745
00:47:26,750 --> 00:47:30,430
અને લાંબા પહેલાં, 4 pset અથવા 5 માટે અમે તમને એક Valgrind કહેવાય કાર્યક્રમ સજ્જ પડશે,

746
00:47:30,430 --> 00:47:34,160
જે સ્પિરિટમાં GDB જેવું જ છે કે જેમાં તે કંઈક અંશે એક arcane ઈન્ટરફેસના મળ્યું છે,

747
00:47:34,160 --> 00:47:35,750
પરંતુ જીવનમાં તેની હેતુ માટે તમને મદદ કરે છે.

748
00:47:35,750 --> 00:47:39,380
અને Valgrind એ કાર્યક્રમ છે કે જે ભવિષ્યમાં તમારા કાર્યક્રમો શોધ છે

749
00:47:39,380 --> 00:47:42,550
મેમરી લીક્સ શોધી, શું GetString અથવા malloc છે,

750
00:47:42,550 --> 00:47:47,800
જેને આપણે બધા વધારે ઉપયોગ અમે CS50 લાઇબ્રેરી તરીકે ખૂબ ઉપયોગ કરવાનું બંધ શરૂ કરી શકશો.

751
00:47:47,800 --> 00:47:53,030
અમે છેલ્લે હવે શબ્દભંડોળ સૉર્ટ કરો અને સિદ્ધાંત માનસિક મોડેલની સૉર્ટ હોય

752
00:47:53,030 --> 00:47:55,170
જેની સાથે આ તૂટેલા કાર્યક્રમ ઉકેલવા માટે.

753
00:47:55,170 --> 00:47:59,410
>> તેથી આ તૂટેલા કાર્યક્રમ માં, સ્વેપ સ્વેપ ની અંદર કામ કરે છે,

754
00:47:59,410 --> 00:48:05,280
પરંતુ તે મુખ્ય માં ખરેખર ક્યારેય કામ કર્યું કારણ કે એક્સ અને વાય રિકોલ મુખ્ય પસાર કર્યો હતો,

755
00:48:05,280 --> 00:48:07,260
અને તે કિંમતો દ્વારા પસાર કરવામાં આવ્યા હતા, જેથી વાત કરવા માટે.

756
00:48:07,260 --> 00:48:09,330
તેમને નકલો માટે સ્વેપ આપવામાં આવી હતી.

757
00:48:09,330 --> 00:48:12,520
સ્વેપ ના અંત સુધીમાં, a અને b ખરેખર લે કરવામાં આવી હતી,

758
00:48:12,520 --> 00:48:16,120
પરંતુ અલબત્ત એક્સ અને વાય, કારણ કે અમે સોમવારે ચર્ચા ન હતી.

759
00:48:16,120 --> 00:48:19,940
તેથી હું લીલા અહીં પ્રસ્તાવ કે આ ખરેખર ઉકેલ છે અહીં.

760
00:48:19,940 --> 00:48:22,640
અને ખરેખર દો, મને મારા તારા ખસેડવા માત્ર સુસંગત હોઈ

761
00:48:22,640 --> 00:48:24,440
છતાં પણ, ફરીથી, વિધેયાત્મક રીતે આ તો કોઈ વાંધો નથી.

762
00:48:24,440 --> 00:48:28,730
ભવિષ્યમાં સપ્તાહમાં અમે જ્યારે શા માટે અને તેને બાબત સમજાવવા પડશે.

763
00:48:28,730 --> 00:48:30,600
તેથી લીલા હવે ઉકેલ છે.

764
00:48:30,600 --> 00:48:33,700
પ્રમાણિકપણે, તે સંપૂર્ણ ઘણો messier લાગે છે કારણ કે હું આ તારાઓ બધા હોય છે.

765
00:48:33,700 --> 00:48:35,380
દો મને એક વસ્તુ નિર્દેશ કરે છે.

766
00:48:35,380 --> 00:48:40,040
ટોચની અહીં વાક્ય જ્યાં તે કહે છે પૂર્ણાંક * એક અને પૂર્ણાંક * બોલ્ડ

767
00:48:40,040 --> 00:48:42,820
મૂળભૂત છે તે જ વસ્તુ કરવાનું કારણ તે હંમેશા હોય છે.

768
00:48:42,820 --> 00:48:47,070
તે 2 દલીલો અથવા પરિમાણો જાહેર છે સ્વેપ

769
00:48:47,070 --> 00:48:49,940
જેમાં પ્રથમ પૂર્ણાંક નિર્દેશક છે કહેવાય છે,

770
00:48:49,940 --> 00:48:53,100
જે બીજા પૂર્ણાંક બો કહેવાય નિર્દેશક છે.

771
00:48:53,100 --> 00:48:55,770
આ જ વસ્તુ છે કે આ સમયે નવું હકીકત એ છે કે ત્યાં એક તારો ત્યાં છે.

772
00:48:55,770 --> 00:48:59,340
>> કે શું અર્થ છે? એ પૂર્ણાંક નથી, બો પૂર્ણાંક નથી.

773
00:48:59,340 --> 00:49:04,100
એ પૂર્ણાંક સરનામું છે અને બોલ્ડ અલગ પૂર્ણાંક સરનામું છે.

774
00:49:04,100 --> 00:49:06,980
નીચે અહીં, આ છે જ્યાં હું કબૂલ સી ગૂંચવણમાં નોંધાયો નહીં.

775
00:49:06,980 --> 00:49:09,790
હવે અમે એક તારો ઉપયોગ કરી રહ્યાં છો, પરંતુ તે આ સંદર્ભમાં અલગ અલગ અર્થ ધરાવે છે.

776
00:49:09,790 --> 00:49:13,150
કારણ કે અમે પોઇંટરો નથી જાહેર અમે અહીં છે રહ્યાં છો,

777
00:49:13,150 --> 00:49:15,500
અહીં અમે વસ્તુઓ dereferencing છે.

778
00:49:15,500 --> 00:49:21,520
ટેકનિકલી તેથી, સ્વેપ ની અંદર પ્રથમ, બીજો અને ત્રીજા વાક્ય આ સંદર્ભમાં તારો

779
00:49:21,520 --> 00:49:24,560
છે ડિરેફરન્સ ઓપરેટર છે, કે જે હમણાં જ અર્થ થાય ત્યાં જાઓ.

780
00:49:24,560 --> 00:49:27,400
તેથી જ મારું આંગળી h, તીર અનુસર્યું હોય,

781
00:49:27,400 --> 00:49:31,100
* એક અર્થ એ થાય કે સરનામા પર જાઓ અને મને પૂર્ણાંક છે કે જે ત્યાં શોધો.

782
00:49:31,100 --> 00:49:34,250
* બો અર્થ સરનામા પર જાઓ અને મને પસાર શું ત્યાં છે.

783
00:49:34,250 --> 00:49:40,730
તેથી આપણે સોમવાર હવે ચોકઠાંઓ સ્ટેક ઉપયોગ કરવાથી ચિત્ર redraw,

784
00:49:40,730 --> 00:49:43,130
જે નીચે એક મુખ્ય પ્રયત્ન રહ્યું છે,

785
00:49:43,130 --> 00:49:47,600
જે ઉપર એક સ્વેપ હોવી રહ્યું છે,

786
00:49:47,600 --> 00:49:50,880
જેથી અમારી વિશ્વ સોમવાર જેમ જ દેખાય છે, આ જેમ.

787
00:49:50,880 --> 00:49:53,620
અહીં મેમરી એક ભાગ છે કે જે મુખ્ય વાપરવા માટે જવાનું છે.

788
00:49:53,620 --> 00:49:56,520
>> સોમવારથી જણાવ્યું હતું કે કાર્યક્રમ માત્ર 2 ચલો હતી,

789
00:49:56,520 --> 00:50:01,930
એક X અને એક Y કહેવાય કહેવાય છે, અને હું નંબરો 1 અને 2 મૂકી હતી ત્યાં.

790
00:50:01,930 --> 00:50:06,580
હવે જ્યારે હું જેમ સ્વેપ કહી હું સોમવારે આપી હતી,

791
00:50:06,580 --> 00:50:11,000
અગાઉ જ્યારે હું આ કાર્યક્રમની આવૃત્તિ લાલ ઉપયોગ થાય છે, જે આ જેવી લાગે છે,

792
00:50:11,000 --> 00:50:17,470
હું 2 પરિમાણો, એક બોલ્ડ અને મળ્યું, અને આપણે શું અહીં અને અહીં લખી હતી?

793
00:50:17,470 --> 00:50:21,160
ફક્ત 1 અને 2, શાબ્દિક એક્સ અને વાય નકલો.

794
00:50:21,160 --> 00:50:23,070
આજે અમે તે બદલો.

795
00:50:23,070 --> 00:50:28,510
આજે ints માં પસાર બદલે a અને b અમે 2 સરનામાં પાસ જઈ રહ્યાં છો.

796
00:50:28,510 --> 00:50:34,290
તે સરનામાઓ પર ints નિર્દેશિત કરવા માટે થાય છે, પરંતુ તે સરનામાઓનું તેમને પોતાની ints છે.

797
00:50:34,290 --> 00:50:37,330
તેઓ સરનામાઓ છે. તે એક પોસ્ટલ સરનામા જેવી જગ્યાએ છે.

798
00:50:37,330 --> 00:50:40,580
તેથી હવે અમે ફક્ત મારી જાતને સ્ક્રીન પર થોડો વધુ વિગત આપી કરવાની જરૂર છે.

799
00:50:40,580 --> 00:50:43,250
આ મારા કમ્પ્યુટર મેમરી છે, કારણ કે તે આખો દિવસ રહી છે.

800
00:50:43,250 --> 00:50:45,120
હવે અમે કેટલાક મનસ્વી નંબર યોજના કરવાની જરૂર છે.

801
00:50:45,120 --> 00:50:50,580
તેથી આપણે માત્ર કહેવું, તક દ્વારા જ કે આ મેમરી 123 સરનામું, 124 છે.

802
00:50:50,580 --> 00:50:55,660
ચાલો માત્ર કહે છે આ 125 છે, આ 126 છે, અને તેથી આગળ, પરંતુ તે તદ્દન મનસ્વી છે.

803
00:50:55,660 --> 00:50:58,590
અમે હમણાં જ મારા મેમરી કેટલાક નંબરવાળી યોજના કરવાની જરૂર છે.

804
00:50:58,590 --> 00:51:04,030
તેથી હવે જ્યારે હું ખરેખર એક્સ અને વાય પાસ, હું એક્સ અને વાય પાસ ન જાઉં છું;

805
00:51:04,030 --> 00:51:08,400
હું પોસ્ટલ સરનામું એક્સ અને વાય જેથી વાત કરવા માટે, પસાર જાઉં છું

806
00:51:08,400 --> 00:51:11,870
તેથી નહીં અહીં અને અહીં સંગ્રહિત શું 1 અને 2 છે,

807
00:51:11,870 --> 00:51:16,030
પરંતુ જો તમે મારી નાની ટેક્સ્ટ જોઈ શકો છો, જે અહીં અને અહીં પસાર નહીં?

808
00:51:16,030 --> 00:51:23,340
[અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] ચોક્કસ. >> 123 અહીં મૂકો નહીં અને 124 અહીં મૂકો નહીં.

809
00:51:23,340 --> 00:51:28,910
>> હવે, કારણ કે હું આ ખૂબ જ પ્રથમ વાક્ય અહીં રીતે ટોચ પર તારો ઉપયોગ થાય છે,

810
00:51:28,910 --> 00:51:34,340
મારા કાર્યક્રમ માત્ર 123 કે 124 અને જાણે છે, છતાં પણ તેઓ દેખીતી રીતે કરશો પૂર્ણાંકો

811
00:51:34,340 --> 00:51:40,160
કે જે કોઈપણ માનવ નોટિસ શકે છે, તેઓ સરનામાં, આંકડાકીય સરનામાં તરીકે અર્થઘટન કરી કરીશું.

812
00:51:40,160 --> 00:51:43,250
તેઓ અને તેમની જાતને ints ન હોય તો, તેઓ સરનામાં કરશો,

813
00:51:43,250 --> 00:51:46,120
અને તે છે કારણ કે હું નિશ્ચિતપણે તારાઓ છે ત્યાં મૂકો.

814
00:51:46,120 --> 00:51:51,360
તેથી હવે મારી વાસ્તવિક કોડ શું અહીં થાય છે પ્રથમ, બીજો અને ત્રીજી લાઇન છો?

815
00:51:51,360 --> 00:51:53,380
ચાલો ચિત્ર બાકીના દોરે છે.

816
00:51:53,380 --> 00:51:56,980
Tmp તે સોમવારે હતો જેમ જ છે. Tmp વિશે ખાસ કંઈ નથી.

817
00:51:56,980 --> 00:52:03,060
તે માત્ર એક સ્થાનિક 32 બિટ્સ ચલ છે, અને અંદર હું દેખીતી રીતે * ની કિંમત સ્ટોર છું.

818
00:52:03,060 --> 00:52:08,580
હવે, જો હું હમણાં જ કહ્યું tmp = એક, હું શું અહીં મૂકો છો? >> [વિદ્યાર્થી] 123.

819
00:52:08,580 --> 00:52:10,370
123. પરંતુ તે નથી હું શું કરી રહ્યો છું.

820
00:52:10,370 --> 00:52:13,670
હું કહી રહ્યો છું tmp = * એ. નક્ષત્ર અર્થ ત્યાં જાઓ.

821
00:52:13,670 --> 00:52:19,370
અહીં એક છે, 123. હું કેવી રીતે ત્યાં જાઓ છો? ડોળ કરવો જેવા ત્યાં એક તીર છે.

822
00:52:19,370 --> 00:52:24,460
વેલ, તેમાં છે, 1. તેથી tmp શું સંગ્રહિત નહીં દેખીતી રીતે? જસ્ટ 1.

823
00:52:24,460 --> 00:52:29,620
તેથી અન્ય શબ્દોમાં, tmp * એક * એક માધ્યમ છે તે સરનામું છે કે જે વર્તમાનમાં છે જાઓ,

824
00:52:29,620 --> 00:52:31,320
જે દેખીતી રીતે છે 123.

825
00:52:31,320 --> 00:52:33,910
>> ઠીક છે, અહીં આપણે 123 સ્થાન પર છે, હું નંબર 1 જુઓ,

826
00:52:33,910 --> 00:52:35,670
તેથી હું નંબર 1 ત્યાં મૂકી જાઉં છું.

827
00:52:35,670 --> 00:52:39,020
હવે હું શું પંક્તિ 2 શું નથી, * એક = * બો?

828
00:52:39,020 --> 00:52:44,570
આ એક થોડો વધુ સામેલ છે હવે કારણ કે શું છે? તે 123 છે.

829
00:52:44,570 --> 00:52:50,220
તેથી * એક જ્યાં છે? અધિકાર જ્યાં હું પહેલાં હતી. તેથી ત્યાં જાઓ. ઠીક છે.

830
00:52:50,220 --> 00:52:53,420
હવે, છેલ્લે, અને પછી છેવટે આ અર્થમાં બનાવવા શરૂ કરવા માટે, લઇશ,

831
00:52:53,420 --> 00:53:00,280
* બો અર્થ એ થાય કે શું બોલ્ડ છે? 124. તેથી હું ત્યાં જવા માટે જરૂર છે, જે 2 છે.

832
00:53:00,280 --> 00:53:03,430
તેથી હું શું જ્યાં મૂકી શકું?

833
00:53:03,430 --> 00:53:10,100
2 અહીં જાય છે કારણ કે * બો * એક જાય. તેથી હું આ કરી શકશો.

834
00:53:10,100 --> 00:53:13,120
અને તમે પહેલાથી જ જોવા, કદાચ કરી શકો છો, કે જે આપણે ખૂબ નજીક છો

835
00:53:13,120 --> 00:53:17,710
આ મૂર્ખ, સરળ સમસ્યા પ્રથમ વખત યોગ્ય રીતે ઉકેલ માટે

836
00:53:17,710 --> 00:53:20,920
કારણ કે હવે અમે હજી પણ એક્સ શું હતું એ સ્મરણ છે,

837
00:53:20,920 --> 00:53:23,230
અમે 2 નકલો હોય છે, દેખીતી રીતે એ તો સ્પષ્ટ છે કે વાય છે,

838
00:53:23,230 --> 00:53:25,850
પરંતુ 3 લીટી હવે * બો કહે છે.

839
00:53:25,850 --> 00:53:31,080
તેથી અહીં બો છે. * બો અર્થ ત્યાં જાઓ. તેથી જ્યાં સ્થાન છે 124?

840
00:53:31,080 --> 00:53:35,560
તે દેખીતી રીતે અહીં છે. તેથી હું શું અહીં મૂકો છો? દેખીતી રીતે tmp.

841
00:53:35,560 --> 00:53:39,600
તેથી હવે હું આ કરું છું. તેથી હું અહીં 1 અને 2 અહીં છે.

842
00:53:39,600 --> 00:53:43,560
અને હવે શું આ બધા, 123, 124, અને 1 એ શું?

843
00:53:43,560 --> 00:53:47,910
જલદી સ્વેપ વળતર, આ મેમરી સારું તરીકે ગુમાવી છે

844
00:53:47,910 --> 00:53:51,070
જલદી સ્વેપ વળતર, ઓપરેટિંગ સિસ્ટમ તરીકે કારણ કે

845
00:53:51,070 --> 00:53:54,190
ભવિષ્યમાં કે મેમરી ફરીથી ઉપયોગ મફત છે.

846
00:53:54,190 --> 00:53:58,870
માત્ર આ સ્ટેક કહેવાતા નીચે ખાતે મુખ્ય મેમરી આસપાસ લાકડી.

847
00:53:58,870 --> 00:54:01,470
>> અને તેથી અમે આખરે હવે કામ આવૃત્તિ હોય.

848
00:54:01,470 --> 00:54:06,310
મને swap.c જાય, અને નીચેના નોટિસ.

849
00:54:06,310 --> 00:54:11,280
કાર્યક્રમ ટોચ પર હું મારા પ્રોટોટાઇપ પ્રયત્ન કરવા માટે બદલ્યું છે પૂર્ણાંક * એક અને પૂર્ણાંક * બો.

850
00:54:11,280 --> 00:54:15,000
માત્ર એક જ વસ્તુ હું લાલ, કે જે ખરાબ હતું લીલા, જે સારા હોય છે જાઓ બદલી તેથી,

851
00:54:15,000 --> 00:54:17,350
છે મને આજે આ તારા ઉમેર્યા છે.

852
00:54:17,350 --> 00:54:21,520
પરંતુ તે પછી નીચે અહીં પોતે સ્વેપ હું નકલ હતી, પેસ્ટ શું સ્લાઇડ પર હતી.

853
00:54:21,520 --> 00:54:24,140
અહીં તારો, હું અહીં એક તારો છે - કે જે પ્રોટોટાઇપ સાથે બંધબેસે -

854
00:54:24,140 --> 00:54:27,930
અને પછી આ બધું હવે tmp સિવાય તારા હોય છે

855
00:54:27,930 --> 00:54:30,680
કામચલાઉ ચલ ઉપયોગ કારણ કે, ત્યાં નવી કશું ત્યાં છે.

856
00:54:30,680 --> 00:54:33,040
મેં હમણાં જ પૂર્ણાંક માટે કામચલાઉ સંગ્રહ કરવાની જરૂર છે.

857
00:54:33,040 --> 00:54:34,820
તેથી અમે એક તારો ત્યાં જરૂર નથી.

858
00:54:34,820 --> 00:54:39,310
અમે ફક્ત તારો જરૂર છે કે જેથી અમે મનસ્વી સરહદ આ પ્રકારની પાર કરી શકે છે

859
00:54:39,310 --> 00:54:42,900
મારા કમ્પ્યુટર મેમરી આ 2 ફ્રેમ્સ વચ્ચે.

860
00:54:42,900 --> 00:54:45,630
પરંતુ એક છેલ્લા વસ્તુ બદલવા માટે છે, અને તમે તેને જોવામાં હોઈ શકે છે પહેલાથી જ.

861
00:54:45,630 --> 00:54:48,810
અન્ય રેખા શું ચોક્કસપણે વિવિધ હવે છે? >> [વિદ્યાર્થી] અને એક્સ.

862
00:54:48,810 --> 00:54:53,270
>> અરે વાહ, 25 તેથી કોડ છેલ્લા વાક્ય હું આ માટે બદલવા માટે કામ કરવાની જરૂર છે.

863
00:54:53,270 --> 00:54:58,360
એક સપ્તાહ પહેલા અને સોમવારે પણ 25 વાક્ય આ જેવો દેખાતો હતો, એક્સ અને વાય સ્વેપ

864
00:54:58,360 --> 00:55:02,020
અને આ માત્ર કારણ કે જો તમે કહી ભાંગી હતી સ્વેપ પાર્ટીશન (એક્સ, વાય)

865
00:55:02,020 --> 00:55:05,660
તમે એક્સ અને વાય નકલો માટે સ્વેપ આપતા નથી, તો પછી તેની વસ્તુ કરી છે,

866
00:55:05,660 --> 00:55:09,080
પરંતુ તમે ખરેખર એક્સ અને વાય પોતે ક્યારેય બદલી રહ્યાં છીએ.

867
00:55:09,080 --> 00:55:12,880
તેથી જો તમે કોડ માં & "અને" નું ચિહ્ન સાથે આ પાત્ર ક્યારેય જોઇ ​​છે, તે પહેલાં,

868
00:55:12,880 --> 00:55:15,860
માત્ર એક અનુમાન લો. આ & "અને" નું ચિહ્ન શું નથી, દેખીતી રીતે કરે છે?

869
00:55:15,860 --> 00:55:17,890
[વિદ્યાર્થી] સરનામું લે છે. >> સરનામું લે છે.

870
00:55:17,890 --> 00:55:21,160
તેથી & "અને" નું ચિહ્ન કહેતા છે મને x ની સરનામું આપો.

871
00:55:21,160 --> 00:55:25,590
કોણ જાણે જ્યાં તે છે? તે 123 બને છે. હું પડી નથી. જસ્ટ મને x ની સરનામું આપો.

872
00:55:25,590 --> 00:55:28,340
& પિ મને વાય ના સરનામું આપો થાય છે.

873
00:55:28,340 --> 00:55:34,450
અને તે બિંદુ વાર્તા સંપૂર્ણપણે ચિત્ર સાથે સુસંગત છે અમે ક્ષણ પહેલા દોર્યું હતું.

874
00:55:34,450 --> 00:55:38,310
>> તેથી હું પોઇંટરો સ્વીકાર્યું, ચોક્કસપણે પડશે મારા માટે જ્યારે હું આ શીખવાની શરૂઆત કરી,

875
00:55:38,310 --> 00:55:40,570
ચોક્કસપણે હતા એક અત્યંત મારા મન ફરતે વીંટળાય બાબતો.

876
00:55:40,570 --> 00:55:43,760
પરંતુ ખ્યાલ છે, ખાસ કરીને અમે વસ્તુઓ આ પ્રકારનાં સાથે રમવાની રાખવા માટે,

877
00:55:43,760 --> 00:55:48,030
જો તમે આ સુપર સરળ સૉર્ટ તોડી બુદ્ધિપૂર્વક સમસ્યાઓ uninteresting

878
00:55:48,030 --> 00:55:52,270
માત્ર નંબરો આસપાસ ખસેડવા, પોઇન્ટર સાથે ગૂંચવણ ઘણો જ જવાબ ના

879
00:55:52,270 --> 00:55:56,590
ખરેખર આ અત્યંત આધારભૂત મિકેનિક્સ માંથી તારવેલી શકાય છે.

880
00:55:56,590 --> 00:55:59,070
અહીં એક સરનામું છે. તારા સાથે ત્યાં જાઓ.

881
00:55:59,070 --> 00:56:03,830
અથવા ઊલટી, અહીં એક & "અને" નું ચિહ્ન છે. બહાર આકૃતિ સરનામું ખરેખર શું છે.

882
00:56:03,830 --> 00:56:06,270
અધિકાર છે.

883
00:56:06,270 --> 00:56:09,000
તેથી આ મેમરી બધા જ્યાં આવે છે?

884
00:56:09,000 --> 00:56:12,360
અમે આ ચિત્ર વખત બે ડ્રો કર્યા છે, અને હું આશાસ્પદ રાખવા અમે પાછા તે આવવા પડશે,

885
00:56:12,360 --> 00:56:14,920
પરંતુ અહીં તમારા કમ્પ્યુટરની મેમરી રજૂઆત છે

886
00:56:14,920 --> 00:56:17,420
થોડો આપણા chalkboard કરતાં લેબલ થયેલ વધુ અહીં છે.

887
00:56:17,420 --> 00:56:21,590
ટોચ પર લખાણ સેગમેન્ટમાં તમારા કાર્યક્રમ માટે આદર સાથે શું પ્રતિનિધિત્વ?

888
00:56:21,590 --> 00:56:26,090
[અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] માફ કરશો >>? ફરીથી કહો.

889
00:56:26,090 --> 00:56:28,660
[વિદ્યાર્થી] વાસ્તવિક કાર્યક્રમ. >> વાસ્તવિક કાર્યક્રમ.

890
00:56:28,660 --> 00:56:32,430
>> આ 0s અને 1 સે કે તમે સી કોડ લખ્યા બાદ સંકલિત અને પછી ચાલી રહેલ રણકાર તેથી

891
00:56:32,430 --> 00:56:35,910
અને 0s અને 1 સે અંત સુધી પેદા ત્યાં મેમરીમાં tucked રહ્યું

892
00:56:35,910 --> 00:56:38,570
જ્યારે તમે ડબલ તમારા Mac અથવા PC પર ચિહ્ન પર ક્લિક કરો કારણ કે

893
00:56:38,570 --> 00:56:43,010
અથવા તમારા પ્રોમ્પ્ટ પર મારિયો જેવો આદેશ ચલાવો, તમારા 0s અને 1 સે ડિસ્કમાંથી

894
00:56:43,010 --> 00:56:45,700
મળે મેમરીમાં લોડ કરે છે કે જેથી તેમને કોમ્પ્યુટર કામ કરી શકે છે

895
00:56:45,700 --> 00:56:47,540
અને તેમને વધુ ઝડપથી ચલાવો.

896
00:56:47,540 --> 00:56:50,880
તેથી આરંભ માહિતી અને uninitialized માહિતી, અમે ખૂબ તે વિશે વાત કરશે,

897
00:56:50,880 --> 00:56:52,420
પરંતુ તે માત્ર વૈશ્વિક ચલો છે.

898
00:56:52,420 --> 00:56:54,710
આરંભ વૈશ્વિક ચલો કે જે તમે કિંમતો આપ્યો અર્થ થાય છે;

899
00:56:54,710 --> 00:56:59,300
uninitialized વૈશ્વિક ચલો કે તમે હજુ સુધી કિંમતો નથી આપી નહોતી થાય છે.

900
00:56:59,300 --> 00:57:01,900
તો પછી ત્યાં આ પર્યાવરણ ચલો કે જે હું સંપૂર્ણપણે મારા હાથ મોજું પડશે છે,

901
00:57:01,900 --> 00:57:04,860
પરંતુ તેઓ ત્યાં છે અને તે તમારા વપરાશકર્તા નામ જેવું સ્ટોર્સ વસ્તુઓ

902
00:57:04,860 --> 00:57:08,090
અને નીચલા સ્તર વિગતો અન્ય સૉર્ટ.

903
00:57:08,090 --> 00:57:12,880
પરંતુ તમારા મેમરી લેઆઉટ ના juiciest ટુકડાઓ આ સ્ટેકની અને ઢગલો કહેવાય વસ્તુ છે.

904
00:57:12,880 --> 00:57:17,470
ફરી સ્ટેક સ્પષ્ટ હોય છે,, મેમરી કે જ્યારેપણ વિધેયો કહેવામાં આવે છે ઉપયોગ થાય છે,

905
00:57:17,470 --> 00:57:19,710
જ્યારે પણ ત્યાં સ્થાનિક ચલો છે

906
00:57:19,710 --> 00:57:22,120
અને ત્યાં પરિમાણો જ્યારેપણ આસપાસ છે પસાર થઈ રહ્યો છે.

907
00:57:22,120 --> 00:57:24,490
કે તમામ સ્ટેક બને.

908
00:57:24,490 --> 00:57:29,570
આ ઢગલો અમે વિશે વાત કરી છે, પરંતુ એક અનુમાન જેઓ ઢગલો વાપરે લો.

909
00:57:31,120 --> 00:57:32,690
માત્ર મેમરી અલગ ભાગ.

910
00:57:32,690 --> 00:57:36,620
તે માટે અહીં ટોચ પર દોરવામાં આવે થાય છે, પરંતુ તે એક મનસ્વી સચિત્ર સંમેલન છે.

911
00:57:36,620 --> 00:57:41,670
કોણ દેખીતી રીતે ઢગલો ના થઇ ગયા અઠવાડિયા માટે મેમરીનો ઉપયોગ?

912
00:57:41,670 --> 00:57:44,830
તે ટેકનીકલી છે તમે પરંતુ આડકતરી. >> [વિદ્યાર્થી] GetString.

913
00:57:44,830 --> 00:57:47,950
GetString અને malloc. તેથી અહીં મૂળભૂત તફાવત છે.

914
00:57:47,950 --> 00:57:51,300
>> તમે ભૂતકાળમાં થોડા અઠવાડિયા માટે જાણે છે કે જો તમે મેમરી જરૂર છે, માત્ર એક ચલ જાહેર.

915
00:57:51,300 --> 00:57:54,560
જો તમે મેમરી ખૂબ જરૂર છે, એક જમણા તમારા કાર્ય ની અંદર એરે જાહેર.

916
00:57:54,560 --> 00:57:59,620
પરંતુ સમસ્યા અમે સામનો રાખવામાં કર્યો છે જો તમને ચલો સ્થાનિક વિધેયો ની અંદર જાહેર,

917
00:57:59,620 --> 00:58:05,340
તરત કાર્ય વળતર, શું મેમરી અને તે ચલો માટે થાય છે?

918
00:58:05,340 --> 00:58:09,620
તે ફક્ત સૉર્ટ હવે તમારું અધિકાર? તે માત્ર કાલ્પનિક જેવું અદૃશ્ય થઈ જાય છે.

919
00:58:09,620 --> 00:58:13,950
તે હજુ પણ શારીરિક ત્યાં છે, દેખીતી રીતે, પરંતુ તે લાંબા સમય સુધી તમારા માટે ઉપયોગ કરવાનો અધિકાર છે.

920
00:58:13,950 --> 00:58:17,160
આ સ્પષ્ટપણે સમસ્યારૂપ છે જો તમે જીવનમાં કાર્યો લખવા માંગો છો

921
00:58:17,160 --> 00:58:20,440
કે જે વાસ્તવમાં મેમરીને ફાળવવા અને તે આપવા પાછળ નથી તે તુરંત જ.

922
00:58:20,440 --> 00:58:24,180
બિંદુ માં કેસ: જીવન માં GetString હેતુ માટે અગાઉથી કોઈ વિચાર હોય છે

923
00:58:24,180 --> 00:58:26,390
કેવી રીતે શબ્દમાળા હું કીબોર્ડ લખો જાઉં છું મોટી,

924
00:58:26,390 --> 00:58:30,390
પરંતુ તે માટે મેમરીને ફાળવવા માટે ડેવિડ અથવા હેલ્લો પકડી કરવાનો પ્રયત્ન મળ્યું છે

925
00:58:30,390 --> 00:58:32,860
અથવા તે સંપૂર્ણ નિબંધ કે વપરાશકર્તા સાઇન લખ્યો હોઈ શકે છે

926
00:58:32,860 --> 00:58:35,280
તેથી GetString malloc નો ઉપયોગ કર્યો છે.

927
00:58:35,280 --> 00:58:38,910
Malloc તેથી સ્ટેક નથી મદદથી હોવી જ જોઈએ;

928
00:58:38,910 --> 00:58:40,770
તેના બદલે તે આ ઢગલો કહેવાય વસ્તુ મદદથી છે.

929
00:58:40,770 --> 00:58:44,430
ત્યાં મેમરી વિશે વિવિધ કશું જ નથી. તે ઝડપી ધીમી નથી અથવા અથવા તે જેવો કંઈ છે.

930
00:58:44,430 --> 00:58:46,570
તે એક અલગ સ્થાન ફક્ત શારીરિક છે.

931
00:58:46,570 --> 00:58:50,120
>> પરંતુ નિયમ એ છે કે મેમરી કે ઢગલો પર ફાળવવામાં છે

932
00:58:50,120 --> 00:58:56,180
ક્યારેય લેવામાં દૂર તમે જ્યાં સુધી તમે કૉલ - એક અનુમાન લેવા - ફ્રી.

933
00:58:56,180 --> 00:59:00,510
તેનાથી વિપરીત, કોઈપણ મેમરી તમે માત્ર એક એરે જાહેર કરીને સ્ટેક પર માટે પૂછો

934
00:59:00,510 --> 00:59:03,320
અથવા ચલ જાહેર જેમ અમે અઠવાડિયા સુધી આમ કર્યું છે,

935
00:59:03,320 --> 00:59:05,640
તે મૂળભૂત દ્વારા સ્ટેક પર પૂર્ણ થાય છે.

936
00:59:05,640 --> 00:59:09,550
અને તે સમયે મહાન 90% કામ કરે છે, તે વધુ જૂજ પ્રસંગોએ પરંતુ

937
00:59:09,550 --> 00:59:12,470
જ્યાં તમે મેમરીને ફાળવવા અને તે રાખવા આસપાસ માંગો છો,

938
00:59:12,470 --> 00:59:14,730
તો પછી તમારે malloc જેમ કાર્ય વાપરવાની જરૂર છે.

939
00:59:14,730 --> 00:59:19,370
અથવા આપણે GetString છે, જે બદલામાં malloc ઉપયોગ કરે છે જેમ કાર્ય ઉપયોગ કર્યો છે.

940
00:59:19,370 --> 00:59:23,300
ચાલો જોવા જ્યાં આ તોડી અને પછી શકે Binky ખાતે ડોકિયું લો.

941
00:59:23,300 --> 00:59:25,820
અમે ભવિષ્યમાં ફરી કે આવવું પડશે.

942
00:59:25,820 --> 00:59:29,270
અહીં સુપર સરળ કાર્યક્રમ છે કે પ્રથમ 2 રેખાઓ શું કરે છે?

943
00:59:29,270 --> 00:59:33,460
ઇંગલિશ માં, આ કોડ પ્રથમ 2 રેખાઓ અંદર શું કરવું મુખ્ય?

944
00:59:33,460 --> 00:59:35,600
[અશ્રાવ્ય વિદ્યાર્થી જવાબ]

945
00:59:35,600 --> 00:59:37,880
સાવધાન રહો. તે મને એક્સ અથવા વાય ના સરનામા આપતું નથી.

946
00:59:37,880 --> 00:59:41,840
[વિદ્યાર્થી] ints માટે પોઇંટરો આપે છે. >> ગુડ. મને પૂર્ણાંકો માટે 2 પોઇંટરો આપો.

947
00:59:41,840 --> 00:59:45,130
અન્ય શબ્દોમાં, મને મેમરી 2 હિસ્સામાં કે હું આજે ચિત્ર રાખવા આપી,

948
00:59:45,130 --> 00:59:46,950
છતાં પણ હું તેને હમણાં ચોરસ તરીકે, ફગાવી દીધી હતી.

949
00:59:46,950 --> 00:59:50,000
મને મેમરી 2 હિસ્સામાં આપો, એક એક્સ કહેવાય છે, એક વાય કહેવાય -

950
00:59:50,000 --> 00:59:54,320
અગાઉ હું તેમને ઓ અને ટી કહેવાય - અને મેમરી કે ભાગ પ્રકાર શું છે?

951
00:59:54,320 --> 00:59:57,160
તે એક સરનામું સ્ટોર ચાલી રહ્યું છે.

952
00:59:57,160 --> 00:59:59,110
તેનો પ્રકાર પૂર્ણાંક * ના છે.

953
00:59:59,110 --> 01:00:01,630
>> તેથી પૂર્ણાંક ની સરનામા આખરે એક્સ રહેતા હશે,

954
01:00:01,630 --> 01:00:03,860
પૂર્ણાંક ની સરનામા છેવટે વાય રહેતા હશે,

955
01:00:03,860 --> 01:00:08,460
પરંતુ શરૂઆતમાં, શું એક્સ અને વાય ની અંદર શું છે? કોણ જાણે? કચરો કિંમતો.

956
01:00:08,460 --> 01:00:10,180
તે પોઇન્ટર સાથે કરવાનું કંઈ નથી.

957
01:00:10,180 --> 01:00:12,720
જો આપણે ત્યાં કંઈક છે, જે જાણે છે શું ખરેખર ત્યાં મૂક્યું નથી?

958
01:00:12,720 --> 01:00:18,950
હવે એક્સ. અહીં શું થાય છે? આ વંચાય હવે કારણ કે એક્સ એક નિર્દેશક છે. તે પૂર્ણાંક * છે.

959
01:00:18,950 --> 01:00:21,870
તેથી તેનો અર્થ એ કે હું x માં મેમરી કેટલાક ભાગ ના સરનામા મૂકી શકો છો.

960
01:00:21,870 --> 01:00:25,120
Malloc શું આપે? પરફેક્ટ, તે સરનામાઓ આપે છે,

961
01:00:25,120 --> 01:00:28,510
મેમરી સંપૂર્ણ ભાગ પ્રથમ બાઇટ ની સરનામું.

962
01:00:28,510 --> 01:00:31,140
કેટલી બાઇટ્સ આ દેખીતી રીતે છે, હમણાં પૂરતું allocating, તો ઉપકરણ માં?

963
01:00:31,140 --> 01:00:33,510
પૂર્ણાંક માપ શું છે? 4.

964
01:00:33,510 --> 01:00:36,600
જો તમે 1 સપ્તાહ પાછા લાગે, તે સુપર અગત્યનું નથી કે હંમેશા યાદ રાખો કે,

965
01:00:36,600 --> 01:00:38,870
પરંતુ આ કિસ્સામાં તે ઉપયોગી છે તે જાણવા માટે, 4 બાઇટ્સ.

966
01:00:38,870 --> 01:00:41,770
તેથી આ ઢગલો 4 બાઇટ્સ પર allocating છે

967
01:00:41,770 --> 01:00:46,110
અને મને તે પ્રથમ એક સરનામું આપખુદ પરત છે.

968
01:00:46,110 --> 01:00:47,700
હવે, એક્સ શું કરે છે?

969
01:00:47,700 --> 01:00:52,200
એ * x 42 = શું કરે છે?

970
01:00:52,200 --> 01:00:57,150
વાર્તામાં આ બિંદુએ જો અમે એક્સ, કે જે અમુક કચરો કિંમત સાથે આ જેવી લાગે છે,

971
01:00:57,150 --> 01:01:04,120
આ હવે કેટલાક કચરો કિંમત સાથે વાય, હવે 3 લીટી માં હું 4 બાઇટ્સ ફાળવવામાં કર્યું છે.

972
01:01:04,120 --> 01:01:06,950
આ ચિત્ર અનિવાર્યપણે આ જેવો દેખાય છે.

973
01:01:06,950 --> 01:01:12,010
અથવા વધુ ચોક્કસ રીતે, જો આ મનસ્વી 123 સરનામા છે, આ છે આપણી વાર્તા શું હવે જેવો દેખાય છે.

974
01:01:12,010 --> 01:01:23,940
* X 42 = હવે શું અર્થ થાય છે? તેનો અર્થ એ કે તે સરનામું 123 પર જાઓ અને નંબર 42 ત્યાં મૂકો.

975
01:01:23,940 --> 01:01:26,220
હું આ લીટીઓ દોરવા જરૂર નથી કારણ કે અમે શબ્દમાળાઓ કરી રહ્યા નથી.

976
01:01:26,220 --> 01:01:29,480
>> હું ફક્ત આ જેવી જોઈએ છે તે લખાયેલું છે, અને ફક્ત પ્રદર્શન કાજે,

977
01:01:29,480 --> 01:01:33,240
42 પૂર્ણાંક પ્રકારની તરીકે અપ જગ્યા ઘણો લે છે, 4 બાઇટ્સ.

978
01:01:33,240 --> 01:01:35,960
જેથી શું ત્યાં થયું છે, પરંતુ ત્યાં એક સમસ્યા હવે છે.

979
01:01:35,960 --> 01:01:40,580
* વાય = 13. શું અહીં થાય ચાલી રહ્યું છે?

980
01:01:40,580 --> 01:01:46,470
આ સમસ્યા અમારી સરળ વિશ્વમાં * વાય માત્ર અર્થ છે વાય માં સરનામા પર જાઓ.

981
01:01:46,470 --> 01:01:48,590
શું વાય છે? કેટલાક કચરો કિંમત થાય છે.

982
01:01:48,590 --> 01:01:53,150
તેથી આપણે ધારે છે કે જે આ કચરો કિંમત 5551212 છે, કે ઉન્મત્ત કંઈક.

983
01:01:53,150 --> 01:01:56,750
* વાય અર્થ 5551212 સંબોધવા જાઓ.

984
01:01:56,750 --> 01:02:00,450
કે ઉપર અહીં ગમે છે. તે દાખલા તરીકે અસ્તિત્વમાં નથી,.

985
01:02:00,450 --> 01:02:05,310
તેથી * વાય 13 અર્થ હું 13 અહીં ડ્રો કરવાનો પ્રયાસ કરી રહ્યો છું નોંધાયો નહીં. તે અસ્તિત્વમાં નથી.

986
01:02:05,310 --> 01:02:08,790
હું બ્લેકબોર્ડ ના સેગમેન્ટમાં વટાવી દીધી છે. હું શું વિચાર છે?

987
01:02:08,790 --> 01:02:14,930
કે ભેદી સંદેશો સેગ્મેન્ટેશન ક્ષતિમાં કારણ કે હું મેમરી મૂકવા પ્રયાસ કરી રહ્યો છું

988
01:02:14,930 --> 01:02:19,470
એક સ્થાન છે જે અસ્તિત્વમાં નથી અંતે 13 જેવી મૂલ્ય.

989
01:02:19,470 --> 01:02:23,900
કાર્યક્રમ બાકીના ઠીક છે, પરંતુ તે બિંદુ કરે છે તે ન થાય ત્યાં સુધી કામ કરી શકે છે.

990
01:02:23,900 --> 01:02:25,350
તેથી આપણે આ વાર્તા કહી પ્રયાસ કરો.

991
01:02:25,350 --> 01:02:27,830
અમે પાછા એકવાર અમે તે hex વિશે વાત કરી છે કે આવવું પડશે.

992
01:02:27,830 --> 01:02:30,290
ચાલો આ પર જાઓ અને આ Binky કહેવાય વસ્તુ સાથે તારણ,

993
01:02:30,290 --> 01:02:33,710
સ્મૃતિ કે જે સ્ટેનફોર્ડ ઘરે બેસીને claymation સાથે રમવાની અધ્યાપક છે,

994
01:02:33,710 --> 01:02:36,380
બરાબર એ જ કાર્યક્રમ વાર્તા કહો.

995
01:02:36,380 --> 01:02:40,580
તેમાં ફક્ત લગભગ 3 લાંબા મિનિટ. અહીં અમે Binky છે.

996
01:02:40,580 --> 01:02:45,030
[વિડિઓ પર પુરૂષ વક્તા] હાય Binky, જાગે. તે નિર્દેશક આનંદ માટે સમય છે.

997
01:02:45,030 --> 01:02:50,080
[Binky] કે શું છે? પોઇન્ટર વિશે જાણો! ઓહ, એક જાતની મીઠાઈ!

998
01:02:50,080 --> 01:02:53,700
[પુરૂષ વક્તા] સારું, પ્રારંભ કરવા માટે, હું માનું અમે થોડા પોઇંટરો જરૂર જઈ રહ્યાં છો.

999
01:02:53,700 --> 01:02:57,890
>> [Binky] ઠીક. આ કોડ 2 પોઇંટરો જે પૂર્ણાંકો માટે નિર્દેશ કરી શકો છો ફાળવે છે.

1000
01:02:57,890 --> 01:03:02,220
[પુરૂષ વક્તા] ઠીક. વેલ, હું 2 પોઇંટરો જુએ છે, પરંતુ તેઓ કંઈ પણ કરવા માટે તરફ ઇશારો છો તેમ લાગતું નથી.

1001
01:03:02,220 --> 01:03:05,550
[Binky] તે સાચું છે. શરૂઆતમાં, પોઇંટરો કંઈપણ નથી નિર્દેશ નથી.

1002
01:03:05,550 --> 01:03:09,270
આ વસ્તુઓ તેઓ નિર્દેશ pointees કહેવામાં આવે છે, અને તેમને સુયોજિત એક અલગ પગલું છે.

1003
01:03:09,270 --> 01:03:12,330
[પુરૂષ વક્તા] ઓહ, અધિકાર, અધિકાર. હું કે જાણતા હતા. આ pointees અલગ હોય છે.

1004
01:03:12,330 --> 01:03:15,630
Er છે, જેથી તમે એક pointee કેવી રીતે ફાળવી શકું?

1005
01:03:15,630 --> 01:03:21,510
[Binky] ઠીક. આ કોડ નવી પૂર્ણાંક pointee ફાળવે છે, અને આ ભાગ એક્સ તે નિર્દેશ કરવા માટે સુયોજિત કરે છે.

1006
01:03:21,510 --> 01:03:23,500
[પુરૂષ વક્તા] હાય, કે જે વધુ સારી દેખાય છે.

1007
01:03:23,500 --> 01:03:26,030
તેથી તેને કંઈક. >> [Binky] ઠીક.

1008
01:03:26,030 --> 01:03:30,300
હું નિર્દેશક એક્સ ડિરેફરન્સ તેના pointee માં 42 નંબર સ્ટોર પડશે.

1009
01:03:30,300 --> 01:03:34,410
આ યુક્તિ માટે હું મારા dereferencing જાદુઈ લાકડી જરૂર પડશે.

1010
01:03:34,410 --> 01:03:38,610
[પુરૂષ વક્તા] તમારા dereferencing જાદુઈ લાકડી? કે મહાન છે.

1011
01:03:38,610 --> 01:03:44,230
[Binky] આ છે કોડ શું જુએ છે. હું હમણાં જ નંબર સેટ કરશો અને ... [અવાજ ધાણી]

1012
01:03:44,230 --> 01:03:46,100
[પુરૂષ વક્તા] હેય, જુઓ, તેમાં કોઈ રન નોંધાયો નહીં.

1013
01:03:46,100 --> 01:03:50,990
તેથી એક્સ પર ડિરેફરન્સ કરવાથી તીર તેના pointee ઍક્સેસ કરવા માટે નીચે,

1014
01:03:50,990 --> 01:03:53,230
આ કિસ્સામાં તેમાં 42 સંગ્રહવા માટે.

1015
01:03:53,230 --> 01:03:57,630
અરે, તેનો ઉપયોગ કરવા માટે અન્ય નિર્દેશક, વાય દ્વારા 13 નંબર સ્ટોર કરવાનો પ્રયાસ કરો.

1016
01:03:57,630 --> 01:04:03,250
[Binky] ઠીક. હું માત્ર અહીં જઈશ વાય અને વિચાર એ 13 નંબર સુયોજિત

1017
01:04:03,250 --> 01:04:08,360
અને પછી dereferencing અને માત્ર એ જાદુઈ લાકડી લે છે ... [Buzzing અવાજ] થોભો!

1018
01:04:08,360 --> 01:04:10,980
[પુરૂષ વક્તા] ઓહ હેય, તે કામ ન શક્યા ન હતા.

1019
01:04:10,980 --> 01:04:14,870
>> કહો, Binky, મને નથી લાગતું વાય dereferencing એક સારો વિચાર છે

1020
01:04:14,870 --> 01:04:17,880
કારણ કે આ pointee સુયોજિત અલગ પગલું છે

1021
01:04:17,880 --> 01:04:19,850
અને મને નથી લાગતું કે અમે ક્યારેય તેને હતી.

1022
01:04:19,850 --> 01:04:21,770
[Binky] હમ્મ, સારા બિંદુ.

1023
01:04:21,770 --> 01:04:26,640
[પુરૂષ વક્તા] યાહ. અમે નિર્દેશક વાય ફાળવવામાં પરંતુ અમે સેટ કરવા માટે pointee નિર્દેશિત કરવા માટે તેને નથી.

1024
01:04:26,640 --> 01:04:28,780
[Binky] હમ્મ, ખૂબ સચેત.

1025
01:04:28,780 --> 01:04:30,690
[પુરૂષ વક્તા] હાય, તમે સારા શોધી રહ્યાં છો ત્યાં, Binky.

1026
01:04:30,690 --> 01:04:34,160
તમે તેને ઠીક કરી શકે છે કે જેથી એક્સ તરીકે જ pointee માટે વાય પોઇન્ટ? >> [Binky] શ્યોર.

1027
01:04:34,160 --> 01:04:37,100
હું મારા નિર્દેશક નામે જાદુ લાકડી ઉપયોગ કરશો.

1028
01:04:37,100 --> 01:04:39,070
[પુરૂષ વક્તા] કે પહેલાં જેવું સમસ્યા હશે શું?

1029
01:04:39,070 --> 01:04:40,840
[Binky] ના, આ pointees તે સ્પર્શતું નથી.

1030
01:04:40,840 --> 01:04:44,780
તે માત્ર એક નિર્દેશક બદલે બીજા જેવા જ વસ્તુ માટે નિર્દેશ કરે છે. [અવાજ ધાણી]

1031
01:04:44,780 --> 01:04:48,570
[પુરૂષ વક્તા] ઓહ, હું જુઓ. હવે એક્સ તરીકે જ જગ્યાએ વાય નિર્દેશ કરે છે.

1032
01:04:48,570 --> 01:04:51,140
તેથી રાહ જુઓ. હવે વાય સુધારેલ છે. તે pointee છે.

1033
01:04:51,140 --> 01:04:54,520
જેથી તમે ફરી dereferencing માટે 13 ઉપર મોકલવા ના જાદુઈ લાકડી પ્રયાસ કરી શકો છો.

1034
01:04:54,520 --> 01:04:58,130
[Binky] ઉહ, ઠીક છે. અહીં જાય છે. [અવાજ ધાણી]

1035
01:04:58,130 --> 01:05:01,250
[પુરૂષ વક્તા] હાય, કે જુઓ. હવે વાય પર કામ કરે છે dereferencing.

1036
01:05:01,250 --> 01:05:05,200
અને કારણ કે પોઇંટરો કે એક pointee શેર કરી રહ્યાં છે, તેઓ બંને માંથી 13 જુઓ.

1037
01:05:05,200 --> 01:05:06,910
[Binky] અરે વાહ, શેરિંગ. ગમે.

1038
01:05:06,910 --> 01:05:08,880
>> તેથી અમે સ્થાનો હવે સ્વિચ જવું છે?

1039
01:05:08,880 --> 01:05:11,420
[પુરૂષ વક્તા] ઓહ દેખાવ, અમે સમય નથી. >> [Binky] પરંતુ -

1040
01:05:11,420 --> 01:05:13,880
[પુરૂષ વક્તા] માત્ર 3 નિર્દેશક નિયમો યાદ રાખો.

1041
01:05:13,880 --> 01:05:18,630
નંબર 1, આધારભૂત માળખું છે કે તમે એક નિર્દેશક હોય છે અને તે pointee પર નિર્દેશ કરે છે.

1042
01:05:18,630 --> 01:05:23,120
પરંતુ નિર્દેશક અને pointee અલગ હોય છે, અને સામાન્ય ભૂલ એક નિર્દેશક સેટ છે

1043
01:05:23,120 --> 01:05:25,680
પરંતુ તે pointee આપી ભૂલી ગયા છે.

1044
01:05:25,680 --> 01:05:29,580
નંબર 2, નિર્દેશક dereferencing પોઇન્ટર પર શરૂ થાય છે અને તેના પર તીર નીચે

1045
01:05:29,580 --> 01:05:31,060
તેના pointee ઍક્સેસ કરો.

1046
01:05:31,060 --> 01:05:34,340
આપણે જાણીએ છીએ તમામ, આ માત્ર કામ કરે છે જો ત્યાં એક pointee છે,

1047
01:05:34,340 --> 01:05:36,460
પ્રકારની છે, જે નોંધાયો નહીં કરવા માટે નંબર 1 શાસન.

1048
01:05:36,460 --> 01:05:39,870
નંબર 3, નિર્દેશક સોંપણી એક નિર્દેશક લે છે અને તે બદલી

1049
01:05:39,870 --> 01:05:42,390
બીજા નિર્દેશક તરીકે જ pointee માટે નિર્દેશ કરે છે.

1050
01:05:42,390 --> 01:05:45,890
તેથી સોંપણી પછી, 2 પોઇંટરો એ જ pointee માટે નિર્દેશ કરશે.

1051
01:05:45,890 --> 01:05:47,800
ક્યારેક કે શેરિંગ કહેવાય છે.

1052
01:05:47,800 --> 01:05:50,910
>> અને તે તમામ ત્યાં તે ખરેખર છે. હવે પેટા બનાવ્યો.

1053
01:05:50,910 --> 01:05:55,840
આ Binky છે. આ CS50 છે. અમે આગામી સપ્તાહે તમે જોશો. [વધાવી]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]