1
00:00:00,000 --> 00:00:01,110
>> [સંગીત વગાડવાનો]

2
00:00:01,110 --> 00:00:10,567

3
00:00:10,567 --> 00:00:11,650
ડેવિડ જે MALAN: બધા અધિકાર.

4
00:00:11,650 --> 00:00:15,610
આ CS50 છે, અને આ
અઠવાડિયું ચાર અંત છે.

5
00:00:15,610 --> 00:00:19,420
અને વિષયોની એક આજે
ડિજિટલ ફોરેન્સિક્સ કે, છે

6
00:00:19,420 --> 00:00:20,989
માહિતી પાછી ઓફ આર્ટ.

7
00:00:20,989 --> 00:00:22,780
અને ખરેખર, છતાં પણ
તમે મધ્યે છો

8
00:00:22,780 --> 00:00:25,070
હમણાં શાંતિ ત્રણ પર
અને બ્રેકઆઉટ, આગામી સપ્તાહ,

9
00:00:25,070 --> 00:00:27,880
ધ્યાન પર રહેશે
ચોક્કસપણે આ ડોમેન.

10
00:00:27,880 --> 00:00:30,686
>> શાનદાર નોકરી તેથી એક હું ક્યારેય
હતી, પાછા ગ્રેજ્યુએટ સ્કૂલ હતી

11
00:00:30,686 --> 00:00:33,560
હું સ્થાનિક માટે કામ કરતા હતા ત્યારે
મિડલસેક્સ કાઉન્ટી ડિસ્ટ્રીક્ટ એટર્નીની

12
00:00:33,560 --> 00:00:34,950
ઓફિસ, કરી વિદેશી કામ કરે છે.

13
00:00:34,950 --> 00:00:37,450
તેથી અનિવાર્યપણે, મેસેચ્યુસેટ્સ
રાજ્ય પોલીસ, પ્રસંગ પર,

14
00:00:37,450 --> 00:00:40,100
કિસ્સાઓમાં પર કામ જ્યારે કરશે
હાર્ડ ડ્રાઈવો જેવી વસ્તુઓ લાવવા

15
00:00:40,100 --> 00:00:42,185
અને ફ્લોપી ડિસ્ક અને
મેમરી કાર્ડ અને ગમે છે.

16
00:00:42,185 --> 00:00:44,060
અને તેઓ તેમને હાથ કરશે
મને અને મારા માર્ગદર્શક છે,

17
00:00:44,060 --> 00:00:48,070
અને અમારા ધ્યેય પુરાવા શોધવા માટે હતી,
આ મીડિયા પર કોઈપણ, ત્યાં તો.

18
00:00:48,070 --> 00:00:50,700
હવે, તમે જોઈ હોય શકે વસ્રો
વિદેશી આ વિશ્વના

19
00:00:50,700 --> 00:00:53,000
મીડિયા, ટીવી અને ફિલ્મોમાં.

20
00:00:53,000 --> 00:00:55,730
પરંતુ કામ હું હતો, અને
daresay કે વિશ્વમાં,

21
00:00:55,730 --> 00:00:57,550
તમે તેને જુઓ છો જેમ તદ્દન નથી.

22
00:00:57,550 --> 00:01:00,794
માતાનો પર એક નજર શું
તમે કદાચ જોઇ છે.

23
00:01:00,794 --> 00:01:01,460
[વિડિઓ પ્લેબેક]

24
00:01:01,460 --> 00:01:02,930
-OK.

25
00:01:02,930 --> 00:01:05,380
હવે, ચાલો તમે પર સારો દેખાવ વિચાર કરીએ.

26
00:01:05,380 --> 00:01:06,850
>> [સંગીત વગાડવાનો]

27
00:01:06,850 --> 00:01:12,260

28
00:01:12,260 --> 00:01:12,932
>> તે -Hold.

29
00:01:12,932 --> 00:01:13,657
કે પાછા ચલાવો.

30
00:01:13,657 --> 00:01:14,733
>> એક મિનિટ -Wait.

31
00:01:14,733 --> 00:01:15,233
અધિકાર જાઓ.

32
00:01:15,233 --> 00:01:16,371

33
00:01:16,371 --> 00:01:16,870
-ત્યાં.

34
00:01:16,870 --> 00:01:17,369
કે સ્થિર.

35
00:01:17,369 --> 00:01:17,930
પૂર્ણ સ્ક્રીન.

36
00:01:17,930 --> 00:01:18,376
>> -OK.

37
00:01:18,376 --> 00:01:18,875
કે સ્થિર.

38
00:01:18,875 --> 00:01:20,160
તમે તે પર કરશે અપ -Tighten?

39
00:01:20,160 --> 00:01:22,126
>> કે પર -Vector
પાછળ વ્હીલ દ્વારા વ્યક્તિ.

40
00:01:22,126 --> 00:01:24,435
>> અહીં આ સ્થળ પર -Zoom.

41
00:01:24,435 --> 00:01:28,580
>> યોગ્ય સાધનો -સાથે, આ
છબી મોટું અને sharpened કરી શકાય છે.

42
00:01:28,580 --> 00:01:29,330
>> કે -શું છે?

43
00:01:29,330 --> 00:01:30,780
>> ઇટ એક વૃદ્ધિ કાર્યક્રમ છે.

44
00:01:30,780 --> 00:01:32,170
>> કે કોઈ સ્પષ્ટ તમે -Can?

45
00:01:32,170 --> 00:01:33,070
>> હું ખબર નથી.

46
00:01:33,070 --> 00:01:34,150
ચાલો તે વધારવા દો.

47
00:01:34,150 --> 00:01:35,440
>> -Enhance વિભાગ A6.

48
00:01:35,440 --> 00:01:36,570

49
00:01:36,570 --> 00:01:38,562
હું વિગતવાર ઉન્નત, and--

50
00:01:38,562 --> 00:01:40,020
હું વધારવા માટે પૂરતી છે લાગે છે.

51
00:01:40,020 --> 00:01:40,976
મારા સ્ક્રીન પર તે પ્રકાશન.

52
00:01:40,976 --> 00:01:42,559
>> હું તેના આંખ માં પ્રતિબિંબ ઉન્નત.

53
00:01:42,559 --> 00:01:44,322
-Let દ્વારા આ સ્કોર છે
વિડિઓ વૃદ્ધિ.

54
00:01:44,322 --> 00:01:45,210
>> -Edgar, તમે આ વિસ્તૃત કરી શકે છે?

55
00:01:45,210 --> 00:01:45,710
>> પર -Hang.

56
00:01:45,710 --> 00:01:47,570

57
00:01:47,570 --> 00:01:49,458
>> આ પ્રતિબિંબ પર કાર્ય કરી રહી -I've.

58
00:01:49,458 --> 00:01:50,402
>> -ત્યાં માતાનો કોઈની પ્રતિબિંબ.

59
00:01:50,402 --> 00:01:50,902
>> -Reflection.

60
00:01:50,902 --> 00:01:52,870
માણસ ચહેરો એક પ્રતિબિંબ -ત્યાં છે.

61
00:01:52,870 --> 00:01:53,694
>> -ધ પ્રતિબિંબ!

62
00:01:53,694 --> 00:01:54,610
પ્રતિબિંબ -ત્યાં છે.

63
00:01:54,610 --> 00:01:55,880
મિરર પર -Zoom.

64
00:01:55,880 --> 00:01:57,860
તમે પ્રતિબિંબ જોઈ શકે છે.

65
00:01:57,860 --> 00:01:59,630
>> તમે અહીં છબી વધારવા -Can?

66
00:01:59,630 --> 00:02:00,377

67
00:02:00,377 --> 00:02:01,210
તમે તેને વધારવા -Can?

68
00:02:01,210 --> 00:02:02,190
તમે તેને વધારવા -Can?

69
00:02:02,190 --> 00:02:03,066
અમે આ વધારવા -Can?

70
00:02:03,066 --> 00:02:03,898
તમે તેને વધારવા -Can?

71
00:02:03,898 --> 00:02:04,740
બીજા પર -Hold.

72
00:02:04,740 --> 00:02:05,281
હું વધારવા પડશે.

73
00:02:05,281 --> 00:02:06,470
દરવાજા પર -Zoom.

74
00:02:06,470 --> 00:02:06,970
10 -Times.

75
00:02:06,970 --> 00:02:08,009
-Zoom.

76
00:02:08,009 --> 00:02:08,509
માં -Move.

77
00:02:08,509 --> 00:02:09,340
-More.

78
00:02:09,340 --> 00:02:10,094
-Wait, અટકાવો.

79
00:02:10,094 --> 00:02:10,750
-Stop.

80
00:02:10,750 --> 00:02:11,250
તે -Pause.

81
00:02:11,250 --> 00:02:13,542
અમને 75 ડિગ્રી -Rotate
ઊભી આસપાસ, કૃપા કરીને.

82
00:02:13,542 --> 00:02:14,750

83
00:02:14,750 --> 00:02:16,127
>> -Stop.

84
00:02:16,127 --> 00:02:19,330
આ ભાગ પર પાછા જાઓ
દરવાજા વિશે ફરી.

85
00:02:19,330 --> 00:02:21,420
>> બીટમેપ કરી શકો છો કે એક છબી enhancer -Got?

86
00:02:21,420 --> 00:02:24,420
>> અમે પ્રદીપ સિંહ ઉપયોગ કરી શકો છો -Maybe
પદ્ધતિ વિન્ડો માં જોવા માટે.

87
00:02:24,420 --> 00:02:25,902
>> -ધ સોફ્ટવેર કલા રાજ્ય છે.

88
00:02:25,902 --> 00:02:26,866
>> -ધ Eigenvalue બંધ છે.

89
00:02:26,866 --> 00:02:29,758
>> યોગ્ય -સાથે
અલગોરિથમ્સ મિશ્રણ

90
00:02:29,758 --> 00:02:32,168
>> -કુલ માતાનો લેવામાં પ્રકાશ
આગલા સ્તર પર ગાણિતીક નિયમો,

91
00:02:32,168 --> 00:02:34,110
અને હું તેમને ઉપયોગ કરી શકો છો
આ ફોટોગ્રાફ વધારે છે.

92
00:02:34,110 --> 00:02:36,840
>> પર -Lock અને ઝેડ ધરી મોટું.

93
00:02:36,840 --> 00:02:37,351
>> -Enhance.

94
00:02:37,351 --> 00:02:37,850
વધારે છે.

95
00:02:37,850 --> 00:02:38,720
-Enhance.

96
00:02:38,720 --> 00:02:40,070
-Freeze અને વધારે છે.

97
00:02:40,070 --> 00:02:43,420
[સમાપ્ત વિડિઓ પ્લેબેક]

98
00:02:43,420 --> 00:02:45,830
ડેવિડ જે MALAN: તેથી તે છે
બધા શબ્દો છે, પરંતુ તેઓ ન હતા

99
00:02:45,830 --> 00:02:47,870
યોગ્ય રીતે વાક્યો વપરાય છે.

100
00:02:47,870 --> 00:02:52,370
અને ખરેખર ભવિષ્યમાં, કોઈ પણ સમયે,
, તમે કોઈને શબ્દ કહે સાંભળવા કરો,

101
00:02:52,370 --> 00:02:54,250
માત્ર થોડો મજાક ", વધારે".

102
00:02:54,250 --> 00:02:57,190
તમે વધારવા માટે પ્રયત્ન કરો ત્યારે, કારણ કે
દાખલા તરીકે, આ શું થાય છે.

103
00:02:57,190 --> 00:02:58,580
>> અહીં એક ભવ્ય ફોટો છે.

104
00:02:58,580 --> 00:02:59,720
આ CS50 પોતાના Daven છે.

105
00:02:59,720 --> 00:03:03,740
અને અમે કરવા માગે છે ધારવું
તેની આંખ માં ટ્વિંકલ પર ધ્યાન કેન્દ્રિત,

106
00:03:03,740 --> 00:03:05,870
અથવા ના પ્રતિબિંબ
સ્પષ્ટ હતું કે ખરાબ વ્યક્તિ

107
00:03:05,870 --> 00:03:07,820
સુરક્ષા કેમેરા દ્વારા કબજે.

108
00:03:07,820 --> 00:03:10,330
આ શું થાય છે જ્યારે છે
તમે એક છબી પર ઝૂમ કે

109
00:03:10,330 --> 00:03:14,060
માત્ર મર્યાદિત સંખ્યામાં હોય છે
તેની સાથે સંકળાયેલ બીટ્સ.

110
00:03:14,060 --> 00:03:15,420
>> એટલે કે, તમે વિચાર શું છે.

111
00:03:15,420 --> 00:03:19,190
અને ખરેખર, Daven આંખ માં
, કદાચ છ પિક્સેલ્સ છે પરંતુ ચાર

112
00:03:19,190 --> 00:03:22,110
કે ચોકકસ શું કંપોઝ
ત્યાં ઝાંખો હતી.

113
00:03:22,110 --> 00:03:25,890
તેથી સમસ્યા સેટ ચાર અંક આખરે હશે
તમે ખાસ કરીને, આ વિશ્વમાં અન્વેષણ

114
00:03:25,890 --> 00:03:28,090
કંઈક પ્રકૃતિ દ્વારા
અમે ફાઈલ I / O, જ્યાં કૉલ

115
00:03:28,090 --> 00:03:31,000
I / O માત્ર એક ફેન્સી માર્ગ છે
ઇનપુટ અને આઉટપુટ કહેતા.

116
00:03:31,000 --> 00:03:34,280
>> તેથી આમ અત્યાર સુધી, આ ક્રિયાપ્રતિક્રિયાઓ તમામ
અમે એક કમ્પ્યુટર સાથે હતી

117
00:03:34,280 --> 00:03:36,770
સાથે મોટા ભાગે કરવામાં આવી છે તમારા
કીબોર્ડ અને સ્ક્રીન,

118
00:03:36,770 --> 00:03:40,770
પરંતુ હાર્ડ ડિસ્ક સાથે ખૂબ જ નથી,
અથવા મુદ્દાઓ બહાર ફાઇલો બચત તમે

119
00:03:40,770 --> 00:03:41,620
જાતે લખો.

120
00:03:41,620 --> 00:03:44,570
તમારા કાર્યક્રમો આમ અત્યાર સુધી છે
નથી, બનાવવા માટે, અને બચત કરવામાં આવી

121
00:03:44,570 --> 00:03:46,270
અને તેમના પોતાના ફાઈલો સુધારીને.

122
00:03:46,270 --> 00:03:47,150
>> વેલ, એક ફાઇલ શું છે?

123
00:03:47,150 --> 00:03:48,105
ઠીક છે, કોઈ JPEG કંઈક.

124
00:03:48,105 --> 00:03:50,520
આ તમને કદાચ એક છબી છે
હોય અથવા Facebook પર અપલોડ કરો,

125
00:03:50,520 --> 00:03:51,690
અથવા ગમે ત્યાં વેબ પર જુઓ.

126
00:03:51,690 --> 00:03:54,460
ખરેખર, કે ફોટો આપણે
Daven ના જોયું કોઈ JPEG હતી.

127
00:03:54,460 --> 00:03:57,570
અને શું રસપ્રદ છે
JPEGs જેવા ફાઈલો વિશે

128
00:03:57,570 --> 00:04:02,170
તેઓ ઓળખી શકાય છે કે જે,
સામાન્ય રીતે, બીટ્સ ચોક્કસ પેટર્ન દ્વારા.

129
00:04:02,170 --> 00:04:05,200
>> અન્ય શબ્દોમાં, તે શું છે
એક GIF માંથી કોઈ JPEG અલગ પાડે

130
00:04:05,200 --> 00:04:08,109
એક શબ્દ એક પિંગ થી
એક એક્સેલ ફાઈલ ના દસ્તાવેજ?

131
00:04:08,109 --> 00:04:09,900
ઠીક છે, તે માત્ર અલગ છે
બીટ્સ પેટર્ન.

132
00:04:09,900 --> 00:04:12,820
અને તે વિવિધ તરાહો છે
સામાન્ય રીતે તે ફાઈલો શરૂઆતમાં.

133
00:04:12,820 --> 00:04:18,200
>> તમારા કમ્પ્યુટર એક શબ્દ ખોલે જ્યારે જેથી
દસ્તાવેજ, અથવા કમ્પ્યુટર કોઈ JPEG ખોલે છે,

134
00:04:18,200 --> 00:04:20,940
તે પર સામાન્ય રીતે જુએ છે
ફાઈલમાં પ્રથમ કેટલાક બીટ્સ.

135
00:04:20,940 --> 00:04:24,059
અને તે એક પેટર્ન ઓળખે છે,
તે ઓહ, આ એક છબી છે, કહે છે.

136
00:04:24,059 --> 00:04:25,850
મને તે પ્રદર્શિત કરીએ
ગ્રાફિક તરીકે વપરાશકર્તા.

137
00:04:25,850 --> 00:04:27,870
અથવા, ઓહ, આ એક શબ્દ દસ્તાવેજ જેવો દેખાય છે.

138
00:04:27,870 --> 00:04:30,480
મને એક નિબંધ તરીકે વપરાશકર્તા માટે તે દર્શાવે છે.

139
00:04:30,480 --> 00:04:33,020
>> દાખલા તરીકે તેથી, JPEGs,
તે છે બહાર વળે

140
00:04:33,020 --> 00:04:35,460
એકદમ આધુનિક
હૂડ નીચે.

141
00:04:35,460 --> 00:04:40,140
પરંતુ મોટા ભાગના દરેક માં પ્રથમ ત્રણ બાઇટ્સ
JPEG આ ત્રણ નંબરો સાથે શરૂ કરો.

142
00:04:40,140 --> 00:04:44,680
તેથી બાઇટ શૂન્ય, એક, અને બે માં, છે
સૌથી દરેક JPEG, 255 અને પછી નંબર

143
00:04:44,680 --> 00:04:46,675
216 અને પછી નંબર 255.

144
00:04:46,675 --> 00:04:48,990
>> અને તમે કરવાનો પ્રયત્ન કરીશું શું
આગામી સપ્તાહ કરી શરૂ કરવા માટે

145
00:04:48,990 --> 00:04:52,920
ખરેખર નીચે poking છે
JPEGs જેવા ફાઈલોની હૂડ

146
00:04:52,920 --> 00:04:57,210
અને બીટમેપ ફાઇલો જેવા, અને જોયા
શું હંમેશા તરીકે લાંબા સમય માટે કરવામાં આવી છે

147
00:04:57,210 --> 00:04:58,650
જો તમે કમ્પ્યુટરનો ઉપયોગ કરી છે.

148
00:04:58,650 --> 00:05:01,860
>> પરંતુ સામાન્ય રીતે નથી શું છે
આ જેમ દશાંશ નંબર જેવી લખાયેલ છે.

149
00:05:01,860 --> 00:05:04,620
કમ્પ્યુટર વૈજ્ઞાનિકો નથી
દશાંશ વાત કરતા હોય છે.

150
00:05:04,620 --> 00:05:06,139
તેઓ ખરેખર દ્વિસંગી વાત નથી.

151
00:05:06,139 --> 00:05:07,930
ખાસ કરીને, જ્યારે અમે માંગો છો
નંબરો વ્યક્ત,

152
00:05:07,930 --> 00:05:10,710
અમે ખરેખર હેક્સાડેસિમલ વાપરવા માટે,
જે તમે યાદ કરી શકે છે

153
00:05:10,710 --> 00:05:13,027
સમસ્યા સેટ કહે છે, ના
પડકારવામાં જે એક,

154
00:05:13,027 --> 00:05:14,610
તમે એક અલગ સિસ્ટમ વિશે વિચારો.

155
00:05:14,610 --> 00:05:17,170
>> અમે, અલબત્ત, પરિચિત હોય છે
નવ દ્વારા દશાંશ શૂન્ય સાથે.

156
00:05:17,170 --> 00:05:18,215
અમે બાઈનરી વિશે વાત કરી.

157
00:05:18,215 --> 00:05:20,710
અને અમે ખરેખર નથી
ખૂબ અહીં વાપરવા માટે

158
00:05:20,710 --> 00:05:22,470
બહાર પર, કમ્પ્યુટર્સ ઉપયોગ કરશે.

159
00:05:22,470 --> 00:05:24,900
પરંતુ પ્રોગ્રામરો ખૂબ ચાલશે
ઘણી વખત, પરંતુ હંમેશા,

160
00:05:24,900 --> 00:05:29,360
માત્ર અર્થ એ થાય, કે જે હેક્સાડેસિમલ ઉપયોગ
તમે તમારા મૂળાક્ષરમાં 16 અક્ષરો છે

161
00:05:29,360 --> 00:05:31,330
તરીકે બે કે 10 વિરોધ.

162
00:05:31,330 --> 00:05:34,530
>> તેથી તમે કેવી રીતે વધારે માટે ગણતરી કરો
હેક્સાડેસિમલ નવ કરતાં?

