1
00:00:00,000 --> 00:00:02,520
[Powered by Google Translate] [4 વિભાગ - વધુ અનુકૂળ]

2
00:00:02,520 --> 00:00:04,850
[રોબ બોડેન - હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,850 --> 00:00:07,370
[આ CS50 છે. - CS50.TV]

4
00:00:08,920 --> 00:00:13,350
અમે એક ક્વિઝ કાલે હોય તેવા કિસ્સાઓમાં, તમે ગાય્સ કે ખબર ન હતી.

5
00:00:14,810 --> 00:00:20,970
તે બધું તમે વર્ગ જોવા હોઈ શકે છે અથવા વર્ગ માં જોઇ હોવી જોઇએ પર મૂળભૂત છે.

6
00:00:20,970 --> 00:00:26,360
કે પોઇંટરો સમાવેશ થાય છે, તેમ છતાં તેઓ ખૂબ જ તાજેતરનું વિષય છો.

7
00:00:26,360 --> 00:00:29,860
તમે ઓછામાં ઓછું તેમને ઊંચા સ્તરો સમજવા જોઈએ.

8
00:00:29,860 --> 00:00:34,760
જે કંઇ પણ ઉપર વર્ગ ઇનમાં આવ્યું હોય તો તમે ક્વિઝ માટે સમજવા જોઈએ.

9
00:00:34,760 --> 00:00:37,320
તેથી જો તમે તેમના પર પ્રશ્નો હોય, તો તમે તેમને હવે પૂછી શકો છો.

10
00:00:37,320 --> 00:00:43,280
પરંતુ આ એક વિદ્યાર્થી આગેવાની ખૂબ સત્ર પ્રયત્ન રહ્યું છે જ્યાં તમે ગાય્સ પ્રશ્નો પૂછી,

11
00:00:43,280 --> 00:00:45,060
જેથી આસ્થાપૂર્વક લોકો પ્રશ્નો હોય છે.

12
00:00:45,060 --> 00:00:48,020
શું કોઇને પ્રશ્નો છે?

13
00:00:49,770 --> 00:00:52,090
હા. >> [વિદ્યાર્થી] તમે પોઇન્ટર પર જાઓ શકું ફરી?

14
00:00:52,090 --> 00:00:54,350
હું પોઇન્ટર પર જાઓ પડશે.

15
00:00:54,350 --> 00:00:59,180
તમારા ચલો બધા જરૂરી મેમરી રહે છે,

16
00:00:59,180 --> 00:01:04,450
પરંતુ સામાન્ય રીતે તમે તે વિશે ચિંતા નથી અને તમે માત્ર કહેવું એક્સ અને વાય + 2 + 3

17
00:01:04,450 --> 00:01:07,080
અને કમ્પાઇલર બહાર આકૃતિ જ્યાં તમને જે વસ્તુઓ માટે રહેતા હોય.

18
00:01:07,080 --> 00:01:12,990
એકવાર તમે પોઇન્ટર સાથે વ્યવહાર કરી રહ્યા છો, હવે તમે નિશ્ચિતપણે તે મેમરી સરનામાઓ વાપરી રહ્યા છો.

19
00:01:12,990 --> 00:01:19,800
તેથી એક ચલ માત્ર ક્યારેય કોઈપણ સમયે એક સરનામા પર લાઇવ થશે.

20
00:01:19,800 --> 00:01:24,040
જો આપણે એક નિર્દેશક જાહેર કરવા માંગો છો, પ્રકાર શું જેમ દેખાય રહ્યું છે?

21
00:01:24,040 --> 00:01:26,210
>> હું એક નિર્દેશક પૃષ્ઠ જાહેર કરવા માંગો છો. પ્રકાર શું લાગતું નથી?

22
00:01:26,210 --> 00:01:33,530
[વિદ્યાર્થી] પૂર્ણાંક * પી. >> યાહ. તેથી પૂર્ણાંક * પી.

23
00:01:33,530 --> 00:01:38,030
અને હું કેવી રીતે કરી શકું તે માટે એક્સ નિર્દેશ? >> [વિદ્યાર્થી] & "અને" નું ચિહ્ન.

24
00:01:40,540 --> 00:01:45,300
[બોડેન] તેથી & "અને" નું ચિહ્ન શાબ્દિક ઓપરેટર ઓફ સરનામા કહેવામાં આવે છે.

25
00:01:45,300 --> 00:01:50,460
તેથી જ્યારે હું કહું છું અને એક્સ તે ચલ x ની મેમરી સરનામું મેળવવામાં છે.

26
00:01:50,460 --> 00:01:56,790
તેથી હવે હું નિર્દેશક પૃષ્ઠ હોય છે, અને ગમે ત્યાં મારા કોડ માં હું * પૃષ્ઠ ઉપયોગ કરી શકો છો

27
00:01:56,790 --> 00:02:02,960
અથવા હું એક્સ વાપરો અને તેને ચોક્કસ જ વાત હશે શકે છે.

28
00:02:02,960 --> 00:02:09,520
(પાનું *). આ શું કરે છે? કે તારો શું અર્થ છે?

29
00:02:09,520 --> 00:02:13,120
[વિદ્યાર્થી] તે સમયે કિંમત થાય છે. >> યાહ.

30
00:02:13,120 --> 00:02:17,590
તેથી જો અમે તેને જોવા, તે ખૂબ જ ઉપયોગી હોઈ માટે બહાર આકૃતિઓ દોરવા કરી શકો છો

31
00:02:17,590 --> 00:02:22,230
જ્યાં આ એક્સ માટે મેમરી નાના બોક્સમાં છે, કે જે 4 મૂલ્ય ધરાવે થાય છે છે,

32
00:02:22,230 --> 00:02:25,980
તો પછી અમે પૃષ્ઠ માટે મેમરી નાના બોક્સમાં હોય છે,

33
00:02:25,980 --> 00:02:31,590
અને તેથી એક્સ માટે પૃષ્ઠ પોઇન્ટ, તેથી અમે પૃષ્ઠ થી x એક તીર દોરે છે.

34
00:02:31,590 --> 00:02:40,270
તેથી જ્યારે અમે કહીએ છીએ * પૃષ્ઠ અમે કહી રહ્યાં છે તે બોક્સ કે જે પૃષ્ઠ છે જાઓ.

35
00:02:40,270 --> 00:02:46,480
નક્ષત્ર તીર અનુસરો છે અને પછી ગમે તમે નથી કે બોક્સ સાથે ત્યાજ કરવા માંગો છો.

36
00:02:46,480 --> 00:03:01,090
તેથી હું * 7 = પૃષ્ઠ કહેવું શકે છે; અને તે બોક્સમાં કે જે x અને તે 7 થી ફેરફાર છે જશે.

37
00:03:01,090 --> 00:03:13,540
અથવા હું કહી શકે પૂર્ણાંક z = * 2 * પૃષ્ઠ; તે ચિંતામાં મૂકી દે છે કારણ કે તે તારો તારો.

38
00:03:13,540 --> 00:03:19,230
એક તારો પૃષ્ઠ dereferencing છે, અન્ય સ્ટાર 2 દ્વારા ગુણાકાર છે.

39
00:03:19,230 --> 00:03:26,780
નોંધ હું કરી શકે છે માત્ર તેમજ એક્સ સાથે * પૃષ્ઠ લીધું.

40
00:03:26,780 --> 00:03:29,430
તમે તેમને તે જ રીતે ઉપયોગ કરી શકો છો.

41
00:03:29,430 --> 00:03:38,000
અને પછી હું પાછળથી એક સંપૂર્ણપણે નવી વસ્તુ પૃષ્ઠ બિંદુ હોય શકે છે.

42
00:03:38,000 --> 00:03:42,190
મેં હમણાં જ કહી શકો પૃષ્ઠ = &z;

43
00:03:42,190 --> 00:03:44,940
તેથી હવે એક્સ માટે લાંબા સમય સુધી બિંદુઓ પી; તે z નિર્દેશ કરે છે.

44
00:03:44,940 --> 00:03:50,510
અને કોઈપણ સમયે હું * પૃષ્ઠ કરવું તે z કરી જેવી જ છે.

45
00:03:50,510 --> 00:03:56,170
તેથી આ વિશે ઉપયોગી વસ્તુ એક વખત અમે વિધેયો માં મેળવવાનું શરૂ.

46
00:03:56,170 --> 00:03:59,790
>> તે નકામી પ્રકારની કરવા માટે એક નિર્દેશક કે પોઇન્ટ જાહેર કંઈક કરવા માટે

47
00:03:59,790 --> 00:04:03,140
અને પછી તમે તેને dereferencing કરી રહ્યાં છો

48
00:04:03,140 --> 00:04:06,060
જ્યારે તમે મૂળ ચલ ઉપયોગ કરી શકે સાથે શરૂ થાય છે.

49
00:04:06,060 --> 00:04:18,190
પરંતુ જ્યારે તમે વિધેયો પ્રવેશ મેળવવા - તેથી આપણે કહેવું અમે કેટલીક કાર્ય, પૂર્ણાંક foo હોય છે,

50
00:04:18,190 --> 00:04:32,810
કે જે નિર્દેશક લે છે અને માત્ર * પેજ 6 = કરે છે;

51
00:04:32,810 --> 00:04:39,990
જેમ અમે સ્વેપ સાથે પહેલાં થયો હતો, તમે એક અસરકારક સ્વેપ અને એક અલગ કાર્ય ન કરી શકો

52
00:04:39,990 --> 00:04:45,180
માત્ર પૂર્ણાંકો પસાર કારણ કે સી બધું હંમેશા કિંમત દ્વારા પસાર છે.

53
00:04:45,180 --> 00:04:48,360
ત્યારે પણ તમે પોઇંટરો પસાર કરી રહ્યાં છો તમે કિંમત દ્વારા પસાર કરી રહ્યાં છે.

54
00:04:48,360 --> 00:04:51,940
તે જ બને છે કે તે કિંમતો મેમરી સરનામાંઓ છે.

55
00:04:51,940 --> 00:05:00,770
તેથી હું કહું છું કે જ્યારે (પી) foo; હું કાર્ય foo માં નિર્દેશક પસાર છું

56
00:05:00,770 --> 00:05:03,910
અને પછી foo * 6 = પૃષ્ઠ કરી છે;

57
00:05:03,910 --> 00:05:08,600
જેથી અંદર કે કાર્ય છે, * પૃષ્ઠ હજી પણ એક્સ સમકક્ષ,

58
00:05:08,600 --> 00:05:12,720
પરંતુ હું એક્સ કે કાર્ય ની અંદર ઉપયોગ નથી કારણ કે તે કાર્ય અંદર scoped નથી કરી શકો છો.

59
00:05:12,720 --> 00:05:19,510
તેથી * પૃષ્ઠ = 6 એકમાત્ર રસ્તો હું અન્ય કાર્ય એક સ્થાનિક ચલ ઍક્સેસ કરી શકે છે.

60
00:05:19,510 --> 00:05:23,600
અથવા, પણ પોઇંટરો એકમાત્ર રસ્તો હું અન્ય કાર્ય એક સ્થાનિક ચલ ઍક્સેસ કરી શકો છો.

61
00:05:23,600 --> 00:05:31,600
[વિદ્યાર્થી] લેટ્સ કહો કે તમે એક નિર્દેશક પરત માગતા હતા. બરાબર તમે કેવી રીતે કરો કે તમે શું કરશો?

62
00:05:31,600 --> 00:05:44,270
[બોડેન] પૂર્ણાંક વાય = 3 કંઈક માં એક નિર્દેશક વળતર; અને વળતર વાય? >> [વિદ્યાર્થી] યાહ.

63
00:05:44,270 --> 00:05:48,480
[બોડેન] ઠીક. તમે આ ક્યારેય કરવું જોઈએ. આ ખરાબ છે.

64
00:05:48,480 --> 00:05:59,480
મને લાગે છે કે હું આ વ્યાખ્યાન સ્લાઇડ્સ માં જોયું તમે મેમરી આ સમગ્ર રેખાકૃતિ જોયા શરૂ

65
00:05:59,480 --> 00:06:02,880
અહીં તમે જ્યાં મેમરી સરનામા 0 મળી છે

66
00:06:02,880 --> 00:06:09,550
અને નીચે અહીં તમે મેમરી સરનામા 4 શોના 32 માટે અથવા 2 છે.

67
00:06:09,550 --> 00:06:15,120
તેથી પછી તમે અમુક સામગ્રી અને કેટલીક સામગ્રી મળી છે અને તે પછી તમે તમારા સ્ટેક છે

68
00:06:15,120 --> 00:06:21,780
અને તમે તમારા ઢગલો છે, કે જે તમે હમણાં વિશે જાણવામાં, અપ વધતી શરૂ મેળવ્યા છે.

69
00:06:21,780 --> 00:06:24,390
[વિદ્યાર્થી] સ્ટેક ઉપર ઢગલો નથી?

70
00:06:24,390 --> 00:06:27,760
>> યાહ. આ ઢગલો ટોચ પર છે, તે નથી? >> [વિદ્યાર્થી] વેલ, તે ટોચ પર 0 મૂકો.

71
00:06:27,760 --> 00:06:30,320
[વિદ્યાર્થી] ઓહ, તે ટોચ પર 0 મૂકો. >> [વિદ્યાર્થી] ઓહ, ઠીક છે.

72
00:06:30,320 --> 00:06:36,060
ડિસક્લેમર: ગમે ત્યાં CS50 સાથે તમે તેને આ રીતે જોઈ રહ્યા છીએ. >> [વિદ્યાર્થી] ઠીક.

73
00:06:36,060 --> 00:06:40,290
તે માત્ર કે જ્યારે તમે પ્રથમ રન ટાઇમ સ્ટેકનું જોઈ રહ્યાં છો,

74
00:06:40,290 --> 00:06:45,000
ગમે છે જ્યારે તમે એક સ્ટેક તમે એક બીજા ઉપર વસ્તુઓ સ્ટેકીંગ લાગે છે લાગે છે.

75
00:06:45,000 --> 00:06:50,810
તેથી અમે આસપાસ આ વિમાનની મુસાફરી જેથી સ્ટેક એક સ્ટેક સામાન્ય રીતે જેમ વધતી જાય છે વલણ ધરાવે છે

76
00:06:50,810 --> 00:06:55,940
બદલે સ્ટેક નીચે ફાંસી. >> [વિદ્યાર્થી] નહિં heaps તકનીકી અપ પણ વૃદ્ધિ છતાં?

77
00:06:55,940 --> 00:07:01,100
તે તમને શું અર્થ દ્વારા ઉછેર પર આધાર રાખે છે.

78
00:07:01,100 --> 00:07:04,010
આ સ્ટેક અને ઢગલો હંમેશા વિરુદ્ધ દિશામાં વિકસે છે.

79
00:07:04,010 --> 00:07:09,420
એક સ્ટેક હંમેશા અર્થમાં છે વૃદ્ધિ પામતા કે તે વધતી જતી છે

80
00:07:09,420 --> 00:07:12,940
નોંધાયો ઉચ્ચ મેમરી સરનામાંઓ, અને ઢગલો નીચે વધી રહી છે

81
00:07:12,940 --> 00:07:17,260
કે જેમાં તે નીચા મેમરી સરનામાંઓ પર કોઈ રન નોંધાયો વધતી રહી છે.

82
00:07:17,260 --> 00:07:20,250
તેથી ઉપરની 0 છે અને નીચે ઉચ્ચ મેમરી સરનામાંઓ છે.

83
00:07:20,250 --> 00:07:26,390
તેઓ બંને દિશામાં વિરોધ ફક્ત વધતી જતી કરી રહ્યાં છો.

84
00:07:26,390 --> 00:07:29,230
[વિદ્યાર્થી] હું માત્ર કે અર્થ થાય છે કારણ કે તમે કહ્યું તમે તળિયે સ્ટેક મૂકી

85
00:07:29,230 --> 00:07:33,640
કારણ કે તે વધુ લાગે છે કારણ કે સ્ટેક માટે ઢગલો ટોચ પર શરૂ કરવા માટે,

86
00:07:33,640 --> 00:07:37,520
ઢગલો પોતાની ટોચ પર પણ છે, તેથી that's - >> યાહ.

87
00:07:37,520 --> 00:07:44,960
તમે પણ વધતી જતી અને વિશાળ તરીકે ઢગલો લાગે છે, પરંતુ સ્ટેક વધુ રહે છે.

88
00:07:44,960 --> 00:07:50,280
તેથી સ્ટેક એક કે અમે પ્રકારની સુધી વધતી બતાવવા માંગો છો.

89
00:07:50,280 --> 00:07:55,390
પરંતુ સર્વત્ર તમે અન્યથા જોવા ટોચ પર 0 સરનામા બતાવવા રહ્યું છે

90
00:07:55,390 --> 00:07:59,590
અને સૌથી વધુ તળિયે મેમરી સરનામું, તેથી આ તમારી મેમરી સામાન્ય દેખાવ છે.

91
00:07:59,590 --> 00:08:02,100
>> શું તમે એક પ્રશ્ન છે?

92
00:08:02,100 --> 00:08:04,270
[વિદ્યાર્થી] તમે અમને ઢગલો વિશે વધુ કહી શકે છે?

93
00:08:04,270 --> 00:08:06,180
યાહ. હું બીજા કે મળશે.

94
00:08:06,180 --> 00:08:12,220
પ્રથમ, શા માટે વાય અને પરત ફર્યા પાછા જવાનું ખરાબ વસ્તુ છે,

95
00:08:12,220 --> 00:08:18,470
સ્ટેક પર તમે સ્ટેક ફ્રેમ્સ જે બધા વિધેયોને પ્રતિનિધિત્વ સમૂહ છે

96
00:08:18,470 --> 00:08:20,460
જે કહેવાય કરવામાં આવી છે.

97
00:08:20,460 --> 00:08:27,990
અગાઉના વસ્તુઓ અવગણીને, જેથી તમારા સ્ટેક ટોચ હંમેશા મુખ્ય કાર્ય પ્રયત્ન રહ્યું છે

98
00:08:27,990 --> 00:08:33,090
કારણ કે પ્રથમ કાર્ય કે કહેવાય રહ્યું છે તે છે.

99
00:08:33,090 --> 00:08:37,130
અને પછી જ્યારે તમે બીજા કાર્ય કૉલ, સ્ટેક નીચે વિકસે રહ્યું છે.

100
00:08:37,130 --> 00:08:41,640
, તેથી જો હું અમુક કાર્ય, foo, કૉલ અને તેની પોતાની સ્ટેક ફ્રેમ નહીં

101
00:08:41,640 --> 00:08:47,280
કેટલાક કાર્ય બાર, કૉલ કરી શકો છો; તેની પોતાની સ્ટેક ફ્રેમ નોંધાયો નહીં.

102
00:08:47,280 --> 00:08:49,840
અને ફરી યાદ આવવું બાર છે અને તેની પોતે કહી શકે,

103
00:08:49,840 --> 00:08:54,150
અને જેથી બાર બીજા કોલ પોતાના સ્ટેક ફ્રેમ વિચાર રહ્યું છે.

104
00:08:54,150 --> 00:08:58,880
અને તેથી શું આ સ્ટેક ફ્રેમમાં જાય સ્થાનિક ચલો બધા છે

105
00:08:58,880 --> 00:09:03,450
અને કાર્ય દલીલો કે બધા -

106
00:09:03,450 --> 00:09:08,730
કોઈપણ વસ્તુઓ છે કે જે સ્થાનિક રીતે આ કાર્ય માટે scoped છે આ સ્ટેક ફ્રેમમાં જાઓ.

107
00:09:08,730 --> 00:09:21,520
તેથી તેનો અર્થ એ કે જ્યારે હું જણાવ્યું હતું કે બાર કંઈક કામગીરી છે,

108
00:09:21,520 --> 00:09:29,270
હું માત્ર એક પૂર્ણાંક જાહેર અને પછી તે પૂર્ણાંક એક નિર્દેશક પાછા જઈ રહ્યો છું.

109
00:09:29,270 --> 00:09:33,790
તેથી જ્યાં વાય રહેતા નથી?

110
00:09:33,790 --> 00:09:36,900
[વિદ્યાર્થી] વાય પટ્ટીમાં રહે છે. >> [બોડેન] યાહ.

111
00:09:36,900 --> 00:09:45,010
ક્યાંક મેમરી આ થોડું ચોરસ એક littler ચોરસ કે તેને વાય છે.

112
00:09:45,010 --> 00:09:53,370
જ્યારે હું પાછો & પિ, હું મેમરી આ થોડું બ્લોક કરવા માટે નિર્દેશક પરત છું.

113
00:09:53,370 --> 00:09:58,400
પરંતુ પછી જ્યારે કાર્ય વળતર, તેના સ્ટેક ફ્રેમ બોલ સ્ટેક પોપ નહીં.

114
00:10:01,050 --> 00:10:03,530
અને તેથી જ તે સ્ટેક કહેવાય છે.

115
00:10:03,530 --> 00:10:06,570
તે સ્ટેક માહિતી બંધારણ જેવું છે, જો તમને ખબર હોય કે શું છે.

116
00:10:06,570 --> 00:10:11,580
અથવા ટ્રે એક સ્ટેક જેવા પણ હંમેશા ઉદાહરણ છે,

117
00:10:11,580 --> 00:10:16,060
મુખ્ય તળિયે જઇ રહ્યું છે, પછી પ્રથમ કાર્ય તમે કૉલ કરવા માટે કે શીર્ષ પર જાઓ રહ્યું છે,

118
00:10:16,060 --> 00:10:20,400
અને તમે પાછા મુખ્ય ન મળી ત્યાં સુધી તમે બધા વિધેયો કે જે કહેવામાં આવે છે કરેલી પાછા આવી શકો છો

119
00:10:20,400 --> 00:10:22,340
કે તે ટોચ પર મૂકવામાં આવ્યા છે.

120
00:10:22,340 --> 00:10:28,650
>> [વિદ્યાર્થી] તેથી જો તમે કર્યું & પિ છે, કે જે કિંમત નોટિસ વિના બદલવા માટે વિષય છે આવો.

121
00:10:28,650 --> 00:10:31,290
હા, it's - >> [વિદ્યાર્થી] તે ફરીથી લખાઈ હોઈ શકે છે. >> યાહ.

122
00:10:31,290 --> 00:10:34,660
તે સંપૂર્ણપણે છે - જો તમે પ્રયાસ કરો અને -

123
00:10:34,660 --> 00:10:38,040
આ પણ પૂર્ણાંક * બાર કારણ કે તે એક નિર્દેશક પરત છે કરશે,

124
00:10:38,040 --> 00:10:41,310
તેથી તેના વળતર પ્રકાર પૂર્ણાંક * છે.

125
00:10:41,310 --> 00:10:46,500
જો તમે આ કાર્ય પરત કિંમત ઉપયોગ કરવાનો પ્રયાસ કરો, તે અવ્યાખ્યાયિત વર્તન છે

126
00:10:46,500 --> 00:10:51,770
કારણ કે નિર્દેશક ખરાબ મેમરી નિર્દેશ કરે છે. >> [વિદ્યાર્થી] ઠીક.

127
00:10:51,770 --> 00:11:01,250
તેથી જો, ઉદાહરણ તરીકે, તમે જાહેર પૂર્ણાંક * વાય = malloc ((પૂર્ણાંક) sizeof)?

128
00:11:01,250 --> 00:11:03,740
કે વધારે છે. હા.

129
00:11:03,740 --> 00:11:07,730
[વિદ્યાર્થી] અમે કેવી રીતે વિશે વાત કરી ત્યારે અમે અમારી રીસાઇકલ બિન વસ્તુઓ ખેંચો

130
00:11:07,730 --> 00:11:11,750
તેઓ ખરેખર નથી ભૂંસી રહ્યાં છો; અમે ફક્ત તેમના પોઇંટરો ગુમાવી બેસે છે.

131
00:11:11,750 --> 00:11:15,550
તેથી આ કિસ્સામાં અમે ખરેખર તો કિંમત ભૂંસવું અથવા તે મેમરી હજુ પણ ત્યાં જ છો?

132
00:11:15,550 --> 00:11:19,130
સૌથી મોટા ભાગ માટે, તે હજુ પણ ત્યાં જ હશે.

133
00:11:19,130 --> 00:11:24,220
પરંતુ આપણે કહેવું અમે કેટલાક અન્ય કાર્ય, baz કૉલ થાય છે.

134
00:11:24,220 --> 00:11:28,990
Baz અહીં પર તેની પોતાની સ્ટેક ફ્રેમ વિચાર રહ્યું છે.

135
00:11:28,990 --> 00:11:31,470
તે આ સામગ્રી બધી ફરીથી લખી શકાય ચાલી રહ્યું છે,

136
00:11:31,470 --> 00:11:34,180
અને પછી જો તમે પછીથી પ્રયાસ કરો અને નિર્દેશક છે કે તમે પહેલાં મળી વાપરવા માટે,

137
00:11:34,180 --> 00:11:35,570
તે જ કિંમત નથી ચાલી રહ્યું છે.

138
00:11:35,570 --> 00:11:38,150
તે માત્ર બદલાયેલ છે કારણ કે તમે કાર્ય baz કહેવાય રહ્યું છે.

139
00:11:38,150 --> 00:11:43,080
[વિદ્યાર્થી] પરંતુ અમે અમે ન હો, હજુ 3 મળી શકે?

140
00:11:43,080 --> 00:11:44,990
[બોડેન] તમામ શક્યતા, તમે છો.

141
00:11:44,990 --> 00:11:49,670
પરંતુ તમે તે પર આધાર રાખતા નથી કરી શકો છો. સી ફક્ત અવ્યાખ્યાયિત વર્તન કહે છે.

142
00:11:49,670 --> 00:11:51,920
>> [વિદ્યાર્થી] ઓહ, તે કરે છે. ઠીક છે.

143
00:11:51,920 --> 00:11:58,190
તેથી જ્યારે તમે પાછા નિર્દેશક કરવા માંગો છો, તો આ છે જ્યાં malloc ઉપયોગ કરવામાં આવે છે.

144
00:12:00,930 --> 00:12:15,960
હું ખરેખર લખવા છું ફક્ત malloc પાછા (3 * sizeof (પૂર્ણાંક)).

145
00:12:17,360 --> 00:12:24,050
અમે malloc પર વધુ એક બીજા પડશે જાઓ, પરંતુ malloc વિચાર છે તમારા સ્થાનિક ચલો તમામ

146
00:12:24,050 --> 00:12:26,760
હંમેશા સ્ટેક પર જાઓ.

147
00:12:26,760 --> 00:12:31,570
જે કંઇ પણ malloced છે તે ઢગલો પર કોઈ રન નોંધાયો નહીં, અને તે કાયમ માટે અને હંમેશા ઢગલો પર હશે

148
00:12:31,570 --> 00:12:34,490
જ્યાં સુધી તમે તેને બાહ્ય રીતે મુક્ત.

149
00:12:34,490 --> 00:12:42,130
તેથી આ અર્થ એ છે કે જ્યારે તમે કંઈક malloc, તે કાર્ય વળતર બાદ ટકી રહેવા ચાલી રહ્યું છે.

150
00:12:42,130 --> 00:12:46,800
[વિદ્યાર્થી] તે પછી કાર્યક્રમ ચાલી સ્ટોપ્સ અસ્તિત્વ ટકાવી શકશે? >> નંબર

151
00:12:46,800 --> 00:12:53,180
ઠીક છે, તેથી તેને ત્યાં સુધી આ કાર્યક્રમ છે કે જે બધા માર્ગ ચાલી કરવામાં બનશે. હા. >>

152
00:12:53,180 --> 00:12:57,510
અમે ઉપર શું થાય છે જ્યારે કાર્યક્રમ ચાલી સ્ટોપ્સ વિગતો જઈ શકે છે.

153
00:12:57,510 --> 00:13:02,150
તમે મને યાદ કરવાની જરૂર છે, પરંતુ શકે છે કે જે અલગ વસ્તુ રાખે છે.

154
00:13:02,150 --> 00:13:04,190
[વિદ્યાર્થી] તેથી malloc એક નિર્દેશક બનાવે છે? >> યાહ.

155
00:13:04,190 --> 00:13:13,030
Malloc - >> [વિદ્યાર્થી] મને લાગે છે malloc મેમરી કે જે નિર્દેશક ઉપયોગ કરી શકો છો એક બ્લોક નિરૂપણ કરે છે.

156
00:13:15,400 --> 00:13:19,610
[બોડેન] હું કે રેખાકૃતિ ફરીથી કરવા માંગો છો. >> [વિદ્યાર્થી] તેથી આ કાર્ય કામ કરે છે, જોકે?

157
00:13:19,610 --> 00:13:26,430
[વિદ્યાર્થી] યાહ malloc મેમરી બ્લોક કે જે તમે ઉપયોગ કરી શકો છો નિરૂપણ,

158
00:13:26,430 --> 00:13:30,470
અને પછી તે મેમરી પ્રથમ બ્લોક ના સરનામા આપે છે.

159
00:13:30,470 --> 00:13:36,750
>> [બોડેન] યાહ. તેથી જ્યારે તમે malloc, તમે મેમરી કેટલાક બ્લોક પડતો કરી રહ્યાં છો

160
00:13:36,750 --> 00:13:38,260
કે ઢગલો હાલમાં છે.

161
00:13:38,260 --> 00:13:43,040
જો ઢગલો ખૂબ જ નાનો છે, પછી ઢગલો માત્ર વધવા રહ્યું છે, અને તેને આ દિશામાં વધે છે.

162
00:13:43,040 --> 00:13:44,650
તેથી આપણે કહેવું કે ઢગલો ખૂબ નાની છે.

163
00:13:44,650 --> 00:13:49,960
પછી તે થોડો વધવા અને આ બ્લોક કે જે હમણાં જ વધીને નિર્દેશક પાછા વિશે છે.

164
00:13:49,960 --> 00:13:55,130
, જ્યારે તમે મફત સામગ્રી, તમે ઢગલો વધુ રૂમ બનાવી રહ્યા છો

165
00:13:55,130 --> 00:14:00,030
જેથી પછીથી malloc માટે કૉલ કે મેમરી કે તમે પહેલાં મુક્ત હતી પુનઃઉપયોગ કરી શકાય છે.

166
00:14:00,030 --> 00:14:09,950
Malloc અને મફત વિશે મહત્વની બાબત એ છે કે તે તમને સંપૂર્ણ નિયંત્રણ આપે છે

167
00:14:09,950 --> 00:14:12,700
આ મેમરી બ્લોકની જીવનપર્યંત.

168
00:14:12,700 --> 00:14:15,420
વૈશ્વિક ચલો હંમેશા જીવંત.

169
00:14:15,420 --> 00:14:18,500
સ્થાનિક ચલો તેમની મર્યાદામાં જીવંત છે.

170
00:14:18,500 --> 00:14:22,140
જલદી તમે સર્પાકાર તાણવું આગળ જાય છે, જે સ્થાનિક ચલો મૃત છે.

171
00:14:22,140 --> 00:14:28,890
Malloced મેમરી જીવંત છે જ્યારે તમે તેને જીવંત કરવા માંગો છો

172
00:14:28,890 --> 00:14:33,480
અને પછી જ્યારે તમે તે કહેવું રિલીઝ થઈ રીલિઝ છે.

173
00:14:33,480 --> 00:14:38,420
તે ખરેખર છે મેમરીનો માત્ર 3 પ્રકારના ખરેખર.

174
00:14:38,420 --> 00:14:41,840
ત્યાં આપોઆપ મેમરી વ્યવસ્થાપન, કે જે સ્ટેક છે છે.

175
00:14:41,840 --> 00:14:43,840
વસ્તુઓ તમારા માટે આપોઆપ થાય છે.

176
00:14:43,840 --> 00:14:46,910
જ્યારે તમે પૂર્ણાંક એક્સ કહે, મેમરી પૂર્ણાંક એક્સ માટે ફાળવવામાં આવે છે.

177
00:14:46,910 --> 00:14:51,630
જ્યારે એક્સ અવકાશ બહાર જાય છે, મેમરી x માટે પુનઃજીવીત કરી છે.

178
00:14:51,630 --> 00:14:54,790
તો પછી ત્યાં ગતિશીલ મેમરી વ્યવસ્થાપન, કે જે malloc શું છે છે,

179
00:14:54,790 --> 00:14:56,740
જે છે જ્યારે તમે નિયંત્રણ નથી.

180
00:14:56,740 --> 00:15:01,290
તમે ઉમદા નક્કી ત્યારે મેમરી અને ફાળવણી કરવામાં જોઇએ નહિં.

181
00:15:01,290 --> 00:15:05,050
અને પછી ત્યાં સ્થિર છે, જે ફક્ત અર્થ એ થાય કે તે કાયમ રહે છે,

182
00:15:05,050 --> 00:15:06,610
જે વૈશ્વિક ચલો શું છે.

183
00:15:06,610 --> 00:15:10,240
તેઓ મેમરી ફક્ત હંમેશા છો.

184
00:15:10,960 --> 00:15:12,760
>> પ્રશ્નો?

185
00:15:14,490 --> 00:15:17,230
[વિદ્યાર્થી] તમે સર્પાકાર કૌંસ ઉપયોગ કરીને માત્ર એક બ્લોક વ્યાખ્યાયિત કરી શકું

186
00:15:17,230 --> 00:15:21,220
કર્યા પરંતુ એમ ન કરવાનું પાસે નિવેદન અથવા જ્યારે અથવા તે જેવી નિવેદન કંઈપણ જો?

187
00:15:21,220 --> 00:15:29,130
તમે એક કાર્ય તરીકે બ્લોક વ્યાખ્યાયિત કરવા માટે, પરંતુ શકો છો કે સર્પાકાર કૌંસ પણ ધરાવે છે.

188
00:15:29,130 --> 00:15:32,100
તેથી [વિદ્યાર્થી] તમે ફક્ત તમારા કોડમાં સર્પાકાર કૌંસ એક રેન્ડમ જોડી જેવી હોઈ શકે નહિં

189
00:15:32,100 --> 00:15:35,680
કે સ્થાનિક ચલો છે? >> હા, તમે આ કરી શકો છો.

190
00:15:35,680 --> 00:15:45,900
પૂર્ણાંક બાર અંદર અમે {int વાય = 3;} કરી શકે છે.

191
00:15:45,900 --> 00:15:48,440
કે અહીં પ્રયત્ન માનવામાં આવે છે.

192
00:15:48,440 --> 00:15:52,450
પરંતુ તે સંપૂર્ણપણે પૂર્ણાંક વાય તક વ્યાખ્યાયિત કરે છે.

193
00:15:52,450 --> 00:15:57,320
કે જે સેકન્ડ સર્પાકાર તાણવું પછી, વાય હવે ઉપયોગ કરી શકાતો નથી.

194
00:15:57,910 --> 00:16:00,630
તમે લગભગ ક્યારેય કે કરવું.

195
00:16:02,940 --> 00:16:07,370
શું થાય છે જ્યારે એક કાર્યક્રમ પૂર્ણ થાય છે પાછા ફરવામાં,

196
00:16:07,370 --> 00:16:18,760
ત્યાં એક જૂઠાણું / ગેરસમજ અડધા કે અમે ક્રમમાં ફક્ત વસ્તુઓ સરળ બનાવી આપવા પ્રકારની છે.

197
00:16:18,760 --> 00:16:24,410
અમે તમને જણાવવું કે જ્યારે તમે મેમરી ફાળવણી

198
00:16:24,410 --> 00:16:29,860
કે જે તમને ચલ માટે RAM ની કેટલીક ભાગ allocating કરી રહ્યાં છો.

199
00:16:29,860 --> 00:16:34,190
પરંતુ તમે ખરેખર સીધા રેમ કરી રહ્યાં છો ક્યારેય સ્પર્શ તમારા કાર્યક્રમો છે.

200
00:16:34,190 --> 00:16:37,490
જો તમે તેને લાગે, હું કેવી રીતે આકર્ષિત -

201
00:16:37,490 --> 00:16:44,330
અને ખરેખર, જો તમે GDB માં પસાર તમે આ જ વાત જોશો.

202
00:16:51,120 --> 00:16:57,590
અનુલક્ષીને કેટલી વખત તમે તમારી કાર્યક્રમ અથવા કાર્યક્રમ શું તમે ચલાવી રહ્યા છો સ્કોર છે,

203
00:16:57,590 --> 00:16:59,950
સ્ટેક હંમેશા શરૂ થઈ રહ્યું છે -

204
00:16:59,950 --> 00:17:06,510
તમે હંમેશા સરનામા oxbffff કંઈક આસપાસ ચલો જોવા જઈ રહ્યાં છો.

205
00:17:06,510 --> 00:17:09,470
તે સામાન્ય રીતે ક્યાંક છે કે પ્રદેશ છે.

206
00:17:09,470 --> 00:17:18,760
પરંતુ 2 કાર્યક્રમો કદાચ કેવી રીતે તે જ મેમરી પોઇંટરો હોઈ શકે?

207
00:17:20,640 --> 00:17:27,650
[વિદ્યાર્થી] ત્યાં જ્યાં oxbfff માટે રેમ પર હશે તેવું માનવામાં આવે છે કેટલાક મનસ્વી હોદ્દો છે

208
00:17:27,650 --> 00:17:31,320
કે જે વાસ્તવમાં અલગ જ્યારે કાર્ય તરીકે ઓળખાતું હતું તેના પર આધાર રાખીને સ્થળોએ હોઈ શકે છે.

209
00:17:31,320 --> 00:17:35,920
યાહ. શબ્દ વર્ચ્યુઅલ મેમરી છે.

210
00:17:35,920 --> 00:17:42,250
એક વિચાર કે દરેક એક પ્રક્રિયા છે, દરેક એક કાર્યક્રમ છે કે જે તમારા કમ્પ્યુટર પર ચાલી રહ્યું છે

211
00:17:42,250 --> 00:17:49,450
તેની પોતાની હોય છે - સંપૂર્ણપણે સ્વતંત્ર સરનામા જગ્યા - ચાલો 32 બિટ્સ ધારે.

212
00:17:49,450 --> 00:17:51,590
આ સરનામા જગ્યા છે.

213
00:17:51,590 --> 00:17:56,220
તેની પોતાની સંપૂર્ણપણે સ્વતંત્ર 4 વાપરવા માટે ગીગાબાઇટ્સ છે.

214
00:17:56,220 --> 00:18:02,220
>> તેથી જો તમે 2 પ્રોગ્રામો એકી સાથે ચલાવવા માટે, આ કાર્યક્રમ પોતે 4 ગીગાબાઇટ્સ જુએ છે,

215
00:18:02,220 --> 00:18:04,870
આ કાર્યક્રમ પોતે 4 ગીગાબાઇટ્સ જુએ છે,

216
00:18:04,870 --> 00:18:07,720
અને તે આ કાર્યક્રમ માટે ડિરેફરન્સ માટે અશક્ય એક નિર્દેશક છે

217
00:18:07,720 --> 00:18:10,920
અને આ કાર્યક્રમ માંથી મેમરી સાથે અંત.

218
00:18:10,920 --> 00:18:18,200
અને વર્ચ્યુઅલ મેમરી છે જે એક પ્રક્રિયાઓ સરનામા જગ્યા માંથી મેપિંગ છે

219
00:18:18,200 --> 00:18:20,470
રેમ પર વાસ્તવિક વસ્તુઓ છે.

220
00:18:20,470 --> 00:18:22,940
જેથી તે તમારી ઓપરેટિંગ સિસ્ટમ પર છે કે ખબર,

221
00:18:22,940 --> 00:18:28,080
હેય, જ્યારે આ વ્યક્તિ dereferences નિર્દેશક oxbfff છે, કે જે ખરેખરમાં મતલબ

222
00:18:28,080 --> 00:18:31,040
કે તેઓ રેમ 1000 બાઇટ માંગે છે,

223
00:18:31,040 --> 00:18:38,150
જ્યારે આ કાર્યક્રમ dereferences oxbfff જો તેઓ ખરેખર રેમ 10000 બાઇટ માંગે છે.

224
00:18:38,150 --> 00:18:41,590
તેઓ આપખુદ દૂર દૂરની હોઈ શકે છે.

225
00:18:41,590 --> 00:18:48,730
આ એક પ્રક્રિયાઓ સરનામા જગ્યા અંદર પણ વસ્તુઓ સાચી છે.

226
00:18:48,730 --> 00:18:54,770
આની જેમ તે પોતે તમામ 4 ગીગાબાઇટ્સ જુએ છે, પરંતુ આપણે કહેવું -

227
00:18:54,770 --> 00:18:57,290
[વિદ્યાર્થી] દરેક એક પ્રક્રિયા કરે છે -

228
00:18:57,290 --> 00:19:01,350
હવે કહો કે તમે RAM ની માત્ર 4 ગીગાબાઇટ્સ સાથે કોમ્પ્યુટર હોય છે.

229
00:19:01,350 --> 00:19:06,430
નથી દરેક એક પ્રક્રિયા સંપૂર્ણ 4 ગીગાબાઇટ્સ જુઓ છો? હા. >>

230
00:19:06,430 --> 00:19:13,060
પરંતુ 4 ગીગાબાઇટ્સ જુએ છે તે એક જૂઠાણું છે.

231
00:19:13,060 --> 00:19:20,460
તે માત્ર તે વિચારે છે કે તે આ બધી મેમરીનો છે કારણ કે તે ખબર નથી કોઇ અન્ય પ્રક્રિયા અસ્તિત્વમાં છે.

232
00:19:20,460 --> 00:19:28,140
તે માત્ર ત્યારે જ બધી મેમરીનો ઉપયોગ તે ખરેખર જરૂર પડશે.

233
00:19:28,140 --> 00:19:32,340
ઓપરેટિંગ સિસ્ટમ માટે આ પ્રક્રિયા માટે રેમ આપી નથી જઈ રહ્યા

234
00:19:32,340 --> 00:19:35,750
જો તે આ સમગ્ર વિસ્તારમાં કોઇ મેમરી નથી વાપરી છે.

235
00:19:35,750 --> 00:19:39,300
તે તે પ્રદેશ માટે મેમરી આપી નથી ચાલી રહ્યું છે.

236
00:19:39,300 --> 00:19:54,780
પરંતુ વિચાર તે છે - હું લાગે છે કરવાનો પ્રયાસ કરી રહ્યો છું - હું એક એનલોજી કલ્પના કરી શકતો નથી.

237
00:19:54,780 --> 00:19:56,780
છીછરાપણા હાર્ડ છે.

238
00:19:57,740 --> 00:20:02,700
વર્ચ્યુઅલ મેમરી પ્રશ્નો અથવા એક એક વસ્તુઓ તેને ઉકેલવા છે ઓફ

239
00:20:02,700 --> 00:20:06,810
છે કે પ્રક્રિયાઓ સંપૂર્ણપણે એક અન્ય અજાણ પ્રયત્ન કરીશું.

240
00:20:06,810 --> 00:20:12,140
અને જેથી તમે કોઇપણ કાર્યક્રમ લખી શકો છો કે જે હમણાં જ કોઇ નિર્દેશક dereferences,

241
00:20:12,140 --> 00:20:19,340
ગમે માત્ર એક કાર્યક્રમ છે કે જે * (ox1234) કહે લખો,

242
00:20:19,340 --> 00:20:22,890
અને કહે છે કે dereferencing મેમરી 1234 સરનામું.

243
00:20:22,890 --> 00:20:28,870
>> પરંતુ તે ઓપરેટિંગ સિસ્ટમ પર છે પછી શું 1234 અર્થ અનુવાદ.

244
00:20:28,870 --> 00:20:33,960
તેથી 1234 જો આ પ્રક્રિયા માટે માન્ય મેમરી સરનામા બને છે,

245
00:20:33,960 --> 00:20:38,800
જેમ તે સ્ટેક અથવા કંઈક પર છે, તો પછી આ કે મેમરી સરનામા મૂલ્ય આપશે

246
00:20:38,800 --> 00:20:41,960
જ્યાં સુધી આ પ્રક્રિયા જાણે છે.

247
00:20:41,960 --> 00:20:47,520
પરંતુ 1234 જો એ કોઈ માન્ય સરનામું નથી, જેમ કે તે જમીન પર થાય છે

248
00:20:47,520 --> 00:20:52,910
મેમરી કેટલાક અહીં થોડું ટુકડો છે કે જે સ્ટેક બહાર છે અને ઢગલો બહાર

249
00:20:52,910 --> 00:20:57,200
અને તમે ખરેખર છે કે, પછી કે જ્યારે તમે segfaults જેવી વસ્તુઓ વિચાર ઉપયોગ કર્યો નથી

250
00:20:57,200 --> 00:21:00,260
કારણ કે તમે મેમરી સ્પર્શ કરી રહ્યાં છો કે તમે સ્પર્શ નથી.

251
00:21:07,180 --> 00:21:09,340
આ પણ સાચું -

252
00:21:09,340 --> 00:21:15,440
સિસ્ટમ 32-bit, 32 બિટ્સ અર્થ છે કે તમે 32 થી મેમરી સરનામા વ્યાખ્યાયિત બિટ્સ હોય છે.

253
00:21:15,440 --> 00:21:22,970
તે શા માટે પોઇંટરો 8 બાઇટ્સ છે એટલા માટે છે કે 32 બિટ્સ 8 બાઇટ્સ છે - અથવા 4 બાઇટ્સ.

254
00:21:22,970 --> 00:21:25,250
પોઇન્ટર 4 બાઇટ્સ છે.

255
00:21:25,250 --> 00:21:33,680
તેથી જ્યારે તમે oxbfffff જેવા નિર્દેશક જોવા છે, કે જે -

256
00:21:33,680 --> 00:21:40,080
આપેલ કોઈપણ કાર્યક્રમ અંદર તમે હમણાં કોઇ મનસ્વી નિર્દેશક રચવા કરી શકો છો,

257
00:21:40,080 --> 00:21:46,330
ગમે ત્યાં ox0 માંથી બળદની 8 f's માટે - ffffffff.

258
00:21:46,330 --> 00:21:49,180
[વિદ્યાર્થી] શું તમે કહેવું છે કે તેઓ 4 બાઇટ્સ છો? >> યાહ.

259
00:21:49,180 --> 00:21:52,730
[વિદ્યાર્થી] પછી દરેક બાઈટ હશે - >> [બોડેન] હેક્સાડેસિમલ.

260
00:21:52,730 --> 00:21:59,360
હેક્સાડેસિમલ - 5, 6, 7, 8. પોઇન્ટર તેથી તમે હંમેશા હેક્સાડેસિમલ જોવા જઈ રહ્યાં છો.

261
00:21:59,360 --> 00:22:01,710
તે ફક્ત અમે કેવી રીતે પોઇંટરો વર્ગીકૃત.

262
00:22:01,710 --> 00:22:05,240
હેક્સાડેસિમલ દરેક 2 અંક 1 બાઇટ છે.

263
00:22:05,240 --> 00:22:09,600
તેથી ત્યાં 4 બાઇટ્સ માટે 8 હેક્સાડેસિમલ અંકો જ હશે.

264
00:22:09,600 --> 00:22:14,190
તેથી સિસ્ટમ 32-bit દરેક એક નિર્દેશક માટે 4 બાઇટ્સ પ્રયત્ન રહ્યું છે,

265
00:22:14,190 --> 00:22:18,550
જેનો અર્થ થાય છે કે જે તમારા પ્રક્રિયામાં તમે કોઈપણ મનસ્વી 4 બાઇટ્સ રચવા કરી શકો છો

266
00:22:18,550 --> 00:22:20,550
અને તે એક નિર્દેશક આઉટ કરી,

267
00:22:20,550 --> 00:22:32,730
જેનો અર્થ છે કે જ્યાં સુધી તે વાકેફ છે, પછી તે મેમરીમાં ના 32 બાઇટ્સ એક સંપૂર્ણ 2 સંબોધવા કરી શકો છો.

268
00:22:32,730 --> 00:22:34,760
ભલે તે ખરેખર છે કે જે પ્રવેશ નથી,

269
00:22:34,760 --> 00:22:40,190
પણ જો તમારા કમ્પ્યુટર માત્ર 512 મેગાબાઇટ્સ છે, તે વિચારે છે કે તે બધી મેમરીનો છે.

270
00:22:40,190 --> 00:22:44,930
અને ઓપરેટિંગ સિસ્ટમ માટે પૂરતી સ્માર્ટ છે કે તે માત્ર ફાળવવા તમે શું ખરેખર જરૂર છે.

271
00:22:44,930 --> 00:22:49,630
તે જ ન ઓહ, નવી પ્રક્રિયા: 4 શોના.

272
00:22:49,630 --> 00:22:51,930
>> યાહ. >> [વિદ્યાર્થી] એ બળદની શું અર્થ છે? તમે શા માટે લખી શકું?

273
00:22:51,930 --> 00:22:54,980
તે માત્ર હેક્સાડેસિમલ માટે પ્રતીક છે.

274
00:22:54,980 --> 00:22:59,590
જ્યારે તમે બેલ સાથે નંબર શરૂઆત જોવા માટે, ક્રમિક વસ્તુઓ હેક્સાડેસિમલ છે.

275
00:23:01,930 --> 00:23:05,760
[વિદ્યાર્થી] તમે શું થાય છે જ્યારે એક કાર્યક્રમ પૂર્ણ થાય વિશે સમજાવતા હતા. હા. >>

276
00:23:05,760 --> 00:23:09,480
ત્યારે થાય છે જ્યારે એક કાર્યક્રમ પૂર્ણ થાય છે શું ઓપરેટિંગ સિસ્ટમ છે

277
00:23:09,480 --> 00:23:13,600
ફક્ત જોડણીઓની છે કે તે આ સરનામાંઓ માટે છે, અને તે છે ભૂંસી નાંખે.

278
00:23:13,600 --> 00:23:17,770
ઓપરેટિંગ સિસ્ટમ હવે માત્ર એક બીજી વાપરવા માટે કાર્યક્રમ છે કે જે મેમરી આપી શકે છે.

279
00:23:17,770 --> 00:23:19,490
[વિદ્યાર્થી] ઠીક.

280
00:23:19,490 --> 00:23:24,800
તેથી જ્યારે તમે ઢગલો અથવા સ્ટેક અથવા વૈશ્વિક ચલો અથવા કંઈપણ પર કંઈક ફાળવો,

281
00:23:24,800 --> 00:23:27,010
તેઓ બધા જ જલદી કાર્યક્રમ સમાપ્ત થાય છે અદૃશ્ય થઈ

282
00:23:27,010 --> 00:23:32,120
કારણ કે ઓપરેટિંગ સિસ્ટમ હવે કોઇ અન્ય પ્રક્રિયા કે મેમરી આપવા મફત.

283
00:23:32,120 --> 00:23:35,150
[વિદ્યાર્થી] તેમ છતાં ત્યાં કદાચ હજુ પણ હોય તેવા પરચૂરણ ખર્ચ કિંમતો? >> યાહ.

284
00:23:35,150 --> 00:23:37,740
કિંમતો શક્યતા હજુ પણ છે ત્યાં.

285
00:23:37,740 --> 00:23:41,570
તે માત્ર તે માટે તેમને અંતે વિચાર મુશ્કેલ હોઈ છે બનશે.

286
00:23:41,570 --> 00:23:45,230
તે વધુ મુશ્કેલ છે તેમને અંતે વિચાર કરતાં તેને કાઢી ફાઈલ અંતે વિચાર છે

287
00:23:45,230 --> 00:23:51,450
કારણ કે કાઢી ફાઈલ પ્રકારની લાંબા સમય સુધી ત્યાં બેસે છે અને હાર્ડ ડ્રાઇવ ઘણો મોટો હોય છે.

288
00:23:51,450 --> 00:23:54,120
તેથી તે માટે મેમરી વિવિધ ભાગો પર ફરીથી લખી રહ્યું છે

289
00:23:54,120 --> 00:23:58,640
તે પહેલાં મેમરી ના ભાગ કે જે ફાઈલ પર ફરીથી લખી આપવામાં આવે છે બને છે.

290
00:23:58,640 --> 00:24:04,520
પરંતુ મુખ્ય મેમરી, RAM, તમે ઝડપથી ઘણો દ્વારા સાયકલ,

291
00:24:04,520 --> 00:24:08,040
તેથી તે ખૂબ જ ઝડપથી ફરીથી લખાઈ જ હશે.

292
00:24:10,300 --> 00:24:13,340
આ અથવા અન્ય કંઈપણ પર પ્રશ્નો?

293
00:24:13,340 --> 00:24:16,130
[વિદ્યાર્થી] હું એક અલગ વિષય વિશે પ્રશ્નો હોય છે. ઠીક છે. >>

294
00:24:16,130 --> 00:24:19,060
શું કોઇને આ પ્રશ્નો છે?

295
00:24:20,170 --> 00:24:23,120
>> ઠીક છે. વિવિધ વિષય. >> [વિદ્યાર્થી] ઠીક.

296
00:24:23,120 --> 00:24:26,550
હું પ્રથા કેટલાક પરીક્ષણોના પસાર થઇ રહ્યા હતા,

297
00:24:26,550 --> 00:24:30,480
અને તેમાંથી એક તે sizeof અંગે વાત કરી હતી

298
00:24:30,480 --> 00:24:35,630
અને કિંમત કે તે આપે છે અથવા અલગ પ્રકારના ચલ. હા. >>

299
00:24:35,630 --> 00:24:45,060
અને જણાવ્યું હતું કે બંને પૂર્ણાંક અને લાંબા બન્ને 4 વળતર, તેથી તેઓ બન્ને 4 બાઇટ્સ લાંબા છો.

300
00:24:45,060 --> 00:24:48,070
ત્યાં પૂર્ણાંક અને લાંબી વચ્ચે કોઇ તફાવત છે, અથવા તે જ વસ્તુ છે?

301
00:24:48,070 --> 00:24:50,380
હા, ત્યાં તફાવત છે.

302
00:24:50,380 --> 00:24:52,960
આ C સ્ટાન્ડર્ડ -

303
00:24:52,960 --> 00:24:54,950
હું કદાચ અપ વાસણ કરવા જઇ રહ્યો છું.

304
00:24:54,950 --> 00:24:58,800
આ C સ્ટાન્ડર્ડ માત્ર ગમે છે સી શું છે, સી સત્તાવાર દસ્તાવેજો

305
00:24:58,800 --> 00:25:00,340
આ તે શું કહે છે.

306
00:25:00,340 --> 00:25:08,650
જેથી C સ્ટાન્ડર્ડ માત્ર કહે છે કે ચાર રચે છે કાયમ અને હંમેશા 1 બાઇટ હશે.

307
00:25:10,470 --> 00:25:19,040
કે પછી બધું - ટૂંકા હંમેશા માત્ર કરતાં વધારે અથવા ઘરનાં પરચૂરણ કામો માટે સમાન હોવા તરીકે વ્યાખ્યાયિત થયેલ છે.

308
00:25:19,040 --> 00:25:23,010
આ સખત કરતા વધારે છે, પરંતુ હકારાત્મક હોઈ શકે છે.

309
00:25:23,010 --> 00:25:31,940
પૂર્ણાંક ફક્ત કરતાં મોટું અથવા ટૂંકા સમાન હોવા તરીકે વ્યાખ્યાયિત કરવામાં આવે છે.

310
00:25:31,940 --> 00:25:36,210
અને લાંબી ફક્ત કરતાં મોટું અથવા પૂર્ણાંક પર સમાન હોવા તરીકે વ્યાખ્યાયિત કરવામાં આવે છે.

311
00:25:36,210 --> 00:25:41,600
અને લાંબા લાંબા કરતાં વધારે અથવા લાંબા સમાન છે.

312
00:25:41,600 --> 00:25:46,610
તેથી જ વસ્તુ સી પ્રમાણભૂત વ્યાખ્યાયિત બધું સાપેક્ષ ક્રમ છે.

313
00:25:46,610 --> 00:25:54,880
મેમરી વાસ્તવિક જથ્થો કે વસ્તુઓ લાગી સામાન્ય રીતે અમલીકરણ કરવા માટે છે,

314
00:25:54,880 --> 00:25:57,640
પરંતુ તે યોગ્ય તેમજ આ બિંદુએ વ્યાખ્યાયિત કરે છે. >> [વિદ્યાર્થી] ઠીક.

315
00:25:57,640 --> 00:26:02,490
તેથી શોર્ટ્સ લગભગ હંમેશા માટે 2 બાઇટ્સ હશે આવે છે.

316
00:26:04,920 --> 00:26:09,950
Ints લગભગ હંમેશા માટે 4 બાઇટ્સ હશે આવે છે.

317
00:26:12,070 --> 00:26:15,340
લાંબા લોન્ગ્સ લગભગ હંમેશા 8 બાઇટ્સ હશે આવે છે.

318
00:26:17,990 --> 00:26:23,160
અને લોન્ગ્સ, તે છે કે શું તમે 32-bit અથવા સિસ્ટમ 64-bit ઉપયોગ કરી રહ્યા છો તેના પર આધાર રાખે છે.

319
00:26:23,160 --> 00:26:27,450
તેથી લાંબા સિસ્ટમ પ્રકાર અનુલક્ષે રહ્યું છે.

320
00:26:27,450 --> 00:26:31,920
જો તમે ઉપકરણ જેવા સિસ્ટમ 32-bit ઉપયોગ કરી રહ્યાં છો, તે માટે 4 બાઇટ્સ જ હશે.

321
00:26:34,530 --> 00:26:42,570
જો તમે તાજેતરમાં કમ્પ્યુટર્સ ઘણો જેવી 64-bit ઉપયોગ કરી રહ્યાં છો, તે માટે 8 બાઇટ્સ જ હશે.

322
00:26:42,570 --> 00:26:45,230
>> Ints લગભગ હંમેશા આ બિંદુએ 4 બાઇટ્સ.

323
00:26:45,230 --> 00:26:47,140
લાંબા લોન્ગ્સ લગભગ હંમેશા 8 બાઇટ્સ.

324
00:26:47,140 --> 00:26:50,300
ભૂતકાળમાં, ints માત્ર 2 બાઇટ્સ આપવામાં આવે છે.

325
00:26:50,300 --> 00:26:56,840
નોટિસ પણ છે કે આ સંપૂર્ણપણે કરતાં વધારે અને સમાન આ સંબંધો બધા સંતોષે છે.

326
00:26:56,840 --> 00:27:01,280
તેથી લાંબા સંપૂર્ણપણે પૂર્ણાંક તરીકે જ કદ પ્રયત્ન મંજૂરી છે,

327
00:27:01,280 --> 00:27:04,030
અને તે પણ લાંબા લાંબા તે જ કદના પ્રયત્ન માન્ય છે.

328
00:27:04,030 --> 00:27:11,070
અને તે માત્ર તેથી કે સિસ્ટમો 99,999% માં, તે માટે સમાન હોવો રહ્યું છે બને છે

329
00:27:11,070 --> 00:27:15,800
ક્યાં પૂર્ણાંક અથવા લાંબા લાંબા હોય છે. તે માત્ર 32-bit અથવા 64-bit પર આધાર રાખે છે. >> [વિદ્યાર્થી] ઠીક.

330
00:27:15,800 --> 00:27:24,600
ફ્લોટ્સ માં, કેવી રીતે અક્ષાંશ બિટ્સ દ્રષ્ટિએ નિયુક્ત બિંદુ છે?

331
00:27:24,600 --> 00:27:27,160
દ્વિસંગી તરીકે માંગો છો? >> યાહ.

332
00:27:27,160 --> 00:27:30,570
તમે CS50 માટે તે ખબર જરૂર નથી.

333
00:27:30,570 --> 00:27:32,960
તમે પણ 61 કે નથી જાણવા નથી.

334
00:27:32,960 --> 00:27:37,350
કે જે તમને ખરેખર કોઇ કોર્સ નથી જાણવા નથી.

335
00:27:37,350 --> 00:27:42,740
તે માત્ર પ્રતિનિધિત્વ છે.

336
00:27:42,740 --> 00:27:45,440
હું ચોક્કસ બીટ ફાળવવા ભૂલી જાવ.

337
00:27:45,440 --> 00:27:53,380
ફ્લોટિંગ પોઇન્ટ ઓફ વિચાર છે કે તમે બીટ્સ એક ચોક્કસ સંખ્યામાં પ્રતિનિધિત્વ ફાળવવા -

338
00:27:53,380 --> 00:27:56,550
હકીકતે, બધું વૈજ્ઞાનિક નોટેશનમાં છે.

339
00:27:56,550 --> 00:28:05,600
તેથી તમે બીટ્સ એક ચોક્કસ નંબર પર 1,2345 જેમ નંબર જ પ્રતિનિધિત્વ ફાળવવા.

340
00:28:05,600 --> 00:28:10,200
હું 5 કરતાં વધુ અંકો સાથે નંબર ક્યારેય પ્રતિનિધિત્વ કરી શકે છે.

341
00:28:12,200 --> 00:28:26,300
પછી તમે પણ બીટ્સ એક ચોક્કસ નંબર ફાળવી છે કે જેથી તે જેવી હોય છે

342
00:28:26,300 --> 00:28:32,810
તમે માત્ર એક ચોક્કસ નંબર સુધી જઈ શકે છે, જેમ કે સૌથી મોટું હિમાયતી તમારી પાસે કરી શકો છો,

343
00:28:32,810 --> 00:28:36,190
અને તમે માત્ર એક ચોક્કસ હિમાયતી માટે નીચે જઈ શકે છે,

344
00:28:36,190 --> 00:28:38,770
ગમે કે નાના ઘાત તમારી પાસે કરી શકો છો.

345
00:28:38,770 --> 00:28:44,410
>> હું યાદ નથી ચોક્કસ માર્ગ બિટ્સ આ કિંમતો બધી સોંપાયેલ છે,

346
00:28:44,410 --> 00:28:47,940
પરંતુ બીટ્સ એક નિશ્ચિત સંખ્યા 1,2345 માટે સમર્પિત હોય છે,

347
00:28:47,940 --> 00:28:50,930
બિટ્સ બીજા ચોક્કસ સંખ્યા હિમાયતી માટે સમર્પિત હોય છે,

348
00:28:50,930 --> 00:28:55,670
અને તે માત્ર શક્ય કરવા માટે અમુક ચોક્કસ માપ એક હિમાયતી પ્રતિનિધિત્વ કરે છે.

349
00:28:55,670 --> 00:29:01,100
[વિદ્યાર્થી] અને એક ડબલ? વધારાની લાંબા ફ્લોટ જેમ કે છે? >> યાહ.

350
00:29:01,100 --> 00:29:07,940
તે હવે તમે 4 બાઇટ્સ બદલે 8 બાઇટ્સ ઉપયોગ કરી રહ્યા છો તે સિવાય ફ્લોટ તરીકે જ વાત છે.

351
00:29:07,940 --> 00:29:11,960
હવે તમે 9 અંક અથવા 10 અંકોનો ઉપયોગ કરી શકશો,

352
00:29:11,960 --> 00:29:16,630
અને આ માટે 300 ના બદલે 100 થી ઉપર જવા સમર્થ હશે. >> [વિદ્યાર્થી] ઠીક.

353
00:29:16,630 --> 00:29:21,550
અને ફ્લોટ્સ પણ છે 4 બાઇટ્સ. હા. >>

354
00:29:21,550 --> 00:29:27,520
વેલ, ફરી, તે કદાચ સામાન્ય અમલીકરણ પર આધાર રાખે છે એકંદર,

355
00:29:27,520 --> 00:29:30,610
પરંતુ ફ્લોટ્સ 4 બાઇટ્સ હોય છે, ડબલ્સમાં 8 છે.

356
00:29:30,610 --> 00:29:33,440
ડબલ્સમાં ડબલ કહેવામાં આવે છે કારણ કે તેઓ ડબલ ફ્લોટ્સ માપ છે.

357
00:29:33,440 --> 00:29:38,380
[વિદ્યાર્થી] ઠીક. અને ત્યાં ડબલ ડબલ્સ છે? >> નથી ત્યાં.

358
00:29:38,380 --> 00:29:43,660
મને લાગે છે - >> લાંબા લોન્ગ્સ જેમ [વિદ્યાર્થી] >> યાહ. હું નથી લાગતું નથી. હા.

359
00:29:43,660 --> 00:29:45,950
ગયા વર્ષના ટેસ્ટ પર [વિદ્યાર્થી] ત્યાં મુખ્ય કાર્ય વિશે પ્રશ્ન હતો

360
00:29:45,950 --> 00:29:49,490
તમારા કાર્યક્રમ ભાગ હોઈ હોય છે.

361
00:29:49,490 --> 00:29:52,310
જવાબ એ છે કે તે તમારા કાર્યક્રમ ભાગ નથી.

362
00:29:52,310 --> 00:29:55,100
પરિસ્થિતિ શું છે? કે હું શું જોયું.

363
00:29:55,100 --> 00:29:59,090
[બોડેન] એવું લાગે છે - >> [વિદ્યાર્થી] શું પરિસ્થિતિ?

364
00:29:59,090 --> 00:30:02,880
શું તમે સમસ્યા છે? >> [વિદ્યાર્થી] અરે વાહ, હું નિશ્ચિતપણે તે ખેંચવાનો અપ કરી શકો છો.

365
00:30:02,880 --> 00:30:07,910
તે પ્રયત્ન નથી, ટેકનીકલી છે, પરંતુ મૂળભૂત રીતે તે જ હશે.

366
00:30:07,910 --> 00:30:10,030
[વિદ્યાર્થી] હું એક અલગ વર્ષ ના એક જોયું.

367
00:30:10,030 --> 00:30:16,220
તે સાચું અથવા ખોટું જેવી હતી: એ માન્ય - >> ઓહ, એક કેચ ફાઈલ.

368
00:30:16,220 --> 00:30:18,790
. [વિદ્યાર્થી] કોઈપણ કેચ ફાઈલ હોવી જ જોઈએ - [એક જ સમયે બંને બોલતા - દુર્બોધ]

369
00:30:18,790 --> 00:30:21,120
ઠીક છે. જેથી અલગ છે.

370
00:30:21,120 --> 00:30:26,800
>> એક સી. ફાઈલ માત્ર વિધેયો સમાવે જરૂર છે.

371
00:30:26,800 --> 00:30:32,400
તમે મશીન કોડ એક ફાઇલ, દ્વિસંગી, ગમે કમ્પાઇલ કરી શકો છો,

372
00:30:32,400 --> 00:30:36,620
વગર તે એક્ઝેક્યુટેબલ હજુ સુધી છે.

373
00:30:36,620 --> 00:30:39,420
માન્ય એક્ઝેક્યુટેબલ એક મુખ્ય કાર્ય હોવો જ જોઈએ.

374
00:30:39,420 --> 00:30:45,460
તમે 1 ફાઈલમાં 100 કાર્યો પરંતુ કોઇ મુખ્ય લખી શકો છો

375
00:30:45,460 --> 00:30:48,800
અને પછી દ્વિસંગી કે નીચે કમ્પાઇલ,

376
00:30:48,800 --> 00:30:54,460
પછી તમે બીજી ફાઇલ છે કે જે માત્ર મુખ્ય છે લખવા પરંતુ તે આ વિધેયોને સમૂહ કહે છે

377
00:30:54,460 --> 00:30:56,720
અહીં પર આ દ્વિસંગી ફાઈલ છે.

378
00:30:56,720 --> 00:31:01,240
અને તેથી જ્યારે તમે એક્ઝેક્યુટેબલ બનાવી રહ્યા છો, કે જે linker શું કરે છે

379
00:31:01,240 --> 00:31:05,960
છે તે આ એક એક્ઝેક્યુટેબલ માં 2 દ્વિસંગી ફાઈલો સાથે જોડાયેલું છે.

380
00:31:05,960 --> 00:31:11,400
તેથી સી. ફાઈલ માટે એક મુખ્ય કાર્ય હોય છે જરૂર નથી.

381
00:31:11,400 --> 00:31:19,220
અને મોટા પાયા પર તમે કોડ સી. ફાઈલો અને 1 મુખ્ય ફાઈલ હજારો જોશો.

382
00:31:23,960 --> 00:31:26,110
વધુ પ્રશ્નો છે?

383
00:31:29,310 --> 00:31:31,940
[વિદ્યાર્થી] ત્યાં બીજા પ્રશ્ન હતો.

384
00:31:31,940 --> 00:31:36,710
એવું કહેવાય બનાવવા કમ્પાઇલર છે. સાચું કે ખોટું?

385
00:31:36,710 --> 00:31:42,030
અને જવાબ ખોટા હતા, અને હું સમજી તે શા માટે રણકાર જેવી નથી.

386
00:31:42,030 --> 00:31:44,770
પરંતુ અમે શું કરી જો તે નથી કહી શકું?

387
00:31:44,770 --> 00:31:49,990
મેક મૂળભૂત માત્ર છે - હું જોઈ શકો છો ચોકકસ શું તે કહે છે.

388
00:31:49,990 --> 00:31:52,410
પરંતુ તે માત્ર આદેશો ચલાવે છે.

389
00:31:53,650 --> 00:31:55,650
બનાવો.

390
00:31:58,240 --> 00:32:00,870
હું આ અપ ખેંચી શકે છે. યાહ.

391
00:32:10,110 --> 00:32:13,180
ઓહ, હા. મેક પણ છે કે જે કરે છે.

392
00:32:13,180 --> 00:32:17,170
આ કહે છે કે મેક ઉપયોગીતા હેતુ આપોઆપ નક્કી કરવા માટે છે

393
00:32:17,170 --> 00:32:19,610
જે એક મોટા કાર્યક્રમ ટુકડાઓ recompiled કરવાની જરૂર છે

394
00:32:19,610 --> 00:32:22,350
અને આદેશો અદા કરવા માટે તેમને પુનઃકમ્પાઈલ.

395
00:32:22,350 --> 00:32:27,690
તમે જે ફાઇલો સંપૂર્ણપણે વિશાળ છે બનાવવા કરી શકો છો.

396
00:32:27,690 --> 00:32:33,210
મેક ફાઈલોની સમય સ્ટેમ્પ જુએ છે અને, જેમ કે અમારી પહેલાં જણાવ્યું હતું કે,

397
00:32:33,210 --> 00:32:36,930
તમે વ્યક્તિગત ફાઈલો કમ્પાઈલ નીચે કરી શકો છો, અને તે જ્યાં સુધી તમે linker મેળવવા નથી

398
00:32:36,930 --> 00:32:39,270
કે તેઓ સાથે મળીને એક એક્ઝેક્યુટેબલ મૂકવામાં રહ્યા છો.

399
00:32:39,270 --> 00:32:43,810
તેથી જો તમે 10 અલગ અલગ ફાઈલો હોય અને તમે તેમને 1 ફેરફાર કરી શકો છો,

400
00:32:43,810 --> 00:32:47,870
પછી મેક કરવા જઈ રહ્યો છે શું માત્ર પુનઃકમ્પાઈલ છે કે 1 ફાઈલ

401
00:32:47,870 --> 00:32:50,640
અને પછી બધું જ એક સાથે ફરીથી લિંક.

402
00:32:50,640 --> 00:32:53,020
પરંતુ તે ખૂબ કરતા dumber છે.

403
00:32:53,020 --> 00:32:55,690
તે તમારા પર છે સંપૂર્ણપણે વ્યાખ્યાયિત કે જે છે તે શું કરી હોવી જોઈએ.

404
00:32:55,690 --> 00:32:59,560
તે મૂળભૂત રીતે આ સમય સ્ટેમ્પ સામગ્રી ઓળખી ક્ષમતા હોય છે,

405
00:32:59,560 --> 00:33:03,220
પરંતુ તમે મેક ફાઈલ લખવા માટે કંઈપણ કરી શકે છે.

406
00:33:03,220 --> 00:33:09,150
તમે ફાઈલ બનાવવા કે જેથી જ્યારે તમે તે માત્ર cd અન્ય ડિરેક્ટરી માટે બનાવવા લખો. લખી શકો છો

407
00:33:09,150 --> 00:33:15,560
હું હતાશ રહ્યું હતી હું ખીલી બધું મારું ઉપકરણ ની અંદર કારણ કે

408
00:33:15,560 --> 00:33:21,740
અને પછી હું મેક ના પીડીએફ જુઓ.

409
00:33:21,740 --> 00:33:30,720
>> તેથી હું ફાઇન્ડર પર જાઓ અને હું જાઓ કરી શકો છો, સર્વર સાથે જોડાવ,

410
00:33:30,720 --> 00:33:36,950
અને સર્વર સાથે જોડાવા માટે હું મારા ઉપકરણ છે, અને પછી હું પીડીએફ ખોલવા

411
00:33:36,950 --> 00:33:40,190
કે LaTeX દ્વારા સંકલિત નહીં.

412
00:33:40,190 --> 00:33:49,320
પરંતુ હું હતાશ રહ્યું હતી દરેક એક સમય મેં પીડીએફ તાજું જરૂરી છે કારણ કે,

413
00:33:49,320 --> 00:33:53,900
હું તેને એક ચોક્કસ ડિરેક્ટરી છે કે જે તેને ઍક્સેસ કરી શકે નકલ હતી

414
00:33:53,900 --> 00:33:57,710
અને તે નકામી મેળવવામાં આવી હતી.

415
00:33:57,710 --> 00:34:02,650
તેથી તેના બદલે હું મેક ફાઈલ છે, કે જે તમે કેવી રીતે તે વસ્તુઓ બનાવે લખ્યું છે.

416
00:34:02,650 --> 00:34:06,130
કેવી રીતે તમે બનાવવા આ PDF LaTeX છે.

417
00:34:06,130 --> 00:34:10,090
ફક્ત કોઇ પણ અન્ય મેક ફાઈલ - જેવી કે હું માનું કે તમે મેક ફાઇલો જોઇ ન હોય,

418
00:34:10,090 --> 00:34:13,510
પરંતુ અમે તે સાધન વૈશ્વિક મેક ફાઈલ કે જે હમણાં જ કહે છે,

419
00:34:13,510 --> 00:34:16,679
જો તમે એક સી ફાઈલ કમ્પાઈલ કરવામાં આવે છે, રણકાર વાપરો.

420
00:34:16,679 --> 00:34:20,960
અને તેથી મારું મેક ફાઈલ અહીં કે હું બનાવવા હું કહું છું,

421
00:34:20,960 --> 00:34:25,020
આ ફાઇલ કરવા માટે તમે પીડીએફ LaTeX સાથે કમ્પાઇલ કરવા માંગો છો જઈ રહ્યાં છો.

422
00:34:25,020 --> 00:34:27,889
અને તેથી તે પીડીએફ LaTeX કે સંકલન કરી રહી છે.

423
00:34:27,889 --> 00:34:31,880
મેક નથી સંકલન છે. તે માત્ર ક્રમ હું ઉલ્લેખિત છે આ આદેશો ચલાવવા.

424
00:34:31,880 --> 00:34:36,110
તેથી તે પીડીએફ LaTeX ચાલે છે, તે ડિરેક્ટરી હું તે કરી નકલ કરવા માંગો છો માટે નકલ કરે છે,

425
00:34:36,110 --> 00:34:38,270
તે cd ડિરેક્ટરી માટે અને અન્ય વસ્તુઓ કરે છે,

426
00:34:38,270 --> 00:34:42,380
પરંતુ બધા તે જ્યારે ફાઈલ ફેરફારો ઓળખી છે,

427
00:34:42,380 --> 00:34:45,489
અને જો તે બદલી, પછી તે આદેશો કે જે તે માટે માનવામાં આવે છે ચાલશે

428
00:34:45,489 --> 00:34:48,760
ફાઇલ ફેરફારો ત્યારે. >> [વિદ્યાર્થી] ઠીક.

429
00:34:50,510 --> 00:34:54,420
મને ખબર નથી કે જ્યાં વૈશ્વિક મેક ફાઈલો છે મારા માટે તપાસ માટે.

430
00:34:57,210 --> 00:35:04,290
અન્ય પ્રશ્નો છે? ભૂતકાળની કંઈપણ અંગેની ક્વિઝ? કોઈપણ નિર્દેશક વસ્તુઓ?

431
00:35:06,200 --> 00:35:08,730
ત્યાં જેમ પોઇન્ટર સાથે ગૂઢ બાબતો છે -

432
00:35:08,730 --> 00:35:10,220
હું તેના પર ક્વિઝ પ્રશ્ન શોધવા કરવાનો પ્રયત્ન નથી માંગવાનો -

433
00:35:10,220 --> 00:35:16,250
પરંતુ માત્ર વસ્તુ આ પ્રકારની હોય છે.

434
00:35:19,680 --> 00:35:24,060
ખાતરી કરો કે તમે સમજો કે જ્યારે હું કહી બનાવો પૂર્ણાંક * x * વાય -

435
00:35:24,890 --> 00:35:28,130
આ બરાબર અહીં કંઈપણ નથી, હું માનું.

436
00:35:28,130 --> 00:35:32,140
પરંતુ જેમ * x * વાય તે 2 ચલો કે સ્ટેક પર છે.

437
00:35:32,140 --> 00:35:37,220
જ્યારે હું કહી એક્સ = malloc (sizeof (પૂર્ણાંક)), એક્સ હજુ સ્ટેક પર એક ચલ છે,

438
00:35:37,220 --> 00:35:41,180
malloc આ ઢગલો માં ઉપર કેટલાક બ્લોક છે, અને અમે ઢગલો માટે એક્સ બિંદુ આવી રહી છે.

439
00:35:41,180 --> 00:35:43,900
>> આ ઢગલો માટે સ્ટેક પોઇન્ટ પર કંઈક તેથી.

440
00:35:43,900 --> 00:35:48,100
જ્યારે પણ તમે કશું malloc, તમે ખચીત તે નિર્દેશક ની અંદર સંગ્રહિત કરી રહ્યાં છો.

441
00:35:48,100 --> 00:35:55,940
જેથી નિર્દેશક સ્ટેક પર છે, malloced બ્લોક ઢગલો છે.

442
00:35:55,940 --> 00:36:01,240
ઘણા લોકો મૂંઝવણમાં વિચાર અને કહે પૂર્ણાંક * x = malloc; x એટલે ઢગલો છે.

443
00:36:01,240 --> 00:36:04,100
નંબર એક્સ શું નિર્દેશ આ ઢગલો છે.

444
00:36:04,100 --> 00:36:08,540
પોતે એક્સ સ્ટેક પર છે, જ્યાં સુધી કારણ ગમે તે માટે તમે એક્સ વૈશ્વિક ચલ પ્રયત્ન કરેલ છે,

445
00:36:08,540 --> 00:36:11,960
જે કિસ્સામાં તે મેમરી અન્ય પ્રદેશમાં બને છે.

446
00:36:13,450 --> 00:36:20,820
ટ્રૅક રાખવા તેથી, આ બોક્સ અને તીર આકૃતિઓ સુંદર ક્વિઝ માટે સામાન્ય છે.

447
00:36:20,820 --> 00:36:25,740
અથવા જો તે 0 ક્વિઝ પર નથી, તેને 1 ક્વિઝ પર રહેશે.

448
00:36:27,570 --> 00:36:31,940
તમે આ બધી ખબર છે, સંકલન માં પગલાંઓ જોઈએ

449
00:36:31,940 --> 00:36:35,740
કારણ કે તમે તે પર પ્રશ્નોના જવાબ હતો. હા.

450
00:36:35,740 --> 00:36:38,940
[વિદ્યાર્થી] અમે તે પગલાં પર જાઓ શકે - >> શ્યોર.

451
00:36:48,340 --> 00:36:58,640
પગલાંઓ અને સંકલન પહેલાં અમે preprocessing હોય છે,

452
00:36:58,640 --> 00:37:16,750
સંકલન, એસેમ્બલ, અને જોડે છે.

453
00:37:16,750 --> 00:37:21,480
Preprocessing. કે શું થાય છે?

454
00:37:29,720 --> 00:37:32,290
તે સરળ માં પગલું છે - અને સાથે સાથે, જેમ -

455
00:37:32,290 --> 00:37:35,770
તેનો અર્થ તે સ્પષ્ટ પ્રયત્ન કરીશું નથી, પરંતુ તે સૌથી સરળ પગલું છે.

456
00:37:35,770 --> 00:37:38,410
તમે ગાય્સ તે તમે પોતે જ અમલ કરી શકે છે. યાહ.

457
00:37:38,410 --> 00:37:43,410
[વિદ્યાર્થી] લો તમે તમારા હોય શું આ જેવા સમાવેશ થાય છે અને તે પછી અને નકલો પણ વ્યાખ્યાયિત કરે છે.

458
00:37:43,410 --> 00:37:49,250
તે # સમાવેશ થાય છે જેવી વસ્તુઓ માટે જુએ છે અને # વ્યાખ્યાયિત કરવા માટે,

459
00:37:49,250 --> 00:37:53,800
અને તે માત્ર નકલો અને pastes તે ખરેખર શું અર્થ.

460
00:37:53,800 --> 00:37:59,240
તેથી જ્યારે તમે કહી # cs50.h સમાવેશ થાય છે, જે preprocessor નકલ છે અને cs50.h પેસ્ટ

461
00:37:59,240 --> 00:38:01,030
તે લીટી માં.

462
00:38:01,030 --> 00:38:06,640
જ્યારે તમે કહી # એક્સ વ્યાખ્યાયિત કરવા માટે 4 છે, preprocessor સમગ્ર કાર્યક્રમ જાય છે

463
00:38:06,640 --> 00:38:10,400
અને 4 થી x ની તમામ ઘટકોને બદલે છે.

464
00:38:10,400 --> 00:38:17,530
તેથી preprocessor માન્ય સી ફાઈલ લે છે અને માન્ય સી ફાઈલ આઉટપુટો

465
00:38:17,530 --> 00:38:20,300
વસ્તુઓ છે જ્યાં નકલ કરવામાં આવી અને પેસ્ટ કર્યું.

466
00:38:20,300 --> 00:38:24,230
તેથી હવે સંકલન. કે શું થાય છે?

467
00:38:25,940 --> 00:38:28,210
[વિદ્યાર્થી] એવું સી ના દ્વિસંગી જાય છે.

468
00:38:28,210 --> 00:38:30,970
>> [બોડેન] તે બાઈનરી તમામ થતું નથી.

469
00:38:30,970 --> 00:38:34,220
[વિદ્યાર્થી] પછી મશીન કોડ માટે? >> તે મશીન કોડ નથી.

470
00:38:34,220 --> 00:38:35,700
[વિદ્યાર્થી] એસેમ્બલી? >> એસેમ્બલી.

471
00:38:35,700 --> 00:38:38,890
તે એસેમ્બલી જાય તે પહેલાં સી કોડ બધી રીતે જાય છે,

472
00:38:38,890 --> 00:38:45,010
અને મોટા ભાગની ભાષાઓ કંઈક આના જેવું નથી.

473
00:38:47,740 --> 00:38:50,590
કોઈ પણ ભાષા ઉચ્ચ સ્તરીય ચૂંટો અને જો તમે તેને કમ્પાઇલ જઈ રહ્યાં છો,

474
00:38:50,590 --> 00:38:52,390
તે પગલાંઓ માં કમ્પાઇલ સંભાવના છે.

475
00:38:52,390 --> 00:38:58,140
પ્રથમ તે માટે સી માટે Python કમ્પાઇલ ચાલી રહ્યું છે, પછી તે એસેમ્બલી સી કમ્પાઇલ ચાલી રહ્યું છે,

476
00:38:58,140 --> 00:39:01,600
અને પછી વિધાનસભા માટે બાઈનરી અનુવાદ કરો રહ્યું છે.

477
00:39:01,600 --> 00:39:07,800
તેથી કમ્પાઇલ તેને સી ના વિધાનસભા લાવી રહ્યું છે.

478
00:39:07,800 --> 00:39:12,130
આ સંકલન શબ્દ સામાન્ય રીતે તે એક ઉચ્ચ સ્તર માંથી લાવવામાં અર્થ થાય છે

479
00:39:12,130 --> 00:39:14,340
નીચા લેવલ પ્રોગ્રામીંગ ભાષા છે.

480
00:39:14,340 --> 00:39:19,190
તેથી આ સંકલન માં માત્ર પગલું જ્યાં તમે એક ભાષા ઉચ્ચ સ્તર સાથે શરૂ થાય છે

481
00:39:19,190 --> 00:39:23,270
અને એક ભાષા નીચા સ્તર સાથે અંત છે, અને તે છે કેમ પગલું કમ્પાઇલ કહેવામાં આવે છે.

482
00:39:25,280 --> 00:39:33,370
સંકલન દરમિયાન [વિદ્યાર્થી], ચાલો કહે છે કે તમે # સમાવેશ કર્યું છે cs50.h.

483
00:39:33,370 --> 00:39:42,190
વિલ પણ કમ્પાઇલર પુનઃકમ્પાઈલ આ cs50.h, કાર્યો કે ત્યાં છે, જેમ કે

484
00:39:42,190 --> 00:39:45,280
અને એસેમ્બલી કોડમાં કે તેમજ અનુવાદ,

485
00:39:45,280 --> 00:39:50,830
અથવા તેને કૉપિ અને પેસ્ટ કરેલો આવશે કંઈક કે પૂર્વ વિધાનસભા રહી છે?

486
00:39:50,830 --> 00:39:56,910
cs50.h ખૂબ વિધાનસભામાં ખૂબ સમાપ્ત થશે કયારેય.

487
00:39:59,740 --> 00:40:03,680
કાર્ય પ્રોટોટાઇપ અને વસ્તુઓ જેવી સામગ્રી છે ફક્ત તમે સાવચેત રહો.

488
00:40:03,680 --> 00:40:09,270
તે ગેરન્ટી આપે છે કે કમ્પાઇલર વસ્તુઓ તપાસો કે તમે વિધેયો કૉલ કરી શકો છો

489
00:40:09,270 --> 00:40:12,910
જમણી વળતર પ્રકારો અને જમણી દલીલો અને સામગ્રી સાથે.

490
00:40:12,910 --> 00:40:18,350
>> તેથી cs50.h આ ફાઇલમાં preprocessed આવશે, અને પછી જ્યારે તે સંકલન છે

491
00:40:18,350 --> 00:40:22,310
તે મૂળભૂત રીતે બગાઙ છે પછી તે ખાતરી કરો કે બધું યોગ્ય રીતે કરવામાં આવી રહી છે કહેવાય છે બનાવે છે.

492
00:40:22,310 --> 00:40:29,410
પરંતુ CS50 પુસ્તકાલય વ્યાખ્યાયિત કાર્યો, કે જે cs50.h અલગ છે,

493
00:40:29,410 --> 00:40:33,610
તે અલગ શકાતી નથી સંકલન કરશે.

494
00:40:33,610 --> 00:40:37,270
કે જે વાસ્તવમાં લિંક પગલાંની નીચે આવશે, તેથી અમે એક બીજા કે મળશે.

495
00:40:37,270 --> 00:40:40,100
પરંતુ પ્રથમ, શું એસેમ્બલ કરવામાં આવે છે?

496
00:40:41,850 --> 00:40:44,500
[વિદ્યાર્થી] બાઈનરી એસેમ્બલી? >> યાહ.

497
00:40:46,300 --> 00:40:48,190
એસેમ્બલ.

498
00:40:48,190 --> 00:40:54,710
અમે તેને કમ્પાઇલ નથી કહી કારણ કે એસેમ્બલી ઘટનાએ દ્વિસંગી એક શુદ્ધ અનુવાદ હોય.

499
00:40:54,710 --> 00:41:00,230
ત્યાં એસેમ્બલી માંથી દ્વિસંગી પર જઈને ખૂબ ઓછા તર્ક છે.

500
00:41:00,230 --> 00:41:03,180
તે માત્ર એક ટેબલ માં શોધી ગમે છે, ઓહ, અમે આ સૂચના છે;

501
00:41:03,180 --> 00:41:06,290
કે 01110 દ્વિસંગી અનુલક્ષે છે.

502
00:41:10,200 --> 00:41:15,230
અને તેથી ફાઈલો છે કે જે સામાન્ય રીતે એસેમ્બલ આઉટપુટ છે ઓ ફાઈલો છે..

503
00:41:15,230 --> 00:41:19,020
અને ઓ. ફાઇલો છે, આપણે શું પહેલાં કહેતા હતા,

504
00:41:19,020 --> 00:41:21,570
ફાઇલમાં એક મુખ્ય કાર્ય છે કેવી રીતે જરૂર નથી.

505
00:41:21,570 --> 00:41:27,640
કોઈપણ ફાઇલ ઓ. ફાઈલ ડાઉન થઇ શકે છે કારણ કે તે કોઈ માન્ય સી ફાઈલ છે તરીકે કમ્પાઇલ કરેલ છે.

506
00:41:27,640 --> 00:41:30,300
તે ઓ. શકાય નીચે સંકલિત કરી શકે છે.

507
00:41:30,300 --> 00:41:43,030
હવે, લિંક છે જે વાસ્તવમાં એક ટોળું લાવે ઓ ફાઈલો છે. અને તેમને એક્ઝેક્યુટેબલ માટે લાવે છે.

508
00:41:43,030 --> 00:41:51,110
અને તેથી લિંક કરે છે શું છે તમે CS50 પુસ્તકાલય એક ઓ. ફાઇલ તરીકે વિચાર કરી શકો છો.

509
00:41:51,110 --> 00:41:56,980
તે પહેલાથી જ સંકલિત દ્વિસંગી ફાઇલ છે.

510
00:41:56,980 --> 00:42:03,530
અને તેથી જ્યારે તમે તમારી ફાઈલ, તમારા hello.c છે, કે જે GetString કહે કમ્પાઇલ,

511
00:42:03,530 --> 00:42:06,360
hello.c નીચે hello.o માટે કમ્પાઈલ નહીં,

512
00:42:06,360 --> 00:42:08,910
hello.o દ્વિસંગી હવે છે.

513
00:42:08,910 --> 00:42:12,830
તે GetString ઉપયોગ કરે છે, તેથી તે માટે cs50.o પર જાઓ જરૂર છે,

514
00:42:12,830 --> 00:42:16,390
અને linker તેમને એકસાથે smooshes અને આ ફાઈલમાં GetString નકલ કરે છે

515
00:42:16,390 --> 00:42:20,640
અને એક એક્ઝેક્યુટેબલ કે તમામ કાર્યો તેને જરૂર છે સાથે બહાર આવે છે.

516
00:42:20,640 --> 00:42:32,620
તેથી cs50.o ખરેખર એક ઓ ફાઇલ નથી, પરંતુ તે નજીક પર્યાપ્ત છે કે ત્યાં કોઈ મૂળભૂત તફાવત તે છે છે.

517
00:42:32,620 --> 00:42:36,880
તેથી માત્ર લિંક ફાઈલો સમૂહ લાવે

518
00:42:36,880 --> 00:42:41,390
કે અલગથી ના બધા વિધેયોને સમાવે હું ઉપયોગ કરવાની જરૂર છે

519
00:42:41,390 --> 00:42:46,120
અને એક્ઝેક્યુટેબલ કે ખરેખર ચાલશે બનાવે છે.

520
00:42:48,420 --> 00:42:50,780
>> અને જેથી પણ આપણે શું પહેલાં કહેતા હતા

521
00:42:50,780 --> 00:42:55,970
જ્યાં તમે 1000 પાસે કેચ ફાઈલો છે. શકો છો, તો તમે તેમને બધા કમ્પાઈલ ઓ ફાઈલો.

522
00:42:55,970 --> 00:43:00,040
જે કદાચ થોડો સમય લાગી જશે, પછી તમે 1 કેચ ફાઈલ બદલો..

523
00:43:00,040 --> 00:43:05,480
તમે માત્ર કે 1. કો ફાઈલ અને પછી ફરીથી લિંક બાકીનું બધું પુનઃકમ્પાઈલ જરૂર છે,

524
00:43:05,480 --> 00:43:07,690
બધું ફરી પાછા સાથે લિંક.

525
00:43:09,580 --> 00:43:11,430
[વિદ્યાર્થી] જ્યારે અમે લિંક કરી રહ્યાં છો અમે lcs50 લખી?

526
00:43:11,430 --> 00:43:20,510
અરે વાહ, જેથી-lcs50. આ linker કે ધ્વજ સિગ્નલો કે જે તમને પુસ્તકાલયમાં લિંક જોઇએ.

527
00:43:26,680 --> 00:43:28,910
પ્રશ્નો?

528
00:43:41,310 --> 00:43:46,860
શું અમે પ્રથમ વ્યાખ્યાન કે 5 સેકન્ડ કરતાં અન્ય દ્વિસંગી પર ગઇ?

529
00:43:50,130 --> 00:43:53,010
હું નથી લાગતું નથી.

530
00:43:55,530 --> 00:43:58,820
તમે મોટી ઓસ તમામ કે અમે ઉપર ગયા કર્યું છે જાણવું જોઈએ,

531
00:43:58,820 --> 00:44:02,670
અને તમે કરવાનો પ્રયત્ન, જો અમે તમને એક કાર્ય આપ્યો જોઈએ,

532
00:44:02,670 --> 00:44:09,410
તમે કહો તે મોટી ઓ છે, આશરે કરવાનો પ્રયત્ન કરીશું. અથવા સારી રીતે, મોટા ઓ ખરબચડી હોય છે.

533
00:44:09,410 --> 00:44:15,300
તેથી જો તમે વસ્તુઓ સમાન નંબર પર રહ્યાં આંટીઓ માટે નેસ્ટ જુઓ,

534
00:44:15,300 --> 00:44:22,260
>> સ્ક્વેર્ડ [વિદ્યાર્થી] n - પૂર્ણાંક જ, જ <n છે; પૂર્ણાંક આઇ, i <n છે જેમ. >> તે જરૂરી n સ્ક્વેર્ડ કરે છે.

535
00:44:22,260 --> 00:44:25,280
જો તમે ટ્રિપલ નેસ્ટ છે, તે n cubed કરે છે.

536
00:44:25,280 --> 00:44:29,330
તેથી વસ્તુ કે સૉર્ટ તમે તરત જ નિર્દેશ કરવાનો પ્રયત્ન કરીશું.

537
00:44:29,330 --> 00:44:33,890
તમે દાખલ સૉર્ટ કરો અને બબલ સૉર્ટ જણાવો અને સૉર્ટ કરો અને તે તમામ મર્જ કરવાની જરૂર છે.

538
00:44:33,890 --> 00:44:41,420
તેને સરળ છે તે સમજવા માટે શા માટે તેઓ તે n સ્ક્વેર્ડ અને એન લોગ n છે અને તે તમામ

539
00:44:41,420 --> 00:44:47,810
કારણ કે મને લાગે છે કે ત્યાં એક ક્વિઝ પર એક વર્ષ જ્યાં અમે મૂળભૂત રીતે તમે આપેલો હતો

540
00:44:47,810 --> 00:44:55,050
બબલ પ્રકારના એક અમલીકરણ અને કહ્યું હતું કે, "આ કાર્ય ઓફ ચાલી રહેલ સમય શું છે?"

541
00:44:55,050 --> 00:45:01,020
તેથી જો તમે તેને બબલ સૉર્ટ તરીકે ઓળખે છે, તો પછી તમે તુરંત જ n સ્ક્વેર્ડ કહેવું કરી શકો છો.

542
00:45:01,020 --> 00:45:05,470
પરંતુ જો તમે તેને જોવા, તમે પણ તે બબલ સૉર્ટ ખ્યાલ જરૂરી નથી;

543
00:45:05,470 --> 00:45:08,990
તમે હમણાં જ કહેવું આ અને આવું કરી શકતા નથી. આ સ્ક્વેર્ડ n છે.

544
00:45:12,350 --> 00:45:14,710
[વિદ્યાર્થી] ત્યાં ખરેખર કોઈ ખડતલ ઉદાહરણો તમે સાથે આવી શકે છે,

545
00:45:14,710 --> 00:45:20,370
બહાર figuring એક સમાન વિચાર જેમ?

546
00:45:20,370 --> 00:45:24,450
>> મને નથી લાગતું અમે તમને કોઈ ખડતલ ઉદાહરણો આપતા.

547
00:45:24,450 --> 00:45:30,180
આ પરપોટો સૉર્ટ વસ્તુ વિશે તરીકે ખડતલ તરીકે અમે જશે છે,

548
00:45:30,180 --> 00:45:36,280
અને પણ છે કે, જ્યાં સુધી તમે સમજો કે તમે એરે પર વારો કરી રહ્યાં છો

549
00:45:36,280 --> 00:45:41,670
એરે દરેક તત્વ માટે, કે જે કંઈક છે જે સ્ક્વેર્ડ n છે પ્રયત્ન રહ્યું છે.

550
00:45:45,370 --> 00:45:49,940
ત્યાં અહીં જેવા સામાન્ય પ્રશ્નો, અમે છે - ઓહ.

551
00:45:55,290 --> 00:45:58,530
જસ્ટ બીજા દિવસે ડો દાવો કર્યો, "હું એક એલ્ગોરિધમ છે કે જે એરે સૉર્ટ કરી શકો છો આવિષ્કાર કર્યો છે

552
00:45:58,530 --> 00:46:01,780
"ઓ (લોગ એન) સમય! માં n સંખ્યાની"

553
00:46:01,780 --> 00:46:04,900
તેથી અમે કેવી રીતે જાણી શકું કે અશક્ય છે?

554
00:46:04,900 --> 00:46:08,850
[અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] >> યાહ.

555
00:46:08,850 --> 00:46:13,710
ખૂબ જ ઓછામાં ઓછા કરવા માટે, તમે એરે દરેક તત્વ સ્પર્શ હોય છે,

556
00:46:13,710 --> 00:46:16,210
જેથી તે અશક્ય છે કે એક એરે સૉર્ટ -

557
00:46:16,210 --> 00:46:20,850
જો બધું ક્રમમાંગોઠવાયેલનથી ક્રમમાં હોય તો, પછી તમે એરે બધું સ્પર્શ કરી રહ્યા છીએ,

558
00:46:20,850 --> 00:46:25,320
જેથી તે અશક્ય છે તે n ના ઓ કરતાં ઓછું કામ કરે છે.

559
00:46:27,430 --> 00:46:30,340
[વિદ્યાર્થી] તમે અમને n ના ઓ માં તે કરવા સક્ષમ હોવાની કે ઉદાહરણ દર્શાવ્યું

560
00:46:30,340 --> 00:46:33,920
જો તમે મેમરીની જરુર વાપરો. >> યાહ.

561
00:46:33,920 --> 00:46:37,970
અને that's - હું ભૂલી જાઓ શું that's - તે પ્રકારની ગણાય છે?

562
00:46:47,360 --> 00:46:51,330
હમ્મ. તે એક પૂર્ણાંક સોર્ટિંગ એલ્ગોરિધમ છે.

563
00:46:59,850 --> 00:47:05,100
હું આ માટે ખાસ નામ શોધી હતી કે હું છેલ્લા અઠવાડિયે યાદ નથી કરી શકે છે.

564
00:47:05,100 --> 00:47:13,000
યાહ. આ પ્રકારની પ્રકારો કે જે n ના મોટા ઓ વસ્તુઓ પરિપૂર્ણ કરી શકે છે.

565
00:47:13,000 --> 00:47:18,430
પરંતુ ત્યાં મર્યાદાઓ હોય છે, જેમ કે તમે માત્ર પૂર્ણાંકો ચોક્કસ સંખ્યા કરી શકો છો ઉપયોગ છે.

566
00:47:20,870 --> 00:47:24,560
પ્લસ તમે કંઈક that's સૉર્ટ કરવાનો પ્રયાસ કરી રહ્યાં છો જો -

567
00:47:24,560 --> 00:47:30,750
જો તમારી એરે 012, -12, 151, 4 મિલિયન છે,

568
00:47:30,750 --> 00:47:35,120
પછી તે એક તત્વ સંપૂર્ણપણે સમગ્ર સોર્ટિંગ વિનાશ રહ્યું છે.

569
00:47:42,060 --> 00:47:44,030
>> પ્રશ્નો?

570
00:47:49,480 --> 00:47:58,870
[વિદ્યાર્થી] જો તમે ફરી યાદ આવવું કાર્ય હોય છે અને તે માત્ર ફરી યાદ આવવું કોલ્સ બનાવે છે

571
00:47:58,870 --> 00:48:02,230
પરત નિવેદન અંદર, કે ફરી યાદ આવવું પૂંછડી છે,

572
00:48:02,230 --> 00:48:07,360
અને જેથી રનટાઇમ દરમ્યાન વધુ મેમરી નથી ઉપયોગ કરશે

573
00:48:07,360 --> 00:48:12,550
અથવા તેને ઓછામાં ઓછા તુલનાત્મક મેમરીનો ઉપયોગ એક ઉકેલ પુનરાવર્તન થશે?

574
00:48:12,550 --> 00:48:14,530
[બોડેન] હા.

575
00:48:14,530 --> 00:48:19,840
આ સંભવિત અંશે ધીમી હોઇ શકે છે, પરંતુ ખરેખર.

576
00:48:19,840 --> 00:48:23,290
ફરી યાદ આવવું ટેઈલ ખૂબ સારી છે.

577
00:48:23,290 --> 00:48:32,640
સ્ટેક ફ્રેમ્સ પર ફરીથી છીએ, આપણે કહેવું અમે મુખ્ય હોય છે

578
00:48:32,640 --> 00:48:42,920
અને અમે પૂર્ણાંક (પૂર્ણાંક x) બાર અથવા કંઈક હોય છે.

579
00:48:42,920 --> 00:48:52,310
આ એક સંપૂર્ણ ફરી યાદ આવવું કાર્ય નથી, પરંતુ વળતર બાર (x - 1).

580
00:48:52,310 --> 00:48:57,620
તેથી દેખીતી રીતે, આ અપૂર્ણ છે. તમે આધાર કેસો અને સામગ્રી જરૂર છે.

581
00:48:57,620 --> 00:49:00,360
પરંતુ અહીં વિચાર છે કે આ ફરી યાદ આવવું પૂંછડી હોય છે,

582
00:49:00,360 --> 00:49:06,020
કે જે જ્યારે મુખ્ય કોલ્સ પટ્ટી તેને તેના સ્ટેક ફ્રેમ બનશે થાય છે.

583
00:49:09,550 --> 00:49:12,440
આ સ્ટેક ફ્રેમમાં ત્યાં મેમરી થોડું બ્લોક જ હશે

584
00:49:12,440 --> 00:49:17,490
કે તેની દલીલ એક્સ અનુલક્ષે છે.

585
00:49:17,490 --> 00:49:25,840
અને તેથી આપણે કહેવું મુખ્ય બાર (100) કૉલ થાય છે;

586
00:49:25,840 --> 00:49:30,050
તેથી એક્સ થી 100 તરીકે બહાર શરૂ થઈ રહ્યું છે.

587
00:49:30,050 --> 00:49:35,660
જો કમ્પાઇલર ઓળખે છે કે આ એક પૂંછડી ફરી યાદ આવવું કાર્ય છે,

588
00:49:35,660 --> 00:49:38,540
પછી જ્યારે બાર તેની ફરી યાદ આવવું કોલ બાર માટે બનાવે છે,

589
00:49:38,540 --> 00:49:45,490
તેના બદલે એક નવી સ્ટેક ફ્રેમ, કે જે જ્યાં સ્ટેક મોટા ભાગે વધતી શરૂ બનાવવા,

590
00:49:45,490 --> 00:49:48,220
છેવટે તે ઢગલો માં ચલાવો અને પછી તમે segfaults મળશે

591
00:49:48,220 --> 00:49:51,590
કારણ કે મેમરી અથડાઈ શરૂ થાય છે.

592
00:49:51,590 --> 00:49:54,830
>> તેથી તેના બદલે તેના પોતાના સ્ટેક ફ્રેમ બનાવવા માટે, તેને ખ્યાલ કરી શકો છો,

593
00:49:54,830 --> 00:49:59,080
હેય, હું આ સ્ટેક ફ્રેમ પર પાછા આવવાની ખરેખર ક્યારેય જરૂર છે,

594
00:49:59,080 --> 00:50:08,040
તેથી તેના બદલે હું માત્ર 99 સાથે આ દલીલ બદલો અને પડશે પછી બાર શરૂ બધા ઉપર.

595
00:50:08,040 --> 00:50:11,810
અને પછી તેને ફરીથી કરવા કરશે અને તેના બદલામાં બાર સુધી પહોંચી જશે (x - 1),

596
00:50:11,810 --> 00:50:17,320
અને એક નવી સ્ટેક ફ્રેમ બનાવવા બદલે, તે માત્ર 98 સાથે તેના વર્તમાન દલીલ બદલશે

597
00:50:17,320 --> 00:50:20,740
અને પછી બાર ખૂબ જ શરૂઆત પર પાછા કૂદકો.

598
00:50:23,860 --> 00:50:30,430
તે કામગીરી સ્ટેક પર કે 1 કિંમત બદલી અને શરૂઆત પર પાછા જમ્પિંગ,

599
00:50:30,430 --> 00:50:32,430
ખૂબ અસરકારક છે.

600
00:50:32,430 --> 00:50:41,500
તેથી માત્ર આ એક અલગ કાર્ય જેવા જ મેમરી વપરાશ જે પુનરાવર્તન છે

601
00:50:41,500 --> 00:50:45,390
કારણ કે તમે માત્ર 1 સ્ટેક ફ્રેમ ઉપયોગ કરી રહ્યાં છો, પરંતુ તમે downsides નથી પીડાતા કરી રહ્યાં છો

602
00:50:45,390 --> 00:50:47,240
માટે વિધેયો કૉલ કર્યા છે.

603
00:50:47,240 --> 00:50:50,240
કૉલ વિધેયો અંશે ખર્ચાળ હોય છે કારણ કે તે આ તમામ સેટઅપ કરવું શકે છે

604
00:50:50,240 --> 00:50:52,470
અને teardown અને આ તમામ સામગ્રી.

605
00:50:52,470 --> 00:50:58,160
તેથી આ પૂંછડી રિકર્ઝન સારો છે.

606
00:50:58,160 --> 00:51:01,170
[વિદ્યાર્થી] તે શા માટે નવા પગલાંઓ બનાવવા નથી?

607
00:51:01,170 --> 00:51:02,980
કારણ કે તે ખબર પડે છે કે તે જરૂરી નથી.

608
00:51:02,980 --> 00:51:07,800
બાર માટે કોલ માત્ર ફરી યાદ આવવું કોલ પરત આવે છે.

609
00:51:07,800 --> 00:51:12,220
તેથી તે માટે વળતર કિંમત સાથે કંઇપણ જરૂર નથી.

610
00:51:12,220 --> 00:51:15,120
તે માત્ર તરત જ તેને પરત ચાલી રહ્યું છે.

611
00:51:15,120 --> 00:51:20,530
તેથી જ તે તેની પોતાની દલીલ બદલો અને પ્રારંભ બનશે.

612
00:51:20,530 --> 00:51:25,780
અને પણ, જો તમે પૂંછડી ફરી યાદ આવવું આવૃત્તિ નહિં હોય,

613
00:51:25,780 --> 00:51:31,460
પછી તમે આ બધા બાર જ્યાં જ્યારે આ પટ્ટી આપે વિચાર

614
00:51:31,460 --> 00:51:36,010
તે આ માટે તેની કિંમત પરત, પછી કે બાર તરત જ આપે છે

615
00:51:36,010 --> 00:51:39,620
અને તે આ એક કરવા માટે તેની કિંમત આપે છે, તો પછી તે માત્ર તરત જ પાછા જવાનું છે

616
00:51:39,620 --> 00:51:41,350
અને આ એક કરવા માટે તેની કિંમત આવો.

617
00:51:41,350 --> 00:51:45,350
તેથી તમે આ બધું સ્ટેક બંધ પોપિંગ આ સાચવી રહ્યા છો

618
00:51:45,350 --> 00:51:48,730
કારણ કે વળતર કિંમત માત્ર તમામ રીતે પસાર કરી બેક અપ રીતે જઈ રહ્યું છે.

619
00:51:48,730 --> 00:51:55,400
તેથી અમારા દલીલ શા માટે બદલો માત્ર સુધારાયેલ દલીલ સાથે અને પ્રારંભ કરીએ?

620
00:51:57,460 --> 00:52:01,150
જો કાર્ય ફરી યાદ આવવું પૂંછડી નથી, જો તમે કંઈક કરવા -

621
00:52:01,150 --> 00:52:07,530
[વિદ્યાર્થી] જો બાર (x + 1). >> યાહ.

622
00:52:07,530 --> 00:52:11,770
>> તેથી જો તમે તે શરત મૂકી, પછી તમે પરત કિંમત સાથે કંઈક કરી રહ્યા છીએ.

623
00:52:11,770 --> 00:52:16,260
અથવા જો તમે માત્ર 2 વળતર કરવું * બાર (x - 1).

624
00:52:16,260 --> 00:52:23,560
તેથી હવે બાર (x - 1) કરવા પરત કરવાની જરૂર માટે 2 કિંમત ગણી ગણતરી કરવા માટે,

625
00:52:23,560 --> 00:52:26,140
તેથી હવે તેની પોતાની અલગ સ્ટેક ફ્રેમ જરૂર નથી,

626
00:52:26,140 --> 00:52:31,180
અને હવે, કોઈ બાબત હાર્ડ તમે કેવી રીતે પ્રયત્ન કરો, તમે જરૂર જઈ રહ્યાં છો -

627
00:52:31,180 --> 00:52:34,410
આ પૂંછડી ફરી યાદ આવવું નથી.

628
00:52:34,410 --> 00:52:37,590
[વિદ્યાર્થી] હું એક રિકર્ઝન લાવવા માટે એક પૂંછડી રિકર્ઝન માટે લક્ષ્ય રાખ્યું પ્રયાસ છો -

629
00:52:37,590 --> 00:52:41,450
[બોડેન] એક આદર્શ વિશ્વમાં, પરંતુ CS50 તમને નથી.

630
00:52:43,780 --> 00:52:49,280
ક્રમમાં પૂંછડી રિકર્ઝન વિચાર, સામાન્ય રીતે, તમે વધારાની દલીલ સેટ

631
00:52:49,280 --> 00:52:53,550
જ્યાં બાર વાય માં પૂર્ણાંક એક્સ લેશે

632
00:52:53,550 --> 00:52:56,990
અને વાય અંતિમ વસ્તુ તમે પાછા માંગો છો અનુલક્ષે છે.

633
00:52:56,990 --> 00:53:03,650
(1 - એક્સ), 2 * વાય તેથી તો પછી આ તમે બાર પાછો જઈ રહ્યાં છો.

634
00:53:03,650 --> 00:53:09,810
જેથી ફક્ત એક ઉચ્ચ સ્તર તમે કેવી રીતે વસ્તુઓ પૂંછડી ફરી યાદ આવવું કરવા પરિવર્તિત થાય છે.

635
00:53:09,810 --> 00:53:13,790
પરંતુ વધારાની દલીલ -

636
00:53:13,790 --> 00:53:17,410
અને પછી અંતે જ્યારે તમે તમારી આધાર કેસ પહોંચે છે, તમે માત્ર વાય પાછા

637
00:53:17,410 --> 00:53:22,740
કારણ કે તમે સમગ્ર સમય કરવામાં પરત કિંમત છે કે જે તમે કરવા માંગો છો એકઠું કર્યું છે.

638
00:53:22,740 --> 00:53:27,280
તમે પ્રકારની તેને આવી છે iteratively કરી પરંતુ ફરી યાદ આવવું કોલોની મદદથી.

639
00:53:32,510 --> 00:53:34,900
પ્રશ્નો?

640
00:53:34,900 --> 00:53:39,890
નિર્દેશક અંકગણિત વિશે કદાચ જ્યારે શબ્દમાળાઓ મદદથી જેમ, [વિદ્યાર્થી]. શ્યોર. >>

641
00:53:39,890 --> 00:53:43,610
પોઇન્ટર અંકગણિત.

642
00:53:43,610 --> 00:53:48,440
જ્યારે શબ્દમાળાઓ મદદથી તેને સરળ છે કારણ કે શબ્દમાળાઓ ઘરનાં પરચૂરણ કામો તારાઓ છે,

643
00:53:48,440 --> 00:53:51,860
અક્ષરો કાયમ અને હંમેશા એક બાઈટ છે,

644
00:53:51,860 --> 00:53:57,540
અને તેથી નિર્દેશક અંકગણિત નિયમિત અંકગણિત જ્યારે તમે શબ્દમાળાઓ સાથે કામ કરીએ છીએ સમકક્ષ છે.

645
00:53:57,540 --> 00:54:08,790
ચાલો માત્ર કોલસો બનાવો ઓ * = "હેલો" કહે છે.

646
00:54:08,790 --> 00:54:11,430
તેથી અમે મેમરીમાં બ્લોક હોય છે.

647
00:54:19,490 --> 00:54:22,380
તે 6 બાઇટ્સ જરૂર છે કારણ કે તમે હંમેશા નલ ટર્મીનેટર જરૂર છે.

648
00:54:22,380 --> 00:54:28,620
અને કોલસો બનાવો * ઓ આ એરે શરૂઆતમાં નિર્દેશ રહ્યું છે.

649
00:54:28,620 --> 00:54:32,830
તેથી ઓ ત્યાં નિર્દેશ કરે છે.

650
00:54:32,830 --> 00:54:36,710
હવે, આ મૂળભૂત કેવી રીતે કોઈપણ એરે કામ કરે છે,

651
00:54:36,710 --> 00:54:40,780
પછી ભલેને તે malloc દ્વારા અથવા તે સ્ટેક પર છે કે નહીં તે વળતર હતી.

652
00:54:40,780 --> 00:54:47,110
કોઈપણ એરે મૂળભૂત એરે શરૂઆત કરવા માટે નિર્દેશક છે,

653
00:54:47,110 --> 00:54:53,640
અને પછી કોઈપણ એરે કામગીરી, કોઈપણ ઈન્ડેક્સીંગ, ફક્ત કે જે એરે જવા છે ચોક્કસ ઓફસેટ.

654
00:54:53,640 --> 00:55:05,360
>> તેથી જ્યારે હું [3] ઓ કંઈક કહેવું છે; આ s પર રહ્યું છે અને સાઇન 3 અક્ષરો ગણતરી

655
00:55:05,360 --> 00:55:12,490
તેથી ઓ [3] અમે 0 હોય,, 1, 2, 3, તેથી ઓ [3] આ l નો સંદર્ભ લો રહ્યું છે.

656
00:55:12,490 --> 00:55:20,460
[વિદ્યાર્થી] અને અમે + s 3 કરી અને પછી કૌંસ સ્ટાર દ્વારા જ કિંમત સુધી પહોંચી શકે છે?

657
00:55:20,460 --> 00:55:22,570
હા.

658
00:55:22,570 --> 00:55:26,010
આ * (ઓ + + 3) સમકક્ષ છે;

659
00:55:26,010 --> 00:55:31,240
અને તે કાયમ માટે અને હંમેશા સમકક્ષ કોઈ બાબત તમે શું છે.

660
00:55:31,240 --> 00:55:34,070
તમને ક્યારેય કૌંસ વાક્યરચના વાપરે છે.

661
00:55:34,070 --> 00:55:37,770
તમે હંમેશા * વાક્યરચના (3 + s) નો ઉપયોગ કરી શકો છો.

662
00:55:37,770 --> 00:55:40,180
લોકો કૌંસ વાક્યરચના માંગો છતાં વલણ ધરાવે છે.

663
00:55:40,180 --> 00:55:43,860
[વિદ્યાર્થી] તેથી તમામ એરે વાસ્તવમાં માત્ર છે પોઇન્ટર.

664
00:55:43,860 --> 00:55:53,630
ત્યાં થોડો તફાવત એ છે કે જ્યારે હું કહું છું પૂર્ણાંક x [4]; >> [વિદ્યાર્થી] શું દર્શાવે છે કે મેમરી બનાવી છે?

665
00:55:53,630 --> 00:56:03,320
[બોડેન] તે માટે સ્ટેક પર 4 ints બનાવો, જેથી 16 બાઇટ્સ એકંદર રહ્યું છે.

666
00:56:03,320 --> 00:56:05,700
તે સ્ટેક પર 16 બાઇટ્સ બનાવી રહ્યું છે.

667
00:56:05,700 --> 00:56:09,190
એક્સ ગમે ત્યાં નથી સંગ્રહાયેલ છે.

668
00:56:09,190 --> 00:56:13,420
તે માત્ર એક વસ્તુ શરૂઆત ઉલ્લેખ પ્રતીક છે.

669
00:56:13,420 --> 00:56:17,680
કારણ કે તમે આ કાર્ય ની અંદર એરે જાહેર

670
00:56:17,680 --> 00:56:22,340
આ કમ્પાઈલર શું રહ્યું છે ફક્ત ચલ x ની તમામ ઘટકોને બદલવા છે

671
00:56:22,340 --> 00:56:26,400
જ્યાં તે માટે આ 16 બાઇટ્સ મૂકી પસંદ કરો થયું છે.

672
00:56:26,400 --> 00:56:30,040
તે ચાર રચે છે * s ની સાથે નથી કારણ કે ઓ એક વાસ્તવિક નિર્દેશક છે.

673
00:56:30,040 --> 00:56:32,380
તે પછી અન્ય વસ્તુઓ માટે નિર્દેશ મફત છે.

674
00:56:32,380 --> 00:56:36,140
એક્સ સતત છે. તમે તેને અલગ એરે માટે બિંદુ હોઈ શકે નહિં. >> [વિદ્યાર્થી] ઠીક.

675
00:56:36,140 --> 00:56:43,420
પરંતુ આ વિચાર, આ ઈન્ડેક્સીંગ, એ જ અનુલક્ષીને છે કે તે પરંપરાગત એરે છે

676
00:56:43,420 --> 00:56:48,230
અથવા જો તે કંઈક અથવા જો એક નિર્દેશક છે તે malloced એરે માટે નિર્દેશક છે.

677
00:56:48,230 --> 00:56:59,770
અને હકીકતમાં, તે આવું સમકક્ષ કે જે પણ આ જ વાત છે.

678
00:56:59,770 --> 00:57:05,440
તે વાસ્તવમાં માત્ર ભાષાંતર શું કૌંસ ની અંદર છે અને શું બ્રેકેટ્સ બાકી છે,

679
00:57:05,440 --> 00:57:07,970
તેમને ઉમેરે મળીને, અને dereferences.

680
00:57:07,970 --> 00:57:14,710
તેથી આ માત્ર તરીકે માન્ય છે * (ઓ + + 3) અથવા ઓ. [3]

681
00:57:16,210 --> 00:57:22,090
[વિદ્યાર્થી] તમે 2-પરિમાણીય એરે માટે પોઇન્ટ પોઇન્ટર હોય શકે છે?

682
00:57:22,090 --> 00:57:27,380
>> તે સખત હોય છે. પરંપરાગત રીતે, નં.

683
00:57:27,380 --> 00:57:34,720
એક એરે 2-પરિમાણીય માત્ર કેટલાક અનુકૂળ સિન્ટેક્ષ સાથે એરે 1-પરિમાણીય છે

684
00:57:34,720 --> 00:57:54,110
કારણ કે જ્યારે હું કહી પૂર્ણાંક x [3] [3], આ ખરેખર માત્ર 9 કિંમતો સાથે 1 એરે છે.

685
00:57:55,500 --> 00:58:03,000
અને તેથી જ્યારે હું અનુક્રમણિકા, પણ કમ્પાઇલર જાણે હું શું અર્થ થાય.

686
00:58:03,000 --> 00:58:13,090
જો હું કહું છું x [1] [2] છે, તે જાણે છે હું બીજી પંક્તિ પર જાઓ કરવા માંગો છો, તેથી તે પ્રથમ 3 અવગણો ચાલી રહ્યું છે,

687
00:58:13,090 --> 00:58:17,460
અને પછી તે બીજી વસ્તુ કે, તેથી તે આ એક બનશે માંગે છે.

688
00:58:17,460 --> 00:58:20,480
પરંતુ તે હજુ પણ માત્ર એક એરે એક પરિમાણીય છે.

689
00:58:20,480 --> 00:58:23,660
અને તેથી જો હું એરે માટે નિર્દેશક સોંપવા માગતા હતા,

690
00:58:23,660 --> 00:58:29,770
હું એમ કહીશ પૂર્ણાંક * પૃષ્ઠ = x;

691
00:58:29,770 --> 00:58:33,220
એક્સ પ્રકાર માત્ર છે -

692
00:58:33,220 --> 00:58:38,280
તે x ની રફ કહેતા પ્રકાર છે કારણ કે તે માત્ર એક પ્રતીક છે અને તે એક વાસ્તવિક ચલ નથી,

693
00:58:38,280 --> 00:58:40,140
પરંતુ તે માત્ર પૂર્ણાંક * છે.

694
00:58:40,140 --> 00:58:44,840
એક્સ ફક્ત આ શરૂઆત કરવા માટે નિર્દેશક છે. >> [વિદ્યાર્થી] ઠીક.

695
00:58:44,840 --> 00:58:52,560
અને તેથી હું [2] [1] ઍક્સેસ કરી શકશો નહીં.

696
00:58:52,560 --> 00:58:58,370
મને લાગે છે કે ત્યાં એક નિર્દેશક જાહેર માટે ખાસ વાક્યરચના છે,

697
00:58:58,370 --> 00:59:12,480
પૂર્ણાંક જેવા હાસ્યાસ્પદ કંઈક (* [પૃ. - સંપૂર્ણપણે હાસ્યાસ્પદ હું પણ ખબર નથી.

698
00:59:12,480 --> 00:59:17,090
પરંતુ ત્યાં કૌંસ અને વસ્તુઓ સાથે જેમ પોઇંટરો જાહેર માટે વાક્યરચના છે.

699
00:59:17,090 --> 00:59:22,960
એ પણ છે કે જે તમને ન દો શકે છે.

700
00:59:22,960 --> 00:59:26,640
હું પાછા કંઈક છે જે મને સત્ય કહેવું કરશે જોવા શકે છે.

701
00:59:26,640 --> 00:59:34,160
હું તેના માટે પાછળથી જુઓ, તો ત્યાં બિંદુ માટે વાક્યરચના છે. પરંતુ તમે તેને ક્યારેય દેખાશે નહીં.

702
00:59:34,160 --> 00:59:39,670
અને પણ સિન્ટેક્ષ જેથી પ્રાચીન કે જો તમે તેને વાપરવા માટે, લોકો baffled આવશે.

703
00:59:39,670 --> 00:59:43,540
બહુપરીમાણીય એરે ખૂબ જ ઓછી છે, કારણ કે તે છે.

704
00:59:43,540 --> 00:59:44,630
તમે ખૂબ ખૂબ -

705
00:59:44,630 --> 00:59:48,490
વેલ, જો તમે મેટ્રિક્સ વસ્તુઓ કરી રહ્યા છીએ તે ભાગ્યે જ ન ચાલી રહ્યું છે,

706
00:59:48,490 --> 00:59:56,730
પરંતુ સી તમે ભાગ્યે જ બહુપરીમાણીય એરે ઉપયોગ કરી રહ્યા છીએ.

707
00:59:57,630 --> 01:00:00,470
યાહ. >> [વિદ્યાર્થી] હવે કહો કે તમે ખરેખર લાંબા એરે હોય છે.

708
01:00:00,470 --> 01:00:03,900
>> તેથી વર્ચ્યુઅલ મેમરી તેને તમામ સતત પ્રયત્ન દેખાય છે,

709
01:00:03,900 --> 01:00:05,640
જમણી એકબીજા આગામી તત્વો જેમ,

710
01:00:05,640 --> 01:00:08,770
પરંતુ ભૌતિક મેમરી માં, તે શક્ય છે કે માટે કરવામાં વિભાજિત હશે? હા. >>

711
01:00:08,770 --> 01:00:16,860
વર્ચ્યુઅલ મેમરી કેવી રીતે કામ કરે છે તે માત્ર અલગ -

712
01:00:19,220 --> 01:00:24,860
ફાળવણી એકમ એક પાનું, કે જે 4 કિલોબાઇટ હોઇ શકે છે,

713
01:00:24,860 --> 01:00:29,680
અને તેથી જ્યારે પ્રક્રિયા કહે છે, હેય, હું આ મેમરી વાપરવા માંગો,

714
01:00:29,680 --> 01:00:35,970
ઓપરેટિંગ સિસ્ટમ તેને મેમરી થોડો બ્લોક માટે 4 કિલોબાઇટ ફાળવી રહ્યું છે.

715
01:00:35,970 --> 01:00:39,100
જો તમે માત્ર મેમરીના સમગ્ર બ્લોક એક થોડો બાઇટ વાપરવા માટે,

716
01:00:39,100 --> 01:00:42,850
ઓપરેટિંગ સિસ્ટમ માટે તે સંપૂર્ણ 4 કિલોબાઇટ આપી રહ્યું છે.

717
01:00:42,850 --> 01:00:49,410
તેથી તેનો અર્થ શું છે હું કરી શકે છે - આપણે કહેવું કે આ મારું સ્ટેક છે.

718
01:00:49,410 --> 01:00:53,180
આ સ્ટેક અલગ કરી શકાય છે. મારા સ્ટેક મેગાબાઇટ્સ અને મેગાબાઇટ્સ હોઈ શકે છે.

719
01:00:53,180 --> 01:00:55,020
મારા સ્ટેક વિશાળ હોઈ શકે છે.

720
01:00:55,020 --> 01:01:00,220
પરંતુ સ્ટેક પોતે વ્યક્તિગત પાનાંઓમાંથી વિભાજિત કરી શકાય છે,

721
01:01:00,220 --> 01:01:09,010
જે દો જો આપણે અહીં પર જોવા કહો કે આ અમારી રેમ છે,

722
01:01:09,010 --> 01:01:16,600
જો હું RAM ની 2 ગીગાબાઇટ્સ છે, આ મારા RAM ના zeroth બાઇટ જેવી વાસ્તવિક સરનામા 0 છે,

723
01:01:16,600 --> 01:01:22,210
અને આ 2 તમામ માર્ગ ગીગાબાઇટ્સ નીચે અહીં છે.

724
01:01:22,210 --> 01:01:27,230
તેથી આ પાનું અહીં પર આ બ્લોક અનુલક્ષે શકે છે.

725
01:01:27,230 --> 01:01:29,400
આ પાનું અહીં પર આ બ્લોક અનુલક્ષે શકે છે.

726
01:01:29,400 --> 01:01:31,560
આ એક આ અહીં ઉપર એક અનુલક્ષે શકે છે.

727
01:01:31,560 --> 01:01:35,540
તેથી ઓપરેટિંગ સિસ્ટમ માટે ભૌતિક મેમરી સોંપણી મફત છે

728
01:01:35,540 --> 01:01:39,320
કોઈપણ વ્યક્તિગત આપખુદ પાનું છે.

729
01:01:39,320 --> 01:01:46,180
અને તે અર્થ એ થાય કે જો આ સરહદ ઝાકઝમાળ સ્ટ્રેડલ થાય છે,

730
01:01:46,180 --> 01:01:50,070
ઝાકઝમાળ માટે આ છોડી થાય છે અને એક પાનું આ હુકમ અધિકાર,

731
01:01:50,070 --> 01:01:54,460
પછી તે એરે માટે ભૌતિક મેમરી માં વિભાજિત કરવામાં રહ્યું છે.

732
01:01:54,460 --> 01:01:59,280
અને પછી જ્યારે તમે કાર્યક્રમ બહાર નીકળવા, જ્યારે પ્રક્રિયા સમાપ્ત થાય છે,

733
01:01:59,280 --> 01:02:05,690
આ જોડણીઓની ભૂંસી વિચાર કરો અને પછી તે અન્ય વસ્તુઓ માટે આ થોડું બ્લોક્સ ઉપયોગ મફત છે.

734
01:02:14,730 --> 01:02:17,410
વધુ પ્રશ્નો છે?

735
01:02:17,410 --> 01:02:19,960
[વિદ્યાર્થી] આ નિર્દેશક અંકગણિત. >> ઓહ હા.

736
01:02:19,960 --> 01:02:28,410
શબ્દમાળાઓ સરળ હતા, પરંતુ ints કંઈક જોઈ,

737
01:02:28,410 --> 01:02:35,000
તેથી માટે પૂર્ણાંક x [4];

738
01:02:35,000 --> 01:02:41,810
આ ઝાકઝમાળ છે કે તે 4 પૂર્ણાંકો એક malloced એરે માટે નિર્દેશક છે કે શું,

739
01:02:41,810 --> 01:02:47,060
તે જ રીતે સારવાર કરી રહ્યું છે.

740
01:02:50,590 --> 01:02:53,340
[વિદ્યાર્થી] તેથી એરે આ ઢગલો પર હોય છે?

741
01:03:01,400 --> 01:03:05,270
[બોડેન] એરેમાં આ ઢગલો પર નથી. >> [વિદ્યાર્થી] ઓહ.

742
01:03:05,270 --> 01:03:08,320
>> [બોડેન] એરે આ પ્રકારની સ્ટેક પર હોઇ શકે છે

743
01:03:08,320 --> 01:03:12,220
જ્યાં સુધી તમે તેને જાહેર - વૈશ્વિક ચલો ઉપેક્ષા કરે છે. શું વૈશ્વિક ચલો ઉપયોગ કરશો નહીં.

744
01:03:12,220 --> 01:03:16,280
અંદર કાર્ય હું કહી ના પૂર્ણાંક x [4];

745
01:03:16,280 --> 01:03:22,520
તે આ એરે માટે સ્ટેક પર બ્લોક 4-પૂર્ણાંક બનાવી રહ્યું છે.

746
01:03:22,520 --> 01:03:26,960
પરંતુ આ malloc (4 * (પૂર્ણાંક) sizeof); માટે ઢગલો પર જાઓ રહ્યું છે.

747
01:03:26,960 --> 01:03:31,870
પરંતુ આ બિંદુ પછી હું ખૂબ ખૂબ જ રીતે એક્સ અને પૃષ્ઠ ઉપયોગ કરી શકો છો,

748
01:03:31,870 --> 01:03:36,140
અપવાદોને બાદ કરતાં મેં કહ્યું વિશે પહેલાં તમે પૃષ્ઠ પુનઃસોંપણી શકે કરતાં અન્ય.

749
01:03:36,140 --> 01:03:40,960
પારિભાષિક રીતે, તેમના કદ કંઈક અલગ હોય છે, પરંતુ તે સંપૂર્ણપણે અપ્રસ્તુત છે.

750
01:03:40,960 --> 01:03:43,310
તમે તેમના માપ ખરેખર ક્યારેય ઉપયોગ કરે છે.

751
01:03:48,020 --> 01:03:56,810
આ પૃષ્ઠ હું કહી શકે પૃષ્ઠ [3] = 2; અથવા x [3] = 2;

752
01:03:56,810 --> 01:03:59,680
તમે તેમને બરાબર એ જ રીતે ઉપયોગ કરી શકો છો.

753
01:03:59,680 --> 01:04:01,570
તેથી નિર્દેશક હવે અંકગણિત - હા.

754
01:04:01,570 --> 01:04:07,390
[વિદ્યાર્થી] કરશો તો તમને પૃષ્ઠ * આમ જો તમે કૌંસમાં નથી?

755
01:04:07,390 --> 01:04:11,720
કૌંસમાં ગર્ભિત ડિરેફરન્સ છે. ઠીક છે. >>

756
01:04:11,720 --> 01:04:20,200
ખરેખર, પણ તમે સાથે કહી રહ્યાં છે શું તમે બહુપરીમાણીય એરે મેળવી શકો છો

757
01:04:20,200 --> 01:05:02,650
પોઇન્ટર સાથે, તમે શું કરી શકો છો કંઈક જેવું છે, ચાલો, કહો પૂર્ણાંક ** પીપી malloc = (sizeof (પૂર્ણાંક *) * 5);

758
01:05:02,650 --> 01:05:06,900
હું હમણાં જ તે બધા બહાર પ્રથમ લખી શકશો.

759
01:05:37,880 --> 01:05:41,020
હું એક કે જે માંગતા ન હતાં.

760
01:05:41,020 --> 01:05:42,550
ઠીક છે.

761
01:05:42,550 --> 01:05:48,910
શું હું અહીં કર્યું છે - તે પીપી [i] પ્રયત્ન કરીશું.

762
01:05:48,910 --> 01:05:53,680
તેથી પીપી એક નિર્દેશક માટે નિર્દેશક છે.

763
01:05:53,680 --> 01:06:02,420
તમે પીપી mallocing કરી રહ્યા છીએ 5 પૂર્ણાંક તારાઓનો એક એરે માટે નિર્દેશ કરે છે.

764
01:06:02,420 --> 01:06:10,950
તેથી મેમરીમાં તમે સ્ટેક પૃષ્ઠ પર

765
01:06:10,950 --> 01:06:20,150
તે 5 બ્લોકો જે બધા છે પોતાને પોઇંટરો ઝાકઝમાળ નિર્દેશિત કરવા માટે ચાલી રહ્યું છે.

766
01:06:20,150 --> 01:06:28,210
અને પછી હું નીચે અહીં malloc જ્યારે, હું malloc કે તે વ્યક્તિગત પોઇંટરો દરેક

767
01:06:28,210 --> 01:06:32,080
આ ઢગલો પર 4 બાઇટ્સ એક અલગ બ્લોક નિર્દેશિત કરવા માટે કરીશું.

768
01:06:32,080 --> 01:06:35,870
તેથી 4 બાઇટ્સ આ નિર્દેશ કરે છે.

769
01:06:37,940 --> 01:06:40,660
અને અલગ 4 બાઇટ્સ આ એક નિર્દેશ કરે છે.

770
01:06:40,660 --> 01:06:43,200
>> અને તે બધા જ પોતાના 4 બાઇટ્સ માટે નિર્દેશ કરે છે.

771
01:06:43,200 --> 01:06:49,080
આ મારા બહુપરીમાણીય વસ્તુઓ કરવાનું એક રસ્તો આપે છે.

772
01:06:49,080 --> 01:06:58,030
હું પીપી [3] [4], પરંતુ હવે આ જ વસ્તુ નથી તરીકે બહુપરીમાણીય એરે કહેવું શકે

773
01:06:58,030 --> 01:07:05,390
કારણ કે બહુપરીમાણીય એરે તે [3] [4] એક એક્સ એરે માં ઓફસેટ એક હતી. અનુવાદ

774
01:07:05,390 --> 01:07:14,790
આ dereferences, પૃષ્ઠ ત્રીજા અનુક્રમણિકા ઍક્સેસ, પછી dereferences કે

775
01:07:14,790 --> 01:07:20,790
અને વપરાશની - 4 અમાન્ય હશે - બીજા ઇન્ડેક્સ.

776
01:07:24,770 --> 01:07:31,430
જ્યારે જ્યારે અમે હતા પૂર્ણાંક x [3] [4] તરીકે બહુપરીમાણીય એરે પહેલા

777
01:07:31,430 --> 01:07:35,740
અને જ્યારે તમે કૌંસ ડબલ તે ખરેખર માત્ર એક જ ડિરેફરન્સ છે,

778
01:07:35,740 --> 01:07:40,490
તમે એક નિર્દેશક અનુસરી રહ્યાં છો અને પછી ઓફસેટ,

779
01:07:40,490 --> 01:07:42,850
આ ખરેખર 2D સંદર્ભો.

780
01:07:42,850 --> 01:07:45,840
તમે 2 અલગ પોઇંટરો અનુસરો.

781
01:07:45,840 --> 01:07:50,420
તેથી આ પણ ટેકનિકલી પરવાનગી આપે છે તમે બહુપરીમાણીય એરે હોય

782
01:07:50,420 --> 01:07:53,550
જ્યાં દરેક વ્યક્તિગત એરે વિવિધ કદના છે.

783
01:07:53,550 --> 01:07:58,000
મને લાગે છે જેગ્ડ બહુપરીમાણીય એરે છે તે કહેવાય છે

784
01:07:58,000 --> 01:08:01,870
ખરેખર પ્રથમ વસ્તુ કંઈક છે જે 10 તત્વો છે નિર્દેશ કરી શકે છે કારણ કે,

785
01:08:01,870 --> 01:08:05,540
બીજી વસ્તુ કંઈક કે જે 100 ઘટકો હોય છે માટે નિર્દેશ કરી શકે છે.

786
01:08:05,540 --> 01:08:10,790
[વિદ્યાર્થી] ત્યાં પોઇન્ટર તમે કરી શકો છો સંખ્યા પર કોઇ મર્યાદા છે

787
01:08:10,790 --> 01:08:14,290
અન્ય પોઇંટરો તરફ? >> નંબર

788
01:08:14,290 --> 01:08:17,010
તમે ***** પૂર્ણાંક પૃષ્ઠ હોઈ શકે છે.

789
01:08:18,050 --> 01:08:23,760
પાછા નિર્દેશક અંકગણિત - >> [વિદ્યાર્થી] ઓહ. >> યાહ.

790
01:08:23,760 --> 01:08:35,649
[વિદ્યાર્થી] જો હું પૂર્ણાંક *** પૃષ્ઠ છે અને તે પછી હું dereferencing કરવા અને હું કહી પૃષ્ઠ * આ કિંમત સમકક્ષ હોય છે,

791
01:08:35,649 --> 01:08:39,560
છે તે માત્ર dereferencing 1 નું સ્તર કરવા જાઉં? હા. >>

792
01:08:39,560 --> 01:08:43,340
તેથી જો હું વસ્તુ છે કે છેલ્લા નિર્દેશક તરફ સંકેત છે ઍક્સેસ કરવા માંગો છો -

793
01:08:43,340 --> 01:08:46,210
પછી તમે *** પૃષ્ઠ નથી. ઠીક છે. >>

794
01:08:46,210 --> 01:08:54,080
તેથી આ 1 બ્લોક, બીજો બ્લોક પોઇન્ટ, અન્ય બ્લોક માટે પોઇન્ટ પૃષ્ઠ પોઇન્ટ છે.

795
01:08:54,080 --> 01:09:02,010
પછી જો તમે * શું પૃષ્ઠ = કંઈક બીજું, પછી તમે આ બદલી રહ્યા હોય

796
01:09:02,010 --> 01:09:13,640
હવે એક અલગ બ્લોક માટે નિર્દેશ કરે છે. ઠીક છે. >>

797
01:09:13,640 --> 01:09:17,649
>> [બોડેન] અને જો આ malloced હતા, પછી તમે હવે મેમરી લીક કર્યો છે

798
01:09:17,649 --> 01:09:20,430
જ્યાં સુધી તમે આ વિવિધ સંદર્ભો છે થવું

799
01:09:20,430 --> 01:09:25,270
કારણ કે તમે પાછા તે ચામાં ન મળી કે જે તમે હમણાં જ ફેંકી દીધો શકો છો.

800
01:09:25,270 --> 01:09:29,550
પોઇન્ટર અંકગણિત.

801
01:09:29,550 --> 01:09:36,310
પૂર્ણાંક x [4]; માટે 4 પૂર્ણાંકો ઝાકઝમાળ ફાળવી રહ્યું છે

802
01:09:36,310 --> 01:09:40,670
જ્યાં એક્સ માટે એરે શરૂઆતમાં નિર્દેશ રહ્યું છે.

803
01:09:40,670 --> 01:09:50,420
તેથી જ્યારે હું x [1] કંઈક કહેવું; હું તે એરે બીજા પૂર્ણાંક પર જવાની કરવા માંગો છો,

804
01:09:50,420 --> 01:09:53,319
જે આ એક હશે.

805
01:09:53,319 --> 01:10:04,190
પરંતુ ખરેખર, કે જે એરે માં 4 બાઇટ્સ છે કારણ કે આ પૂર્ણાંક અપ 4 બાઇટ્સ લે છે.

806
01:10:04,190 --> 01:10:08,470
તેથી 1 ઓફસેટ એક ખરેખર મતલબ 1 ઓફસેટ

807
01:10:08,470 --> 01:10:12,030
સમય ગમે તે એરે પ્રકાર છે માપ.

808
01:10:12,030 --> 01:10:17,170
આ પૂર્ણાંકો ઝાકઝમાળ છે, તેથી તે પૂર્ણાંક 1 નું વખત કદ કરી જાણે છે જ્યારે તે ઓફસેટ કરવા માંગે છે.

809
01:10:17,170 --> 01:10:25,260
અન્ય વાક્યરચના. યાદ રાખો કે આ * (x + 1) જેટલી છે;

810
01:10:25,260 --> 01:10:35,250
હું જ્યારે નિર્દેશક + 1, કે વળતર શું સરનામા કે નિર્દેશક સ્ટોર છે કહેવું

811
01:10:35,250 --> 01:10:40,360
વત્તા 1 વખત નિર્દેશક પ્રકાર માપ.

812
01:10:40,360 --> 01:10:59,510
તેથી જો એક્સ ox100 =, પછી x + 1 = ox104.

813
01:10:59,510 --> 01:11:19,750
અને તમે આ દુરુપયોગ અને કંઈક કહી શકો ઘરનાં પરચૂરણ કામો જેવા * કેચ = (કોલસો *) એક્સ;

814
01:11:19,750 --> 01:11:23,050
અને હવે સી એક્સ તરીકે જ સરનામા હશે છે.

815
01:11:23,050 --> 01:11:26,040
સી ox100 સમાન હોવું રહ્યું છે,

816
01:11:26,040 --> 01:11:31,490
પરંતુ કેચ + 1 માટે ox101 સમાન હોવું રહ્યું છે

817
01:11:31,490 --> 01:11:38,030
કારણ કે નિર્દેશક અંકગણિત પોઇન્ટર પ્રકાર કે જે તમે ઉમેરવા છે તેના પર આધાર રાખે છે.

818
01:11:38,030 --> 01:11:45,390
જેથી કેચ + 1, તે કેચ પર જુએ છે, તે ચાર રચે છે નિર્દેશક છે, તેથી તે માટે ઘરનાં પરચૂરણ કામો ની 1 વખત કદ ઉમેરવા ચાલી રહ્યું છે,

819
01:11:45,390 --> 01:11:48,110
જે હંમેશા માટે 1 પ્રયત્ન રહ્યું છે, જેથી તમે 101 વિચાર,

820
01:11:48,110 --> 01:11:54,890
જ્યારે જો હું એક્સ, જે પણ હજી પણ 100 કરવા માટે, એક્સ + 1 માટે 104 પ્રયત્ન રહ્યું છે.

821
01:11:56,660 --> 01:12:06,340
[વિદ્યાર્થી] તમે C + + માટે ક્રમમાં 1 કરીને તમારા નિર્દેશક આગળ ઉપયોગ કરી શકું?

822
01:12:06,340 --> 01:12:09,810
હા, તમે આ કરી શકો છો.

823
01:12:09,810 --> 01:12:16,180
તમે કે એક્સ સાથે નથી કારણ કે એક્સ માત્ર એક પ્રતીક છે, તો તે સતત છે; તમે એક્સ બદલી શકતા નથી.

824
01:12:16,180 --> 01:12:22,610
>> પરંતુ સી માત્ર એક નિર્દેશક બને છે, જેથી C + + સંપૂર્ણપણે માન્ય છે અને તેને 1 દ્વારા વધારો થશે.

825
01:12:22,610 --> 01:12:32,440
જો કો માત્ર પૂર્ણાંક * હતા, પછી C + + 104 આવશે.

826
01:12:32,440 --> 01:12:41,250
+ + નિર્દેશક અંકગણિત કરે છે જેમ કેચ + 1 નિર્દેશક અંકગણિત હોય કરવામાં આવશે.

827
01:12:43,000 --> 01:12:48,870
આ વાસ્તવમાં મર્જ સૉર્ટ જેવી વસ્તુઓ એક કેવી રીતે ઘણો છે -

828
01:12:49,670 --> 01:12:55,710
તેના બદલે વસ્તુઓ નકલો બનાવવા, તમે તેના બદલે પસાર કરી શકો છો -

829
01:12:55,710 --> 01:13:02,400
ગમે જો હું એરે આ અડધી પસાર કરવા માગે છે - ચાલો આ અંગેના કેટલાક ભૂંસવું.

830
01:13:04,770 --> 01:13:10,520
હવે કહો કે હું કાર્ય માં એરે આ બાજુ પસાર કરવા માંગતા હતા.

831
01:13:10,520 --> 01:13:12,700
હું શું કે કાર્ય પસાર થશે?

832
01:13:12,700 --> 01:13:17,050
જો હું એક્સ પસાર કરવા માટે, હું આ સરનામા પસાર છું.

833
01:13:17,050 --> 01:13:23,780
પરંતુ હું આ ખાસ સરનામા પસાર કરવા માંગો છો. તેથી હું શું પસાર કરવું જોઈએ?

834
01:13:23,780 --> 01:13:26,590
[વિદ્યાર્થી] પોઇન્ટર + 2?

835
01:13:26,590 --> 01:13:29,350
[બોડેન] તેથી એક્સ + 2. હા.

836
01:13:29,350 --> 01:13:31,620
કે આ સરનામાં જ હશે.

837
01:13:31,620 --> 01:13:42,810
તમે પણ ખૂબ વારંવાર તરીકે તે જોશો x [2] અને પછી એ સરનામું.

838
01:13:42,810 --> 01:13:47,850
જેથી તમે તેનો સરનામા લાગી કારણ કે કૌંસ ગર્ભિત ડિરેફરન્સ છે જરૂર છે.

839
01:13:47,850 --> 01:13:53,250
x [2] આ કિંમત છે કે જે આ બૉક્સમાં છે સંદર્ભ લે છે, અને પછી તમે તે બોક્સની સરનામા માંગો છો,

840
01:13:53,250 --> 01:13:56,850
જેથી તમે કહેવું અને એક્સ. [2]

841
01:13:56,850 --> 01:14:02,880
જેથી મર્જ સૉર્ટ કંઈક જ્યાં તમે કંઈક કરવા માટે અડધા યાદી કેવી રીતે પસાર કરવા માંગતા હોય છે

842
01:14:02,880 --> 01:14:08,790
તમે ખરેખર માત્ર પસાર & x [2] હાલમાં, અને જ્યાં સુધી ફરી યાદ આવવું કોલ ચિંતા છે,

843
01:14:08,790 --> 01:14:12,510
મારી નવી એરે ત્યાં શરૂ થાય છે.

844
01:14:12,510 --> 01:14:15,130
છેલ્લા મિનિટ પ્રશ્નો.

845
01:14:15,130 --> 01:14:20,050
[વિદ્યાર્થી] જો અમે & "અને" નું ચિહ્ન મૂકી અથવા તો - એટલે કે શું કહેવાય? >> સ્ટાર?

846
01:14:20,050 --> 01:14:23,200
[વિદ્યાર્થી] નક્ષત્ર. >> ટેક્નિકલ, ડિરેફરન્સ ઓપરેટર છે, પરંતુ - >> [વિદ્યાર્થી] ડિરેફરન્સ.

847
01:14:23,200 --> 01:14:29,310
>> જો આપણે એક તારો અથવા & "અને" નું ચિહ્ન મૂકી નથી, જો હું માત્ર વાય કહેવું થાય છે = x અને x એક નિર્દેશક છે?

848
01:14:29,310 --> 01:14:34,620
વાય પ્રકાર શું છે? >> [વિદ્યાર્થી] હું માત્ર તે 2 નિર્દેશક કહેવું પડશે.

849
01:14:34,620 --> 01:14:38,270
તેથી જો તમે માત્ર કહેવા વાય = x, હવે એક્સ અને વાય બિંદુ જ વસ્તુ છે. >> જ વસ્તુ [વિદ્યાર્થી] બિંદુ.

850
01:14:38,270 --> 01:14:45,180
અને જો એક્સ પૂર્ણાંક નિર્દેશક છે? >> તે કારણ કે તમે પોઇંટરો નથી સોંપી શકે ફરિયાદ કરશે.

851
01:14:45,180 --> 01:14:46,540
[વિદ્યાર્થી] ઠીક.

852
01:14:46,540 --> 01:14:51,860
કે પોઇંટરો યાદ રાખો, તેમ છતાં અમે તેમને તીરો તરીકે આલેખન

853
01:14:51,860 --> 01:15:02,010
ખરેખર તમામ તેઓ દુકાન - પૂર્ણાંક * એક્સ - ખરેખર બધા એક્સ સ્ટોર કરે છે ox100 કંઈક છે,

854
01:15:02,010 --> 01:15:06,490
જે અમે 100 અંતે સંગ્રહિત બ્લોક તરફ ઇશારો તરીકે પ્રસ્તુત થાય છે.

855
01:15:06,490 --> 01:15:19,660
તેથી જ્યારે હું કહું છું પૂર્ણાંક * વાય = x; હું માત્ર વાય માં છું ox100 નકલ,

856
01:15:19,660 --> 01:15:24,630
જે અમે માત્ર વાય તરીકે પ્રતિનિધિત્વ જઈ રહ્યાં છો, પણ ox100 માટે નિર્દેશ કરતી હશે.

857
01:15:24,630 --> 01:15:39,810
અને જો હું કહું છું પૂર્ણાંક હું = (પૂર્ણાંક) એક્સ; પછી હું સંગ્રહવા માટે ગમે ox100 મૂલ્ય છે રહ્યું છે

858
01:15:39,810 --> 01:15:45,100
અંદર હોય, પરંતુ હવે તે એક નિર્દેશક બદલે પૂર્ણાંક તરીકે અર્થઘટન કરી રહ્યું છે.

859
01:15:45,100 --> 01:15:49,310
પરંતુ તમે કાસ્ટ જરૂર અથવા અન્ય તે ફરિયાદ કરશે.

860
01:15:49,310 --> 01:15:53,300
[વિદ્યાર્થી] તેથી તમે ભૂમિકા અર્થ નથી -

861
01:15:53,300 --> 01:16:00,290
છે તે વાય ઓફ એક્સ અથવા કાસ્ટિંગ પૂર્ણાંક ઓફ પૂર્ણાંક નિર્ણાયક હશે?

862
01:16:00,290 --> 01:16:03,700
[બોડેન] શું?

863
01:16:03,700 --> 01:16:07,690
[વિદ્યાર્થી] ઠીક. આ કૌંસ પછી ત્યાં જે x અથવા ત્યાં સારું પ્રયત્ન રહ્યું છે?

864
01:16:07,690 --> 01:16:11,500
>> [બોડેન] ક્યાં. એક્સ અને વાય સમકક્ષ હોય છે. >> [વિદ્યાર્થી] ઠીક.

865
01:16:11,500 --> 01:16:14,390
કારણ કે તે બંને પોઇંટરો છો. >> યાહ.

866
01:16:14,390 --> 01:16:21,050
[વિદ્યાર્થી] તેથી તે પૂર્ણાંક ફોર્મ માં હેક્સાડેસિમલ 100 સંગ્રહવા માંગો છો? >> [બોડેન] યાહ.

867
01:16:21,050 --> 01:16:23,620
પરંતુ ગમે તે નિર્દેશ મૂલ્ય નથી.

868
01:16:23,620 --> 01:16:29,940
[બોડેન] યાહ. >> [વિદ્યાર્થી] તેથી માત્ર પૂર્ણાંક ફોર્મ માં સરનામું. ઠીક છે.

869
01:16:29,940 --> 01:16:34,720
[બોડેન] જો તમે કેટલાક વિચિત્ર કારણોસર કરવા માગે છે,

870
01:16:34,720 --> 01:16:38,900
તમે સંપૂર્ણપણે પોઇન્ટર સાથે વ્યવહાર અને શકે પૂર્ણાંકો સાથે ક્યારેય વ્યવહાર

871
01:16:38,900 --> 01:16:49,240
અને માત્ર પૂર્ણાંક * x = 0 જેવા છે.

872
01:16:49,240 --> 01:16:53,000
પછી તમે ખરેખર એક વખત નિર્દેશક અંકગણિત થઈ રહ્યું શરૂ થાય છે ગુંચવણ ના થવી રહ્યા છીએ.

873
01:16:53,000 --> 01:16:56,570
તેથી નંબરો છે કે તેઓ સ્ટોર અર્થહીન છે.

874
01:16:56,570 --> 01:16:58,940
તે ફક્ત તમે કેવી રીતે અંત તેમને ઈન્ટરપ્રીટ.

875
01:16:58,940 --> 01:17:02,920
તેથી હું પૂર્ણાંક * ના ox100 પૂર્ણાંક પર નકલ મફત છું,

876
01:17:02,920 --> 01:17:07,790
કદાચ ન કાઢવા માટે અંતે yelled કરો જઈને you're - અને હું સોંપી મફત છું -

877
01:17:07,790 --> 01:17:18,160
હું (પૂર્ણાંક *) આ મનસ્વી પૂર્ણાંક * માં ox1234 કંઈક સોંપી મફત છું.

878
01:17:18,160 --> 01:17:25,480
તેથી ox123 છે જેમ માન્ય મેમરી સરનામા તરીકે વાય & છે.

879
01:17:25,480 --> 01:17:32,060
& પિ કંઈક કે જે ઘટનાએ છે ox123 પરત થાય છે.

880
01:17:32,060 --> 01:17:35,430
[વિદ્યાર્થી] કે જે ખરેખર ઠંડી માટે હેક્સાડેસિમલ માંથી અક્ષાંશ ફોર્મ પર જાઓ માર્ગ થશે,

881
01:17:35,430 --> 01:17:39,230
જો તમે એક નિર્દેશક હોય ગમે અને તમે તેને પૂર્ણાંક તરીકે ભૂમિકા?

882
01:17:39,230 --> 01:17:44,860
[બોડેન] તમે ખરેખર માત્ર printf જેમ ઉપયોગ કરીને છાપી શકો છો.

883
01:17:44,860 --> 01:17:50,300
હવે કહો કે હું પૂર્ણાંક વાય = 100 હોય છે.

884
01:17:50,300 --> 01:18:02,700
તેથી printf (% d \ n - તરીકે તમે પહેલેથી જ ખબર હોવી જોઇએ - print કે પૂર્ણાંક,% એક્સ.

885
01:18:02,700 --> 01:18:05,190
અમે હમણાં જ તે હેક્સાડેસિમલ તરીકે છાપી પડશે.

886
01:18:05,190 --> 01:18:10,760
તેથી નિર્દેશક હેક્સાડેસિમલ તરીકે સંગ્રહિત થાય છે,

887
01:18:10,760 --> 01:18:12,960
અને પૂર્ણાંક અક્ષાંશ તરીકે સંગ્રહાયેલ છે.

888
01:18:12,960 --> 01:18:14,700
બધું દ્વિસંગી તરીકે સંગ્રહાયેલ છે.

889
01:18:14,700 --> 01:18:17,950
તે માત્ર છે કે અમે હેક્સાડેસિમલ તરીકે પોઇંટરો બતાવવા વલણ ધરાવે છે

890
01:18:17,950 --> 01:18:23,260
કારણ કે અમે આ 4 બાઇટ બ્લોકમાં વસ્તુઓ વિચારો,

891
01:18:23,260 --> 01:18:25,390
અને મેમરી સરનામાંઓ માટે પરિચિત હોય છે.

892
01:18:25,390 --> 01:18:28,890
માફ જેમ, જો તે બીએફ સાથે શરૂ થાય છે, પછી તે સ્ટેક પર બને છે.

893
01:18:28,890 --> 01:18:35,560
તેથી તે માત્ર હેક્સાડેસિમલ તરીકે પોઇંટરો અમારી અર્થઘટન છે.

894
01:18:35,560 --> 01:18:39,200
ઠીક છે. કોઈપણ છેલ્લા પ્રશ્નો છે?

895
01:18:39,200 --> 01:18:41,700
>> હું અહીં થોડી હોઇ જો પછી તમે જે કંઈપણ પડશે.

896
01:18:41,700 --> 01:18:46,070
અને તે કે ઓવરને છે.

897
01:18:46,070 --> 01:18:48,360
>> [વિદ્યાર્થી] યે! [વધાવી]

898
01:18:51,440 --> 01:18:53,000
>> [CS50.TV]