163
00:05:34,530 --> 00:05:41,120
તમે જાઓ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
એક માત્ર સંમેલન દ્વારા સી, ડી, ઇ, એફ, બી.

164
00:05:41,120 --> 00:05:43,540
પરંતુ કી છે દરેક છે
આ એક પ્રતીક છે.

165
00:05:43,540 --> 00:05:44,340
કોઈ 10 છે.

166
00:05:44,340 --> 00:05:48,400
દરેક કારણ કે આ બોલ પર કોઈ 11, સે દીઠ છે
તમારા અંકો, માત્ર દશાંશ માં ગમે

167
00:05:48,400 --> 00:05:51,940
માત્ર દ્વિસંગી માં ગમે અને, ફક્ત જોઈએ
સંમેલન દ્વારા એક જ અક્ષર છે,.

168
00:05:51,940 --> 00:05:55,280
>> પછી અમે મૂળાક્ષર કે તેથી
હેક્સાડેસિમલ માટે અમારા નિકાલ પર.

169
00:05:55,280 --> 00:05:58,600
તેથી કોઈ JPEG તમે જો જેમ શું લાગતું નથી
તે પ્રથમ ત્રણ લખી હતી

170
00:05:58,600 --> 00:06:01,980
, દશાંશ નથી બાઇટ્સ પરંતુ
દાખલા તરીકે, હેક્સાડેસિમલ તરીકે?

171
00:06:01,980 --> 00:06:03,640
અને શા માટે હેક્સ કે ઉપયોગી પણ બધા છે?

172
00:06:03,640 --> 00:06:05,290
>> વેલ, એક ઉદાહરણ પર એક ઝડપી દેખાવ.

173
00:06:05,290 --> 00:06:09,030
હું બિટ્સ લખી તેથી જો કે
આ બાદ નંબરોની પ્રતિનિધિત્વ

174
00:06:09,030 --> 00:06:12,450
આ થોડી કાટવાળું હોઈ શકે
હવે પાછા થોડા અઠવાડિયા થી,

175
00:06:12,450 --> 00:06:14,820
ડાબી એક અને પરંતુ
યોગ્ય એક ખૂબ સરળ હોય છે.

176
00:06:14,820 --> 00:06:17,990
255 સૌથી મોટી સંખ્યા અમે હતી
આઠ બિટ્સ સાથે રજૂ કરી શકે છે.

177
00:06:17,990 --> 00:06:18,820
તે બધા લોકો હતા.

178
00:06:18,820 --> 00:06:21,320
તેથી હળવું છે કે માત્ર એક જ
રસપ્રદ મધ્યમાં છે.

179
00:06:21,320 --> 00:06:24,700
અને તમે પ્રકારની બહાર કરો તો
ગણિત, તમે ખરેખર, કે જાણી જશે

180
00:06:24,700 --> 00:06:27,949
એક કે પેટર્ન અને
zeros 216 રજૂ કરે છે.

181
00:06:27,949 --> 00:06:30,240
તેથી આપણે માત્ર માટે નિયત દો
હવે આ યોગ્ય છે.

182
00:06:30,240 --> 00:06:31,730
પરંતુ શા માટે આ રસપ્રદ છે?

183
00:06:31,730 --> 00:06:33,970
>> વેલ, એક બાઈટ, અલબત્ત, આઠ બિટ્સ છે.

184
00:06:33,970 --> 00:06:38,980
અને તે તમને લાગે તો તારણ છે કે
ચાર બીટ્સ બે હિસ્સામાં તરીકે બાઇટ,

185
00:06:38,980 --> 00:06:39,500
આ જેમ.

186
00:06:39,500 --> 00:06:41,000
મને માત્ર કેટલાક જગ્યા ઉમેરો.

187
00:06:41,000 --> 00:06:42,550
તેથી પહેલાં, પછી.

188
00:06:42,550 --> 00:06:46,520
હું માત્ર કેટલાક સફેદ જગ્યા ઉમેર્યા છે
અહીં વિઝ્યુલાઇઝેશન ખાતર.

189
00:06:46,520 --> 00:06:51,840
કેવી રીતે અમે હવે માં પ્રતિનિધિત્વ કરી શકે છે,
કહે છે, હેક્સાડેસિમલ બીટ્સ દરેક ચતુર્ભુજ,

190
00:06:51,840 --> 00:06:52,880
ચાર બિટ્સ દરેક સમૂહ?

191
00:06:52,880 --> 00:06:56,420
>> દાખલા તરીકે, ડાબી પર તેથી
હવે, અમે દ્વિસંગી 1111 છે.

192
00:06:56,420 --> 00:07:00,420
બાદ માં કે જે નંબર શું છે,
તમે ગણિત બહાર કરી છે?

193
00:07:00,420 --> 00:07:03,780
તમે જેના સ્થાને છે, twos સ્થળ,
આ ચોગ્ગા સ્થળ, અને સહિતની સંખ્યાબંધ ઉડાનો ભરી સ્થળ.

194
00:07:03,780 --> 00:07:04,341
>> પ્રેક્ષક: 15.

195
00:07:04,341 --> 00:07:05,340
ડેવિડ જે MALAN: તે 15 છે.

196
00:07:05,340 --> 00:07:08,340
તેથી અમે આઠ વત્તા ચાર કરો તો
વત્તા બે વત્તા એક, અમે 15 મેળવો.

197
00:07:08,340 --> 00:07:11,790
તેથી હું નીચે 15 લખી શકે છે
1111, પરંતુ અહીં સમગ્ર બિંદુ

198
00:07:11,790 --> 00:07:13,190
હેક્સાડેસિમલ છે, અક્ષાંશ નથી.

199
00:07:13,190 --> 00:07:17,310
તેથી તેના બદલે નીચે લખવાની 15, 1-5,
હું હેક્સ કે લખવા જઈ રહ્યો છું

200
00:07:17,310 --> 00:07:22,311
જો તમારી પાસે તમે પાછા લાગે છે કે જે જો
એફ દ્વારા શૂન્ય, શું 15 પ્રયત્ન રહ્યું છે?

201
00:07:22,311 --> 00:07:22,810
પ્રેક્ષક: એફ.

202
00:07:22,810 --> 00:07:24,434
ડેવિડ જે MALAN: તેથી તે તે એફ બહાર કરે છે.

203
00:07:24,434 --> 00:07:29,140
અને તમે કહેતા કે કામ કરી શકે છે,
10 જો સાથે સાથે,, પછી ઠીક, એફ 15 છે.

204
00:07:29,140 --> 00:07:33,250
તેથી ખરેખર, અમે લખાણ લખે શકે
એફ એફ તરીકે નંબરો આ જ સેટ.

205
00:07:33,250 --> 00:07:35,750
અને પછી અમે ગણિત એક બીટ કરો તો,
અમે તે ડી કે જાણી શકશો.

206
00:07:35,750 --> 00:07:38,650
આઠ, ખૂબ સરળ છે કારણ કે અમે
આ સહિતની સંખ્યાબંધ ઉડાનો ભરી જગ્યાએ એક એક છે.

207
00:07:38,650 --> 00:07:40,620
અને પછી, અમે એફ એફ માતાનો એક દંપતિ વધુ હોય છે.

208
00:07:40,620 --> 00:07:44,669
>> તેથી શું મનુષ્યો સંમેલન દ્વારા કરવા માટે હોય છે
તેઓ ઉપયોગ કરો છો ત્યારે હેક્સાડેસિમલ તેઓ માત્ર છે

209
00:07:44,669 --> 00:07:47,710
વધુ સંક્ષિપ્તમાં આ થોડું લખવા,
કે સફેદ જગ્યા મોટા ભાગના છુટકારો મળે છે.

210
00:07:47,710 --> 00:07:50,890
અને માત્ર સુપર સ્પષ્ટ કરવા
આ હેક્સાડેસિમલ છે કે વાચકો,

211
00:07:50,890 --> 00:07:54,670
વચ્ચે સરળ સંમેલન
મનુષ્યો તમે શૂન્ય લખી છે

212
00:07:54,670 --> 00:07:58,000
અન્ય કોઈ અર્થ હોય છે જે એક્સ,
એક દ્રશ્ય ઓળખકર્તા કરતાં,

213
00:07:58,000 --> 00:07:59,590
અહીં એક હેક્સ નંબર આવે છે.

214
00:07:59,590 --> 00:08:04,210
>> અને પછી, તમે એફ બે અંકો મૂકી
આ કિસ્સામાં એફ, તો પછી ડી એક, પછી એફ એફ.

215
00:08:04,210 --> 00:08:06,700
તેથી લાંબા વાર્તા ટૂંકી,
હેક્સાડેસિમલ ફક્ત કરે છે

216
00:08:06,700 --> 00:08:11,990
ઉપયોગી હોઈ દરેક તેના
એ, એફ દ્વારા શૂન્ય સંપૂર્ણપણે રેખાઓ

217
00:08:11,990 --> 00:08:13,880
ચાર બીટ્સ એક પેટર્ન સાથે.

218
00:08:13,880 --> 00:08:18,080
>> તમે બે હેક્સાડેસિમલ અંકો છે તેથી જો,
શૂન્ય ફરીથી અને ફરીથી એફ, દ્વારા,

219
00:08:18,080 --> 00:08:20,256
કે સંપૂર્ણપણે તમે આપે છે
આઠ બિટ્સ અથવા એક બાઇટ.

220
00:08:20,256 --> 00:08:22,380
તે કરે છે તેથી કે શા માટે છે
પરંપરાગત ઉપયોગી છે.

221
00:08:22,380 --> 00:08:24,990
કોઈ બૌદ્ધિક છે
ખરેખર બહાર સામગ્રી,

222
00:08:24,990 --> 00:08:27,010
તેના વાસ્તવિક ઉપયોગીતા કરતાં અન્ય.

223
00:08:27,010 --> 00:08:29,310
>> હવે JPEGs માત્ર નથી
ગ્રાફિક્સ માટે બંધારણો ફાઈલ.

224
00:08:29,310 --> 00:08:33,230
તમે ત્યાં છે કે યાદ શકે છે
વિશ્વમાં આ જેમ ફાઇલો,

225
00:08:33,230 --> 00:08:34,830
ઓછામાં ઓછા પાછા થોડા વર્ષો થી.

226
00:08:34,830 --> 00:08:37,580
>> તેથી આ ખરેખર હતી
વિન્ડોઝ XP સ્થાપિત

227
00:08:37,580 --> 00:08:39,960
વિશ્વભરમાં પીસી લાખો પર.

228
00:08:39,960 --> 00:08:43,000
અને આ એક બીટમેપ ફાઇલ, બીએમપી હતી.

229
00:08:43,000 --> 00:08:47,690
અને એક બીટમેપ ફાઇલ, તમે આગામી જોશો
સપ્તાહ, માત્ર બિંદુઓ એક પેટર્ન અર્થ થાય છે,

230
00:08:47,690 --> 00:08:51,710
તેઓ કહેવાય કરી રહ્યાં છો કારણ કે પિક્સેલ્સ,
ખરેખર, બીટ્સ પર નકશો.

231
00:08:51,710 --> 00:08:55,160
>> તેથી શું છતાં રસપ્રદ છે,
આ ફાઇલ ફોર્મેટ, BMP વિશે છે

232
00:08:55,160 --> 00:08:58,590
કે હૂડ નીચે, તે
માત્ર ત્રણ બાઇટ્સ કરતાં વધુ છે

233
00:08:58,590 --> 00:09:01,020
, કે જેથી તેના હેડર કંપોઝ
, પ્રથમ થોડા કરડવાથી વાત કરવા માટે.

234
00:09:01,020 --> 00:09:03,330
તે ખરેખર થોડી લાગે છે
પ્રથમ નજરમાં જટિલ.

235
00:09:03,330 --> 00:09:04,704
અને તમે પી સમૂહ આ જોશો.

236
00:09:04,704 --> 00:09:06,810
અને કંઈક મેળવવામાં
આ ખાસ બહાર હવે

237
00:09:06,810 --> 00:09:10,720
માત્ર એ હકીકત છે, જેથી મહત્વપૂર્ણ નથી
કે દરેક બીટમેપ શરૂઆતમાં

238
00:09:10,720 --> 00:09:13,823
ફાઇલ, ગ્રાફિકલ બંધારણ,
નંબરો સંપૂર્ણ જથ્થો છે.

239
00:09:13,823 --> 00:09:14,980

240
00:09:14,980 --> 00:09:16,720
>> હવે માઈક્રોસોફ્ટ, આ
આ બંધારણમાં લેખક,

241
00:09:16,720 --> 00:09:18,820
તે કહી શકે છે
વસ્તુઓ નથી ints અને અક્ષરો

242
00:09:18,820 --> 00:09:22,259
અને ફ્લોટ્સ પણ શબ્દો અને ડી
શબ્દો અને લોન્ગ્સ અને બાઇટ્સ.

243
00:09:22,259 --> 00:09:23,800
તેથી તેઓ માત્ર અલગ ડેટા પ્રકારો છો.

244
00:09:23,800 --> 00:09:25,170
તેઓ અલગ અલગ નામો છો
આ જ વાત માટે.

245
00:09:25,170 --> 00:09:26,740
પરંતુ તમે પી સેટ ચાર અંક કે જોશો.

246
00:09:26,740 --> 00:09:31,450
>> પરંતુ આ કહે છે માત્ર છે કે માનવ જો
પર કેટલાક .BMP ફાઈલ ડબલ ક્લિક કરે તેના

247
00:09:31,450 --> 00:09:35,015
અથવા તેણીના હાર્ડ ડ્રાઈવ, અને વિન્ડો ખોલે છે
તેને અથવા તેણીને કે છબી દર્શાવે છે,

248
00:09:35,015 --> 00:09:38,500
કે ઓપરેટિંગ કારણ કે થયું
સિસ્ટમ કદાચ માત્ર જણાયું

249
00:09:38,500 --> 00:09:41,460
આ .BMP ફાઇલ એક્સ્ટેંશન
ફાઇલ નામ,

250
00:09:41,460 --> 00:09:45,010
પણ હકીકત એ છે કે કેટલાક
બીટ્સ પેટર્ન માટે સંમેલન

251
00:09:45,010 --> 00:09:47,490
ખૂબ શરૂઆતમાં
કે બીટમેપ ફાઈલની.

252
00:09:47,490 --> 00:09:50,270
>> પરંતુ હવે પર ધ્યાન કેન્દ્રિત દો
આવા જટિલ ફાઇલ,

253
00:09:50,270 --> 00:09:52,120
પરંતુ તેના બદલે આ કંઈક છે.

254
00:09:52,120 --> 00:09:55,190
હું gedit અહીં ધારો
માત્ર શરૂઆત છે

255
00:09:55,190 --> 00:09:57,070
ખૂબ સરળ છે કે જે કાર્યક્રમ.

256
00:09:57,070 --> 00:09:58,860
હું કેટલાક ઉપર સમાવેશ થાય છે મળી છે.

257
00:09:58,860 --> 00:10:02,120
હવે હું મળી છે # સમાવેશ થાય છે "structs.h" પરંતુ
હું એક ક્ષણ પાછા કે આવવું પડશે.

258
00:10:02,120 --> 00:10:03,974
પરંતુ હવે માટે ઉપયોગી છે.

259
00:10:03,974 --> 00:10:05,890
તેથી આ એક કાર્યક્રમ છે
કે અમલ કરવા માટે ચાલી રહ્યું છે

260
00:10:05,890 --> 00:10:07,335
રજિસ્ટ્રાર ડેટાબેઝ જેવા હોય છે.

261
00:10:07,335 --> 00:10:09,710
તેથી વિદ્યાર્થીઓને ડેટાબેઝ,
અને વિશ્વમાં દરેક વિદ્યાર્થી

262
00:10:09,710 --> 00:10:13,190
કદાચ કેટલાક એક નામ અને એક ઘર અને છે
અન્ય સામગ્રી, પરંતુ અમે તે સરળ રાખવા પડશે.

263
00:10:13,190 --> 00:10:15,140
દરેક વિદ્યાર્થી એક નામ અને એક ઘર છે.

264
00:10:15,140 --> 00:10:17,700
>> હું લખવા માગતા હતા તેથી જો
જેની હેતુ જીવનમાં કાર્યક્રમ

265
00:10:17,700 --> 00:10:19,860
માત્ર થી ફરી વળવું હતી
ત્રણ સુધી પર શૂન્ય,

266
00:10:19,860 --> 00:10:22,070
ત્રણ વિદ્યાર્થીઓ હોય તો
હાર્વર્ડ યુનિવર્સિટી ખાતે.

267
00:10:22,070 --> 00:10:25,350
અને હું માત્ર GetString ઉપયોગ મેળવવા માંગો છો,
દરેક વિદ્યાર્થી નામ અને ઘર,

268
00:10:25,350 --> 00:10:26,600
અને પછી માત્ર તે છાપે.

269
00:10:26,600 --> 00:10:28,630
>> આ પ્રકારના અઠવાડિયું જેવી છે
એક, અઠવાડિયું બે સામગ્રી હવે,

270
00:10:28,630 --> 00:10:30,810
હું માત્ર માટે એક માંગો છો જ્યાં
લૂપ અથવા તે કંઈક.

271
00:10:30,810 --> 00:10:34,500
અને હું GetString થોડા કૉલ કરવા માંગો છો
વખત, અને પછી થોડા વખત એફ છાપો.

272
00:10:34,500 --> 00:10:37,340
તેથી હું છતાં, આ કરવા શકે છે કેવી રીતે,
જ્યારે એક નામ અને એક ઘર બંને

273
00:10:37,340 --> 00:10:39,070
દરેક વિદ્યાર્થી માટે સામેલ છે?

274
00:10:39,070 --> 00:10:42,830
>> તેથી મારી પ્રથમ વૃત્તિ કદાચ
આ કંઈક કરવું છે.

275
00:10:42,830 --> 00:10:49,620
હું પ્રથમ તો સાથે સાથે, મને આપે છે, કહે છે,
, નામો કહેવાય શબ્દમાળાઓ ઝાકઝમાળ છે.

276
00:10:49,620 --> 00:10:51,530
અને હું એક hardcode ત્રણ અહીં નથી માંગતા.

277
00:10:51,530 --> 00:10:53,064
શું હું ત્યાં મૂકી કરવા માંગો છો?

278
00:10:53,064 --> 00:10:55,730
કે જે હમણાં જ કારણ કે, વિદ્યાર્થીઓ તેથી
ટોચ પર જાહેર સતત,

279
00:10:55,730 --> 00:10:57,860
હું hardcode નથી જ
ઘણા સ્થળોએ ત્રણ.

280
00:10:57,860 --> 00:11:00,859
આ રીતે, હું તે એક જ જગ્યાએ બદલી શકો છો
અને તે દરેક જગ્યાએ ફેરફાર અસર કરે છે.

281
00:11:00,859 --> 00:11:04,470
અને પછી, હું કરી શકે
શબ્દમાળા વિદ્યાર્થીઓ ધરાવે છે.

282
00:11:04,470 --> 00:11:10,250
>> અને હવે, હું કંઈક કરી શકે છે
હું વિદ્યાર્થીઓ <;; માટે (હું = 0 પૂર્ણાંક હું ++.

283
00:11:10,250 --> 00:11:14,390
તેથી હું ઝડપી લખીને છું, પરંતુ આ છે
હવે કદાચ પરિચિત વાક્યરચના.

284
00:11:14,390 --> 00:11:17,030
>> અને હવે, આ વધુ તાજેતરના હતી.

285
00:11:17,030 --> 00:11:22,890
હું હું મી મૂકી કરવા માંગો છો,
વિદ્યાર્થી નામ, હું આ કરવા લાગે છે.

286
00:11:22,890 --> 00:11:26,480
અને પછી, નથી નામો
પરંતુ ઘરો હું કૌંસ.

287
00:11:26,480 --> 00:11:29,930
હું આ, GetString કરવા માટે, અને દો
મને પાછા જાઓ અને આ વાક્ય નક્કી કરે છે.

288
00:11:29,930 --> 00:11:30,430
સંમતિ?

289
00:11:30,430 --> 00:11:31,200
નાસંમત?

290
00:11:31,200 --> 00:11:32,366
તે ખૂબ જ વપરાશકર્તા મૈત્રીપૂર્ણ છે.

291
00:11:32,366 --> 00:11:33,890
હું શું કરવું તે વપરાશકર્તા કહ્યું નથી.

292
00:11:33,890 --> 00:11:36,520
>> પરંતુ હવે, હું તો પણ
પછી, ચાલો માગતા હતા

293
00:11:36,520 --> 00:11:40,060
જેમ કે, આ વસ્તુઓ છાપી
બહાર તેથી TODO પછી.

294
00:11:40,060 --> 00:11:42,330
હું વધુ સાથે કરવા જઇ રહ્યો છું
હોવાની દલીલ છે આ this--

295
00:11:42,330 --> 00:11:45,970
એક યોગ્ય અમલીકરણ
નામો અને ઘરો, ત્રણ મેળવવામાં

296
00:11:45,970 --> 00:11:48,870
વપરાશકર્તા માંથી દરેક તેમને કુલ.

297
00:11:48,870 --> 00:11:51,280
>> પરંતુ આ ખૂબ જ સારી ડિઝાઇન, અધિકાર નથી?

298
00:11:51,280 --> 00:11:55,220
શું એક વિદ્યાર્થી માત્ર એક નામ ધરાવે છે
અને એક ઘર છે, પણ એક ID નંબર,

299
00:11:55,220 --> 00:11:57,770
અને એક ટેલિફોન નંબર,
અને એક ઇમેઇલ સરનામું,

300
00:11:57,770 --> 00:12:00,280
અને કદાચ ઘર પાનું, અને
કદાચ એક પક્ષીએ હેન્ડલ,

301
00:12:00,280 --> 00:12:03,730
અને અન્ય વિગતો કોઈપણ સંખ્યાની
એક વિદ્યાર્થી અથવા એક વ્યક્તિ સાથે સંકળાયેલ છે,

302
00:12:03,730 --> 00:12:04,610
વધુ સામાન્ય રીતે.

303
00:12:04,610 --> 00:12:07,720
અમે ઉમેરવા માટે શરૂ થશે કેવી રીતે
આ કાર્યક્રમ માટે વિધેય?

304
00:12:07,720 --> 00:12:14,080
>> ઠીક છે, હું કદાચ સરળ માર્ગ જેવી લાગે છે
, કંઈક કરી ચાલો કહે છે હોય છે,

305
00:12:14,080 --> 00:12:16,490
IDs વિદ્યાર્થીઓ ઈન્.

306
00:12:16,490 --> 00:12:18,380
તેથી હું ત્યાં તેમની તમામ ID ને મૂકી શકો છો.

307
00:12:18,380 --> 00:12:22,240
અને પછી, કંઈક માટે
ફોન નંબરો, જેમ કે

308
00:12:22,240 --> 00:12:24,400
હું કેવી રીતે ખાતરી નથી
હજુ સુધી કે પ્રતિનિધિત્વ કરે છે.

309
00:12:24,400 --> 00:12:30,280
તેથી આપણે આગળ અને માત્ર કોલ જાઓ
આ વિદ્યાર્થીઓ, Twitters જે

310
00:12:30,280 --> 00:12:33,550
થોડી વિચિત્ર છે, પરંતુ છે
અને ક્ષેત્રો સમૂહ વધુ.

311
00:12:33,550 --> 00:12:36,360
>> હું અસરકારક રીતે કરવા માટે શરૂ કર્યું છે
નકલ અને અહીં પેસ્ટ કરો.

312
00:12:36,360 --> 00:12:39,416
અને આ ખૂબ વધવા રહ્યું છે
ખૂબ ઝડપથી અતિભારે, અધિકાર?

313
00:12:39,416 --> 00:12:42,290
ત્યાં તો તે સરસ નહિં હોય
વિશ્વમાં એ માહિતી બંધારણ જાણીતા

314
00:12:42,290 --> 00:12:45,600
નથી પૂર્ણાંક અથવા સ્ટ્રિંગ છે, પરંતુ કંઈક તરીકે
ઉચ્ચ સ્તર, એક તાત્વિક, તેથી

315
00:12:45,600 --> 00:12:47,570
એક વિદ્યાર્થી તરીકે ઓળખાય છે, વાત કરવા માટે?

316
00:12:47,570 --> 00:12:50,220
સી આંતરિક સાથે આવી હતી
વિદ્યાર્થીઓ માટે વિધેય,

317
00:12:50,220 --> 00:12:52,260
પરંતુ હું તે જેમ આપવા માગે તો શું?

318
00:12:52,260 --> 00:12:55,640
>> ઠીક છે, તે હું જાઉં છું, બહાર વળે
, structs.h અહીં તરીકે ઓળખાતી ફાઈલ ખોલવા

319
00:12:55,640 --> 00:12:57,090
અને તમે બરાબર કરી શકો છો.

320
00:12:57,090 --> 00:12:58,290
અને અમે હવે આ કરી શરૂ રહ્યા છીએ.

321
00:12:58,290 --> 00:13:01,490
અને પી સેટ ત્રણ હૂડ નીચે,
જો તમે પહેલાથી જ હવે આ કરી રહ્યો છું.

322
00:13:01,490 --> 00:13:05,920
એક ગ્રામ RECT તરીકે આવી કોઈ વસ્તુ છે કે
પ્રોગ્રામીંગ ભાષા સી એક ત અંડાકાર

323
00:13:05,920 --> 00:13:10,570
>> સ્ટેનફોર્ડ ખાતે લોકો તે અમલમાં
અહીં આ અભિગમ ઉપયોગ કરીને ડેટા પ્રકારો,

324
00:13:10,570 --> 00:13:13,900
પોતાના નવી માહિતી જાહેર
નવી કીવર્ડ ઉપયોગ પ્રકારો

325
00:13:13,900 --> 00:13:16,744
કહેવાય સ્ટ્રક્ટ અને અન્ય
એક કહેવાય typedef.

326
00:13:16,744 --> 00:13:19,660
અને ખરેખર, છતાં પણ સિન્ટેક્ષ
સામગ્રી પાસેથી થોડી અલગ લાગે છે

327
00:13:19,660 --> 00:13:23,550
અમે પહેલા જોઇ છે
સિદ્ધાંત, તે સુપર સરળ છે.

328
00:13:23,550 --> 00:13:25,297
>> આ માત્ર "એક પ્રકાર વ્યાખ્યાયિત કરે છે." અર્થ એ થાય

329
00:13:25,297 --> 00:13:27,255
તે એક જ હશે
માળખું, અને એક માળખું

330
00:13:27,255 --> 00:13:29,400
માત્ર એક કન્ટેનર જેવી છે
ઘણી વસ્તુઓ માટે.

331
00:13:29,400 --> 00:13:31,780
અને તે માળખું રહ્યું છે
નામ કહેવાય શબ્દમાળા હોય,

332
00:13:31,780 --> 00:13:33,210
અને શબ્દમાળા ઘર કહેવાય છે.

333
00:13:33,210 --> 00:13:37,520
અને આપણે માત્ર સગવડ માટે, કૉલ કરો,
આ સમગ્ર માહિતી બંધારણ વિદ્યાર્થી.

334
00:13:37,520 --> 00:13:40,320
>> તેથી આ ક્ષણે તમે વિચાર
અર્ધવિરામ, તમે હવે છે

335
00:13:40,320 --> 00:13:43,280
તમારા પોતાના ડેટા બનાવવામાં
પ્રકાર કહેવાય વિદ્યાર્થી

336
00:13:43,280 --> 00:13:46,420
કે હવે, પૂર્ણાંક સાથે રહે છે
અને ફ્લોટ, અને કોલસો બનાવો, અને શબ્દમાળા

337
00:13:46,420 --> 00:13:50,270
અને જી RECT, અને જી અંડાકાર, અને કોઈપણ નંબર
અન્ય વસ્તુઓ લોકો શોધ છે.

338
00:13:50,270 --> 00:13:53,340
>> તેથી આ વિશે ઉપયોગી છે
હવે હું પાછા જાઓ છે

339
00:13:53,340 --> 00:13:57,430
0 સ્ટ્રક્ટ અને આ સમાપ્ત
મેં લખ્યું જે અમલીકરણ,

340
00:13:57,430 --> 00:14:02,080
અહીં અગાઉથી, બધા નોંધ્યું છે કે
અનિવાર્ય messiness કે

341
00:14:02,080 --> 00:14:05,490
હું ઉમેરવામાં તરીકે થઈ રહ્યું શરૂ અંગે હતું
ફોન નંબરો અને Twitters અને બધા

342
00:14:05,490 --> 00:14:07,370
આ અન્ય વસ્તુઓ
એક વિદ્યાર્થી વ્યાખ્યા,

343
00:14:07,370 --> 00:14:11,810
હવે તે સંક્ષિપ્તમાં આવરિત છે
વિદ્યાર્થીઓને માત્ર એક એરે તરીકે.

344
00:14:11,810 --> 00:14:15,500
>> અને તે વિદ્યાર્થીઓને દરેક હવે
તે અંદર ઘણી વસ્તુઓ છે.

345
00:14:15,500 --> 00:14:16,930
જેથી માત્ર એક પ્રશ્ન નહીં.

346
00:14:16,930 --> 00:14:19,700
તમે કેવી રીતે નામ પર વિચાર છે,
અને ઘર, અને ID ને,

347
00:14:19,700 --> 00:14:21,640
અને બીજું ગમે છે
વિદ્યાર્થી ની અંદર?

348
00:14:21,640 --> 00:14:22,930
સુપર સરળ છે, એ જ.

349
00:14:22,930 --> 00:14:25,730
ન્યૂ વાક્યરચના છે, પરંતુ એક સરળ વિચાર.

350
00:14:25,730 --> 00:14:29,239
>> એરે માં તમે સરળતાથી અનુક્રમણિકા,
અમે છેલ્લા અઠવાડિયે અને આ હતી.

351
00:14:29,239 --> 00:14:31,030
અને શું સ્પષ્ટ છે
વાક્યરચના નવા ભાગ?

352
00:14:31,030 --> 00:14:32,590

353
00:14:32,590 --> 00:14:35,880
જસ્ટ., જેનો અર્થ થાય છે "અંદર જાઓ
માળખું અને આ ક્ષેત્રમાં કહેવાય મળી

354
00:14:35,880 --> 00:14:39,030
નામ, ઘર કહેવાય ક્ષેત્ર વિચાર
વિદ્યાર્થી કહેવાય ક્ષેત્ર છે. "

355
00:14:39,030 --> 00:14:41,940
>> તેથી પી સેટ ત્રણ, તમે છો
હજી પણ તે પર કામ,

356
00:14:41,940 --> 00:14:44,020
હજુ પણ છે અને મોટા ભાગના લોકો
, તમે ખ્યાલ છે કે છે

357
00:14:44,020 --> 00:14:46,130
જેવી વસ્તુઓ ઉપયોગ શરૂ
જી rects અને જી ovals

358
00:14:46,130 --> 00:14:50,201
અને અન્ય વસ્તુઓ તેમ લાગતું નથી કે
અઠવાડિયું ઝીરો, એક, અથવા બે માંથી આવે છે,

359
00:14:50,201 --> 00:14:52,950
કે સ્ટેનફોર્ડ કારણ કે ખ્યાલ
અમુક નવા ડેટા પ્રકારો જાહેર કર્યો.

360
00:14:52,950 --> 00:14:56,160
>> અને ખરેખર, કે બરાબર શું અમે પડશે
પી સેટ ચાર અંક માં, સાથે સાથે, કરવા માટે, જ્યારે

361
00:14:56,160 --> 00:14:59,880
અમે વસ્તુઓ સાથે વ્યવહાર શરૂ
છબીઓ, ત્યાર બાદ બીટમેપ, અને વધુ ગમે છે.

362
00:14:59,880 --> 00:15:02,882
જેથી માત્ર એક સતામણી કરનાર અને એક છે
આવે છે તે માટે માનસિક મોડલ.

363
00:15:02,882 --> 00:15:04,590
હવે, હું procrastinated
થોડી આ સવારે.

364
00:15:04,590 --> 00:15:09,560
હું તે જોવા માટે પ્રકારની વિચિત્ર હતી
માઇક્રોસોફ્ટ વોલપેપર ખરેખર

365
00:15:09,560 --> 00:15:10,310
આજે જેવો દેખાય છે.

366
00:15:10,310 --> 00:15:15,200
અને તે 2006 માં કોઈને બહાર વળે
ખરેખર લગભગ ચોક્કસપણે ગયા

367
00:15:15,200 --> 00:15:19,210
તે જ હાજર વાસ્તવમાં ફોટોગ્રાફ
શું આ દિવસોમાં કે જેવો દેખાય છે.

368
00:15:19,210 --> 00:15:21,380
આ ક્ષેત્ર હવે થોડી overgrown છે.

369
00:15:21,380 --> 00:15:24,850
>> તેથી છબીઓ હવે કહીએ તો,
અહીં Daven પાછા લાવવા દો

370
00:15:24,850 --> 00:15:26,890
સ્ક્રીન અને નિકોલસ પર,
અને માત્ર તમે યાદ

371
00:15:26,890 --> 00:15:30,540
કે તમે લંચ માટે અમને જોડાવા માંગો છો, તો
અમારા સામાન્ય URL પર આ શુક્રવાર, હેડ

372
00:15:30,540 --> 00:15:31,440
અહીં.

373
00:15:31,440 --> 00:15:33,530
>> તેથી જ્યાં અમે સોમવારે છોડી હતી?

374
00:15:33,530 --> 00:15:35,140
અમે અધિકાર છે, આ સમસ્યા રજૂ?

375
00:15:35,140 --> 00:15:37,610
આ મોટે ભાગે એક સાચો હતો
સ્વેપ અમલીકરણ,

376
00:15:37,610 --> 00:15:40,460
જેમાં તમે બે ints લેવા
એક, બી કહેવાય છે, એક કહેવાય

377
00:15:40,460 --> 00:15:44,130
લૌરા અહીં કર્યું, જેમ તેમને સ્વેપ
દૂધ અને પાણી સાથે સ્ટેજ પર,

378
00:15:44,130 --> 00:15:46,820
કામચલાઉ ઉપયોગ કરીને
ચલ, અથવા ખાલી કપ,

379
00:15:46,820 --> 00:15:50,540
અમે એક અને એક માં બી મૂકી શકે છે, જેથી
વસ્તુઓ એક વાસણ કર્યા વિના બી.

380
00:15:50,540 --> 00:15:51,560
અમે એક ચલ ઉપયોગ થાય છે.

381
00:15:51,560 --> 00:15:52,870
તે કામચલાઉ નોકર કહેવાય છે.

382
00:15:52,870 --> 00:15:55,520
>> પરંતુ મૂળભૂત શું હતું
સોમવારે આ કોડ સાથે સમસ્યા?

383
00:15:55,520 --> 00:15:57,700

384
00:15:57,700 --> 00:15:58,870
અહીં સમસ્યા શું હતું?

385
00:15:58,870 --> 00:16:00,106

386
00:16:00,106 --> 00:16:00,605
અરે વાહ.

387
00:16:00,605 --> 00:16:01,970
>> પ્રેક્ષક: તે વધુ જગ્યા લે છે.

388
00:16:01,970 --> 00:16:04,719
>> ડેવિડ જે MALAN: વધુ લે છે
જગ્યા, હું એક ચલ ઉપયોગ કરું છું, કારણ કે,

389
00:16:04,719 --> 00:16:05,400
અને તે બરાબર છે.

390
00:16:05,400 --> 00:16:07,300
કે સાચું છે, પણ હું છું
કે ઠીક છે કહેવું જાઉં.

391
00:16:07,300 --> 00:16:10,030
તે ભવ્ય માં માત્ર 32 બિટ્સ છે
વસ્તુઓ યોજના, તેથી નથી એક મોટી સોદો.

392
00:16:10,030 --> 00:16:10,655
અન્ય વિચારો?

393
00:16:10,655 --> 00:16:12,572
પ્રેક્ષક: તે માત્ર અદલબદલ
સ્થાનિક ચલો.

394
00:16:12,572 --> 00:16:13,571
ડેવિડ જે MALAN: ચોક્કસ.

395
00:16:13,571 --> 00:16:15,090
તે માત્ર ત્યારે જ સ્થાનિક ચલો અદલબદલ.

396
00:16:15,090 --> 00:16:18,173
કોઈપણ સમયે તમે એક કાર્ય કૉલ કારણ કે
હું Annenberg ના ટ્રે હતી જ્યારે

397
00:16:18,173 --> 00:16:19,840
છેલ્લા સમય, તમે તળિયે મુખ્ય છે.

398
00:16:19,840 --> 00:16:23,560
જલદી તમે કહેવાય કાર્ય કૉલ તરીકે
સ્વેપ, સ્વેપ એક્સ અને વાય ન મળી નથી,

399
00:16:23,560 --> 00:16:24,400
મૂળ કિંમતો.

400
00:16:24,400 --> 00:16:26,392
અમે શું દાવો હતી, સ્વેપ વિચાર કરે છે?

401
00:16:26,392 --> 00:16:27,100
પ્રેક્ષક: નકલો.

402
00:16:27,100 --> 00:16:28,090
ડેવિડ જે MALAN: તેમને નકલો તેથી.

403
00:16:28,090 --> 00:16:31,120
તેથી તે તમે છો, એક અને બે નહીં
છેલ્લા સમય ના ઉદાહરણ યાદ,

404
00:16:31,120 --> 00:16:34,730
પરંતુ એક અને બે એક નકલ
કે સફળતાપૂર્વક સ્વૅપ છે.

405
00:16:34,730 --> 00:16:38,550
પરંતુ કમનસીબે અંતે,
તે કિંમતો હજુ પણ એ જ છે.

406
00:16:38,550 --> 00:16:41,880
તેથી અમે સાથે આ જોઈ શકો છો અમારા
નવો મિત્ર, આસ્થાપૂર્વક GDB,

407
00:16:41,880 --> 00:16:45,180
તમે અથવા TFs અને Ca માતાનો હોય છે
નીચે પ્રમાણે તરફ તમે માર્ગદર્શક કરવામાં.

408
00:16:45,180 --> 00:16:51,210
>> તેથી કોઈ સ્વેપ રિકોલ ચાલો જેમ દેખાય છે
આ જેમ this-- દેખાવ ખોલો.

409
00:16:51,210 --> 00:16:54,160
અમે બે, એક વાય એક્સ આરંભ.

410
00:16:54,160 --> 00:16:55,620
પ્રિન્ટ એફ માતાનો એક ટોળું હતી.

411
00:16:55,620 --> 00:16:58,080
પરંતુ તે પછી, કી કૉલ
અહીં, સ્વેપ હતી

412
00:16:58,080 --> 00:17:00,260
બરાબર કોડ અમે છે
માત્ર એક ક્ષણ પહેલા થયો છે.

413
00:17:00,260 --> 00:17:03,180
જે પ્રથમ સાચું છે
નજરમાં, પરંતુ વિધેયાત્મક રીતે,

414
00:17:03,180 --> 00:17:06,800
આ કાર્યક્રમ છે, કારણ કે કામ કરતું નથી
તે કાયમ માટે એક્સ અને વાય સ્વેપ નથી.

415
00:17:06,800 --> 00:17:10,190
>> તેથી, ઝડપી ગરમ ચાલો આ જુઓ
અહીં GDB, એક ./noswap સાથે.

416
00:17:10,190 --> 00:17:11,867

417
00:17:11,867 --> 00:17:15,200
જબરજસ્ત માહિતી એક ટોળું કે
હું હવે નિયંત્રણ એલ સાથે છુટકારો મળશે.

418
00:17:15,200 --> 00:17:17,516
અને હવે, હું જાઉં છું
આગળ વધો અને તે ચાલે છે.

419
00:17:17,516 --> 00:17:19,349
અને કમનસીબે, કે
કે ઉપયોગી ન હતી.

420
00:17:19,349 --> 00:17:22,355
આ અંદર કાર્યક્રમ ચાલી હતી
કાર્યક્રમ, GDB, એક ડીબગર કહેવાય

421
00:17:22,355 --> 00:17:23,730
પરંતુ તે મને આસપાસ થેલી, કોથળી દો ન હતી.

422
00:17:23,730 --> 00:17:26,229
>> તેથી હું ખરેખર વિરામ કરી શકો છો કેવી રીતે
આ કાર્યક્રમ અંદર અમલ?

423
00:17:26,229 --> 00:17:27,410

424
00:17:27,410 --> 00:17:28,329
તેથી તૂટી જાય છે.

425
00:17:28,329 --> 00:17:32,340
અને હું કોઇ પર તોડી શકે
વાક્ય નંબર, એક, 10, 15.

426
00:17:32,340 --> 00:17:35,530
પરંતુ હું પણ પ્રતીકાત્મક તોડી શકે છે
વિરામ મુખ્ય કહેતા.

427
00:17:35,530 --> 00:17:38,980
અને તે વિરામ સેટ બનશે
બિંદુ, દેખીતી રીતે મુખ્ય માં લીટી 16 પર.

428
00:17:38,980 --> 00:17:40,050
અને જ્યાં 16 લીટી છે?

429
00:17:40,050 --> 00:17:42,960
ચાલો કોડ માટે જાઓ
અને noswap સુધી જાઓ.

430
00:17:42,960 --> 00:17:46,930
અને ખરેખર, 16 લીટી છે
ખૂબ પ્રથમ કાર્યક્રમ.

431
00:17:46,930 --> 00:17:52,130
>> તેથી હવે, હું આગળ જાઓ અને પ્રકાર જો
આ સમય ચાલે દાખલ કરો, તે થોભાવવામાં.

432
00:17:52,130 --> 00:17:53,080
તેથી આપણે આસપાસ થેલી, કોથળી દો.

433
00:17:53,080 --> 00:17:55,716
શા માટે એક્સ શૂન્ય છે એક્સ છાપો?

434
00:17:55,716 --> 00:17:56,705

435
00:17:56,705 --> 00:17:57,830
અને ડોલર સાઇન અવગણો.

436
00:17:57,830 --> 00:17:59,725
તે પારખુ માટે માત્ર છે
કાર્યક્રમના વપરાશ.

437
00:17:59,725 --> 00:18:00,780

438
00:18:00,780 --> 00:18:03,140
શા માટે આ ક્ષણે એક્સ શૂન્ય છે?

439
00:18:03,140 --> 00:18:03,640
અરે વાહ.

440
00:18:03,640 --> 00:18:07,061
>> પ્રેક્ષક: તે અધિકાર પહેલાં થોભાવવામાં
16 લીટી નથી, ખરેખર 16 લીટી પર.

441
00:18:07,061 --> 00:18:08,060
ડેવિડ જે MALAN: ચોક્કસ.

442
00:18:08,060 --> 00:18:11,630
GDB, મૂળભૂત રીતે, થોભાવવામાં છે
માત્ર 16 લીટી પહેલાં અમલ.

443
00:18:11,630 --> 00:18:14,820
તેથી તે ચલાવવામાં નથી જે
કેટલાક અજ્ઞાત કિંમત છે એક્સ છે.

444
00:18:14,820 --> 00:18:17,150
અને અમે તે છે કે નસીબદાર મળી
શૂન્ય જેવા સ્વચ્છ કંઈક.

445
00:18:17,150 --> 00:18:20,310
તેથી હવે હું આગામી લખો છો,
હવે તે 16 ચલાવવામાં.

446
00:18:20,310 --> 00:18:22,000
મને 17 ચલાવવા માટે માટે રાહ જોઈ રહ્યું છે.

447
00:18:22,000 --> 00:18:23,400
મને આગળ અને પ્રિન્ટ એક્સ જાઓ.

448
00:18:23,400 --> 00:18:24,094
તે એક છે.

449
00:18:24,094 --> 00:18:25,260
મને આગળ અને પ્રિન્ટ વાય જાઓ.

450
00:18:25,260 --> 00:18:26,176
હવે હું શું જોવું જોઈએ?

451
00:18:26,176 --> 00:18:27,660

452
00:18:27,660 --> 00:18:28,560
>> AUDIENCE: [અશ્રાવ્ય]

453
00:18:28,560 --> 00:18:29,165
>> ડેવિડ જે MALAN: થોડું મોટેથી.

454
00:18:29,165 --> 00:18:30,040
>> AUDIENCE: [અશ્રાવ્ય]

455
00:18:30,040 --> 00:18:30,537

456
00:18:30,537 --> 00:18:32,120
ડેવિડ જે MALAN: જવાબ નથી ખૂબ સર્વસંમતિ.

457
00:18:32,120 --> 00:18:34,760
તેથી હા, અમે કેટલાક કચરો કિંમત જુઓ.

458
00:18:34,760 --> 00:18:37,862
હવે, વાય ત્યાં 134514064 છે.

459
00:18:37,862 --> 00:18:39,320
ઠીક છે, તે માત્ર કેટલાક કચરો કિંમત છે.

460
00:18:39,320 --> 00:18:41,350
મારા કાર્યક્રમ RAM વાપરે
વિવિધ હેતુઓ માટે.

461
00:18:41,350 --> 00:18:42,350
અન્ય કાર્યો છે.

462
00:18:42,350 --> 00:18:44,040
અન્ય લોકો મારા કમ્પ્યુટર અંદર લખ્યું હતું.

463
00:18:44,040 --> 00:18:46,789
તેથી તે બિટ્સ માટે ઉપયોગ કરવામાં આવે છે
અન્ય કિંમતો, અને હું શું જોઈ રહ્યો છું

464
00:18:46,789 --> 00:18:49,470
કેટલાક અવશેષો છે
કે મેમરી પહેલાં ઉપયોગ.

465
00:18:49,470 --> 00:18:53,350
>> તેથી કોઈ મોટો સોદો છે, કારણ કે જલદી
હું આગામી લખો અને પછી વાય પ્રિન્ટ તરીકે,

466
00:18:53,350 --> 00:18:55,640
તેને આરંભ છે
હું માંગો છો તે કિંમત.

467
00:18:55,640 --> 00:18:57,400
તેથી હવે, ચાલો થોડી ઝડપી આગળ જાઓ.

468
00:18:57,400 --> 00:18:58,540
આગામી માટે એન.

469
00:18:58,540 --> 00:18:59,570
માતાનો ફરીથી કરવા દો.

470
00:18:59,570 --> 00:19:00,530
માતાનો ફરીથી કરવા દો.

471
00:19:00,530 --> 00:19:02,404
પરંતુ હું હિટ નથી માંગતા
અહીં, કારણ કે હું તો

472
00:19:02,404 --> 00:19:05,110
અંદર થઈ રહ્યું છે તે જોવા માટે કરવા માંગો છો
સ્વેપ, આદેશ શું છે?

473
00:19:05,110 --> 00:19:05,520
>> પ્રેક્ષક: પગલાંઓ.

474
00:19:05,520 --> 00:19:06,436
>> ડેવિડ જે MALAN: પગલાંઓ.

475
00:19:06,436 --> 00:19:09,800
તેથી આ એક માં મને જાય
તેના બદલે તે ઉપર કરતાં કાર્ય,.

476
00:19:09,800 --> 00:19:12,270
અને હવે, તે થોડું છુપાયેલું છે
પ્રામાણિકપણે, પરંતુ આ માત્ર છે

477
00:19:12,270 --> 00:19:14,581
હવે હું રેખા 33 છું મને કહી.

478
00:19:14,581 --> 00:19:15,580
અને માતાનો ફરીથી આ કરવા દો.

479
00:19:15,580 --> 00:19:16,080
પ્રિંટ કામચલાઉ નોકર.

480
00:19:16,080 --> 00:19:17,129

481
00:19:17,129 --> 00:19:20,170
કચરો કિંમત, નકારાત્મક આ સમય,
પરંતુ તે માત્ર હજુ પણ કચરો કિંમત છે.

482
00:19:20,170 --> 00:19:22,810
તેથી આપણે આગળ, પ્રિન્ટ કામચલાઉ નોકર કરવા દો.

483
00:19:22,810 --> 00:19:27,130
તે 1 થી આરંભ છે, જે
એક ઉર્ફ x ની કિંમત હતી.

484
00:19:27,130 --> 00:19:29,110
>> હવે, જ્યાં અમારા એક છે અને આવતા એક્સ?

485
00:19:29,110 --> 00:19:32,510
ઠીક છે, અમે મુખ્ય માં નોટિસ
આ કિંમતો એક્સ અને વાય કહેવાય છે.

486
00:19:32,510 --> 00:19:34,740
અમે પછી નીચે પ્રમાણે તેમને સ્વેપ પસાર કર્યો હતો.

487
00:19:34,740 --> 00:19:37,010
એક્સ અલ્પવિરામ વાય, પ્રથમ આવ્યા હતા.

488
00:19:37,010 --> 00:19:40,020
અને પછી, સ્વેપ તેમને એક્સ અને વાય કહી શકે છે.

489
00:19:40,020 --> 00:19:42,630
પરંતુ ચોકસાઈ માટે, તે છે
એક બોલ્ડ અને તેમને કહે છે.

490
00:19:42,630 --> 00:19:45,970
પરંતુ a અને b હવે હશે આવે છે
અનુક્રમે એક્સ અને વાય, નકલો.

491
00:19:45,970 --> 00:19:50,660
>> હું કામચલાઉ નોકર પાછા GDB પર જાઓ તેથી જો
હવે એક છે અને એક હવે છે.

492
00:19:50,660 --> 00:19:56,130
હું હવે આગળ શું અને તો પણ પ્રિન્ટ કરી
એક, એક પહેલાથી જ ઉપર ખસેડવામાં આવ્યો છે.

493
00:19:56,130 --> 00:20:00,030
આ દૂધ ભૂતપૂર્વ ધસી આવ્યું છે
નારંગીનો રસ કાચ, અથવા ઊલટું.

494
00:20:00,030 --> 00:20:04,750
>> અને હવે હું આગામી ફરી કરવા માટે, અને જો
હું એક સેનીટી ચેક તરીકે છાપે છે,

495
00:20:04,750 --> 00:20:07,687
એક હજુ પણ બે છે, પરંતુ બોલ્ડ હવે છે.

496
00:20:07,687 --> 00:20:08,770
પ્રમાણિકપણે, તે હજુ પણ છે.

497
00:20:08,770 --> 00:20:10,670
હું શું કામચલાઉ નોકર પડી નથી.

498
00:20:10,670 --> 00:20:16,850
પરંતુ જલદી હું હવે લખો, ચાલો કહે
હવે હું અંતે છું, પાછા જાઓ ચાલુ રાખવા

499
00:20:16,850 --> 00:20:17,480
આ કાર્યક્રમ.

500
00:20:17,480 --> 00:20:20,730
અને કમનસીબે, એક્સ છે
હજુ પણ એક અને વાય હજુ બે છે.

501
00:20:20,730 --> 00:20:22,272
>> તેથી GDB ની ઉપયોગિતા શું હતું?

502
00:20:22,272 --> 00:20:23,980
તે મને ઠીક મદદ કરી શકી નહીં
સમસ્યા સે દીઠ,

503
00:20:23,980 --> 00:20:26,265
પરંતુ તે આસ્થાપૂર્વક મને મદદ
અનુભૂતિની દ્વારા સમજી

504
00:20:26,265 --> 00:20:30,000
કે હા, મારા તર્ક અધિકાર છે, પરંતુ
મારી કોડ આખરે કર્યા નથી

505
00:20:30,000 --> 00:20:31,450
કાયમી અસર.

506
00:20:31,450 --> 00:20:34,570
જેથી અમે છો એક સમસ્યા છે
હવે આજે ઉકેલવા માટે જઈ રહી છે.

507
00:20:34,570 --> 00:20:37,870
>> પરંતુ આ માર્ગ દ્વારા ત્યાં વિચાર કરીએ.

508
00:20:37,870 --> 00:20:39,230
શબ્દમાળા એક જૂઠાણું છે.

509
00:20:39,230 --> 00:20:41,860
તે, પણ, એક માહિતી પ્રકાર
આ તે છે સી માં અસ્તિત્વમાં છે

510
00:20:41,860 --> 00:20:44,750
કેટલાક માટે સમાનાર્થી આવી
કંઈક બીજું માટે સમય,

511
00:20:44,750 --> 00:20:47,300
અને અમે નીચે જણાવે છે કે કરી શકો છો.

512
00:20:47,300 --> 00:20:53,282
>> મને આગળ વધો અને ખોલો
એક કાર્યક્રમ તુલના-0 કહેવાય.

513
00:20:53,282 --> 00:20:56,240
અને આ એક બહાર લખો બદલે,
અમે કોડ લઈ જવામાં શરૂ કરી શકશો

514
00:20:56,240 --> 00:20:58,040
મને પહેલેથી જ લખ્યું હતું, પરંતુ
તે માત્ર થોડા રેખાઓ છે.

515
00:20:58,040 --> 00:20:59,570
તેથી આ સરખામણી-0 છે.

516
00:20:59,570 --> 00:21:02,380
અને પ્રથમ વસ્તુ હું કરી રહ્યો છું
લખાણ એક વાક્ય રહ્યો છે.

517
00:21:02,380 --> 00:21:05,610
>> પરંતુ હું છું શું નોટિસ
પ્રથમ વખત કરી.

518
00:21:05,610 --> 00:21:07,910
શું સ્પષ્ટ રીતે 21 લીટી વિશે અલગ છે?

519
00:21:07,910 --> 00:21:10,020

520
00:21:10,020 --> 00:21:11,402
ખરેખર, એક મિનિટ રાહ જુઓ.

521
00:21:11,402 --> 00:21:12,110
આ નકલ બે છે.

522
00:21:12,110 --> 00:21:13,568
તે પણ યોગ્ય કાર્યક્રમ નથી.

523
00:21:13,568 --> 00:21:14,780
બધા હક છે, સ્પોઇલર ચેતવણી.

524
00:21:14,780 --> 00:21:16,890
બધા હક છે, તેથી કે વાંધો નથી.

525
00:21:16,890 --> 00:21:18,520
તે ભવિષ્યના પ્રશ્નનો જવાબ છે.

526
00:21:18,520 --> 00:21:21,450
>> અહીં-0 સરખાવવા માટે, અને હું છું છે
લખાણ એક વાક્ય વિચાર વિશે.

527
00:21:21,450 --> 00:21:22,435
કાર્યક્રમ માતાનો ખૂબ જ સરળ.

528
00:21:22,435 --> 00:21:23,560
તેથી આ સરળ છે.

529
00:21:23,560 --> 00:21:28,070
આ અઠવાડિયાના એક, અઠવાડિયું બે સામગ્રી જેવી છે
આ ક્ષણે. શબ્દમાળા ઓ = GetString.

530
00:21:28,070 --> 00:21:29,700
હવે, હું નીચે અહીં ફરીથી છે.

531
00:21:29,700 --> 00:21:31,830
શબ્દમાળા ટી = GetString.

532
00:21:31,830 --> 00:21:35,300
આ અને પછી, છેલ્લા વસ્તુ
કાર્યક્રમ, તેનું નામ સૂચવે છે,

533
00:21:35,300 --> 00:21:37,090
હું તેમને સરખાવવા માટે પ્રયાસ જાઉં છું છે.

534
00:21:37,090 --> 00:21:40,709
>> તેથી ઓ તો, પ્રથમ શબ્દમાળા,
= ટી, પછી હું છું બરાબર

535
00:21:40,709 --> 00:21:42,250
તમે આ જ વાત લખો કહેવા જાઉં.

536
00:21:42,250 --> 00:21:44,291
બાકી, હું કહેવા જાઉં છું
તમે અલગ વસ્તુઓ લખો.

537
00:21:44,291 --> 00:21:45,880
તેથી આપણે કમ્પાઇલ અને આ કાર્યક્રમ ચલાવો.

538
00:21:45,880 --> 00:21:48,481
તેથી શૂન્ય તુલના કરો.

539
00:21:48,481 --> 00:21:48,980
સારી લાગે છે.

540
00:21:48,980 --> 00:21:50,490
કોઈ સંકલન ભૂલો.

541
00:21:50,490 --> 00:21:52,386
>> મને આગળ હવે જાઓ
અને ./compare-0 લખો.

542
00:21:52,386 --> 00:21:55,230

543
00:21:55,230 --> 00:21:59,220
મને આગળ વધો અને કંઈક કહો
: Daven અને કંઈક: રોબ.

544
00:21:59,220 --> 00:22:00,450
અને હું અલગ વસ્તુઓ લખો.

545
00:22:00,450 --> 00:22:01,250
અત્યાર સુધી, જેથી સારા.

546
00:22:01,250 --> 00:22:02,680
કાર્યક્રમ યોગ્ય હોય તેમ લાગે છે.

547
00:22:02,680 --> 00:22:03,880
>> પરંતુ તેને ફરીથી ચલાવો.

548
00:22:03,880 --> 00:22:05,800
કંઈક કહો: ગાબે.

549
00:22:05,800 --> 00:22:07,140
કંઈક કહો: ગાબે.

550
00:22:07,140 --> 00:22:08,520

551
00:22:08,520 --> 00:22:09,020
અધિકાર છે.

552
00:22:09,020 --> 00:22:10,851
કદાચ હું જગ્યા પટ્ટી દબાવો
અથવા ફંકી કંઈક.

553
00:22:10,851 --> 00:22:11,600
માતાનો ફરીથી કરવા દો.

554
00:22:11,600 --> 00:22:13,020
Zamyla તેથી.

555
00:22:13,020 --> 00:22:13,970

556
00:22:13,970 --> 00:22:14,470
Zamyla.

557
00:22:14,470 --> 00:22:15,740

558
00:22:15,740 --> 00:22:17,330
વિવિધ વસ્તુઓ.

559
00:22:17,330 --> 00:22:19,430
તેથી શું થઈ રહ્યું છે?

560
00:22:19,430 --> 00:22:23,200
>> તેથી અમે આ બે રેખાઓ છે
કોડ છે, GetString બે વખત કહેવાય છે.

561
00:22:23,200 --> 00:22:25,760
અને પછી, હું ફક્ત છું
અને ટી સરખાવવા માટે પ્રયાસ કરે છે.

562
00:22:25,760 --> 00:22:28,370
પરંતુ રહ્યું છે પછી શું?

563
00:22:28,370 --> 00:22:31,180
માટે ઠીક છે, મારા હસ્તાક્ષર માતાનો વિશે
કંઈક આ ઉદાહરણ કસાઈ.

564
00:22:31,180 --> 00:22:34,630
અને ચાલો ખરેખર ફેંકવું દો
આ અહીં પર, એ જ.

565
00:22:34,630 --> 00:22:37,390

566
00:22:37,390 --> 00:22:45,712
>> તેથી અમે એક લીટી જેવી છે
શબ્દમાળા ઓ = GetString.

567
00:22:45,712 --> 00:22:48,295
જેથી ફક્ત પ્રથમ છે
કે કાર્યક્રમ રસપ્રદ વાક્ય.

568
00:22:48,295 --> 00:22:49,920

569
00:22:49,920 --> 00:22:52,974
પરંતુ આ બધા સમય રહી છે તે
હૂડ નીચે રહ્યું?

570
00:22:52,974 --> 00:22:55,890
ઠીક છે, ડાબી બાજુ બાજુ શબ્દમાળા છે,
જે ચલ અમુક પ્રકારના છે,

571
00:22:55,890 --> 00:22:56,785
અને તે ઓ કહેવાય છે.

572
00:22:56,785 --> 00:23:00,019
તેથી હું આ મેમરી ઉપયોગ કરે છે ખબર છે કે,
અથવા RAM, કોઈક મારા કમ્પ્યુટર માં.

573
00:23:00,019 --> 00:23:02,060
તેથી હું અમૂર્ત કરવા જઇ રહ્યો છું
એક ચોરસ કે દોરે છે.

574
00:23:02,060 --> 00:23:04,820
32 બિટ્સ, તે બહાર વળે છે, પરંતુ
ભવિષ્યમાં પર વધુ.

575
00:23:04,820 --> 00:23:06,410
અને પછી, શું અહીં ચાલી રહ્યું છે?

576
00:23:06,410 --> 00:23:08,700
>> ઠીક છે, દેખીતી રીતે GetString
વપરાશકર્તા માંથી શબ્દમાળા મળે છે.

577
00:23:08,700 --> 00:23:11,360
અને GetString મળી
Zamyla અથવા ગાબે અથવા Daven.

578
00:23:11,360 --> 00:23:14,640
તેથી આપણે પ્રથમ પસંદ કરીએ
તે, Daven હતી.

579
00:23:14,640 --> 00:23:19,174
તેથી અસરકારક રીતે, શું GetString મળી
મને કે પ્રથમ કિસ્સામાં ડી એક વી ઈ એ હતી.

580
00:23:19,174 --> 00:23:22,690

581
00:23:22,690 --> 00:23:25,045
અને પછી, બીજું શું કર્યું
તે મને ગુપ્ત આપી?

582
00:23:25,045 --> 00:23:25,920
AUDIENCE: [અશ્રાવ્ય]

583
00:23:25,920 --> 00:23:28,720
ડેવિડ જે MALAN: અરે વાહ,
આ / 0 અથવા નલ પાત્ર.

584
00:23:28,720 --> 00:23:30,550
તેથી તે અસરકારક રીતે મને શબ્દમાળા આપી હતી.

585
00:23:30,550 --> 00:23:34,550
પરંતુ અમે પહેલાથી જ અગાઉના પરથી ખબર
શબ્દમાળા માત્ર એક વ્યૂહરચના છે કે લાગે છે

586
00:23:34,550 --> 00:23:37,895
અક્ષરો, અને તે દ્વારા બંધ છે
આ ખાસ સંત્રી પાત્ર, / 0.

587
00:23:37,895 --> 00:23:39,220

588
00:23:39,220 --> 00:23:42,310
>> પરંતુ આ વાત સાચી હોય તો
અને આ એક ચોરસ છે,

589
00:23:42,310 --> 00:23:44,160
આ સ્પષ્ટ રીતે એક બહુ મોટા લંબચોરસ છે.

590
00:23:44,160 --> 00:23:46,830
અને ખરેખર, આ છે,
હું માત્ર 32 બિટ્સ દાવો.

591
00:23:46,830 --> 00:23:49,500
અને આ સ્પષ્ટ રીતે વધુ 32 છે
બિટ્સ, આ કદાચ છે કારણ કે

592
00:23:49,500 --> 00:23:51,583
આઠ વત્તા આઠ વત્તા આઠ
વત્તા આઠ વત્તા આઠ,

593
00:23:51,583 --> 00:23:53,320
માત્ર તે ASCII માં બાઇટ્સ છે.

594
00:23:53,320 --> 00:23:57,030
કેવી રીતે હેક અમે ફિટ જવું છે
અહીં આ થોડું બોક્સમાં Daven?

595
00:23:57,030 --> 00:23:59,880
>> વેલ, શું ખરેખર GetString કરી છે?

596
00:23:59,880 --> 00:24:03,680
વેલ, આ ગ્રીડ અહીં રજૂ
મારા કમ્પ્યુટર મેમરી અથવા રેમ.

597
00:24:03,680 --> 00:24:07,564
તેથી આપણે આપખુદ જો કે કહેવું
આ દરેક એક બાઈટ પ્રતિનિધિત્વ

598
00:24:07,564 --> 00:24:09,730
પછી અમે દરેક વિચાર કરી શકો છો
બાઇટ એક સરનામું હોવા તરીકે,

599
00:24:09,730 --> 00:24:13,830
33 ઓક્સફર્ડ સ્ટ્રીટ, અથવા 34 જેવી
ઓક્સફર્ડ સ્ટ્રીટ, અથવા 35 ઓક્સફર્ડ સ્ટ્રીટ.

600
00:24:13,830 --> 00:24:16,700
>> તેથી ઘરો સરનામાઓ છે જેમ
અને ઇમારતો સરનામાં હોય છે,

601
00:24:16,700 --> 00:24:19,810
જેથી વ્યક્તિગત બાઇટ્સ કરી
મેમરી સરનામાંઓ અથવા હોય છે

602
00:24:19,810 --> 00:24:21,042
કે અનન્ય તેમને ઓળખે છે.

603
00:24:21,042 --> 00:24:22,000
હવે, આ મનસ્વી છે.

604
00:24:22,000 --> 00:24:25,370
પરંતુ હું જાઉં છું, સરળ રાખવા માટે
માત્ર સંમેલન દ્વારા હેક્સાડેસિમલ વાપરવા માટે,

605
00:24:25,370 --> 00:24:28,200
પરંતુ 0x અન્ય કશું અર્થ થાય છે
કરતાં "આ હેક્સાડેસિમલ છે."

606
00:24:28,200 --> 00:24:31,030
અને હું દાવો છે કે જાઉં છું આ
"ડી" મેમરી બાઇટ એક પર થાય.

607
00:24:31,030 --> 00:24:34,210
>> હું બીજું કંઇ થઇ રહ્યું મળી
મેમરી, તેથી Daven પ્રથમ સ્થળ મળી

608
00:24:34,210 --> 00:24:35,509
બાઇટ એક છે.

609
00:24:35,509 --> 00:24:36,800
આ, તો પછી, 0x2 હોઈ ચાલે છે.

610
00:24:36,800 --> 00:24:37,831

611
00:24:37,831 --> 00:24:38,705
આ 0x3 રહ્યું છે.

612
00:24:38,705 --> 00:24:39,840

613
00:24:39,840 --> 00:24:41,800
આ 0x4 હોઈ ચાલે છે.

614
00:24:41,800 --> 00:24:43,025
આ 0x5 રહ્યું છે.

615
00:24:43,025 --> 00:24:44,025
આ 0x6 હોઈ ચાલે છે.

616
00:24:44,025 --> 00:24:45,560

617
00:24:45,560 --> 00:24:48,290
>> પરંતુ તમે એક જ વિચારવાનો શરૂ
શું કમ્પ્યુટરની કરી વિશે

618
00:24:48,290 --> 00:24:50,710
હૂડ નીચે,
તમે અટકળ બાંધવી શરૂ કરી શકો છો

619
00:24:50,710 --> 00:24:54,960
તમે કેવી રીતે, કેટલાક વર્ષ પહેલાં, કરશે
પોતે સી અમલ કર્યો છે.

620
00:24:54,960 --> 00:24:58,360
કદાચ GetString શું છે
returning-- તે કારણ કે

621
00:24:58,360 --> 00:25:00,946
તે નથી જેવી લાગે છે
પરત Daven, સે દીઠ,

622
00:25:00,946 --> 00:25:03,320
તે ચોક્કસ નથી ચાલી રહ્યું છે કારણ કે
આ થોડું box-- ફિટ

623
00:25:03,320 --> 00:25:05,090
તેથી શું GetString કદાચ પરત આવે છે?

624
00:25:05,090 --> 00:25:07,958

625
00:25:07,958 --> 00:25:08,920
>> AUDIENCE: [અશ્રાવ્ય]

626
00:25:08,920 --> 00:25:10,540
>> ડેવિડ જે MALAN: Daven સ્થિતિ.

627
00:25:10,540 --> 00:25:12,770
અને તે આ કરી રહ્યું છે
ક્યારેય અઠવાડિયું એક છે.

628
00:25:12,770 --> 00:25:16,150
શું GetString ખરેખર છે
પરત શબ્દમાળા, સે દીઠ નથી.

629
00:25:16,150 --> 00:25:17,780
કે નાના સફેદ ખોટા એક છે.

630
00:25:17,780 --> 00:25:22,520
તે ના સરનામા પરત છે
મેમરીમાં શબ્દમાળા અનન્ય સરનામું.

631
00:25:22,520 --> 00:25:24,820
Daven 33 ઓક્સફર્ડ સ્ટ્રીટ પર રહે છે.

632
00:25:24,820 --> 00:25:29,310
પરંતુ વધુ સંક્ષિપ્તમાં, ગેવિન રહે
0x1 પર નંબર વન સરનામું.

633
00:25:29,310 --> 00:25:32,280
>> તેથી શું આ મૂકવા નહીં
નાના બોક્સમાં પછી, સ્પષ્ટ કરવા

634
00:25:32,280 --> 00:25:35,930
કે જેઓ શબ્દમાળા માત્ર સરનામું છે.

635
00:25:35,930 --> 00:25:38,110
તેથી આ બધા સમય, આ
છે થઈ રહ્યું કરવામાં આવી.

636
00:25:38,110 --> 00:25:41,650
પરંતુ આ અંતે સંકેતો શું
હવે જો ધરાવે છે

637
00:25:41,650 --> 00:25:44,710
તે અંદર એક નંબર, કોણ છે છે
તમે બંધ કરવા, પ્રોગ્રામર,

638
00:25:44,710 --> 00:25:47,970
કોઈપણ નંબર મૂકવા થી
કોઈપણ ચલ અને માત્ર જમ્પિંગ

639
00:25:47,970 --> 00:25:49,080
મેમરી કે ભાગ છે?

640
00:25:49,080 --> 00:25:51,320
અને ખરેખર, અમે જોશો
કે ધમકી આગામી સમય છે.

641
00:25:51,320 --> 00:25:53,500
>> પરંતુ હવે માટે, આ અપૂરતી લાગે છે.

642
00:25:53,500 --> 00:25:55,630
મને કહે, તો મને એક વિચાર
શબ્દમાળા, તમે મને Daven આપે છે.

643
00:25:55,630 --> 00:25:57,230
પરંતુ તમે ખરેખર મને Daven આપી નથી.

644
00:25:57,230 --> 00:25:59,310
તમે મને આપી બધા Daven સરનામાં છે.

645
00:25:59,310 --> 00:26:04,310
હું પછી ખાતરી માટે ખબર નથી કેવી રીતે
જ્યાં Daven શરૂ થાય છે અને ends--

646
00:26:04,310 --> 00:26:07,140
વાર્તા માતાનો weird-- મેળવવામાં
Daven શરૂ થાય છે અને અંત થાય છે, જ્યાં

647
00:26:07,140 --> 00:26:10,435
અને, આગામી પછી
મેમરીમાં શબ્દમાળા શરૂ થાય છે?

648
00:26:10,435 --> 00:26:11,520

649
00:26:11,520 --> 00:26:13,620
>> સારું, તમે સોંપવામાં કરી રહ્યાં છો
મને Daven શરૂઆત,

650
00:26:13,620 --> 00:26:17,230
અનિવાર્યપણે, કેવી રીતે ખબર પડે
તેમના નામ ઓવરને જ્યાં છે?

651
00:26:17,230 --> 00:26:20,550
તે ખાસ નલ પાત્ર, જે
તમામ વધુ મહત્વપૂર્ણ હવે છે

652
00:26:20,550 --> 00:26:23,040
આ નીચે શબ્દમાળાઓ જો
હૂડ ફક્ત ઓળખાય છે

653
00:26:23,040 --> 00:26:25,820
અનન્ય મેમરી તેમના સ્થાન દ્વારા.

654
00:26:25,820 --> 00:26:28,130
તેથી આ બધા સમય, તે છે
શું થઈ રહ્યું કરવામાં આવી છે.

655
00:26:28,130 --> 00:26:32,470
>> તેથી અમે હવે જુઓ ત્યારે
અહીં કોડ છે, સમજાવવું

656
00:26:32,470 --> 00:26:35,790
તમે 26 લીટી માં ભૂલ કરશે તો.

657
00:26:35,790 --> 00:26:39,560
શા Zamyla અને Zamyla અલગ છે?

658
00:26:39,560 --> 00:26:41,330
શા ગાબે અને ગાબે અલગ છે?

659
00:26:41,330 --> 00:26:42,154
અરે વાહ, પાછળ.

660
00:26:42,154 --> 00:26:43,390
>> પ્રેક્ષક: તેઓ અલગ અલગ સરનામા છે.

661
00:26:43,390 --> 00:26:45,931
>> ડેવિડ જે MALAN: ફક્ત કારણ કે
તેઓ અલગ અલગ સરનામા છે.

662
00:26:45,931 --> 00:26:48,820
તમે GetString કૉલ જ્યારે કારણ
ફરીથી, હું અહીં ઝડપથી કરીશ, જે

663
00:26:48,820 --> 00:26:52,870
આ બીજા લાઇન, શબ્દમાળા છે
ટી, હું કાર્યક્રમ હતી,

664
00:26:52,870 --> 00:26:55,030
GetString બીજા કૉલ સમકક્ષ હોય છે.

665
00:26:55,030 --> 00:26:56,370

666
00:26:56,370 --> 00:26:58,670
હું ફોન આગળના સમયે
GetString, હું જાઉં છું

667
00:26:58,670 --> 00:27:00,190
મેમરી એક અલગ ભાગ મળે છે.

668
00:27:00,190 --> 00:27:02,220
>> GetString માન્ય છે
ઓપરેટિંગ પૂછો

669
00:27:02,220 --> 00:27:03,800
વધુ અને વધુ મેમરી માટે સિસ્ટમ.

670
00:27:03,800 --> 00:27:07,894
તે જ ફરી ઉપયોગ નથી ચાલી રહ્યું છે
છ બાઇટ્સ દરેક એક સમય.

671
00:27:07,894 --> 00:27:09,810
જો તે નવી બનશે
મેમરી ભાગ, જે

672
00:27:09,810 --> 00:27:12,780
ટી વિચાર રહ્યું છે એનો અર્થ એ થાય
અહીં કેટલીક અન્ય કિંમત.

673
00:27:12,780 --> 00:27:15,380
>> હું તેથી જ્યારે ઓ = બરાબર
ટી, તમે સરખામણી કરી રહ્યાં છો

674
00:27:15,380 --> 00:27:17,880
આ અને એક સામે સામે ડી
આ અને આ સામે વી.

675
00:27:17,880 --> 00:27:19,588
તમે આ સરખામણી કરી રહ્યા છો
, કે જે આ સામે

676
00:27:19,588 --> 00:27:24,020
પ્રમાણિકપણે ખૂબ ઉપયોગી useless-- છે
ખૂબ નકામી છે ખરેખર જે કારણ કે

677
00:27:24,020 --> 00:27:25,830
શબ્દમાળાઓ મેમરીમાં જ્યાં ધ્યાન આપતા?

678
00:27:25,830 --> 00:27:26,850
>> અને ખરેખર, અમે છે.

679
00:27:26,850 --> 00:27:28,980
અને અમે નથી જઈ રહ્યાં છો
ખાસ કરીને કાળજી શરૂ કરો.

680
00:27:28,980 --> 00:27:34,180
માત્ર ભૂલો પેદા થાય છે શકે છે, તે હદ સુધી
અને સુરક્ષા ધમકીઓ ઇચ્છા પેદા થાય છે કરી શકો છો

681
00:27:34,180 --> 00:27:36,100
અમે ખરેખર આ વિશે કાળજી શરૂ કરો.

682
00:27:36,100 --> 00:27:37,230
તેથી આપણે આ સમસ્યા ઉકેલવા દો.

683
00:27:37,230 --> 00:27:39,650
તમે સુપર ફક્ત તેને ઠીક, બહાર ફેંકે છે.

684
00:27:39,650 --> 00:27:42,600
>> અને હું પહેલાં, ખરેખર ચાલો
ફરીથી જણાવે છે કે, શું કરશે

685
00:27:42,600 --> 00:27:47,170
એક CS50 વર્ગ જો તમે કરી
અને તમે અમલ કરવા માટે હતી

686
00:27:47,170 --> 00:27:48,600
બે શબ્દમાળાઓ સામે સરખામણી.

687
00:27:48,600 --> 00:27:51,440
તમે સ્પષ્ટ રીતે માત્ર ઓ = ટી બરાબર ઉપયોગ કરી શકતા નથી.

688
00:27:51,440 --> 00:27:54,090
પરંતુ માત્ર તાર્કિક, કેવી રીતે
જો તમે આ શબ્દમાળા તુલના કરશે

689
00:27:54,090 --> 00:27:56,370
સી કોડ ઉપયોગ કરીને આ શબ્દમાળા સામે?

690
00:27:56,370 --> 00:27:56,880
અરે વાહ.

691
00:27:56,880 --> 00:27:58,780
>> પ્રેક્ષક: જસ્ટ કરવા માટે
લૂપ માટે [અશ્રાવ્ય]

692
00:27:58,780 --> 00:28:00,670

693
00:28:00,670 --> 00:28:01,670
ડેવિડ જે MALAN: યોગ્ય છે.

694
00:28:01,670 --> 00:28:02,900
AUDIENCE: [અશ્રાવ્ય]

695
00:28:02,900 --> 00:28:03,310
ડેવિડ જે MALAN: અરે વાહ.

696
00:28:03,310 --> 00:28:05,390
જસ્ટ લૂપ અથવા માટે ઉપયોગ
લૂપ અથવા જે છે.

697
00:28:05,390 --> 00:28:08,710
પરંતુ માત્ર મૂળભૂત વિચાર લાગુ પડે છે કે
આ મેમરી અથવા એક એરે એક ભાગ છે

698
00:28:08,710 --> 00:28:11,590
અને છે આ, ફરી વળવું
બંને એક જ સમયે.

699
00:28:11,590 --> 00:28:12,960
અને માત્ર અક્ષરો સરખામણી કરી.

700
00:28:12,960 --> 00:28:14,260
>> અને તમે એક હોઈ મળી છે
થોડી કાળજી, તમે કારણ કે

701
00:28:14,260 --> 00:28:16,247
એક આંગળી નહિં માંગો
અન્ય ભૂતકાળ જાઓ

702
00:28:16,247 --> 00:28:18,080
એક શબ્દમાળા છે કારણ કે
અન્ય કરતાં લાંબા સમય સુધી.

703
00:28:18,080 --> 00:28:21,380
તેથી તમારા માટે ચેક કરવા માંગો છો જઈ રહ્યાં છો
અંતે આ ખાસ કિંમત છે, નલ.

704
00:28:21,380 --> 00:28:24,017
પરંતુ તે ખરેખર છે,
અંતે, જે સરળ.

705
00:28:24,017 --> 00:28:26,100
અને પ્રમાણિકપણે, અમે જરૂર નથી
કે વ્હીલ પુનઃશોધ.

706
00:28:26,100 --> 00:28:27,960
અહીં આવૃત્તિ બે છે.

707
00:28:27,960 --> 00:28:32,910
અને શું હું અહીં કહેવું જાઉં છું છે
બદલે ઓ સરખામણી ના, = ટી બરાબર

708
00:28:32,910 --> 00:28:38,964
શબ્દમાળા જો હું તેના બદલે, કહેવું જાઉં છું
ઓ અલ્પવિરામ ટી સરખામણી = 0 સમકક્ષ હોય છે.

709
00:28:38,964 --> 00:28:40,130
હવે, શબ્દમાળા શું સરખામણી છે?

710
00:28:40,130 --> 00:28:43,046
>> તે એક કાર્ય છે, તારણ આપે છે કે
જેની હેતુ જીવનમાં સી, સાથે આવે છે

711
00:28:43,046 --> 00:28:44,650
બે શબ્દમાળાઓ સરખાવવા માટે છે.

712
00:28:44,650 --> 00:28:48,300
અમે વાંચી અને, જો તુલના જગાડવો તેના
મદદ પાનું અથવા દસ્તા અથવા CS50

713
00:28:48,300 --> 00:28:50,630
સંદર્ભ, તે ચાલશે
ફક્ત તમે તે જગાડવો કહી

714
00:28:50,630 --> 00:28:55,730
નકારાત્મક ક્યાં વળતર તુલના
નંબર અથવા હકારાત્મક નંબર અથવા શૂન્ય,

715
00:28:55,730 --> 00:28:57,660
શૂન્ય અર્થ એ થાય છે કે તેઓ સમાન છો.

716
00:28:57,660 --> 00:28:58,570
>> તેથી માત્ર અટકળ.

717
00:28:58,570 --> 00:29:00,390
તે શું જો અર્થ શકે
સરખામણી વળતર જગાડવો

718
00:29:00,390 --> 00:29:02,110
નકારાત્મક કિંમત અથવા હકારાત્મક કિંમત?

719
00:29:02,110 --> 00:29:02,785

720
00:29:02,785 --> 00:29:04,285
પ્રેક્ષક: કરતાં વધારે અથવા કરતાં ઓછો હોય છે.

721
00:29:04,285 --> 00:29:05,570
ડેવિડ જે MALAN: અરે વાહ,
કરતાં વધારે અથવા કરતાં ઓછો હોય છે.

722
00:29:05,570 --> 00:29:08,640
તેથી જો તમે સમગ્ર સૉર્ટ માગે છે
એક dictionary-- માં શબ્દમાળાઓ ટોળું

723
00:29:08,640 --> 00:29:12,975
અમે આખરે road-- નીચે કરશે તરીકે
સંપૂર્ણ કાર્ય સંભવિત ઉપયોગ કરવા માટે,

724
00:29:12,975 --> 00:29:15,850
તે આ કરી રહ્યું છે કારણ કે
તમારા માટે શબ્દમાળાઓ સરખામણી, અને કહી

725
00:29:15,850 --> 00:29:20,060
તમે એક બોલ્ડ પહેલાં આવે છે, અથવા કરે છે
બી એક મૂળાક્ષરોની પહેલાં આવે છે.

726
00:29:20,060 --> 00:29:21,490
અમે બરાબર કરી શકો છો.

727
00:29:21,490 --> 00:29:23,620
>> અને હું અન્ય એક હતી નોટિસ
આ ઉદાહરણમાં વસ્તુ.

728
00:29:23,620 --> 00:29:26,870
બીજું શું વધારે બદલાઈ ગયો છે
આ મુખ્ય કાર્ય માં?

729
00:29:26,870 --> 00:29:28,500

730
00:29:28,500 --> 00:29:29,350
ચાર *.

731
00:29:29,350 --> 00:29:31,150
અને આ કે અન્ય સફેદ જૂઠ છે.

732
00:29:31,150 --> 00:29:33,750
આ બધા સમય, જ્યારે તમે કર્યું
શબ્દમાળા લખી કરવામાં,

733
00:29:33,750 --> 00:29:38,350
અમે ગુપ્ત પુનર્લેખન કરવામાં આવી છે
ચાર તરીકે શબ્દમાળા * તેથી ખરેખર છે કે રણકાર

734
00:29:38,350 --> 00:29:39,270
તમે સમજે છે.

735
00:29:39,270 --> 00:29:42,450
>> અન્ય શબ્દોમાં, cs50.h માં
અને અમે આખરે જોશો,

736
00:29:42,450 --> 00:29:45,950
અમે સમાનાર્થી કહેવાય શબ્દમાળા કરી
કે ઘરનાં પરચૂરણ કામો * તરીકે જ વાત છે.

737
00:29:45,950 --> 00:29:49,910
અને હવે માટે, માત્ર તે ખબર
* આ સંદર્ભમાં, ઓછામાં ઓછા,

738
00:29:49,910 --> 00:29:51,286
સરનામાં છે.

739
00:29:51,286 --> 00:29:52,210
>> શું સરનામું?

740
00:29:52,210 --> 00:29:56,390
ઠીક છે, હકીકત એ છે કે હું જણાવ્યું હતું કે
ઘરનાં પરચૂરણ કામો * અને * પૂર્ણાંક અથવા * ફ્લોટ નથી

741
00:29:56,390 --> 00:30:00,820
ઘરનાં પરચૂરણ કામો * છે કે જે થાય છે
ચાર રચે ની સરનામું.

742
00:30:00,820 --> 00:30:06,770
અહીં આ નાના બોક્સમાં ઉર્ફે
શબ્દમાળા ખરેખર પ્રકાર ઘરનાં પરચૂરણ કામો * છે,

743
00:30:06,770 --> 00:30:10,490
જે કહેતા ફક્ત ફેન્સી માર્ગ છે,
આ બૉક્સમાં એક સરનામું જાય છે.

744
00:30:10,490 --> 00:30:12,430
અને શું તે સરનામા માટે નો સંદર્ભ લો છે?

745
00:30:12,430 --> 00:30:13,780
દેખીતી રીતે, એક કોલસો બનાવો.

746
00:30:13,780 --> 00:30:16,410
>> પરંતુ અમે સંપૂર્ણપણે કરી શકે
પૂર્ણાંક * અને અન્ય વસ્તુઓ હોય છે.

747
00:30:16,410 --> 00:30:20,790
પરંતુ હવે માટે, ઘરનાં પરચૂરણ કામો * ખરેખર સૌથી છે
સરળ અને રસ છે.

748
00:30:20,790 --> 00:30:23,310
તેથી આ સમસ્યા રહ્યું છે
ફરીથી, જોકે, વધે.

749
00:30:23,310 --> 00:30:24,830
>> હું આ કાર્યક્રમ ખોલો ધારો.

750
00:30:24,830 --> 00:30:27,670
હવે અમે આગાહી કરી શકો છો ચાલો જોવા જો
શું આ કોડ સાથે ખોટું છે.

751
00:30:27,670 --> 00:30:31,140
આ કાર્યક્રમ તેથી, નકલ-0, હું છું
આગળ વધો અને ફરીથી કહી રહ્યા

752
00:30:31,140 --> 00:30:34,190
GetString અને ઓ માં કિંમત સ્ટોર કરે છે.

753
00:30:34,190 --> 00:30:38,800
>> અને પછી, શા માટે હું આ કરી રહ્યો છું
માત્ર અઠવાડિયા ભૂતકાળની રિમાઇન્ડર તરીકે?

754
00:30:38,800 --> 00:30:40,960
અમે તે GetString કહે કર્યું
ક્યારેક નલ આપે છે.

755
00:30:40,960 --> 00:30:42,793
તે શું અર્થ છે જો
GetString નલ આપે?

756
00:30:42,793 --> 00:30:45,040

757
00:30:45,040 --> 00:30:46,034
કંઈક ખોટું થયું હતું.

758
00:30:46,034 --> 00:30:48,950
તે કદાચ શબ્દમાળા પણ છે એનો અર્થ એ થાય
મોટા, મેમરીનો કમ્પ્યુટરની બહાર.

759
00:30:48,950 --> 00:30:51,724
તે સુપર, સુપર, સુપર થાય
ભાગ્યે જ, પરંતુ તે બની શકે છે.

760
00:30:51,724 --> 00:30:53,890
અમે તે માટે ચેક કરવા માંગો છો,
અને તે અમે કરી રહ્યા છીએ બધા છે.

761
00:30:53,890 --> 00:30:57,910
>> જો તમે ન કરો તો અમે હવે જોશો કારણ કે
વસ્તુઓ માટે habitually ચકાસણી શરૂ

762
00:30:57,910 --> 00:31:00,870
નલ જેમ, તમે કદાચ
ખરેખર જાઓ શરૂ

763
00:31:00,870 --> 00:31:03,106
મેમરી સરનામાંઓ માટે અમાન્ય કે છે.

764
00:31:03,106 --> 00:31:05,980
અને તમે પ્રેરીત શરૂ રહ્યા છીએ
વધુ અને વધુ સેગ્મેન્ટેશન ખામી.

765
00:31:05,980 --> 00:31:08,360
અથવા મેક અથવા પીસી, માત્ર
કમ્પ્યુટર કારણ અટકી

766
00:31:08,360 --> 00:31:10,340
અથવા કાર્યક્રમ સંભવિત, સ્થિર.

767
00:31:10,340 --> 00:31:14,930
>> તેથી હવે, હું કોપી 0.c માં દાવો હું
માર્ગ દ્વારા આ શબ્દમાળાઓ નકલ કરીશ

768
00:31:14,930 --> 00:31:15,685
28 લીટી.

769
00:31:15,685 --> 00:31:16,850

770
00:31:16,850 --> 00:31:18,750
અને પછી, હું જાઉં છું
તળિયે દાવો

771
00:31:18,750 --> 00:31:21,430
અહીં હું જાઉં છું કે
એક તેમને બદલવા માટે.

772
00:31:21,430 --> 00:31:22,330
>> તેથી આ નોટિસ.

773
00:31:22,330 --> 00:31:24,370
હું અમારા જૂના મિત્ર strlen કૉલ છું.

774
00:31:24,370 --> 00:31:28,960
અને માત્ર ઇંગલિશ માં સમજાવવું
આ વાક્ય 34 શું કરવાનું છે?

775
00:31:28,960 --> 00:31:32,480
શું ટી કૌંસ 0 કરે
ડાબી પર રજૂ કરે છે.

776
00:31:32,480 --> 00:31:32,980
અરે વાહ.

777
00:31:32,980 --> 00:31:34,339
>> પ્રેક્ષક: ટી પ્રથમ અક્ષર?

778
00:31:34,339 --> 00:31:35,880
ડેવિડ જે MALAN: ટી પ્રથમ અક્ષર.

779
00:31:35,880 --> 00:31:36,379
આ તે છે.

780
00:31:36,379 --> 00:31:40,024
ટી પ્રથમ અક્ષર છે, હું માંગો છો
આ મોટા આવૃત્તિ સોંપી

781
00:31:40,024 --> 00:31:41,190
ટી માં પ્રથમ અક્ષર.

782
00:31:41,190 --> 00:31:43,200
તેથી આ અક્ષરો છે
પ્રથમ અક્ષર.

783
00:31:43,200 --> 00:31:46,340
અને પછી, ખૂબ જ છેલ્લા વસ્તુ હું
આ કાર્યક્રમ છે હું અહીં છે દાવો

784
00:31:46,340 --> 00:31:50,340
મૂળ, ઓ, અને અહીં નકલ, ટી છે.

785
00:31:50,340 --> 00:31:54,610
>> પરંતુ વાર્તા પર આધારિત અમે માત્ર
, શબ્દમાળાઓ ખરેખર છે તે વિશે જણાવ્યું

786
00:31:54,610 --> 00:31:57,520
ખરેખર રેખા 28 છે
કરી, અને શું છે

787
00:31:57,520 --> 00:31:59,405
જવા પરિણામી ભૂલ
સ્ક્રીન પર હોય?

788
00:31:59,405 --> 00:32:01,300

789
00:32:01,300 --> 00:32:03,500
>> તેથી પ્રથમ, પ્રથમ પ્રશ્ન, 28.

790
00:32:03,500 --> 00:32:09,040
શબ્દમાળા ટી = ખરેખર શું કરવાનું છે?

791
00:32:09,040 --> 00:32:16,430
અમે ડાબી બાજુની પર હોય
અહીં બાજુ શબ્દમાળા ટી = ઓ;

792
00:32:16,430 --> 00:32:19,400
કે મને એક બોક્સ આપે છે
અહીં અને એક બોક્સ અહીં.

793
00:32:19,400 --> 00:32:25,530
અને, આ સરનામું 0x છે ધારવું
માતાનો આપખુદ, આ સમય, કહે 50 કરીએ.

794
00:32:25,530 --> 00:32:28,847
શું શબ્દમાળા ટી = ઓ કરે
હૂડ નીચે છે?

795
00:32:28,847 --> 00:32:30,340
>> AUDIENCE: [અશ્રાવ્ય]

796
00:32:30,340 --> 00:32:34,100
>> ડેવિડ જે MALAN: તે મેમરી સંગ્રહ
ત્યાં સંબોધવા, તેથી 0x50 ત્યાં જાય છે.

797
00:32:34,100 --> 00:32:37,980
હવે તેથી, જો હું પ્રથમ પર જાઓ
ટી માં અક્ષર અને તે મોટા,

798
00:32:37,980 --> 00:32:39,535
હું અસરકારક રીતે ઓ શું કરી રહ્યો છું?

799
00:32:39,535 --> 00:32:41,300

800
00:32:41,300 --> 00:32:43,450
હું ખરેખર અધિકાર, આ જ વાત કરી રહ્યો છું?

801
00:32:43,450 --> 00:32:47,680
કારણ કે જો સરનામું 0x50-- અને માત્ર, હું
અહીં બોર્ડ પર ઘણી જગ્યા નથી,

802
00:32:47,680 --> 00:32:51,750
પરંતુ, આ અહીં નીચે 0x50 છે કે ધારે
મારા કમ્પ્યુટર મેમરી ક્યાંક.

803
00:32:51,750 --> 00:32:55,825
>> અને હું, ઉદાહરણ તરીકે, ગાબે છે
આ જેમ, અહીં લોઅરકેસ માં.

804
00:32:55,825 --> 00:32:57,120

805
00:32:57,120 --> 00:33:01,980
અને હું જણાવ્યું હતું કે, ટી કૌંસ
0 મૂડીગત નહીં.

806
00:33:01,980 --> 00:33:04,860
વેલ, ટી કૌંસ 0 છે
ટી માં પ્રથમ અક્ષર.

807
00:33:04,860 --> 00:33:07,840
તેથી ઓછી જી રહ્યું છે
બની મોટા જી પરંતુ સમસ્યા

808
00:33:07,840 --> 00:33:09,410
શું પણ નિર્દેશ છે નથી છે?

809
00:33:09,410 --> 00:33:10,300
>> પ્રેક્ષક: આ જ.

810
00:33:10,300 --> 00:33:11,841
>> ડેવિડ જે MALAN: આ જ ચોક્કસ વસ્તુ.

811
00:33:11,841 --> 00:33:16,342
તેથી કદાચ એક સરળ સમજૂતી,
સિન્ટેક્ષ થોડી વિચિત્ર હોય તો પણ.

812
00:33:16,342 --> 00:33:17,050
તેથી આ કરવા દો.

813
00:33:17,050 --> 00:33:20,210
./copy-0 પછી કોપી 0 કરો અને.

814
00:33:20,210 --> 00:33:21,820

815
00:33:21,820 --> 00:33:24,110
કંઈક કહો: ગાબે.

816
00:33:24,110 --> 00:33:26,760
અને ના કમનસીબે, બંને
તેમને હવે મૂડીગત કરવામાં આવી છે,

817
00:33:26,760 --> 00:33:29,500
પરંતુ તે માટે અંતર્ગત
અમે ફક્ત છો કારણ

818
00:33:29,500 --> 00:33:32,350
હવે સરનામાં સાથે વ્યવહાર.

819
00:33:32,350 --> 00:33:36,470
>> તેથી અમે કેવી રીતે શરૂ કરવું
સરનામાં કોઈ પન intended--

820
00:33:36,470 --> 00:33:39,270
અમે સંબોધવા શરૂ કેવી રીતે
આ ચોક્કસ સમસ્યા?

821
00:33:39,270 --> 00:33:44,400
વેલ, copy1.c માં, વસ્તુઓ ચાલુ છે
થોડી વધુ જટિલ વિચાર.

822
00:33:44,400 --> 00:33:49,310
પણ હું એક દાવો કરશે
સરળ સરળ ઉકેલ.

823
00:33:49,310 --> 00:33:50,852
>> પ્રથમ નજરમાં વિચાર તેથી હાર્ડ.

824
00:33:50,852 --> 00:33:53,560
પ્રથમ માટે સરળ હોઈ ચાલે નથી
સમય તમે, કદાચ, તે લખો

825
00:33:53,560 --> 00:33:57,440
પરંતુ સમસ્યા એ છે કે જો
ફક્ત ટી = ઓ માત્ર કરી

826
00:33:57,440 --> 00:33:59,694
નકલો સરનામું, શું,
ફરી હું તમને પર પસંદ કરી શકો છો જો,

827
00:33:59,694 --> 00:34:02,110
ઉકેલ હોઈ ચાલે છે
ખરેખર એક શબ્દમાળા નકલ માટે?

828
00:34:02,110 --> 00:34:04,906

829
00:34:04,906 --> 00:34:06,770
>> પ્રેક્ષક: અમે કદાચ પડશે
ફરીથી લૂપ વાપરો.

830
00:34:06,770 --> 00:34:06,890
>> ડેવિડ જે MALAN: અરે વાહ.

831
00:34:06,890 --> 00:34:08,390
તેથી અમે ફરીથી લૂપ જરૂર જઈ રહ્યાં છો.

832
00:34:08,390 --> 00:34:11,800
અને અમે નકલ કરવા માંગો છો, કારણ કે
અન્ય શબ્દમાળા એક શબ્દમાળા ઓ,

833
00:34:11,800 --> 00:34:14,120
અમે કદાચ તે કરવા માંગો છો
અક્ષર દ્વારા પાત્ર.

834
00:34:14,120 --> 00:34:17,199
પરંતુ સમસ્યા છે, છે
આ મૂળ ઓ છે

835
00:34:17,199 --> 00:34:22,159
હવે અમે સ્પષ્ટપણે શરૂ કરવાની જરૂર છે
ટી માટે મેમરી ફાળવણી.

836
00:34:22,159 --> 00:34:24,320
>> અન્ય શબ્દોમાં, ચાલો
આ એક છેલ્લા સમય redraw.

837
00:34:24,320 --> 00:34:28,659
આ શબ્દમાળા ઓ = GetString છે.

838
00:34:28,659 --> 00:34:30,956

839
00:34:30,956 --> 00:34:32,455
અને માતાનો સાથે સાથે, અહીં આ મૂકી દો.

840
00:34:32,455 --> 00:34:36,639

841
00:34:36,639 --> 00:34:37,420
આ GetString છે.

842
00:34:37,420 --> 00:34:39,070

843
00:34:39,070 --> 00:34:43,860
કંઈક માટે અને પછી, ચિત્ર
કે પહેલાં તરીકે હોઈ ચાલે છે,

844
00:34:43,860 --> 00:34:44,360
ત એક બાય ઈ / 0.

845
00:34:44,360 --> 00:34:47,294

846
00:34:47,294 --> 00:34:48,960
કે આ જેવી થોડી કંઈક જુએ છે.

847
00:34:48,960 --> 00:34:53,650
અને ઓ તેથી, અમે આ 0x50 કૉલ
અને તે 51, 52 જ હશે.

848
00:34:53,650 --> 00:34:54,409
>> તેથી આ 0x50 છે.

849
00:34:54,409 --> 00:34:55,679

850
00:34:55,679 --> 00:34:59,690
અને પછી, હું શબ્દમાળા ટી છે.

851
00:34:59,690 --> 00:35:02,450
મેમરી માં, કે જે હમણાં જ ચાલી રહ્યું છે
મને આ જેવી થોડી ચોરસ આપે છે.

852
00:35:02,450 --> 00:35:04,080
તેથી કી પગલું હવે શું છે?

853
00:35:04,080 --> 00:35:09,870
હું ટી માં ઓ નકલ કરવા માંગો છો, શું
ખાલી અમે અહીં ભરવા માટે જરૂર છે?

854
00:35:09,870 --> 00:35:12,050
અથવા આપણે શું જરૂર છે
ઊંચા સ્તરે છે?

855
00:35:12,050 --> 00:35:14,101

856
00:35:14,101 --> 00:35:14,600
અરે વાહ?

857
00:35:14,600 --> 00:35:16,200

858
00:35:16,200 --> 00:35:17,020
કોઇએ?

859
00:35:17,020 --> 00:35:17,690
અરે વાહ.

860
00:35:17,690 --> 00:35:19,214
>> પ્રેક્ષક: અમે [અશ્રાવ્ય] જરૂર છે.

861
00:35:19,214 --> 00:35:21,380
ડેવિડ જે MALAN: અરે વાહ, અમે
આ ખાલી ભરો જરૂર છે.

862
00:35:21,380 --> 00:35:24,340
હું પછી નકલ અને ન કરી શકો છો
ગાબે નામ ઉઠાવે

863
00:35:24,340 --> 00:35:28,120
હું ઓપરેટિંગ સિસ્ટમ પૂછો સુધી
મેમરી અન્ય ભાગ માટે

864
00:35:28,120 --> 00:35:30,640
કે મૂળ તરીકે ઓછામાં ઓછા તરીકે મોટી છે.

865
00:35:30,640 --> 00:35:32,130
જેથી એક પ્રશ્ન સાથે નહીં.

866
00:35:32,130 --> 00:35:36,080
>> હું ઓપરેટિંગ સિસ્ટમ નથી પૂછો કેવી રીતે
માત્ર એક સરળ થોડું નિર્દેશક માટે

867
00:35:36,080 --> 00:35:38,530
આ કહે છે, એક
સરનામું, નિર્દેશક નથી

868
00:35:38,530 --> 00:35:40,980
એક સરળ નાના બોક્સમાં માટે
આ જેવી શબ્દમાળા કહેવાય?

869
00:35:40,980 --> 00:35:44,200
હું કેવી રીતે ઓપરેટિંગ પૂછો નથી
મેમરી એક મોટા ભાગ માટે સિસ્ટમ?

870
00:35:44,200 --> 00:35:48,430
આમ અત્યાર સુધીમાં, હું માત્ર તે પાછા મેળવેલ કર્યું
આડકતરી GetString કૉલ દ્વારા.

871
00:35:48,430 --> 00:35:50,740
આમ કેવી રીતે GetString છે
તેના મેમરી મેળવવામાં પણ?

872
00:35:50,740 --> 00:35:53,430
>> ઠીક છે, તે છે તે બહાર કરે છે
અહીં આ અન્ય કાર્ય

873
00:35:53,430 --> 00:35:55,160
કે અમે હવે વાપરવા માટે શરૂ કરી શકશો.

874
00:35:55,160 --> 00:35:59,780
હવે, આ રીતે વધુ ભેદી than-- લાગે
અને હું તેને જોઈ શકે છે જે માત્ર એક જ છું

875
00:35:59,780 --> 00:36:03,150
આ વાક્ય રીતે વધુ ભેદી લાગે છે
પછી તે પ્રથમ નજરમાં જોઈએ.

876
00:36:03,150 --> 00:36:04,650
પરંતુ તે સિવાય પીંજવું દો.

877
00:36:04,650 --> 00:36:07,950
>> ડાબી બાજુ પર, હું ઘરનાં પરચૂરણ કામો * ટી છે.

878
00:36:07,950 --> 00:36:13,280
ઇંગલિશ માં તેથી, ચાલો તૈયાર કરવા માટે શરૂ કરો
ટેકનિકલ કલકલ યોગ્ય વાક્યો.

879
00:36:13,280 --> 00:36:19,757
તેથી આ ફાળવણી છે
પ્રકાર ચાર ચલ ટી કહેવાય *.

880
00:36:19,757 --> 00:36:21,090
હવે, કે ખરેખર શું અર્થ છે?

881
00:36:21,090 --> 00:36:23,881
>> ઠીક છે, કે જે થાય છે, હું શું કરીશ
ટી કહેવાય ચલ મૂકવા?

882
00:36:23,881 --> 00:36:24,780

883
00:36:24,780 --> 00:36:26,402
ચાર રચે એક સરનામું.

884
00:36:26,402 --> 00:36:28,360
જેથી, માત્ર સરળ છે
વધુ વાજબી રીતે

885
00:36:28,360 --> 00:36:29,930
ડાબી બાજુ વર્ણન.

886
00:36:29,930 --> 00:36:32,890
જેથી અહીં માત્ર આ બોક્સ બનાવે છે.

887
00:36:32,890 --> 00:36:34,760
તેથી બાજુ જમણી બાજુ,
કદાચ, રહ્યું છે

888
00:36:34,760 --> 00:36:37,170
મોટા કે ફાળવવા માટે
મેમરી કેવી રીતે ભાગ?

889
00:36:37,170 --> 00:36:38,340
તેથી આપણે આ સિવાય પીંજવું દો.

890
00:36:38,340 --> 00:36:41,131
>> તે પ્રથમ નજરમાં જબરજસ્ત છે
પરંતુ અંદર અહીં શું થઈ રહ્યું છે?

891
00:36:41,131 --> 00:36:43,740
પ્રથમ, malloc, છે જે
અમારા નવા મિત્ર, દેખીતી રીતે છે

892
00:36:43,740 --> 00:36:45,450
"મેમરીને ફાળવવા."

893
00:36:45,450 --> 00:36:49,560
તેથી આ પસાર થઈ રહી દલીલ છે
તેને, તેથી તે એક સુંદર મોટી દલીલ છે.

894
00:36:49,560 --> 00:36:50,970
તેથી આપણે આ સિવાય પીંજવું દો.

895
00:36:50,970 --> 00:36:53,410
>> ઓ strlen, અલબત્ત, રજૂ કરવું

896
00:36:53,410 --> 00:36:54,142

897
00:36:54,142 --> 00:36:55,600
પ્રેક્ષક: અક્ષરો સંખ્યા.

898
00:36:55,600 --> 00:36:56,710
ડેવિડ જે MALAN: જસ્ટ
ઓ માં અક્ષરો સંખ્યા.

899
00:36:56,710 --> 00:36:59,040
તેથી ઓ લંબાઈ, મૂળ શબ્દમાળા.

900
00:36:59,040 --> 00:37:00,350
તેથી જી એક બાય ઈ.

901
00:37:00,350 --> 00:37:02,320
તેથી તે કદાચ ચાર આ કિસ્સામાં છે.

902
00:37:02,320 --> 00:37:05,485
શા માટે હું પછી +1 કરી રહ્યો છું
ઓ strlen કૉલ?

903
00:37:05,485 --> 00:37:06,360
AUDIENCE: [અશ્રાવ્ય]

904
00:37:06,360 --> 00:37:07,590
ડેવિડ જે MALAN: તે માટે
ખાસ નલ પાત્ર.

905
00:37:07,590 --> 00:37:11,260
તમે મને પૂછો તો લંબાઈ શું
ગાબે નામ, હું ચાર કહેવું જાઉં છું.

906
00:37:11,260 --> 00:37:14,480
હૂડ નીચે, જોકે, હું જરૂર
નલ પાત્ર માટે કે પાંચમા બાઇટ.

907
00:37:14,480 --> 00:37:16,100
હું +1 કરી રહ્યો છું તેથી કે શા માટે છે.

908
00:37:16,100 --> 00:37:21,730
>> હવે માત્ર કિસ્સામાં તમે આ ચાલી રહ્યું છે
કરતાં અન્ય કમ્પ્યુટર પર કાર્યક્રમ, કહે છે,

909
00:37:21,730 --> 00:37:24,610
CS50 સાધન,
જ્યાં ચાર રચે માપ

910
00:37:24,610 --> 00:37:26,350
અલગ હોઈ શકે છે
મારી પોતાની કમ્પ્યુટર માંથી

911
00:37:26,350 --> 00:37:30,590
હું આ કૉલ કરી શકે છે
ઓપરેટર sizeof, માત્ર, કમ્પ્યૂટર પૂછો

912
00:37:30,590 --> 00:37:32,870
એક માપ છે
આ કમ્પ્યુટર પર ઘરનાં પરચૂરણ કામો?

913
00:37:32,870 --> 00:37:37,400
>> અને આ પાંચ ગુણાકાર દ્વારા
ચાર રચે માપ દ્વારા ઉદાહરણ, જે

914
00:37:37,400 --> 00:37:40,440
સૌથી કમ્પ્યુટર્સ પર ચાલશે
માત્ર એક, malloc કરી

915
00:37:40,440 --> 00:37:44,830
મને આ મોટા માટે ફાળવી રહ્યું છે
અહીં જમણી બાજુ પર પર મેમરી ભાગ.

916
00:37:44,830 --> 00:37:47,140
અને તે પાછા બનશે
તે છે તેથી તે કાર્ય છે

917
00:37:47,140 --> 00:37:48,265
શું મને પરત ચાલી રહ્યું?

918
00:37:48,265 --> 00:37:50,914

919
00:37:50,914 --> 00:37:51,830
પ્રેક્ષક: આ સરનામું?

920
00:37:51,830 --> 00:37:53,709
ડેવિડ જે MALAN: શું આ સરનામું?

921
00:37:53,709 --> 00:37:55,250
પ્રેક્ષક: મેમરી ઓફ તે ફાળવણી?

922
00:37:55,250 --> 00:37:56,450
ડેવિડ જે MALAN: ના
મેમરી તે ફાળવવામાં આવે છે.

923
00:37:56,450 --> 00:37:59,189
તેથી હું પ્રમાણિકપણે, કોઈ વિચાર હોય છે
જ્યાં આ અંત રહ્યું છે.

924
00:37:59,189 --> 00:38:01,480
હું પ્રસ્તાવ જાઉં છું
તે 0x88 અંતે અંત બનશે.

925
00:38:01,480 --> 00:38:02,770

926
00:38:02,770 --> 00:38:06,009
સંપૂર્ણપણે મનસ્વી છે, પરંતુ
0x50 કરતાં અન્ય ક્યાંક,

927
00:38:06,009 --> 00:38:08,800
ઓપરેટિંગ સિસ્ટમ, કારણ કે તે
વિન્ડોઝ અને Mac OS મારા માટે શું છે,

928
00:38:08,800 --> 00:38:11,230
તે આપી દીધો છે કે નહીં તેની ખાતરી
મને RAM ની અલગ હિસ્સામાં.

929
00:38:11,230 --> 00:38:14,210
>> તેથી આ કિંમત છે આ છે
મેમરી ભાગ અંત શકે છે.

930
00:38:14,210 --> 00:38:16,060
તેથી આ 0x88, અહીં થાય છે.

931
00:38:16,060 --> 00:38:17,480

932
00:38:17,480 --> 00:38:21,570
તેથી હવે સ્પષ્ટ રીતે, હું સમજી શકે
આ એ જ નથી કે,

933
00:38:21,570 --> 00:38:23,960
તેઓ નિર્દેશ કરતી રહ્યાં છો કારણ કે
મેમરી વિવિધ હિસ્સામાં.

934
00:38:23,960 --> 00:38:29,980
હવે હું ખરેખર આ નકલ કરવા માંગો છો તેથી જો
માં, ચાલો તમારા સૂચિત ઉકેલ કરવા દો.

935
00:38:29,980 --> 00:38:36,870
>> , ચાલો માત્ર જાઓ લૂપ માટે બનાવવા દો
અને ટી કૌંસ કરી હું કૌંસ હું નહીં.

936
00:38:36,870 --> 00:38:39,760
હવે હું ઉપયોગ કરી શકો છો કારણ કે
આ એરે જેવી સંકેત,

937
00:38:39,760 --> 00:38:43,390
કારણ કે, તેમ છતાં malloc ખૂબ
સામાન્ય મને મેમરી ફાળવે,

938
00:38:43,390 --> 00:38:45,290
મેમરી માત્ર સંલગ્ન બાઇટ્સ છે.

939
00:38:45,290 --> 00:38:47,240
બાઇટ, બાઇટ, બાઇટ, પાછા પાછળ પાછળ.

940
00:38:47,240 --> 00:38:50,030
>> હું પ્રોગ્રામર તરીકે ચોક્કસ કરી શકો છો
ઝાકઝમાળ, તરીકે સારવાર જે

941
00:38:50,030 --> 00:38:55,090
હું આ છેલ્લે પરિચિત ઉપયોગ કરી શકો છો છે
માત્ર કેટલાક ચોરસ કૌંસ ના સંકેત.

942
00:38:55,090 --> 00:38:56,462

943
00:38:56,462 --> 00:39:00,020
>> તેથી મને, કારણ કે ત્યાં વિરામ દો
આ પણ, બધા એક જ સમયે ઘણો છે

944
00:39:00,020 --> 00:39:03,530
મૂળભૂત વિચાર રીકેપ માટે છતાં
કે જેઓ શબ્દમાળા છે, આ બધા સમય,

945
00:39:03,530 --> 00:39:05,550
નવી માહિતી પ્રકાર સે દીઠ નથી.

946
00:39:05,550 --> 00:39:10,150
તે માત્ર એક કહેવાતા નિર્દેશક છે
એક અક્ષર એક સરનામું,

947
00:39:10,150 --> 00:39:12,650
જે માત્ર અર્થ એ થાય કે તે એક નંબર છે
કે માનવ સંમેલન દ્વારા

948
00:39:12,650 --> 00:39:15,350
અમે 0x કંઈક તરીકે લખી છે.

949
00:39:15,350 --> 00:39:18,590
>> પરંતુ તે માત્ર એક નંબર છે
33 ઓક્સફર્ડ સ્ટ્રીટ જેમ,

950
00:39:18,590 --> 00:39:20,530
જે બને છે
સીએસ ઇમારતની સરનામું.

951
00:39:20,530 --> 00:39:22,000

952
00:39:22,000 --> 00:39:23,545
આ વિગતો પર કોઈપણ પ્રશ્ન છે?

953
00:39:23,545 --> 00:39:24,790

954
00:39:24,790 --> 00:39:25,289
અરે વાહ?

955
00:39:25,289 --> 00:39:28,530
>> પ્રેક્ષક: શા માટે અમે તપાસ કરી
સમાન ટી માટે null છે?

956
00:39:28,530 --> 00:39:30,740
>> ડેવિડ જે MALAN: અમે શા માટે કરવું
નલ બરાબર ટી માટે ચકાસવા?

957
00:39:30,740 --> 00:39:33,250
અમે documentation-- વાંચી તો
malloc માટે મહાન question--,

958
00:39:33,250 --> 00:39:37,020
તે દંડ પ્રિન્ટ કહેવું રહ્યું છે
ક્યારેક malloc, નલ પાછા શકે

959
00:39:37,020 --> 00:39:38,080
માત્ર GetString જેમ.

960
00:39:38,080 --> 00:39:41,820
અને ખરેખર, GetString નલ આપે
, બદલામાં, malloc નલ આપે છે,

961
00:39:41,820 --> 00:39:43,130
GetString malloc વાપરે છે.

962
00:39:43,130 --> 00:39:46,400
>> ઓએસ અને જો કે, થાય શકે
મેક ઓએસ, વિન્ડોઝ, ગમે, ખાલી છે

963
00:39:46,400 --> 00:39:48,130
તમારા માટે મેમરી સમાપ્ત.

964
00:39:48,130 --> 00:39:49,820
જેથી ત્યાં શું થયું છે.

965
00:39:49,820 --> 00:39:52,910
>> અને મને એક અન્ય વસ્તુ ઉઘાડી દો
કે જે હમણાં જ તમારા મન તમાચો શકે છે

966
00:39:52,910 --> 00:39:55,100
અથવા સંપૂર્ણપણે ખૂબ દૂર લીટી પર છે.

967
00:39:55,100 --> 00:39:59,770
પરંતુ મને ખેંચવાનો દો
નકલ માટે લૂપ માટે જ છે,

968
00:39:59,770 --> 00:40:05,480
જે ક્ષણ પહેલા, સ્મૃતિ હતી
આ. ટી કૌંસ હું ઓ કૌંસ હું નહીં.

969
00:40:05,480 --> 00:40:06,740
>> સરસ અને વપરાશકર્તા મૈત્રીપૂર્ણ.

970
00:40:06,740 --> 00:40:09,330
ફરીથી અઠવાડિયું બે જેવી લાગે છે.

971
00:40:09,330 --> 00:40:14,920
પરંતુ આ આવૃત્તિ ખરેખર બની શકે છે
ભેદી લાગે છે કે જે આ છે, એ ફરીથી લખી.

972
00:40:14,920 --> 00:40:18,280
તે એક ટેકનિક કહેવાય નિર્દેશક છે
અંકગણિત, સરનામું અંકગણિત.

973
00:40:18,280 --> 00:40:19,600
પરંતુ શા માટે આ કામ કરે છે?

974
00:40:19,600 --> 00:40:22,220
>> હવે annoyingly, આ
સી લેખકો ઉપયોગ કરવાનો નિર્ણય લીધો

975
00:40:22,220 --> 00:40:25,070
વિવિધ હેતુઓ માટે * પ્રતીક.

976
00:40:25,070 --> 00:40:29,020
અમે તે પહેલાથી જ વાર ઉપયોગ જોઇ છે
એટલે કે ઘરનાં પરચૂરણ કામો *, "મને એક ચલ આપી

977
00:40:29,020 --> 00:40:31,210
કે છે બનશે
ચાર રચે ની સરનામું. "

978
00:40:31,210 --> 00:40:33,990
કે સંદર્ભમાં તેથી ઘરનાં પરચૂરણ કામો *
"મને એક ચલ આપે છે." અર્થ એ થાય

979
00:40:33,990 --> 00:40:40,050
>> કમનસીબે, તમે * વગર વાપરો
તે આગળ એક શબ્દ, ચાર જેમ,

980
00:40:40,050 --> 00:40:41,905
તે હવે કહેવાય છે આ
ડિરેફરન્સ ઓપરેટર.

981
00:40:41,905 --> 00:40:43,530
અને અમે લાંબા પહેલાં આ વધુ જોવા મળશે.

982
00:40:43,530 --> 00:40:44,930
પરંતુ તે માત્ર "ત્યાં જાઓ." એનો અર્થ એ થાય

983
00:40:44,930 --> 00:40:49,070
કોઇ મને આપ્યો તો, કહેતા જેવું છે
કાગળ એક ભાગ પર "33 ઓક્સફર્ડ સ્ટ્રીટ,"

984
00:40:49,070 --> 00:40:53,830
હું "* 33 ઓક્સફર્ડ સ્ટ્રીટ," જો કે એનો અર્થ એ થાય
"આ સીએસ મકાન માટે માર્ગ નીચે જાઓ."

985
00:40:53,830 --> 00:40:57,220
>> તેથી * માત્ર ત્યાં જાઓ જો અર્થ
તે સામે કોઈ શબ્દ છે.

986
00:40:57,220 --> 00:40:59,100
તેથી સ્પષ્ટ છે, ટી શું છે?

987
00:40:59,100 --> 00:41:03,250
ટી ના ભાગ ના સરનામું
મને પાછા આપવામાં આવી હતી કે મેમરી.

988
00:41:03,250 --> 00:41:06,650
ઓ, સ્પષ્ટ કરવા શું, સરનામું છે
આ ઉદાહરણમાં આપણે ચર્ચા કરવામાં આવી છે,

989
00:41:06,650 --> 00:41:07,500
લોઅરકેસ ગાબે ના?

990
00:41:07,500 --> 00:41:08,990

991
00:41:08,990 --> 00:41:10,005
ઓ સરનામું છે of--

992
00:41:10,005 --> 00:41:11,585

993
00:41:11,585 --> 00:41:12,460
પ્રેક્ષક: આ શબ્દમાળા.

994
00:41:12,460 --> 00:41:14,126
ડેવિડ જે MALAN: ગાબે મૂળ નામ છે.

995
00:41:14,126 --> 00:41:16,660
તેથી તે સરનામું છે
મેમરી આ ભાગ.

996
00:41:16,660 --> 00:41:22,220
તેથી હું કહી જો ટી + + એ સિવાય હું હું નોટિસ,
અમારા જૂના મિત્ર છે.

997
00:41:22,220 --> 00:41:24,770
તે માત્ર એક ઇન્ડેક્સ ચલ છે
કે પર શૂન્ય માંથી વારો છે

998
00:41:24,770 --> 00:41:26,960
શબ્દમાળા ઓ લંબાઈ છે.

999
00:41:26,960 --> 00:41:30,367
તેથી તે, પછી શૂન્ય, એક જ હશે
પછી બે, પછી ત્રણ, તો પછી ચાર.

1000
00:41:30,367 --> 00:41:33,200
તેથી આપણે આ નવા ભેગા દો
સ્ક્રેચ જેવા પઝલ ટુકડાઓ, તમે કરશે જો,

1001
00:41:33,200 --> 00:41:36,140
છતાં પણ, ફરીથી, આ વાક્યરચના
સ્ક્રેચ કરતાં વધુ arcane છે.

1002
00:41:36,140 --> 00:41:39,522
તેથી ટી એક સરનામું + + છે
હું મને આપી રહ્યું છે

1003
00:41:39,522 --> 00:41:42,480
એક નંબર, આ કારણ છે
અમે હેક્સ તરીકે ચિત્રકામ કરવામાં આવ્યા છે કે નંબરો.

1004
00:41:42,480 --> 00:41:43,560
પરંતુ તેઓ માત્ર નંબરો છો.

1005
00:41:43,560 --> 00:41:49,960
>> ટી ના સરનામા અમે જણાવ્યું હતું કે તેથી જો
હતી 0x88, 0x88 વત્તા શૂન્ય છે.

1006
00:41:49,960 --> 00:41:51,564

1007
00:41:51,564 --> 00:41:53,980
તમે આરામદાયક નથી, તો પણ
હજુ સુધી હેક્સ સાથે, એક અનુમાન છે.

1008
00:41:53,980 --> 00:41:54,410
>> પ્રેક્ષક: મૂળ.

1009
00:41:54,410 --> 00:41:55,850
>> ડેવિડ જે MALAN: 0x88 છતાં.

1010
00:41:55,850 --> 00:41:58,910
તેથી * શું અર્થ 0x88 છે?

1011
00:41:58,910 --> 00:42:02,670
તે અર્થ એ થાય કે જે "ત્યાં જાઓ", એનો અર્થ એ થાય
અસરકારક રીતે, "અહીં તમારી આંગળી મૂકો."

1012
00:42:02,670 --> 00:42:06,930
અને હવે જમણી બાજુ પર
આ સમીકરણ, * અને પછી parens માં,

1013
00:42:06,930 --> 00:42:11,586
ઓ હું, કે જે અર્થ એ થાય ઓ + +
અહીં થોડી ગ્રામ અપ સંબોધવા.

1014
00:42:11,586 --> 00:42:16,220
ઓ + + 0, અલબત્ત, છે ગમે ઓ, છે.

1015
00:42:16,220 --> 00:42:21,230
>> તેથી હવે, તે * ઓ છે, જે માત્ર * 33 જેવા
ઓક્સફર્ડ સ્ટ્રીટ સરનામું પર જાઓ અર્થ એ થાય

1016
00:42:21,230 --> 00:42:22,010
ઓ.

1017
00:42:22,010 --> 00:42:24,170
અહીં આ આંગળી, જમણા હાથમાં છે.

1018
00:42:24,170 --> 00:42:26,050
તેથી શું હું શું નકલ કરીશ?

1019
00:42:26,050 --> 00:42:30,260
છે, કે જે જમણી બાજુ પર આ બાબત,
ગાબે, અહીં માં અહીં થોડી ગ્રામ,.

1020
00:42:30,260 --> 00:42:32,750
>> કે અને તેથી અસર
લૂપ પ્રથમ પુનરાવૃત્તિ,

1021
00:42:32,750 --> 00:42:36,200
તમે તેને લાગે છે, તેમ છતાં દરખાસ્ત તરીકે
કંઈપણ કરતાં ક્રેઝી વધુ જટિલ

1022
00:42:36,200 --> 00:42:42,110
અમે પહેલાં જોઇ છે માત્ર કહી રહ્યાં છે
અહીં જાઓ અને અહીં અક્ષર નકલ કરો.

1023
00:42:42,110 --> 00:42:44,700
તે તમે બંને સ્થાનો પર એક નકશો આપી દીધો છે.

1024
00:42:44,700 --> 00:42:46,130
>> અને અમે આ વધુ જોશો.

1025
00:42:46,130 --> 00:42:50,600
પરંતુ હવે માટે, આશા માત્ર છે
આ મૂળભૂત વિચારો કેટલાક દાખલ.

1026
00:42:50,600 --> 00:42:53,550
અને ખરેખર, ચાલો જોવા દો
અહીં એક અંતિમ કાર્યક્રમ,

1027
00:42:53,550 --> 00:42:57,480
અને પછી વચન ક્લેમેશન,
જે બધું બધા અધિકાર કરશે.

1028
00:42:57,480 --> 00:42:57,980
અધિકાર છે.

1029
00:42:57,980 --> 00:43:01,680
તેથી મને ત્યાં અમે જાઓ ઘણું ખોલો.

1030
00:43:01,680 --> 00:43:02,850

1031
00:43:02,850 --> 00:43:05,440
અમે પાછા આવવા પડશે me-- તેથી દો
લાંબા પહેલાં આ ચિત્ર છે.

1032
00:43:05,440 --> 00:43:08,360
મને અહીં આ અંતિમ ઉદાહરણ ખોલો.

1033
00:43:08,360 --> 00:43:09,440

1034
00:43:09,440 --> 00:43:12,710
>> અહીં એક સુપર, સુપર છે
પરિપૂર્ણ કે કાર્યક્રમ

1035
00:43:12,710 --> 00:43:15,050
નીચેના કરે છે જીવનમાં કંઈ નથી.

1036
00:43:15,050 --> 00:43:18,740
તે પ્રથમ બે ચલો, એક્સ જાહેર
અને આ સમય નંબરો નથી કે વાય,

1037
00:43:18,740 --> 00:43:19,240
સે દીઠ.

1038
00:43:19,240 --> 00:43:20,448
તેઓ સે દીઠ, પૂર્ણાંકો નથી.

1039
00:43:20,448 --> 00:43:22,899
તેઓ * દેખીતી રીતે છે પૂર્ણાંક.

1040
00:43:22,899 --> 00:43:25,690
તેથી માત્ર કોઈને, તે શું અર્થ છે
તમારી માહિતી પ્રકાર છે, તમારા ચલ,

1041
00:43:25,690 --> 00:43:26,860
પ્રકાર પૂર્ણાંક * તારો છે?

1042
00:43:26,860 --> 00:43:30,240
કે પૂર્ણાંક ની સરનામા છે.

1043
00:43:30,240 --> 00:43:31,990
>> તેથી હું તે હજુ સુધી છે કે જ્યાં કોઈ વિચાર કર્યું.

1044
00:43:31,990 --> 00:43:35,150
તે માત્ર ", છેવટે, મૂકવા અર્થ
અહીં પૂર્ણાંક ની સરનામું. "

1045
00:43:35,150 --> 00:43:38,340
તે છે ત્યાં 0x50, 0x88,
મેમરી, એક સરનામું ત્યાં રહ્યું છે.

1046
00:43:38,340 --> 00:43:40,200
અને તે વાય શું છે
પણ, હોઈ ચાલે.

1047
00:43:40,200 --> 00:43:44,920
>> હું હવે કહે તો એક્સ = malloc ((પૂર્ણાંક) sizeof),
આ કહેતા ફેન્સી માર્ગ છે,

1048
00:43:44,920 --> 00:43:49,000
હેય ઓપરેટિંગ સિસ્ટમ, malloc દ્વારા,
માપ માટે મને પૂરતી મેમરી આપી

1049
00:43:49,000 --> 00:43:52,370
કદાચ, કે જે પૂર્ણાંક છે,
32 બિટ્સ અથવા ચાર બાઇટ્સ જ હશે.

1050
00:43:52,370 --> 00:43:53,680
>> તેથી malloc શું પાછા છે?

1051
00:43:53,680 --> 00:43:55,250
Malloc એક સરનામું આપે છે.

1052
00:43:55,250 --> 00:43:57,020
તેથી શું એક્સ સંગ્રહિત કરી રહ્યું છે?

1053
00:43:57,020 --> 00:44:00,600
ના ભાગ ની સરનામું
મેમરી, ચાર બાઇટ્સ, કે malloc

1054
00:44:00,600 --> 00:44:03,360
માત્ર પૂછીને મારા માટે જોવા મળે છે
ઓપરેટિંગ સિસ્ટમ.

1055
00:44:03,360 --> 00:44:08,240
>> હવે દરમિયાન, રેખા
અહીં ચાર, આ * એક્સ = 42.

1056
00:44:08,240 --> 00:44:09,990
જસ્ટ સ્પષ્ટ કરવા
નીચે ત્યાં શું ચાલી રહ્યું છે?

1057
00:44:09,990 --> 00:44:11,530
ડાબી બાજુ પર, * એક્સ.

1058
00:44:11,530 --> 00:44:13,610
કે * 33 ઓક્સફર્ડ સ્ટ્રીટ જેવું છે.

1059
00:44:13,610 --> 00:44:15,523
તેથી * એક્સ શું અર્થ થાય છે?

1060
00:44:15,523 --> 00:44:16,450
>> પ્રેક્ષક: પર જાઓ.

1061
00:44:16,450 --> 00:44:17,908
>> ડેવિડ જે MALAN: તે સરનામા પર જાઓ.

1062
00:44:17,908 --> 00:44:20,466
ત્યાં કે ભાગ
મેમરી તે પર જાઓ છે.

1063
00:44:20,466 --> 00:44:21,979
અને દેખીતી રીતે, શું ત્યાં મૂકી?

1064
00:44:21,979 --> 00:44:22,520
પ્રેક્ષક: 42.

1065
00:44:22,520 --> 00:44:23,580
ડેવિડ જે MALAN: 42.

1066
00:44:23,580 --> 00:44:25,650
બધા હક છે, * વાય જ વિચાર.

1067
00:44:25,650 --> 00:44:26,860
વાય માં સરનામા પર જાઓ.

1068
00:44:26,860 --> 00:44:31,740
ત્યાં સંખ્યા 13 મૂકો,
પરંતુ આ સમયે વાય શું છે?

1069
00:44:31,740 --> 00:44:33,172

1070
00:44:33,172 --> 00:44:34,630
પ્રેક્ષક: કોઈ મેમરી વાય માટે છે.

1071
00:44:34,630 --> 00:44:35,710
ડેવિડ જે MALAN: ત્યાં
વાય માટે કોઈ મેમરી છે.

1072
00:44:35,710 --> 00:44:38,215
તેથી શું કદાચ વાય કરે
અમે કહેતા થઈ છે, છે?

1073
00:44:38,215 --> 00:44:38,520
>> પ્રેક્ષક: કચરો.

1074
00:44:38,520 --> 00:44:39,480
>> ડેવિડ જે MALAN: કેટલાક કચરો કિંમત.

1075
00:44:39,480 --> 00:44:41,320
હવે, કચરો કિંમત હજુ પણ નંબર છે.

1076
00:44:41,320 --> 00:44:43,160
તે હજુ પણ એક સરનામું લેવામાં શકાય.

1077
00:44:43,160 --> 00:44:45,160
તે કોઈને છતાં છે
, નીચે કંઈક લખાયેલી

1078
00:44:45,160 --> 00:44:48,002
અને હું અર્થ તરીકે ખોટું અર્થઘટન
શેરી નીચે કેટલાક મકાન.

1079
00:44:48,002 --> 00:44:50,460
અને તમે માત્ર જાય પ્રયાસ કરો
તમે માલિક નથી કેટલાક મકાન,

1080
00:44:50,460 --> 00:44:53,710
અથવા મેમરી કેટલાક ભાગ તમે નથી
આપવામાં આવી, ખરાબ વસ્તુઓ થાય છે શકે છે.

1081
00:44:53,710 --> 00:44:57,740
કમ્પ્યુટર કેટલાક અન્ય ભાંગી, અથવા શકે
અનિશ્ચિત વર્તન થાય શકે છે.

1082
00:44:57,740 --> 00:45:01,310
>> તો પછી, Binky આ ​​પ્રસ્તાવના છે.

1083
00:45:01,310 --> 00:45:04,290
હું હજુ પણ 20, યાદ
કેટલાક વિચિત્ર વર્ષ પછી,

1084
00:45:04,290 --> 00:45:07,200
હું જ્યારે હું આખરે હતી, જ્યાં
પોઇન્ટર સમજી.

1085
00:45:07,200 --> 00:45:09,520
>> તમે જો, કહે છે જે
ત્રણ મિનિટ અહીં છોડી

1086
00:45:09,520 --> 00:45:12,170
અને હું નથી લાગે છે
પોઇન્ટર સમજી, ખ્યાલ

1087
00:45:12,170 --> 00:45:14,410
હું 20 માટે યાદ છે
કેટલાક ઉન્મત્ત કારણોસર વર્ષ

1088
00:45:14,410 --> 00:45:17,140
જ્યારે શા માટે તે છેલ્લે સ્તરે
માં, મારા શિક્ષણ સાથે બેઠક

1089
00:45:17,140 --> 00:45:19,501
સાથી, Nishat મહેતા માં
એલિયટ ડાઇનિંગ હોલ ઓફ પાછા.

1090
00:45:19,501 --> 00:45:21,250
હવે, હું યાદ છે
આ હતો કારણ કે

1091
00:45:21,250 --> 00:45:23,920
આ મુદ્દાઓ હું માં એક
ચોક્કસ સાથે સંઘર્ષ કર્યો.

1092
00:45:23,920 --> 00:45:26,470
અને પછી, તે આખરે ક્લિક,
જેમ હું વિષયો ઘણો કબૂલ કરું છું

1093
00:45:26,470 --> 00:45:27,460
છેવટે કરશે.

1094
00:45:27,460 --> 00:45:32,590
અને હવે, કે જે બધા લાગે બનાવવા માટે
ખુશ અને તમામ વધુ સમજી,

1095
00:45:32,590 --> 00:45:35,360
માતાનો એક અંતિમ નજર અમારા
અહીં Binky ખાતે છેલ્લા ત્રણ મિનિટ,

1096
00:45:35,360 --> 00:45:37,675
અમારા મિત્ર, નિક થી
સ્ટેનફોર્ડ માંથી Parlante.

1097
00:45:37,675 --> 00:45:38,910

1098
00:45:38,910 --> 00:45:41,580
>> [વિડિઓ પ્લેબેક]

1099
00:45:41,580 --> 00:45:42,750
>> -Hey, Binky.

1100
00:45:42,750 --> 00:45:43,500
અપ વેક!

1101
00:45:43,500 --> 00:45:45,960
તે નિર્દેશક આનંદ માટે સમય છે.

1102
00:45:45,960 --> 00:45:47,012
>> કે -શું છે?

1103
00:45:47,012 --> 00:45:48,723
પોઇન્ટર વિશે જાણો!

1104
00:45:48,723 --> 00:45:50,580
ઓહ, એક જાતની મીઠાઈ!

1105
00:45:50,580 --> 00:45:53,563
>> -વેલ, પ્રારંભ કરવા માટે, અમે છો ધારી
બે પોઇંટરો જરૂર જઈ.

1106
00:45:53,563 --> 00:45:54,390
>> -OK.

1107
00:45:54,390 --> 00:45:57,930
આ કોડ છે, બે પોઇંટરો ફાળવે
જે પૂર્ણાંકો માટે નિર્દેશ કરી શકો છો.

1108
00:45:57,930 --> 00:45:58,430
-OK.

1109
00:45:58,430 --> 00:46:02,140
ઠીક છે, હું બે પોઇંટરો જુએ છે, પરંતુ તેઓ
કંઈપણ પોઇન્ટ લાગે છે નથી.

1110
00:46:02,140 --> 00:46:02,980
>> એટલે સાચું છે.

1111
00:46:02,980 --> 00:46:05,100
શરૂઆતમાં, પોઇંટરો
કંઈપણ માટે નિર્દેશ નથી.

1112
00:46:05,100 --> 00:46:08,030
તેઓ કહે છે માટે નિર્દેશ આ વસ્તુઓ
pointees, અને માતાનો તેમને સુયોજિત

1113
00:46:08,030 --> 00:46:09,370
એક અલગ પગલું.

1114
00:46:09,370 --> 00:46:10,220
>> અધિકાર, અધિકાર, -Oh.

1115
00:46:10,220 --> 00:46:10,950
હું જાણતા હતા કે.

1116
00:46:10,950 --> 00:46:12,385
આ pointees અલગ છે.

1117
00:46:12,385 --> 00:46:14,315
Er છે, જેથી તમે કેવી રીતે એક pointee ફાળવવા છે?

1118
00:46:14,315 --> 00:46:15,340

1119
00:46:15,340 --> 00:46:15,960
>> -OK.

1120
00:46:15,960 --> 00:46:18,970
વેલ, આ કોડ ફાળવે
નવી પૂર્ણાંક pointee,

1121
00:46:18,970 --> 00:46:20,950
અને આ ભાગ સેટ એક્સ તે માટે નિર્દેશ.

1122
00:46:20,950 --> 00:46:22,050

1123
00:46:22,050 --> 00:46:23,230
>> -Hey, કે વધુ સારી દેખાય છે.

1124
00:46:23,230 --> 00:46:25,060
તેથી તે કંઈક છે.

1125
00:46:25,060 --> 00:46:25,990
>> -OK.

1126
00:46:25,990 --> 00:46:30,455
હું નિર્દેશક એક્સ ડિરેફરન્સ પડશે
તેના pointee માં 42 નંબર સ્ટોર કરે છે.

1127
00:46:30,455 --> 00:46:32,830
આ યુક્તિ માટે, હું જરૂર પડશે મારા
Dereferencing ના મેજિક વાન્ડ.

1128
00:46:32,830 --> 00:46:34,130

1129
00:46:34,130 --> 00:46:36,080
>> Dereferencing ના -તમારા મેજિક વાન્ડ?

1130
00:46:36,080 --> 00:46:37,357

1131
00:46:37,357 --> 00:46:38,190
તેનો કે મહાન છે.

1132
00:46:38,190 --> 00:46:39,340

1133
00:46:39,340 --> 00:46:41,080
>> -આ કોડ શું લાગે છે.

1134
00:46:41,080 --> 00:46:44,110
હું માત્ર નંબર, અને [પીઓપી] સુયોજિત પડશે

1135
00:46:44,110 --> 00:46:44,700
>> -Hey, જુઓ.

1136
00:46:44,700 --> 00:46:46,140
ત્યાં તે જાય છે.

1137
00:46:46,140 --> 00:46:50,980
>> એક્સ નીચે પર ખોટો સંદર્ભ કરી -તેથી
તીર તેના pointee ઍક્સેસ કરવા માટે.

1138
00:46:50,980 --> 00:46:53,160
આ કિસ્સામાં, ત્યાં એક સ્ટોર 42.

1139
00:46:53,160 --> 00:46:57,710
અરે સંખ્યા સંગ્રહવા માટે તે ઉપયોગ કરવાનો પ્રયાસ કરો
અન્ય નિર્દેશક દ્વારા 13, વાય.

1140
00:46:57,710 --> 00:46:58,760
>> -OK.

1141
00:46:58,760 --> 00:47:03,270
હું માત્ર વાય માટે અહીં પર જઈશ,
અને સંખ્યા 13 સેટ અપ છે.

1142
00:47:03,270 --> 00:47:07,930
અને પછી, ના વાન્ડ લેવા
Dereferencing છે અને માત્ર [ચેતન]

1143
00:47:07,930 --> 00:47:08,960
>> -Oh!

1144
00:47:08,960 --> 00:47:09,500
>> હેય, -Oh!

1145
00:47:09,500 --> 00:47:11,090
તે કામ ન હતી.

1146
00:47:11,090 --> 00:47:15,630
Binky, હું dereferencing લાગતું નથી, કહો
તમે જાણો છો, કારણ કે વાય, એક સારો વિચાર છે

1147
00:47:15,630 --> 00:47:17,850
આ pointee સુયોજિત
એક અલગ પગલું છે.

1148
00:47:17,850 --> 00:47:20,450
અને હું અમે ક્યારેય તે કર્યું નથી લાગતું નથી.

1149
00:47:20,450 --> 00:47:21,480
>> -Good બિંદુ.

1150
00:47:21,480 --> 00:47:21,980
-Yeah.

1151
00:47:21,980 --> 00:47:25,680
અમે નિર્દેશક વાય ફાળવવામાં પરંતુ અમે
ક્યારેય એક pointee માટે નિર્દેશ સુયોજિત કરો.

1152
00:47:25,680 --> 00:47:27,190

1153
00:47:27,190 --> 00:47:28,616
>> -Very સચેત.

1154
00:47:28,616 --> 00:47:30,240
-Hey, તમે ત્યાં Binky સારી શોધી રહ્યાં છે.

1155
00:47:30,240 --> 00:47:33,400
તમે કે જેથી તેને ઠીક કરી શકે છે વાય પોઇન્ટ
એક્સ તરીકે જ pointee માટે?

1156
00:47:33,400 --> 00:47:34,000
>> -Sure.

1157
00:47:34,000 --> 00:47:36,780
હું મારા મેજિક વાન્ડ ઉપયોગ કરશો
પોઇન્ટર સોંપણી ના.

1158
00:47:36,780 --> 00:47:38,740
>> હોઈ ચાલે છે કે નબળી ગણાય છે
પહેલાં જેવી સમસ્યા?

1159
00:47:38,740 --> 00:47:39,240
-કોઈ.

1160
00:47:39,240 --> 00:47:40,660
આ pointees સ્પર્શ નથી.

1161
00:47:40,660 --> 00:47:44,450
તે માત્ર એક નિર્દેશક બદલે
અન્ય જેવા જ વસ્તુ માટે નિર્દેશ.

1162
00:47:44,450 --> 00:47:45,450
>> -Oh, હું જુઓ.

1163
00:47:45,450 --> 00:47:48,200
એક્સ તરીકે જ જગ્યાએ હવે વાય નિર્દેશ કરે છે.

1164
00:47:48,200 --> 00:47:48,910
તેથી રાહ જુઓ.

1165
00:47:48,910 --> 00:47:49,950
હવે, વાય સુધારેલ છે.

1166
00:47:49,950 --> 00:47:51,120
તે એક pointee છે.

1167
00:47:51,120 --> 00:47:54,510
તેથી તમે આ લાકડી પ્રયાસ કરી શકો છો
13 ઉપર મોકલવા માટે ફરી dereferencing.

1168
00:47:54,510 --> 00:47:56,510
>> ઠીક છે, -Uh.

1169
00:47:56,510 --> 00:47:58,160
અહીં તે જાય છે. [પીઓપી]

1170
00:47:58,160 --> 00:47:59,340
>> -Hey, કે જુઓ.

1171
00:47:59,340 --> 00:48:00,750
હવે વાય પર કામ કરે છે dereferencing.

1172
00:48:00,750 --> 00:48:04,991
અને પોઇન્ટર શેર કરી રહ્યાં છે કારણ કે
એક pointee છે, તેઓ બંને 13 જુઓ.

1173
00:48:04,991 --> 00:48:05,490
-Yeah.

1174
00:48:05,490 --> 00:48:06,870
શેરિંગ, ગમે.

1175
00:48:06,870 --> 00:48:08,820
તેથી અમે હવે સ્થાનો સ્વિચ જવું છે?

1176
00:48:08,820 --> 00:48:09,440
>> ઓહ, લાગે છે.

1177
00:48:09,440 --> 00:48:10,830
અમે સમય નથી.

1178
00:48:10,830 --> 00:48:11,570
>> -But--

1179
00:48:11,570 --> 00:48:13,530
>> ત્રણ નિર્દેશક નિયમો યાદ-ફક્ત.

1180
00:48:13,530 --> 00:48:16,560
નંબર વન, મૂળભૂત માળખું
તમે એક નિર્દેશક હોય છે,

1181
00:48:16,560 --> 00:48:18,680
અને તે pointee પર નિર્દેશ કરે છે.

1182
00:48:18,680 --> 00:48:20,640
પરંતુ નિર્દેશક અને
pointee, અલગ છે

1183
00:48:20,640 --> 00:48:22,610
અને સામાન્ય ભૂલ
નિર્દેશક સુયોજિત કરવા માટે છે,

1184
00:48:22,610 --> 00:48:25,000
પરંતુ તે pointee આપી ભૂલી છે.

1185
00:48:25,000 --> 00:48:28,170
>> સંખ્યા બે, નિર્દેશક dereferencing
નિર્દેશક પર શરૂ થાય છે

1186
00:48:28,170 --> 00:48:31,050
અને ઉપર તેના તીર નીચે
તેના pointee ઍક્સેસ કરવા માટે.

1187
00:48:31,050 --> 00:48:33,400
આપણે બધાં જ જાણીએ, આ
જો ત્યાં માત્ર કામ કરે છે

1188
00:48:33,400 --> 00:48:36,270
એક pointee છે, કે જે પ્રકારની
નંબર વન શાસન પાછા મળે છે.

1189
00:48:36,270 --> 00:48:39,000
>> સંખ્યા ત્રણ, નિર્દેશક
સોંપણી એક નિર્દેશક લે છે

1190
00:48:39,000 --> 00:48:42,320
અને નિર્દેશ કરવા માટે તેને બદલે છે
અન્ય નિર્દેશક તરીકે જ pointee.

1191
00:48:42,320 --> 00:48:44,160
સોંપણી પછી તેથી,
બે પોઇન્ટર

1192
00:48:44,160 --> 00:48:45,910
એ જ pointee માટે નિર્દેશ કરશે.

1193
00:48:45,910 --> 00:48:47,990
ક્યારેક, કે શેરિંગ કહેવાય છે.

1194
00:48:47,990 --> 00:48:49,740
અને તે ખરેખર, તે ત્યાં છે બધા છે.

1195
00:48:49,740 --> 00:48:50,277
બાય બાય હવે.

1196
00:48:50,277 --> 00:48:51,110
[સમાપ્ત વિડિઓ પ્લેબેક]

1197
00:48:51,110 --> 00:48:52,568
ડેવિડ જે MALAN: તે CS50 માટે છે.

1198
00:48:52,568 --> 00:48:55,110
અમે આગામી સપ્તાહે તમે જોશો.

1199
00:48:55,110 --> 00:48:56,064