1
00:00:00,000 --> 00:00:11,200

2
00:00:11,200 --> 00:00:12,580
>> DAVID MALAN: બધા હક, પાછા સ્વાગત છે.

3
00:00:12,580 --> 00:00:13,290
આ CS50 છે.

4
00:00:13,290 --> 00:00:15,130
આ સપ્તાહના સાત શરૂઆત છે.

5
00:00:15,130 --> 00:00:18,890
તેથી તે જ્યારે આવી છે, જેથી હું અમે કરશો વિચાર્યું છે
જ્યાં અમે એક વાવંટોળ મુલાકાત લો

6
00:00:18,890 --> 00:00:20,760
બંધ છોડી દીધી અને જ્યાં આપણે હવે જઈ રહ્યાં છો.

7
00:00:20,760 --> 00:00:23,310
>> આ બાબત અહીં પડી શકે છે તેથી
પ્રથમ કેટલાક angst થાય છે.

8
00:00:23,310 --> 00:00:27,680
પરંતુ આસ્થાપૂર્વક, તમે શરૂ કરી રહ્યા છીએ
આ અહીં સૂચવે છે શું acclimate -

9
00:00:27,680 --> 00:00:32,670
જે નિર્દેશક પ્રતિનિધિત્વ સ્ટાર
વધુ જનસાધારણ ના નિયમો માત્ર શું?

10
00:00:32,670 --> 00:00:33,400
તેથી તે એક સરનામું છે.

11
00:00:33,400 --> 00:00:35,490
>> તેથી તે સરનામું છે
મેમરી માં કંઈક.

12
00:00:35,490 --> 00:00:38,260
અને અમે પાછા છાલ સ્તરો શરૂ
થોડા અઠવાડિયા પહેલા, વસ્તુઓ ગમે

13
00:00:38,260 --> 00:00:41,800
GetString અને અન્ય જેમ કે કાર્યો
આ બધા સમય પરત કરવામાં આવી છે

14
00:00:41,800 --> 00:00:46,010
જેવા મેમરી વસ્તુઓ સરનામાં,
પ્રથમ પાત્ર સરનામા

15
00:00:46,010 --> 00:00:46,990
અમુક શ્રેણી.

16
00:00:46,990 --> 00:00:50,360
>> તેથી આપણે પણ, valgrind રજૂઆત કરી હતી
જો તમે આ સમસ્યા માટે ઉપયોગ શરૂ કરશો

17
00:00:50,360 --> 00:00:53,380
ખાસ કરીને આગામી માટે સુયોજિત
સમસ્યા તેમજ સુયોજિત કરો.

18
00:00:53,380 --> 00:00:54,980
અને valgrind અમારા માટે શું કરે છે?

19
00:00:54,980 --> 00:00:57,520

20
00:00:57,520 --> 00:01:01,020
તે મેમરી લિક માટે ચકાસે છે, અને તે
પણ મેમરી દુરુપયોગ માટે ચકાસે છે.

21
00:01:01,020 --> 00:01:05,890
>> તે કેટલાક સંભાવના સાથે શોધી શકાય છે જો
તમારો કોડ મેમરી સ્પર્શ ચાલે છે

22
00:01:05,890 --> 00:01:07,100
તે માત્ર ન જોઈએ.

23
00:01:07,100 --> 00:01:10,410
જેથી છિદ્ર જરૂરી છે, પરંતુ જો તમે નથી
કેટલાક સીમાઓને જાઓ

24
00:01:10,410 --> 00:01:14,730
અરે, અને તમે ખરેખર valgrind સ્કોર
અને તે વર્તન પ્રેરિત કરતી

25
00:01:14,730 --> 00:01:17,870
valgrind છે તમારા કાર્યક્રમ ચાલી રહ્યો છે
તે અંદર ચાલી રહ્યું છે, તમે મળશે

26
00:01:17,870 --> 00:01:21,460
આ જેમ સંદેશા - "અમાન્ય લખી
, એક દંપતિ યાદ જે કદ 4, "

27
00:01:21,460 --> 00:01:25,880
અઠવાડિયા પહેલા હું આકસ્મિક હતું કે અર્થ
પણ અત્યાર સુધી એક ઈન્ પર ગમે

28
00:01:25,880 --> 00:01:27,250
એક એરે ની સીમાઓને.

29
00:01:27,250 --> 00:01:30,790
અને તેથી કદ 4 અહીં માપ અર્થ એ થાય
ચોક્કસ ઈન્ છે.

30
00:01:30,790 --> 00:01:35,260
>> તેથી હકીકતમાં આશ્ચાસન લઇ
valgrind આઉટપુટનું, તે બંધારણ,

31
00:01:35,260 --> 00:01:36,170
માત્ર ભયાનક છે.

32
00:01:36,170 --> 00:01:40,180
તે વાસણ મારફતે જોવા માટે ખરેખર હાર્ડ
આ રસપ્રદ જાણકારી માટે.

33
00:01:40,180 --> 00:01:42,910
તેથી શું અમે અહીં કર્યું માત્ર ટૂંકસાર છે
વધુ દંપતિ કેટલાક

34
00:01:42,910 --> 00:01:43,850
રસપ્રદ રેખાઓ.

35
00:01:43,850 --> 00:01:46,760
પરંતુ ખ્યાલ છે કે valgrind ના 80%
આઉટપુટ એક એક બીટ હોઈ ચાલે છે

36
00:01:46,760 --> 00:01:47,650
વિક્ષેપ.

37
00:01:47,650 --> 00:01:52,820
>> માત્ર આ જેવા પેટર્ન માટે જુઓ -
અધિકાર અમાન્ય છે, અમાન્ય, 40 બાઇટ્સ વાંચી

38
00:01:52,820 --> 00:01:56,690
અને બ્લોકો કેટલાક નંબર ચોક્કસપણે છે
કે જેમ કીવર્ડ્સ, હારી ગયો હતો.

39
00:01:56,690 --> 00:02:01,920
અને શું આશા જોશો કેટલાક છે
કાર્ય શું ટ્રેસ કાઇન્ડ

40
00:02:01,920 --> 00:02:03,340
ભૂલ સાઇન ખરેખર છે

41
00:02:03,340 --> 00:02:07,195
અહીં આ કિસ્સામાં, કયા વાક્ય
મારી કોડ દેખીતી રીતે ભૂલ હતી?

42
00:02:07,195 --> 00:02:09,729

43
00:02:09,729 --> 00:02:14,130
>> હતી memory.c તરીકે ઓળખાતી ફાઈલ માં 26
અમે સાથે રમતા હતા ઉદાહરણ

44
00:02:14,130 --> 00:02:14,890
તે સમયે.

45
00:02:14,890 --> 00:02:16,460
તેથી તે malloc માં કદાચ નથી.

46
00:02:16,460 --> 00:02:18,630
તે જગ્યાએ મારો કોડ કદાચ હતી.

47
00:02:18,630 --> 00:02:20,910
તેથી અમે ફરી આ જોશો
અને ફરીથી લાંબા પહેલા.

48
00:02:20,910 --> 00:02:24,080
>> Scanf તેથી, આ એક માં આવ્યા
આમ અત્યાર સુધી સ્વરૂપો દંપતિ.

49
00:02:24,080 --> 00:02:26,410
અમે થોડા સમય sscanf જોયું.

50
00:02:26,410 --> 00:02:28,330
તે કંઈક એક નંબર હતી
તમે તમારી માં વિભાજિત dived

51
00:02:28,330 --> 00:02:29,535
ક્વિઝ માટે તૈયારીઓ.

52
00:02:29,535 --> 00:02:33,130
અને scanf ખરેખર શું CS50
પુસ્તકાલયમાં નીચે ઉપયોગ કરી રહ્યો છે

53
00:02:33,130 --> 00:02:36,560
ક્રમમાં અમુક સમય માટે શાંત હૂડ
વપરાશકર્તા ઇનપુટ વિચાર.

54
00:02:36,560 --> 00:02:40,420
>> હમણાં પૂરતું, હું CS50 પર ખસેડો જો
સાધન, અહીં એક મને ખોલો દો

55
00:02:40,420 --> 00:02:45,315
scanf-0.c કહેવાય છે કે ઉદાહરણ આજે
અને તે સુપર સરળ છે.

56
00:02:45,315 --> 00:02:46,590
તે માત્ર કોડ થોડા લીટીઓ છે.

57
00:02:46,590 --> 00:02:50,880
પરંતુ તે દર્શાવે ખરેખર કેવી રીતે getInt
આ સમયે બધા કામ કરવામાં આવ્યું છે.

58
00:02:50,880 --> 00:02:54,710
>> રેખા 16 માં અહીં આ કાર્યક્રમ છે,
, હું એક ઈન્ જાહેર કે નોટિસ.

59
00:02:54,710 --> 00:02:57,270
તેથી કોઈ પોઇન્ટર, જાદુઈ કંઇ
ત્યાં માત્ર એક ઈન્.

60
00:02:57,270 --> 00:03:00,330
પછી વાક્ય 17, હું તમને પૂછવા
એક નંબર માટે વપરાશકર્તા, કૃપા કરીને.

61
00:03:00,330 --> 00:03:02,930
પછી અંતમાં 18 માં, હું અહીં scanf વાપરો.

62
00:03:02,930 --> 00:03:06,910
અને હું ઉલ્લેખ પ્રકારની જેમ printf છે,
હું કંપની અપેક્ષા છું કે

63
00:03:06,910 --> 00:03:08,110
ટકા હું અવતરણ ચિહ્નો પૂરાં કરવાં.

64
00:03:08,110 --> 00:03:10,920
>> ટકા એટલે, અલબત્ત,
એક ઈન્ સૂચવે છે.

65
00:03:10,920 --> 00:03:14,580
પરંતુ નોટિસ શું બીજા
scanf દલીલ છે.

66
00:03:14,580 --> 00:03:17,350
તમે કેવી રીતે બીજા વર્ણન કરશે
અલ્પવિરામથી પછી દલીલ?

67
00:03:17,350 --> 00:03:19,450
કે શું?

68
00:03:19,450 --> 00:03:20,670
>> તે X ની સરનામું.

69
00:03:20,670 --> 00:03:25,490
તેથી આ કારણ આપીને ઉપયોગી છે
X ની સરનામા સાથે scanf, શું કરે છે

70
00:03:25,490 --> 00:03:29,560
તે કરવા માટે કે જે કાર્ય સમર્થ?

71
00:03:29,560 --> 00:03:33,010
માત્ર ત્યાં જાઓ, પણ શું?

72
00:03:33,010 --> 00:03:34,060
>> તે ફેરફાર કરો.

73
00:03:34,060 --> 00:03:38,080
તમે ત્યાં જઈ શકે છે, કારણ કે તે પ્રકારની છે
મેમરીમાં પાંચ આંકડાના US સ્થાન માટે નકશો છે.

74
00:03:38,080 --> 00:03:41,900
અને તેથી લાંબા તમે પૂરી પાડે scanf, અથવા
જેમ કે એક નકશો, કે જે કોઈપણ કાર્ય

75
00:03:41,900 --> 00:03:45,840
કાર્ય ત્યાં જાઓ અને કરી શકે છે માત્ર
મૂલ્ય જોવા છે, પરંતુ તે પણ કરી શકો છો

76
00:03:45,840 --> 00:03:49,670
ઉપયોગી છે જો કે જે મૂલ્ય, ફેરફાર
scanf જીવન માં હેતુ માટે છે

77
00:03:49,670 --> 00:03:53,060
ખાસ કરીને, વપરાશકર્તા ઇનપુટ સ્કૅન
કીબોર્ડ છે.

78
00:03:53,060 --> 00:03:57,830
અને એફ જેમ, ફોર્મેટ સૂચવે
printf, એફ એક ફોર્મેટ સૂચવે

79
00:03:57,830 --> 00:03:58,930
તમે છાપવાનો કરવા માંગો છો તે સ્ટ્રિંગ.

80
00:03:58,930 --> 00:04:04,430
>> તેથી ટૂંકા, આ રેખા 18 ખાલી કહે છે,
વપરાશકર્તાની એક ઈન્ વાંચવાનો પ્રયત્ન કરો

81
00:04:04,430 --> 00:04:10,420
કીબોર્ડ અને અંતે X ની અંદર તે સ્ટોર
X ખાતે રહેવા માટે થાય છે ગમે સરનામું.

82
00:04:10,420 --> 00:04:14,860
અને પછી છેલ્લે, લાઇન 19 માત્ર કહે છે,
આ કિસ્સામાં ઈન્ માટે આભાર.

83
00:04:14,860 --> 00:04:15,940
>> તેથી મને આગળ વધો અને આ બનાવવા દો.

84
00:04:15,940 --> 00:04:18,570
તેથી scanf 0 બનાવે છે.

85
00:04:18,570 --> 00:04:20,130
મને આગળ વધો અને સાઇન ઝૂમ દો

86
00:04:20,130 --> 00:04:22,960
હું સાથે જઇ અને આ સ્કોર પડશે
બિંદુઓ scanf 0 સ્લેશ.

87
00:04:22,960 --> 00:04:24,020
નંબર છે, કૃપા કરીને?

88
00:04:24,020 --> 00:04:24,720
50.

89
00:04:24,720 --> 00:04:25,730
50 માટે આભાર.

90
00:04:25,730 --> 00:04:27,270
તેથી તે ખૂબ સરળ છે.

91
00:04:27,270 --> 00:04:28,160
>> તે હવે શું કરી નથી?

92
00:04:28,160 --> 00:04:29,940
જો તે સમગ્ર ટોળું કરી નથી
ભૂલ ચકાસણી છે.

93
00:04:29,940 --> 00:04:33,000
હમણાં પૂરતું, હું સહકાર ન હોય તો,
અને હું એક નંબર લખી નથી, પરંતુ

94
00:04:33,000 --> 00:04:37,860
તેના બદલે હું "હેલો," કંઈક લખવા
એ વિચિત્ર માત્ર પ્રકારની છે.

95
00:04:37,860 --> 00:04:41,130
આ વસ્તુઓ CS50 અને તેથી એક
લાઇબ્રેરી કેટલીક અમને માટે કરી દેવામાં આવી છે

96
00:04:41,130 --> 00:04:43,440
સમય કે reprompting છે
અને reprompting.

97
00:04:43,440 --> 00:04:49,320
>> આ ફરી પ્રયાસ શબ્દસમૂહ બોલાવવાનો, cs50.c હતી
અને કે getInt માં કારણ છે

98
00:04:49,320 --> 00:04:51,670
જો CS50 પુસ્તકાલય ખરેખર સમગ્ર છે
લાંબા લીટીઓ ટોળું, અમે કરશો કારણ કે

99
00:04:51,670 --> 00:04:53,190
આ જેમ મૂર્ખ સામગ્રી માટે તપાસ.

100
00:04:53,190 --> 00:04:55,730
વપરાશકર્તા આપી ન હતી
અમને, હકીકતમાં, એક ઈન્?

101
00:04:55,730 --> 00:04:57,910
તે અથવા તેણી અમને કંઈક આપી હતી
એક મૂળાક્ષર અક્ષર જેવા?

102
00:04:57,910 --> 00:05:01,410
જો એમ હોય તો, અમે શોધી કરવા માંગો છો
કે અને તેમને કિકિયારી.

103
00:05:01,410 --> 00:05:03,915
>> પરંતુ બધી વસ્તુઓ વધુ રસપ્રદ વિચાર
આ આગામી ઉદાહરણ છે.

104
00:05:03,915 --> 00:05:09,840
હું scanf-1.c પર જાઓ નહિં, તો શું એક છે
મૂળભૂત બદલાયેલ છે કે વસ્તુ

105
00:05:09,840 --> 00:05:11,135
આ આગામી ઉદાહરણ?

106
00:05:11,135 --> 00:05:13,690

107
00:05:13,690 --> 00:05:16,010
હું, અલબત્ત, ચાર * મદદથી છું
તેના બદલે ઈન્ છે.

108
00:05:16,010 --> 00:05:19,210
>> કારણ કે ચાર * તેથી આ,, રસપ્રદ છે
યાદ, માત્ર ખરેખર છે

109
00:05:19,210 --> 00:05:20,190
શબ્દમાળા તરીકે જ વાત.

110
00:05:20,190 --> 00:05:23,840
તેથી તે કદાચ જેવી આ સુપર છે લાગે છે
GetString સરળ અમલીકરણ.

111
00:05:23,840 --> 00:05:26,010
પરંતુ હું સ્તર પાછા peeled કર્યું
જો CS50 ગ્રંથાલયનો, હું તેથી

112
00:05:26,010 --> 00:05:27,550
હવે આ ચાર * ફોન.

113
00:05:27,550 --> 00:05:30,070
તેથી માતાનો જોવા દો, જ્યાં ગમે તો,
અમે ખોટું જાઓ.

114
00:05:30,070 --> 00:05:30,840
>> રેખા 17 -

115
00:05:30,840 --> 00:05:33,950
હું ફરી મારા કંઈક આપવા, કૃપા કરીને કહે છે
આ કિસ્સામાં, એક સ્ટ્રિંગ.

116
00:05:33,950 --> 00:05:37,940
અને પછી આગળના વાક્ય, હું scanf કૉલ
ફરીથી, જો તે બંધારણમાં કોડ આપ્યા,

117
00:05:37,940 --> 00:05:39,310
પરંતુ આ સમય ટકા ઓ.

118
00:05:39,310 --> 00:05:41,900
અને પછી આ સમય, હું છું
તે બફર આપવી.

119
00:05:41,900 --> 00:05:43,550
>> હવે હું ઉપયોગ ન છું, નોટિસ
આ & "અને" નું ચિહ્ન.

120
00:05:43,550 --> 00:05:47,120
પરંતુ શા માટે અહીં કદાચ ઠીક છે?

121
00:05:47,120 --> 00:05:49,760
પહેલેથી જ બફર શું છે કારણ?

122
00:05:49,760 --> 00:05:50,770
જો તે પહેલાથી જ નિર્દેશક છે.

123
00:05:50,770 --> 00:05:51,650
તે પહેલાથી જ એક સરનામું છે.

124
00:05:51,650 --> 00:05:54,510
>> અને દો આ શબ્દ મને દો ", સ્વાંગ" છે
માત્ર માટે, ઉદાહરણ તરીકે, તે ઓ કૉલ

125
00:05:54,510 --> 00:05:55,050
સરળતા.

126
00:05:55,050 --> 00:05:58,250
પરંતુ હું તે બફર કહેવાય કર્યું કારણ કે
સામાન્ય રીતે, પ્રોગ્રામિંગ, તમે એક હોય તો

127
00:05:58,250 --> 00:06:02,130
મેમરી ચંકને છે, કે જે શબ્દમાળા ખરેખર
, ફક્ત તમે તે બફર કૉલ શકે છે.

128
00:06:02,130 --> 00:06:04,460
તે જાણકારી સંગ્રહવા માટે એક સ્થળ છે.

129
00:06:04,460 --> 00:06:07,400
>> જ્યારે YouTube, જેવી વસ્તુઓ માટે સરખી
તેઓ, તેથી વાત કરવા માટે, તટસ્થ રહ્યા છો

130
00:06:07,400 --> 00:06:10,270
માત્ર તે બીટ્સ ડાઉનલોડ રહ્યું અર્થ એ થાય
ઇન્ટરનેટ અને તેમને સ્ટોર

131
00:06:10,270 --> 00:06:14,160
સ્થાનિક અરે, જેથી મેમરી એક સ્થાનિક ચંકને
તમે વિના પાછળથી તેને જોઈ શકો છો કે જે

132
00:06:14,160 --> 00:06:16,830
તે છોડવામાં આવી રહ્યા છે અથવા અટકી
તમે પાછા રમે છે.

133
00:06:16,830 --> 00:06:20,930
>> તેથી સમસ્યા, છતાં અહીં છે
હું scanf જણાવું છું, કારણ કે એક અપેક્ષા

134
00:06:20,930 --> 00:06:22,320
વપરાશકર્તા માંથી શબ્દમાળા.

135
00:06:22,320 --> 00:06:24,410
અહીં ની સરનામા ચોક્કો
મેમરીની ચંકને.

136
00:06:24,410 --> 00:06:26,180
ત્યાં કે શબ્દમાળા મૂકો.

137
00:06:26,180 --> 00:06:31,230
શા માટે છે કે જે બાઉન્ડ આપી છે
જોકે અમને મુશ્કેલી?

138
00:06:31,230 --> 00:06:33,490
>> કે શું?

139
00:06:33,490 --> 00:06:35,510
હું ઍક્સેસ કરવાની મંજૂરી છું
મેમરી કે ભાગ?

140
00:06:35,510 --> 00:06:36,250
તમે જાણો છો, મને ખબર નથી.

141
00:06:36,250 --> 00:06:39,210
બફર આરંભ કરવામાં આવ્યો છે કારણ કે
ખાવા માટે?

142
00:06:39,210 --> 00:06:39,820
નથી ખરેખર.

143
00:06:39,820 --> 00:06:43,090
અને તેથી તે અમે ફોન કરવામાં આવ્યાં છે શું
એક કચરો કિંમત છે, કે જે

144
00:06:43,090 --> 00:06:44,040
એક સામાન્ય શબ્દ નથી.

145
00:06:44,040 --> 00:06:49,200
તે માત્ર અમે શું બીટ્સ કોઈ વિચાર હોય છે એનો અર્થ એ થાય
કે ચાર બાઇટ્સ ની અંદર છે

146
00:06:49,200 --> 00:06:51,240
હું બફર તરીકે ફાળવવામાં આવ્યા છે.

147
00:06:51,240 --> 00:06:52,450
>> હું malloc કહેવાય નથી.

148
00:06:52,450 --> 00:06:53,940
હું ચોક્કસપણે GetString કહેવાય નથી કર્યું.

149
00:06:53,940 --> 00:06:56,380
તેથી જે ખરેખર શું છે તે જાણે છે
બફર ની અંદર?

150
00:06:56,380 --> 00:07:00,550
અને હજુ સુધી scanf કહેવાની અકારણ, ત્યાં જાઓ
અને વપરાશકર્તા ટાઇપ ગમે મૂકો.

151
00:07:00,550 --> 00:07:04,460
>> તેથી કારણ તેવી શક્યતા છે
અમારા કોડ અમે ચલાવવા તો શું?

152
00:07:04,460 --> 00:07:05,700
કદાચ segfault.

153
00:07:05,700 --> 00:07:07,970
કદાચ નથી, પરંતુ કદાચ segfault.

154
00:07:07,970 --> 00:07:10,620
અને હું કહી કદાચ નથી કારણ કે ક્યારેક
તમે ક્યારેક, તો

155
00:07:10,620 --> 00:07:11,380
જો તમે segfault વિચાર નથી.

156
00:07:11,380 --> 00:07:14,280
ક્યારેક તમે માત્ર નસીબદાર વિચાર છે, પરંતુ
તે છતાં જશે

157
00:07:14,280 --> 00:07:15,340
અમારા કાર્યક્રમ માં ભૂલ.

158
00:07:15,340 --> 00:07:17,060
>> તેથી મને આગળ વધો અને આ કમ્પાઇલ દો.

159
00:07:17,060 --> 00:07:18,280
હું તે જૂની શાળા માર્ગ કરવા જઇ રહ્યો છું.

160
00:07:18,280 --> 00:07:23,825
તેથી રણકાર આડંબર 0, scanf 1,
scanf-1.c દાખલ કરો.

161
00:07:23,825 --> 00:07:24,720
અરે, ખૂબ જ જૂની સ્કૂલ.

162
00:07:24,720 --> 00:07:26,550
માતાનો જોવા દો.

163
00:07:26,550 --> 00:07:28,440
હું ક્યાં ગયા હતા?

164
00:07:28,440 --> 00:07:29,700
ઓહ, ચાર * બફર.

165
00:07:29,700 --> 00:07:33,595

166
00:07:33,595 --> 00:07:35,130
ઓહ, તમે આભાર -

167
00:07:35,130 --> 00:07:36,930
બરાબર, સેવ -

168
00:07:36,930 --> 00:07:37,690
ખૂબ જૂના સ્કૂલ.

169
00:07:37,690 --> 00:07:38,900
બધા હક, તે જ્યારે કરવામાં આવી છે.

170
00:07:38,900 --> 00:07:41,720
>> તેથી હું માત્ર ફાઈલ પછી સાચવી લીધો છે
કે કામચલાઉ બનાવવા

171
00:07:41,720 --> 00:07:42,700
એક ક્ષણ પહેલા બદલો.

172
00:07:42,700 --> 00:07:46,090
અને હવે હું તેને કમ્પાઈલ થયેલ છે
જાતે રણકાર સાથે.

173
00:07:46,090 --> 00:07:49,500
અને હવે હું આગળ જવા માટે જઇ રહ્યો છું
અને દાખલ કરો, scanf 1 રન બનાવ્યો.

174
00:07:49,500 --> 00:07:50,290
શબ્દમાળા કરો.

175
00:07:50,290 --> 00:07:51,600
હું લખો પડશે "હેલ્લો."

176
00:07:51,600 --> 00:07:54,070
>> અને હવે, અહીં printf, પ્રમાણિકપણે, જ્યાં ચોક્કો
થોડી હેરાન કરે છે શકે છે.

177
00:07:54,070 --> 00:07:56,020
તે ખરેખર જવા નથી
આ કિસ્સામાં segfault.

178
00:07:56,020 --> 00:07:59,860
Printf થોડી ખાસ છે કારણ કે
તે સામાન્ય રીતે વપરાય છે જેથી સુપર કે

179
00:07:59,860 --> 00:08:03,570
અનિવાર્યપણે printf કરી છે
અમને તરફેણમાં અને અનુભૂતિની,

180
00:08:03,570 --> 00:08:04,830
કે એક માન્ય નિર્દેશક નથી.

181
00:08:04,830 --> 00:08:09,080
મારી માત્ર પ્રિન્ટ પર મને લેવા દો
કૌંસ નલ બહાર, પણ

182
00:08:09,080 --> 00:08:13,340
તે જરૂરી નથી છતાં શું
આપણે આપણી જાતને અપેક્ષા.

183
00:08:13,340 --> 00:08:16,940
>> તેથી આપણે ખરેખર સરળતાથી પ્રેરિત કરી શકતા નથી
આ સ્પષ્ટ રીતે આ સાથે segfault, પરંતુ

184
00:08:16,940 --> 00:08:18,600
હું ઈચ્છતો વર્તન નથી.

185
00:08:18,600 --> 00:08:19,800
તેથી સરળ ઉકેલ શું છે?

186
00:08:19,800 --> 00:08:25,650
વેલ, scanf-2 માં, મને પ્રસ્તાવ દો કે
બદલે ખરેખર માત્ર એક ફાળવણી

187
00:08:25,650 --> 00:08:30,100
ચાર *, મને થોડી સ્માર્ટ વિશે હોઈ દો
આ, અને મને બફર ફાળવી દો

188
00:08:30,100 --> 00:08:32,940
16 અક્ષરો એક ક્રમ છે.

189
00:08:32,940 --> 00:08:34,200
>> તેથી હું માર્ગો એક દંપતિ માં કરી શકો છો.

190
00:08:34,200 --> 00:08:35,610
હું સંપૂર્ણપણે malloc ઉપયોગ કરી શકે છે.

191
00:08:35,610 --> 00:08:38,980
પરંતુ હું અઠવાડિયામાં બે પાછા જઈ શકે છે જ્યારે
હું માત્ર એક સમગ્ર ટોળું જરૂરી

192
00:08:38,980 --> 00:08:39,620
અક્ષરો.

193
00:08:39,620 --> 00:08:40,860
માત્ર એક એરે છે.

194
00:08:40,860 --> 00:08:44,870
તેથી મને બદલે બફર ફરી નિર્ધારિત દો
16 અક્ષરો એક એરે છે.

195
00:08:44,870 --> 00:08:47,340
>> અને હવે, જ્યારે હું બફર પાસ -

196
00:08:47,340 --> 00:08:49,940
અને આપણે ન કંઈક છે
સપ્તાહ બે વિશે વાત -

197
00:08:49,940 --> 00:08:53,730
પણ તમે એક એરે તરીકે સારવાર કરી શકે છે
તે એક સરનામું છતાં.

198
00:08:53,730 --> 00:08:56,390
અમે જોઈ કર્યું તરીકે ટેક્નિકલ,, તેઓ કરશો
થોડુંક અલગ.

199
00:08:56,390 --> 00:09:01,290
તમે તેને પસાર પરંતુ જો scanf દિમાગમાં નહીં
એક એરે નામ, કારણ કે શું

200
00:09:01,290 --> 00:09:05,030
અમને આવશ્યક છે રણકાર કરશે
જો કે એરે નામ સારવાર

201
00:09:05,030 --> 00:09:08,280
16 બાઇટ્સ ની ચંકને ઓફ સરનામું.

202
00:09:08,280 --> 00:09:09,550
>> તેથી આ વધુ સારું છે.

203
00:09:09,550 --> 00:09:12,110
આ હવે હું આશા કરી શકે છે એનો અર્થ એ થાય
નીચેની નથી.

204
00:09:12,110 --> 00:09:16,800
મને એક ક્ષણ માટે બહાર ઝૂમ કરીએ અને
ઠીક સંકલિત scanf 2, બનાવવા થાય છે.

205
00:09:16,800 --> 00:09:19,390
હવે મને સ્લેશ scanf-2 મળી નથી દો.

206
00:09:19,390 --> 00:09:22,430
શબ્દમાળા કરો. "હેલો." અને તે
આ સમય કામ લાગતું.

207
00:09:22,430 --> 00:09:26,020
>> પરંતુ કોઈને દૃશ્ય પ્રસ્તાવ કરી શકો છો
જેમાં તે હજુ પણ કામ ન શકે?

208
00:09:26,020 --> 00:09:28,550
યાહ?

209
00:09:28,550 --> 00:09:30,640
16 અક્ષરો કરતાં લાંબા સમય સુધી કંઈક.

210
00:09:30,640 --> 00:09:32,020
અને ખરેખર, અમે હોઈ શકે છે
થોડી વધુ ચોક્કસ.

211
00:09:32,020 --> 00:09:36,540
લાંબા સમય સુધી પછી 15 અક્ષરો કંઈક,
ખરેખર અમે ધ્યાનમાં રાખવા જરૂર છે, કારણ કે

212
00:09:36,540 --> 00:09:39,920
અમે તે બેકસ્લેશ શૂન્ય જરૂર છે
સર્વથા શબ્દમાળા ઓવરને અંતે

213
00:09:39,920 --> 00:09:42,950
જે એક કોરે scanf સામાન્ય રીતે ચાલશે છે
અમને કાળજી લેવા.

214
00:09:42,950 --> 00:09:46,210
>> તેથી મને કંઈક કરવા દો -

215
00:09:46,210 --> 00:09:48,040
ક્યારેક આપણે આ કરી શકો છો
કે જેમ તે છોડી દો.

216
00:09:48,040 --> 00:09:50,630
ઠીક છે, તેથી હવે અમે પ્રેરિત કર્યા છે
અમારા સેગ્મેન્ટેશન ક્ષતિમાં.

217
00:09:50,630 --> 00:09:51,000
શા માટે?

218
00:09:51,000 --> 00:09:54,940
હું 15 થી વધુ માટે લખ્યો છે કારણ કે
અક્ષરો, અને તેથી અમે ખરેખર કર્યું

219
00:09:54,940 --> 00:09:58,280
સ્પર્શ મેમરી કે હું ખરેખર
ન જોઈએ.

220
00:09:58,280 --> 00:10:00,180
>> તેથી શું ખરેખર અહીં ઉકેલ છે?

221
00:10:00,180 --> 00:10:02,210
વેલ, અમે લાંબા સમય સુધી શબ્દમાળા શું જરૂર હોય તો?

222
00:10:02,210 --> 00:10:03,960
ઠીક છે, આપણે કદાચ તે 32 બાઇટ્સ બનાવે છે.

223
00:10:03,960 --> 00:10:05,160
ઠીક છે, તે શું છે તે લાંબા સમય સુધી પૂરતી નથી તો શું?

224
00:10:05,160 --> 00:10:06,040
કેવી રીતે 64 બાઇટ્સ?

225
00:10:06,040 --> 00:10:07,080
શું છે કે જે લાંબા સમય સુધી પૂરતી નથી તો શું?

226
00:10:07,080 --> 00:10:09,640
કેટલો 128 વિશે અથવા 200 બાઇટ્સ?

227
00:10:09,640 --> 00:10:12,660
શું ખરેખર અહીં ઉકેલ છે
સામાન્ય કિસ્સામાં, અમે ખબર નથી તો

228
00:10:12,660 --> 00:10:14,460
વપરાશકર્તા લખો જવા છે તે આગળ?

229
00:10:14,460 --> 00:10:20,000

230
00:10:20,000 --> 00:10:23,050
>> તે મૂર્ખ માં એક મોટી પીડા માત્ર પ્રકારની છે
પ્રમાણિક હોઇ શકે છે, જે છે શા માટે

231
00:10:23,050 --> 00:10:29,050
CS50 પુસ્તકાલય થોડા ડઝન રેખાઓ હોય છે
સામૂહિક અમલ કે કોડ કે જે

232
00:10:29,050 --> 00:10:32,390
અમે નથી કે જે રીતે શબ્દમાળા GetString
અગાઉથી ખબર હોય શું

233
00:10:32,390 --> 00:10:33,430
વપરાશકર્તા લખવાનું ચાલુ છે.

234
00:10:33,430 --> 00:10:37,370
ખાસ કરીને, જો તમે પાછળ જુઓ
cs50.c બે અઠવાડિયા પહેલા થી, તમે જોશો

235
00:10:37,370 --> 00:10:40,480
કે GetString વાસ્તવમાં કરે છે
આ રીતે scanf વાપરે નહિં.

236
00:10:40,480 --> 00:10:43,720
તેના બદલે, તે એક અક્ષર વાંચે
એક સમયે.

237
00:10:43,720 --> 00:10:46,010
>> કારણ કે લગભગ એક સરસ વસ્તુ
એક અક્ષર વાંચવા અમે છે

238
00:10:46,010 --> 00:10:48,490
હંમેશા જાતને ખાતરી
ઓછામાં ઓછા એક ચાર હોય છે.

239
00:10:48,490 --> 00:10:51,740
હું માત્ર લેવા પછી ચાર જાહેર કરી શકો છો અને
માત્ર આ સાચી બાળક પગલાંઓ

240
00:10:51,740 --> 00:10:54,380
એક પર એક અક્ષર વાંચી
કીબોર્ડ સમય.

241
00:10:54,380 --> 00:10:58,240
અને પછી, શું તમે GetString જોશો
કરે છે, તે બહાર બનાવ્યા દરેક સમય છે

242
00:10:58,240 --> 00:11:02,280
, મેમરી 16 બાઇટ્સ કહે છે, તે ઉપયોગ કરે છે
malloc, અથવા એક પિતરાઇ તેના માટે

243
00:11:02,280 --> 00:11:06,810
જૂના નકલ, વધુ મેમરી ફાળવણી
પછી નવું, અને ક્રોલ માં મેમરી

244
00:11:06,810 --> 00:11:09,900
સાથે એક સમયે એક અક્ષર મેળવવામાં
અને તે બહાર ચાલે છે ત્યારે

245
00:11:09,900 --> 00:11:13,370
મેમરી ચંકને, કબજામાં લેવાની દૂર ફેંકી દે છે
મેમરી મોટી ચંકને, જૂની નકલ

246
00:11:13,370 --> 00:11:14,750
નવું, અને પુનરાવર્તન નહીં.

247
00:11:14,750 --> 00:11:18,480
અને તે ખરેખર સાચી પીડા છે
સરળ કંઈક અમલ

248
00:11:18,480 --> 00:11:19,710
વપરાશકર્તા ઇનપુટ મેળવવામાં.

249
00:11:19,710 --> 00:11:21,090
>> તેથી તમે scanf ઉપયોગ કરી શકો છો.

250
00:11:21,090 --> 00:11:22,430
તમે અન્ય જેવું જ કામ કરી શકો છો.

251
00:11:22,430 --> 00:11:25,420
અને એક પાઠ્યપુસ્તક ઘણો અને ઓનલાઇન
ઉદાહરણો નથી, પરંતુ તેઓ બધા છો

252
00:11:25,420 --> 00:11:27,210
આ જેવી સમસ્યાનો ભોગ.

253
00:11:27,210 --> 00:11:29,550
અને છેવટે, એક segfault રહેલી
પ્રકારની હેરાન છે.

254
00:11:29,550 --> 00:11:30,680
તે વપરાશકર્તા માટે સારી નથી.

255
00:11:30,680 --> 00:11:33,560
>> પરંતુ ખરાબ કિસ્સામાં, શું કરે છે
તેને મૂળભૂત રીતે તમારા મૂકી

256
00:11:33,560 --> 00:11:37,160
જોખમ કોડ?

257
00:11:37,160 --> 00:11:39,250
હુમલો કેટલાક પ્રકારની છે, સંભવિતપણે.

258
00:11:39,250 --> 00:11:41,680
અમે એક જેમ કે હુમલો વિશે વાત -
સ્ટેક વહેતું.

259
00:11:41,680 --> 00:11:44,660
પરંતુ સામાન્ય રીતે, તમે કરવા માટે માન્ય રહ્યાં છો, તો
ઓવરફ્લો બફર, જેમ આપણે કર્યું

260
00:11:44,660 --> 00:11:48,070
માત્ર લેખિત સાથે પહેલા અઠવાડિયા દંપતિ
વધુ સ્ટેક પર "હેલો" કરતાં, તમે

261
00:11:48,070 --> 00:11:52,330
ખરેખર એક, સંભવિત, ઉપર લઇ જઇ શકો છો
કોમ્પ્યુટર, અથવા ઓછામાં ઓછા માહિતી અંતે વિચાર કે

262
00:11:52,330 --> 00:11:53,510
તમે ને અનુલક્ષતું નથી.

263
00:11:53,510 --> 00:11:55,970
>> અમે શા માટે છે, જેથી ટૂંકા માં, આ છે
તે તાલીમ વ્હીલ્સ.

264
00:11:55,970 --> 00:11:59,090
પરંતુ હવે, અમે તેમને બોલ લેવા શરૂ
અમારા કાર્યક્રમો લાંબા સમય સુધી જરૂર છે,

265
00:11:59,090 --> 00:12:00,610
વપરાશકર્તા માંથી જરૂરી ઇનપુટ.

266
00:12:00,610 --> 00:12:03,960
પરંતુ સમસ્યા કિસ્સામાં, છ સેટ
તમારી ઇનપુટ એક વિશાળ માંથી આવશે

267
00:12:03,960 --> 00:12:07,520
150 સાથે શબ્દકોશ ફાઈલ કેટલાક
વિચિત્ર હજાર શબ્દો.

268
00:12:07,520 --> 00:12:10,330
>> તેથી તમે ચિંતા કરવાની રહેશે નહીં
વપરાશકર્તાની મનસ્વી ઇનપુટ.

269
00:12:10,330 --> 00:12:13,720
અમે તમને કેટલીક ધારણા આપશે
તે ફાઈલ વિશે.

270
00:12:13,720 --> 00:12:20,340
પોઇન્ટર અથવા scanf પર કોઈપણ પ્રશ્નો
અથવા સામાન્ય રીતે વપરાશકર્તા ઈનપુટ?

271
00:12:20,340 --> 00:12:24,450
>> બધા હક, જેથી એક ખાતે પછી ઝડપી દેખાવ
બે અઠવાડિયા પહેલા થી વિષય પાછળનો.

272
00:12:24,450 --> 00:12:28,590
અને તે એક સ્ટ્રક્ટ આ ખ્યાલ હતો.

273
00:12:28,590 --> 00:12:34,180
નથી - એક આ વિચારને
શું હતું, જે સ્ટ્રક્ટ?

274
00:12:34,180 --> 00:12:35,430
સ્ટ્રક્ટ અમારા માટે શું કર્યું?

275
00:12:35,430 --> 00:12:39,280

276
00:12:39,280 --> 00:12:39,860
>> નિર્ધારિત -

277
00:12:39,860 --> 00:12:41,710
માફ?

278
00:12:41,710 --> 00:12:42,820
એક ચલ પ્રકાર વ્યાખ્યાયિત કરે છે.

279
00:12:42,820 --> 00:12:44,410
તેથી સૉર્ટ છે.

280
00:12:44,410 --> 00:12:46,180
અમે ખરેખર બે વિષયો સંયોજન કરી રહ્યા છીએ.

281
00:12:46,180 --> 00:12:49,510
Typedef સાથે જેથી અમે યાદ
એક જેવી, આપણા પોતાના એક પ્રકાર જાહેર

282
00:12:49,510 --> 00:12:51,500
ચાર * માટે શબ્દમાળા જેવા સમાનાર્થી.

283
00:12:51,500 --> 00:12:56,200
પરંતુ typedef અને સ્ટ્રક્ટ ઉપયોગ કરીને, આપણે આ કરી શકો છો
સાચી આપણા પોતાના માહિતી માળખાં બનાવો.

284
00:12:56,200 --> 00:12:59,600
>> હમણાં પૂરતું, હું પાછા જાઓ તો gedit માં
અહીં માત્ર એક ક્ષણ માટે છે, અને હું આગળ જાઓ

285
00:12:59,600 --> 00:13:08,230
અને કંઈક જેમ કામ કરે છે, મને સાચવવા દો
આ તરીકે, structs.c, માતાનો કહે દો

286
00:13:08,230 --> 00:13:10,840
અસ્થાયી, હું હમણાં જ જઈ રહ્યો છું
આગળ વધો અને શામેલ કરવા

287
00:13:10,840 --> 00:13:14,360
standardio.h, Int મુખ્ય રદબાતલ.

288
00:13:14,360 --> 00:13:18,960
અને પછી અહીં, હું માંગો છો તે ધારવું
સંગ્રહ કરે છે કે એક પ્રોગ્રામ લખવા માટે

289
00:13:18,960 --> 00:13:21,840
બહુવિધ ઘણા વિદ્યાર્થીઓ
ઘરો, દાખલા તરીકે.

290
00:13:21,840 --> 00:13:24,430
તેથી તે registrarial જેવી છે
અમુક પ્રકારના ડેટાબેઝ.

291
00:13:24,430 --> 00:13:29,550
>> હું નામ એક વિદ્યાર્થી જરૂર, તેથી જો હું
, ચાર * નામ જેવું કંઈક શકે છે

292
00:13:29,550 --> 00:13:31,570
અને હું કંઈક કરીશ -

293
00:13:31,570 --> 00:13:34,410
ખરેખર, આ CS50 લાઇબ્રેરી ઉપયોગ કરવા દેવા
માત્ર એક ક્ષણ માટે તો આ એક બનાવવા માટે

294
00:13:34,410 --> 00:13:38,380
થોડી સરળ, તેથી અમે ઉધાર શકે છે
કોડ ઓફ લીટીઓ તે ડઝનેક.

295
00:13:38,380 --> 00:13:39,340
અને દો માત્ર તેને સરળ રાખવા છે.

296
00:13:39,340 --> 00:13:42,610
અમે તે સ્ટ્રિંગ રાખીશું
અને હવે GetString.

297
00:13:42,610 --> 00:13:47,420
>> તેથી હું નામ સ્ટોર કરી છે કે હવે દાવો
કેટલાક વિદ્યાર્થી, અને હાઉસ ઓફ

298
00:13:47,420 --> 00:13:50,240
ખાલી ચલો મદદથી કેટલાક વિદ્યાર્થી,
અમે હતી અને સપ્તાહ એક છે. જેમ

299
00:13:50,240 --> 00:13:52,370
પરંતુ હવે હું ટેકો કરવા માંગો છો ધારવું
બહુવિધ વિદ્યાર્થીઓ.

300
00:13:52,370 --> 00:13:58,460
બધા હક, જેથી મારી વૃત્તિ કરવું છે
સ્ટ્રિંગ NAME2, GetString, શબ્દમાળા નહીં

301
00:13:58,460 --> 00:14:01,370
house2 GetString નોંધાયો નહીં.

302
00:14:01,370 --> 00:14:05,850
અને પછી અમારા ત્રીજા વિદ્યાર્થી,
NAME3 GetString શું કરીએ.

303
00:14:05,850 --> 00:14:09,170
>> બધા હક, તેથી આ આસ્થાપૂર્વક સ્ટ્રાઇકિંગ છે
મૂર્ખ કાઇન્ડ તરીકે તમે,

304
00:14:09,170 --> 00:14:11,580
આ પ્રક્રિયા ખરેખર ક્યારેય છે કારણ કે
અંત જવા, અને તે માત્ર બનશે

305
00:14:11,580 --> 00:14:13,130
મારી કોડ ખરાબ દેખાવ
અને ખરાબ અને ખરાબ.

306
00:14:13,130 --> 00:14:14,810
પરંતુ અમે સપ્તાહ બે પણ આ હલ.

307
00:14:14,810 --> 00:14:19,450
અમારા પ્રમાણમાં સ્વચ્છ ઉકેલ શું હતું
અમે બહુવિધ ચલો હતી

308
00:14:19,450 --> 00:14:23,580
જ માહિતી તમામ સંબંધિત છે તે પ્રકારના છે, પરંતુ
અમે આ ભયાનક વાસણ નહિં માંગો હતી

309
00:14:23,580 --> 00:14:26,870
એ જ રીતે નામ આપવામાં આવ્યું વેરિયેબલ્સ?

310
00:14:26,870 --> 00:14:30,060
અમે તેના બદલે શું કર્યું?

311
00:14:30,060 --> 00:14:31,260
>> તેથી હું થોડા સ્થળો સાંભળ્યું છે.

312
00:14:31,260 --> 00:14:32,590
અમે એક એરે હતી.

313
00:14:32,590 --> 00:14:37,110
તમે અનેક ઉદાહરણો માંગો છો
કંઈક, શા માટે આપણે આ બધા સાફ નથી

314
00:14:37,110 --> 00:14:39,540
અપ અને માત્ર મને આપી કહે છે,
અરે નામો કહેવાય?

315
00:14:39,540 --> 00:14:41,640
>> અને હવે, હાર્ડ કોડ 3 દો.

316
00:14:41,640 --> 00:14:44,450
અને પછી મને બીજા એરે આપે છે
ઘરો કહેવાય છે, અને માટે મને દો

317
00:14:44,450 --> 00:14:45,800
હવે હાર્ડ કોડ 3.

318
00:14:45,800 --> 00:14:49,220
અને હું મોટા પાયે ઉપર સાફ કર્યું
હું હમણાં બનાવેલ છે કે ગડબડ.

319
00:14:49,220 --> 00:14:52,400
હવે, હું હજુ પણ હાર્ડ 3 કોડેડ છે, પરંતુ કર્યું પણ
3 ગતિશીલ માંથી આવે છે શકે છે

320
00:14:52,400 --> 00:14:54,350
વપરાશકર્તા, અથવા argv, અથવા જેમ.

321
00:14:54,350 --> 00:14:55,720
તેથી આ પહેલેથી જ ક્લીનર છે.

322
00:14:55,720 --> 00:15:00,100
>> પરંતુ શું આ વિશે નકામી છે કે છે
હવે, છતાં પણ એક નામ અચાનક છે

323
00:15:00,100 --> 00:15:02,280
મૂળભૂત કડી
એક વિદ્યાર્થી ઘર -

324
00:15:02,280 --> 00:15:04,720
તે કે હું ખરેખર એક વિદ્યાર્થી છે
પ્રતિનિધિત્વ કરવા માંગો છો -

325
00:15:04,720 --> 00:15:08,080
હવે હું સમાંતર છે કે બે એરે છે
તેઓ છો કે અર્થમાં

326
00:15:08,080 --> 00:15:13,930
સમાન કદ અને નામો કૌંસ 0
ઘરો કૌંસ 0 અનુમાન નકશા,

327
00:15:13,930 --> 00:15:16,600
અને નામો કૌંસ 1 નકશા
ઘરો કૌંસ 1.

328
00:15:16,600 --> 00:15:19,280
અન્ય શબ્દોમાં, કે જે વિદ્યાર્થી જીવન
કે ઘર છે, અને તે અન્ય વિદ્યાર્થી

329
00:15:19,280 --> 00:15:20,530
કે અન્ય ઘરમાં રહે છે.

330
00:15:20,530 --> 00:15:23,720
પરંતુ ચોક્કસ આ હોઈ શકે
પણ વધુ સ્વચ્છ પૂર્ણ થઈ.

331
00:15:23,720 --> 00:15:24,990
>> વેલ, તે કરી શકે છે, હકીકતમાં.

332
00:15:24,990 --> 00:15:28,730
અને મને આગળ વધો અને ખોલવા દો
structs.h અપ, અને તમે પડશે

333
00:15:28,730 --> 00:15:31,130
અહીં આ વિચાર જુઓ.

334
00:15:31,130 --> 00:15:34,905
તમે, હું typedef ઉપયોગ કર્યા કે નોટિસ
પહેલાં જાહેર કરવા માટે એક ક્ષણ જશ આપ્યો હતો અમારી

335
00:15:34,905 --> 00:15:35,570
પોતાના માહિતી પ્રકાર.

336
00:15:35,570 --> 00:15:39,660
પરંતુ હું પણ આ અન્ય શબ્દ વાપરવાની છું
સ્ટ્રક્ટ કહેવાય જે મને એક નવી આપે છે

337
00:15:39,660 --> 00:15:40,790
માહિતી બંધારણ.

338
00:15:40,790 --> 00:15:43,980
>> અને હું દાવો આ માહિતી માળખું ચાલે છે
ની અંદર બે વસ્તુઓ હોય છે

339
00:15:43,980 --> 00:15:47,060
તે - નામ કહેવાય શબ્દમાળા, અને
ઘર કહેવાય શબ્દમાળા.

340
00:15:47,060 --> 00:15:49,820
અને હું જાઉં છું તે નામ આપવા
આ માહિતી માળખું ચાલે છે

341
00:15:49,820 --> 00:15:51,005
વિદ્યાર્થી કહેવામાં આવે છે.

342
00:15:51,005 --> 00:15:54,030
હું, હું માંગો કંઈપણ કૉલ કરી શકે છે
પરંતુ આ અર્થનિર્ધારણ બનાવવા

343
00:15:54,030 --> 00:15:55,810
મારા મન મને સુઝ.

344
00:15:55,810 --> 00:15:59,160
>> તેથી હવે, હું એક વધુ સારું આવૃત્તિ ખોલો તો
કાર્યક્રમના હું લખવાનું શરૂ કર્યું

345
00:15:59,160 --> 00:16:00,390
ત્યાં મને ટોચ પર સ્ક્રોલ દો.

346
00:16:00,390 --> 00:16:03,190
અને કોડ ઓફ કેટલાક વધુ રેખાઓ હોય
અહીં, પરંતુ મને ધ્યાન કેન્દ્રિત દો

347
00:16:03,190 --> 00:16:04,160
એક ક્ષણ.

348
00:16:04,160 --> 00:16:07,790
હું સતત કહેવાતા વિદ્યાર્થીઓ જાહેર કર્યું
અને હાર્ડ હવે 3 કોડેડ.

349
00:16:07,790 --> 00:16:11,110
પરંતુ હવે, નોટિસ કેવી રીતે સ્વચ્છ
મારી કોડ મેળવવા માટે શરૂ થાય છે.

350
00:16:11,110 --> 00:16:15,030
>> રેખા 22 માં, હું જાહેર
વિદ્યાર્થીઓ એરે.

351
00:16:15,030 --> 00:16:18,760
અને વિદ્યાર્થી દેખીતી રીતે કે નોટિસ
હવે માહિતી પ્રકાર.

352
00:16:18,760 --> 00:16:23,360
આ ફાઇલ ટોચ પર, કારણ કે નોટિસ
હું હેડર ફાઈલ સમાવેશ કર્યા છે

353
00:16:23,360 --> 00:16:24,820
હું માત્ર એક ક્ષણ પહેલા અપ ખેંચાય છે.

354
00:16:24,820 --> 00:16:28,820
અને તે હેડર ફાઈલ તદ્દન ખાલી હતી
એક વિદ્યાર્થી આ વ્યાખ્યા.

355
00:16:28,820 --> 00:16:32,470
>> તેથી હવે, હું મારા પોતાના વૈવિધ્યપૂર્ણ માહિતી બનાવેલ
પ્રકાર કે સી વર્ષ લેખકો

356
00:16:32,470 --> 00:16:33,890
પહેલાં અગાઉથી વિચાર ન હતી.

357
00:16:33,890 --> 00:16:34,570
પરંતુ કોઈ સમસ્યા નથી.

358
00:16:34,570 --> 00:16:35,870
હું તેને મારી કરી શકો છો.

359
00:16:35,870 --> 00:16:39,050
તેથી આ વિદ્યાર્થીઓ નામની એક એરે છે
જેના સભ્યો દરેક

360
00:16:39,050 --> 00:16:41,100
એક વિદ્યાર્થી માળખું છે.

361
00:16:41,100 --> 00:16:44,270
અને હું તે ત્રણ માંગો છો
એરેમાં.

362
00:16:44,270 --> 00:16:46,030
>> અને હવે, બાકીના શું કરે છે
આ કાર્યક્રમ છે?

363
00:16:46,030 --> 00:16:47,550
હું થોડી મનસ્વી કંઈક જરૂર છે.

364
00:16:47,550 --> 00:16:51,450
તેથી ઑનલાઇન 24 થી
હું 0 થી 3 ફરી વળવું.

365
00:16:51,450 --> 00:16:54,000
હું પછી માટે વપરાશકર્તા પૂછો
વિદ્યાર્થી માતાનો નામ.

366
00:16:54,000 --> 00:16:56,110
અને પછી હું પહેલાં તરીકે GetString ઉપયોગ કરો.

367
00:16:56,110 --> 00:16:59,410
પછી હું, વિદ્યાર્થી ઘર માટે પૂછો
અને હું પહેલાં તરીકે GetString વાપરો.

368
00:16:59,410 --> 00:17:01,780
>> પરંતુ નોટિસ - સહેજ નવા
વાક્યરચના ભાગ -

369
00:17:01,780 --> 00:17:07,010
હું, આઇ મી વિદ્યાર્થી હજુ ઇન્ડેક્સ કરી શકો છો
પરંતુ હું ચોક્કસ માહિતી અંતે કેવી રીતે મેળવી શકું

370
00:17:07,010 --> 00:17:08,354
જો સ્ટ્રક્ટ ક્ષેત્રમાં અંદર?

371
00:17:08,354 --> 00:17:11,770
ઠીક છે, દેખીતી રીતે આ શું છે
નવી વાક્યરચના ભાગ?

372
00:17:11,770 --> 00:17:13,339
તે માત્ર પર કોઈ ઓપરેટર છે.

373
00:17:13,339 --> 00:17:14,510
>> અમે ખરેખર આ પહેલાં જોઇ ન કર્યા છે.

374
00:17:14,510 --> 00:17:17,819
તમે કરેલા જો તમે pset પાંચ તેને જોઈ કર્યું
બીટમેપ ફાઇલો સાથે પહેલાથી જ માં dived.

375
00:17:17,819 --> 00:17:22,372
પરંતુ કોઈ ફક્ત આ અંદર એનો અર્થ એ થાય
સ્ટ્રક્ટ અથવા બહુવિધ ક્ષેત્રો, ડોટ આપી

376
00:17:22,372 --> 00:17:24,510
નામ અથવા મને કોઈ ઘર આપે છે.

377
00:17:24,510 --> 00:17:28,690
જો સ્ટ્રક્ટ ની અંદર જાઓ અર્થ એ છે કે
અને તે ખાસ કરીને ક્ષેત્રો વિચાર.

378
00:17:28,690 --> 00:17:30,200
>> આ કાર્યક્રમ બાકીના શું કરે છે?

379
00:17:30,200 --> 00:17:31,190
તે બધા કે સેક્સી નથી.

380
00:17:31,190 --> 00:17:34,640
હું ફરીથી 0 થી 3 ફરી વળવું નોટિસ કે,
અને હું માત્ર એક ઇંગલિશ બનાવો

381
00:17:34,640 --> 00:17:40,500
જેથી અને તેથી જેવા શબ્દસમૂહ જેમ કે છે
માંથી કોઈ નામ પસાર જેમ કે ઘર,

382
00:17:40,500 --> 00:17:43,320
આઇ મી વિદ્યાર્થી અને તેમના
ઘર તેમજ.

383
00:17:43,320 --> 00:17:47,560
>> અને પછી છેલ્લે, હવે અમે વિચાર શરૂ કરી શકશો
અમે છીએ હવે તે આ વિશે ગુદા,

384
00:17:47,560 --> 00:17:49,580
શું malloc અને સાથે પરિચિત
અન્ય કાર્યો કરવામાં આવી છે

385
00:17:49,580 --> 00:17:50,570
આ બધા સમય કરી.

386
00:17:50,570 --> 00:17:54,220
શા માટે હું બંને નામ મુક્ત હોય
અને ઘર, છતાં પણ હું

387
00:17:54,220 --> 00:17:56,960
malloc કૉલ કરી હતી?

388
00:17:56,960 --> 00:17:58,020
>> GetString હતી.

389
00:17:58,020 --> 00:18:00,930
અને તે માટે ગંદા ઓછી ગુપ્ત હતી
કેટલાક અઠવાડિયા, પરંતુ GetString છે

390
00:18:00,930 --> 00:18:03,530
તમામ વધારે મેમરી લીક કરવામાં આવી
આમ અત્યાર સુધી બધા સત્ર મૂકો.

391
00:18:03,530 --> 00:18:05,990
અને છેલ્લે valgrand ચાલશે
અમને આ ઉઘાડી.

392
00:18:05,990 --> 00:18:10,730
>> મને ખબર છે કારણ કે પરંતુ તે એક મોટી સોદો નથી
હું માત્ર નામ મુક્ત કરી શકો છો કે જે

393
00:18:10,730 --> 00:18:15,750
અને ઘર, જોકે ટેકનિકલી માટે
સુપર, સુપર સુરક્ષિત હોઇ શકે છે, હું પ્રયત્ન કરીશું

394
00:18:15,750 --> 00:18:17,890
કેટલાક ભૂલ કરી અહીં ચકાસીને.

395
00:18:17,890 --> 00:18:19,040
તમારી વૃત્તિ તમે શું કહી રહ્યા છો?

396
00:18:19,040 --> 00:18:22,480
હું શું તપાસ થવી જોઈએ
હું શું છે મુક્ત પહેલાં

397
00:18:22,480 --> 00:18:25,470
સ્ટ્રિંગ, ઉર્ફ જે ચાર *?

398
00:18:25,470 --> 00:18:33,460
>> હું ખરેખર તપાસ થવી જોઈએ વિદ્યાર્થીઓ, જો
કૌંસ હું કોઈ નામ નથી

399
00:18:33,460 --> 00:18:34,840
સમાન નલ.

400
00:18:34,840 --> 00:18:40,400
પછી તે આગળ અને મફત જવા માટે OK હશો
કે નિર્દેશક, અને સમાન અથવા અન્ય

401
00:18:40,400 --> 00:18:41,160
એક તેમજ.

402
00:18:41,160 --> 00:18:46,860
વિદ્યાર્થીઓ કૌંસ હું કોઈ ઘર ન હોય તો
નલ બરાબર છે, આ હવે રક્ષણ કરશે

403
00:18:46,860 --> 00:18:52,520
ખૂણે કેસ સામે જેમાં
GetString નલ કંઈક આપે છે.

404
00:18:52,520 --> 00:18:57,310
અને અમે printf કરશે, એક ક્ષણ પહેલા જોયું
માત્ર કહીને દ્વારા અમને અહીં અપ રક્ષણ

405
00:18:57,310 --> 00:18:58,990
નલ છે, કે જે અલૌકિક જોવા જવાનું છે.

406
00:18:58,990 --> 00:19:02,340
પરંતુ ઓછામાં ઓછા તે segfault નહીં
આપણે જોયું તેમ.

407
00:19:02,340 --> 00:19:05,990
>> ઠીક છે, મને અહીં એક અન્ય વસ્તુ કરવા દો.
સ્ટ્ર્ક્ટ્સ -0 એક મૂર્ખ કાર્યક્રમ પ્રકારની છે

408
00:19:05,990 --> 00:19:09,700
હું પછી બધા આ માહિતી દાખલ કરો, અને કારણ કે
કાર્યક્રમ સમાપ્ત થાય છે એક વખત તે ગુમાવી છે.

409
00:19:09,700 --> 00:19:10,940
પરંતુ મને આગળ વધો અને આ કરવા દો.

410
00:19:10,940 --> 00:19:12,830
મને ટર્મિનલ બનાવવા દો
એ બીટ મોટી વિંડો.

411
00:19:12,830 --> 00:19:17,000
, મને સ્ટ્ર્ક્ટ્સ 1 બનાવવા દો જે
આ એક નવી આવૃત્તિ છે.

412
00:19:17,000 --> 00:19:18,520
>> હું થોડી ઝૂમ પડશે.

413
00:19:18,520 --> 00:19:21,620
અને હવે મને કોઈ રન દો
સ્ટ્ર્ક્ટ્સ 1 સ્લેશ.

414
00:19:21,620 --> 00:19:22,590
વિદ્યાર્થીના નામ -

415
00:19:22,590 --> 00:19:31,500
ડેવિડ માથેર, રોબ કિર્કલૅંડ શું કરીએ
લોરેન Leverett શું કરીએ.

416
00:19:31,500 --> 00:19:33,650
શું રસપ્રદ છે હવે નોટિસ છે -

417
00:19:33,650 --> 00:19:35,540
અને હું માત્ર આ કારણ ખબર
હું પ્રોગ્રામ લખ્યો -

418
00:19:35,540 --> 00:19:38,930
ફાઇલ મારા વર્તમાન હવે છે
ડિરેક્ટરી students.csv કહેવાય છે.

419
00:19:38,930 --> 00:19:40,420
તમે કેટલાક જોઇ હશે
વાસ્તવિક દુનિયામાં આ.

420
00:19:40,420 --> 00:19:42,980
>> CSV ફાઈલ શું છે?

421
00:19:42,980 --> 00:19:44,170
મૂલ્યો અલ્પવિરામથી અલગ થયેલ છે.

422
00:19:44,170 --> 00:19:46,670
જો તે ગરીબ માણસ જેવા પ્રકારની છે
એક એક્સેલ ફાઈલ આવૃત્તિ.

423
00:19:46,670 --> 00:19:50,580
તે પંક્તિઓ અને કૉલમ્સ એક ટેબલ કે
તમે, એક્સેલ જેવા પ્રોગ્રામમાં ખોલી શકે છે

424
00:19:50,580 --> 00:19:51,800
એક મેક પર અથવા Numbers.

425
00:19:51,800 --> 00:19:55,180
>> અને હું gedit અહીં આ ફાઇલ ખોલવા જો,
સૂચના - અને નંબરો નથી.

426
00:19:55,180 --> 00:19:57,360
માત્ર કહેવાની gedit છે
મને લીટી નંબરો.

427
00:19:57,360 --> 00:19:59,740
આ પ્રથમ વાક્ય પર નોટિસ
ફાઈલ ડેવિડ અને માથેર છે.

428
00:19:59,740 --> 00:20:01,450
આગામી વાક્ય રોબ અલ્પવિરામ કિર્કલૅંડ છે.

429
00:20:01,450 --> 00:20:04,170
અને ત્રીજી લાઇન લોરેન છે
અલ્પવિરામ Leverett.

430
00:20:04,170 --> 00:20:05,480
>> તેથી હું શું બનાવ્યું છે?

431
00:20:05,480 --> 00:20:09,580
હવે હું એક સી કાર્યક્રમ લખેલા કરેલા
અસરકારક રીતે સ્પ્રેડશીટ્સ પેદા કરી શકે છે

432
00:20:09,580 --> 00:20:11,840
માં ખોલી શકાય છે
એક્સેલ જેવા કાર્યક્રમ.

433
00:20:11,840 --> 00:20:15,520
બધા કે જે અનિવાર્ય ડેટા સેટ, પરંતુ
તમે ખૂબ મોટા હિસ્સામાં હોય તો

434
00:20:15,520 --> 00:20:18,440
તમે ખરેખર કરવા માંગો છો કે જે માહિતી
ચાલાકી અને ગ્રાફ અને બનાવવા

435
00:20:18,440 --> 00:20:21,260
જેમ, આ કદાચ એક છે
કે માહિતી બનાવવા માટે માર્ગ.

436
00:20:21,260 --> 00:20:25,370
વધુમાં, CSVs સામાન્ય વાસ્તવમાં સુપર છે
માત્ર સરળ માહિતી સ્ટોર કરવા માટે -

437
00:20:25,370 --> 00:20:28,940
યાહૂ ફાઇનાન્સ, દાખલા તરીકે, તમે વિચાર તો
તેમના કહેવાતા મારફતે સ્ટોક ક્વોટ્સ

438
00:20:28,940 --> 00:20:33,180
API, તમે કરી શકો છો કે જે નિઃશુલ્ક સેવા
વર્તમાન અપ ટુ ધ તારીખ સ્ટોક વિચાર

439
00:20:33,180 --> 00:20:35,650
કંપનીઓ માટે ટાંકે છે, તેઓ
પાછા ડેટા આપી

440
00:20:35,650 --> 00:20:37,800
સુપર સરળ CSV ફોર્મેટ.

441
00:20:37,800 --> 00:20:39,380
>> તેથી આપણે કેવી રીતે તે કરવા છે?

442
00:20:39,380 --> 00:20:42,530
વેલ, આ પ્રોગ્રામ ની સૌથી નોટિસ
લગભગ સમાન.

443
00:20:42,530 --> 00:20:46,870
પરંતુ અહીં નીચે નોટિસ બદલે પ્રિન્ટ
રેખા 35 પર આઉટ વિદ્યાર્થીઓ,

444
00:20:46,870 --> 00:20:51,040
આગળ, હું બચત છું કે દાવો
ડિસ્કમાં વિદ્યાર્થીઓ, તેથી ફાઇલ બચત છે.

445
00:20:51,040 --> 00:20:53,630
>> તેથી હું એક ફાઇલ * જાહેર છું નોટિસ -

446
00:20:53,630 --> 00:20:57,260
હવે, આ સી માં અનિયમિતતા પ્રકારની છે
ગમે તે કારણોસર, ફાઇલ, બધા કેપ્સ છે

447
00:20:57,260 --> 00:21:00,690
જે મોટા ભાગના અન્ય ડેટા પ્રકારો જેવા નથી
સી માં પણ આ એક આંતરિક

448
00:21:00,690 --> 00:21:02,320
માહિતી પ્રકાર, ફાઈલ *.

449
00:21:02,320 --> 00:21:05,900
અને હું, ફાઇલ માટે નિર્દેશક જાહેર છું
તમે તે વિચાર કરી શકો છો કેવી રીતે છે.

450
00:21:05,900 --> 00:21:08,070
>> fopen ખુલ્લી ફાઇલ થાય છે.

451
00:21:08,070 --> 00:21:09,470
તમે શું ફાઈલ ખોલવા માંગો છો?

452
00:21:09,470 --> 00:21:12,620
હું એક ફાઇલ ખોલવા માંગો ચાલશે કે
આપખુદ students.csv કૉલ કરો.

453
00:21:12,620 --> 00:21:14,480
હું માંગો છો તે કંઈપણ કૉલ કરી શકે છે.

454
00:21:14,480 --> 00:21:15,200
>> અને પછી એક અનુમાન લે છે.

455
00:21:15,200 --> 00:21:18,960
બીજી દલીલ શું કરે છે
fopen કદાચ અર્થ?

456
00:21:18,960 --> 00:21:21,480
અધિકાર લખવા માટે વાઈડ કરી શકતો
વાંચવા માટે r છે.

457
00:21:21,480 --> 00:21:24,120
જો ઉમેરો માટે છે તમે
પંક્તિઓ નથી અને ઍડ કરવા માંગો છો

458
00:21:24,120 --> 00:21:25,200
સમગ્ર બાબત પર ફરીથી લખી.

459
00:21:25,200 --> 00:21:28,005
>> પરંતુ હું ફક્ત આ ફાઇલ બનાવવા માંગો છો
એક વાર, તેથી હું ભાવ અવતરણ ચિહ્નો પૂરાં કરવાં વાઇડ ઉપયોગ કરશો.

460
00:21:28,005 --> 00:21:31,880
અને હું વાંચી કર્યા કે માત્ર ખબર
દસ્તાવેજીકરણ, અથવા મદદ પાનું.

461
00:21:31,880 --> 00:21:35,100
ફાઈલ નલ ન હોય તો - બીજા શબ્દોમાં,
કંઈ ત્યાં ખોટું થયું હોય તો -

462
00:21:35,100 --> 00:21:37,820
મને પર ફરી વળવું દો
0 થી 3 વિદ્યાર્થીઓ.

463
00:21:37,820 --> 00:21:40,410
>> અને હવે કંઈક ત્યાં નોટિસ
ક્યારેય જેથી થોડો અલગ

464
00:21:40,410 --> 00:21:42,110
અહીં લગભગ રેખા 41.

465
00:21:42,110 --> 00:21:42,960
તે printf નથી.

466
00:21:42,960 --> 00:21:46,530
તે printf ફાઇલ માટે fprintf છે.

467
00:21:46,530 --> 00:21:47,790
તેથી તે ફાઇલ લખી બનશે.

468
00:21:47,790 --> 00:21:48,860
જે ફાઈલ?

469
00:21:48,860 --> 00:21:53,630
જેના નિર્દેશક તમે સ્પષ્ટ એક
પ્રથમ દલીલ તરીકે.

470
00:21:53,630 --> 00:21:55,940
>> પછી અમે એક ફોર્મેટ સ્ટ્રિંગ સ્પષ્ટ કરો.

471
00:21:55,940 --> 00:21:59,660
પછી આપણે માટે શું કરવા માંગો છો શબ્દમાળા સ્પષ્ટ
પ્રથમ ટકા ઓ માટે પ્લગ, અને

472
00:21:59,660 --> 00:22:04,320
પછી બીજા ચલ અથવા
બીજા ટકા ઓ.

473
00:22:04,320 --> 00:22:06,760
પછી અમે fclose સાથે બંધ થાય છે.

474
00:22:06,760 --> 00:22:09,380
હું છતાં, પહેલાં તરીકે મેમરી મુક્ત કરતાં
હું પાછા જાઓ અને ઉમેરવા જોઈએ

475
00:22:09,380 --> 00:22:10,540
નલ માટે અમુક ચકાસે છે.

476
00:22:10,540 --> 00:22:12,090
>> અને તે છે.

477
00:22:12,090 --> 00:22:16,960
fopen, fprintf, fclose મને આપે છે
લખાણ ફાઈલો બનાવવા માટે ક્ષમતા છે.

478
00:22:16,960 --> 00:22:19,640
હવે, તમે સમસ્યા સેટ પાંચ જુઓ પડશે
છબીઓ સમાવેશ થાય છે, જે તમે ઉપયોગ કરી શકશો

479
00:22:19,640 --> 00:22:20,990
બાઈનરી ફાઈલો બદલે.

480
00:22:20,990 --> 00:22:24,200
પરંતુ મૂળભૂત છે, એ વિચાર, એ જ છે
છતાં પણ તમે કરશો કામગીરી

481
00:22:24,200 --> 00:22:28,710
થોડુંક અલગ છે જુઓ.

482
00:22:28,710 --> 00:22:32,580
>> વાવંટોળ પ્રવાસ તેથી, પરંતુ તમે વિચાર કરશે
ફાઇલ સાથે બધા ખૂબ પરિચિત I/O--

483
00:22:32,580 --> 00:22:34,960
ઇનપુટ અને આઉટપુટ - pset પાંચ સાથે.

484
00:22:34,960 --> 00:22:38,607
અને વિશે કોઇ પ્રશ્નો
અહીં પ્રારંભિક બેઝિક્સ?

485
00:22:38,607 --> 00:22:39,857
યાહ?

486
00:22:39,857 --> 00:22:41,880

487
00:22:41,880 --> 00:22:43,710
>> શું તમે નલ કિંમત મુક્ત કરવાનો પ્રયાસ કરો તો?

488
00:22:43,710 --> 00:22:48,880
મુક્ત મેળવેલ છે જ્યાં સુધી હું માને છે
થોડી વધુ વપરાશકર્તા મૈત્રીપૂર્ણ, તમે આ કરી શકો છો

489
00:22:48,880 --> 00:22:49,890
સંભવિત segfault.

490
00:22:49,890 --> 00:22:54,160
હું નથી કારણ કે તે રીતે પસાર ખરાબ છે
મફત માને, તો તમે ચકાસવા માટે ત્રાસ

491
00:22:54,160 --> 00:22:57,330
તે સંભવિત કચરો હશે કારણ કે
તે માટે પોતે શું કરવા માટે સમય

492
00:22:57,330 --> 00:22:59,022
વિશ્વમાં દરેક.

493
00:22:59,022 --> 00:23:00,590
ગુડ પ્રશ્ન છે, જોકે.

494
00:23:00,590 --> 00:23:04,300
>> બધા હક, આ પ્રકારની નહીં, તેથી
અમને એક રસપ્રદ વિષય છે.

495
00:23:04,300 --> 00:23:07,010
સમસ્યા સમૂહ ની થીમ
પાંચ વિદેશી છે.

496
00:23:07,010 --> 00:23:08,420
ઓછામાં ઓછા તે એક ભાગ છે
સમસ્યા સમૂહ છે.

497
00:23:08,420 --> 00:23:12,030
વિદેશી સામાન્ય રીતે સંદર્ભ લે છે
કે કરી શકે છે અથવા માહિતી વસૂલાત

498
00:23:12,030 --> 00:23:14,110
કાઢી નાખવામાં આવ્યા છે શકે નહિં
ઇરાદાપૂર્વક.

499
00:23:14,110 --> 00:23:18,680
અને તેથી હું તમને ઝડપી આપી કરશો વિચાર્યું
શું સ્વાદ ખરેખર બધા પર ચાલે છે

500
00:23:18,680 --> 00:23:21,230
હેઠળના આ સમય
તમારા કમ્પ્યુટરની હૂડ.

501
00:23:21,230 --> 00:23:23,960
>> હમણાં પૂરતું, તમે અંદર હોય, તો તમારા
લેપટોપ અથવા તમારા ડેસ્કટોપ કમ્પ્યુટર

502
00:23:23,960 --> 00:23:28,040
હાર્ડ ડ્રાઈવ, તે ક્યાં તો એક યાંત્રિક છે
વાસ્તવમાં ચક્રીય કે ઉપકરણ -

503
00:23:28,040 --> 00:23:31,650
platters કહેવાય પરિપત્ર વસ્તુઓ
તદ્દન કે જેવા દેખાય છે તે હું

504
00:23:31,650 --> 00:23:34,540
માત્ર જોકે, અહીં સ્ક્રીન પર હતી
આ વધુને વધુ જૂની શાળા છે.

505
00:23:34,540 --> 00:23:37,370
આ ત્રણ અને-a-અડધા ઇંચ છે
હાર્ડ ડ્રાઈવ.

506
00:23:37,370 --> 00:23:40,070
અને ત્રણ અને અડધા ઇંચ ઉલ્લેખ કરે છે
તમે તેને સ્થાપિત જ્યારે વસ્તુ સાથે

507
00:23:40,070 --> 00:23:40,890
કમ્પ્યુટર માં.

508
00:23:40,890 --> 00:23:44,890
>> હવે તમારા લેપટોપ તમે ઘણા ગાય્ઝ
, નક્કર સ્થિતિમાં ડ્રાઈવો, અથવા SSDs છે

509
00:23:44,890 --> 00:23:46,260
જે ભાગો ખસેડવાની છે નં.

510
00:23:46,260 --> 00:23:49,170
તેઓ RAM જેવા વધુ અને ઓછો જેવા છો
આ યાંત્રિક ઉપકરણો.

511
00:23:49,170 --> 00:23:51,450
પરંતુ વિચારો, પણ આ જ છે
ચોક્કસપણે તેઓ સંબંધ તરીકે

512
00:23:51,450 --> 00:23:52,790
સમસ્યા પાંચ સુયોજિત કરવા માટે.

513
00:23:52,790 --> 00:23:57,400
>> અને જો તમે હાર્ડ ડ્રાઈવ હવે વિશે વિચારો તો
જે વર્તુળ, છે પ્રતિનિધિત્વ

514
00:23:57,400 --> 00:23:58,930
હું અહીં આ જેમ ડ્રો કરીશું.

515
00:23:58,930 --> 00:24:02,290
તમે, તમારા કમ્પ્યુટર પર એક ફાઈલ બનાવી રહ્યા હોય ત્યારે
તે SSD છે, અથવા કે શું

516
00:24:02,290 --> 00:24:06,610
આ કિસ્સામાં, એક જૂની શાળા હાર્ડ ડ્રાઈવ,
તે ફાઈલ બહુવિધ બીટ્સ સમાવેશ થાય છે.

517
00:24:06,610 --> 00:24:10,510
માતાનો આ 0 અને 1 ચોક્કો કહે છે કે દો,
0 સે અને 1 સે એક સમગ્ર ટોળું.

518
00:24:10,510 --> 00:24:11,660
તેથી આ મારા સમગ્ર હાર્ડ ડ્રાઈવ છે.

519
00:24:11,660 --> 00:24:13,225
આ દેખીતી રીતે ખૂબ મોટી ફાઇલ છે.

520
00:24:13,225 --> 00:24:18,080
અને તે સમયે 0 સે અને 1 સે અપ ઉપયોગ કરી રહ્યા છે
ભૌતિક platter ભાગ.

521
00:24:18,080 --> 00:24:19,750
>> ઠીક છે, કે જે ભૌતિક ભાગ શું છે?

522
00:24:19,750 --> 00:24:25,310
વેલ, તે હાર્ડ ડ્રાઇવ પર કે બહાર વળે
આ પ્રકારના ઓછામાં ઓછા છે,

523
00:24:25,310 --> 00:24:27,340
આ નાના ઓછી ચુંબકીય કણો.

524
00:24:27,340 --> 00:24:32,630
અને તેઓ અનિવાર્યપણે ઉત્તર હોય છે અને
તેમને દક્ષિણ ધ્રુવની, જેથી જો તમે

525
00:24:32,630 --> 00:24:35,710
તે ચુંબકીય કણો એક બંધ
આ રીતે, તમે તે કે જે કહી શકે છે

526
00:24:35,710 --> 00:24:36,720
1 પ્રતિનિધિત્વ કરે છે.

527
00:24:36,720 --> 00:24:39,340
અને તે ઊલટું દક્ષિણ તો
ઉત્તર, તમે તે કે જે કહી શકે છે

528
00:24:39,340 --> 00:24:40,390
0 પ્રતિનિધિત્વ કરે છે.

529
00:24:40,390 --> 00:24:43,660
>> તેથી વાસ્તવિક ભૌતિક વિશ્વમાં, કે
તમે કંઈક પ્રતિનિધિત્વ કરી શકે છે કેવી રીતે

530
00:24:43,660 --> 00:24:45,670
દ્વિસંગી 0 રાજ્ય અને 1.

531
00:24:45,670 --> 00:24:46,720
કે જેથી બધા ફાઈલ છે છે.

532
00:24:46,720 --> 00:24:49,300
ચુંબકીય એક સમગ્ર ટોળું છે
તેમના આ રીતે અથવા છે કે કણો

533
00:24:49,300 --> 00:24:51,920
આ રીતે, બનાવવા દાખલાની
ના 0 સે અને 1 સે.

534
00:24:51,920 --> 00:24:56,760
>> પરંતુ તે, તમે ફાઈલ સંગ્રહો ત્યારે બહાર વળે
કેટલીક માહિતી અલગ સચવાય છે.

535
00:24:56,760 --> 00:25:00,000
તેથી આ એક ઓછી ટેબલ છે
ડિરેક્ટરી, તેથી વાત કરવા માટે.

536
00:25:00,000 --> 00:25:05,810
અને હું આ સ્તંભ નામ પર ફોન કરો, અને પડશે
હું આ સ્તંભ પાંચ આંકડાના US સ્થાન કૉલ કરશો.

537
00:25:05,810 --> 00:25:08,850
>> અને હું ધારવું, કહે જઇ રહ્યો છું
આ મારા રેઝ્યૂમે છે.

538
00:25:08,850 --> 00:25:14,050
મારી resume.doc પર સંગ્રહાયેલ છે
પાંચ આંકડાના US સ્થાન, 123 કહે છે ચાલો.

539
00:25:14,050 --> 00:25:15,390
હું હંમેશા કે જે નંબર માટે જાઓ.

540
00:25:15,390 --> 00:25:18,810
પરંતુ માત્ર ગમે કહે છે કે તે પૂરતા
RAM માં, તમે હાર્ડ ડ્રાઈવ લઈ શકે છે

541
00:25:18,810 --> 00:25:22,350
કે gigabyte અથવા 200 ગીગાબાઇટ્સ છે
અથવા ટેરાબાઈટ, અને તમે આ કરી શકો છો

542
00:25:22,350 --> 00:25:23,750
નંબર બાઇટ્સ બધા.

543
00:25:23,750 --> 00:25:26,480
તમે 8 બીટ્સ બધા હિસ્સામાં નંબર કરી શકો છો.

544
00:25:26,480 --> 00:25:29,030
>> તેથી અમે તે આ કહે છે પડશે
પાંચ આંકડાના US સ્થાન 123 છે.

545
00:25:29,030 --> 00:25:32,070
તેથી મારા ઓપરેટિંગ આ ડિરેક્ટરી અંદર
સિસ્ટમ યાદ છે કે મારા

546
00:25:32,070 --> 00:25:34,250
રેઝ્યૂમે પાંચ આંકડાના US સ્થાન 123 પર છે.

547
00:25:34,250 --> 00:25:36,850
પરંતુ તે જ્યારે રસપ્રદ નહીં
તમે ફાઈલ કાઢી નાંખો.

548
00:25:36,850 --> 00:25:37,820
>> દાખલા તરીકે, જેથી -

549
00:25:37,820 --> 00:25:40,790
અને thankfully, વિશ્વના સૌથી વધુ છે
આ પર પડેલા - શું ત્યારે થાય છે

550
00:25:40,790 --> 00:25:45,040
તમે તમારા મેક ઓએસ ટ્રૅશ માટે એક ફાઇલ ખેંચો
અથવા તમારા Windows રીસાયકલ બિન?

551
00:25:45,040 --> 00:25:48,290

552
00:25:48,290 --> 00:25:50,510
કે કરી ના હેતુ શું છે?

553
00:25:50,510 --> 00:25:53,860
તે ફાઈલ છુટકારો મેળવવા માટે દેખીતી રીતે ચોક્કો
પરંતુ શું ખેંચીને ના અધિનિયમ કરે છે અને

554
00:25:53,860 --> 00:25:57,550
તમારા ટ્રૅશ કે માં ડ્રોપ તમારા
રીસાઇકલ બિન કમ્પ્યુટર પર શું?

555
00:25:57,550 --> 00:25:59,230
>> ખરેખર એકદમ કંઈ.

556
00:25:59,230 --> 00:26:00,320
તે માત્ર એક ફોલ્ડર જેવી છે.

557
00:26:00,320 --> 00:26:01,800
તે ખાતરી કરવા માટે ખાસ ફોલ્ડર છે.

558
00:26:01,800 --> 00:26:04,460
પરંતુ તે વાસ્તવમાં ફાઈલ કાઢી નથી?

559
00:26:04,460 --> 00:26:06,780
>> ના, ઠીક છે, કારણ કે તમે કદાચ અમુક
જેવી કરવામાં આવી છે, ખરેખર ઓહ, તમે ન હતી

560
00:26:06,780 --> 00:26:07,420
તે કરવા માટે થાય છે.

561
00:26:07,420 --> 00:26:09,130
તેથી જો તમે ડબલ ક્લિક કરો
ટ્રૅશ કે રિસાયકલ બિન.

562
00:26:09,130 --> 00:26:11,630
તમે આસપાસ poked કરી છે અને તમે પ્રાપ્ત કર્યા છે
માત્ર તેને ખેંચીને ફાઇલ

563
00:26:11,630 --> 00:26:12,110
ત્યાં બહાર.

564
00:26:12,110 --> 00:26:14,420
તેથી સ્પષ્ટ છે, તે જરૂરી નથી
તેને કાઢી નાંખવા.

565
00:26:14,420 --> 00:26:15,990
>> ઠીક, તો તમે સ્માર્ટ કરતા નથી.

566
00:26:15,990 --> 00:26:18,860
તમે જાણો છો કે માત્ર તેને ખેંચીને
ટ્રૅશ કે રિસાયકલ બિન અર્થ એ નથી

567
00:26:18,860 --> 00:26:19,930
તમે ટ્રૅશને ખાલી કરવાથી રહ્યાં છો.

568
00:26:19,930 --> 00:26:24,110
તેથી તમે અપ મેનૂ પર જાઓ અને તમે કહી
કચરાપેટી અથવા ખાલી રીસાયકલ બિન.

569
00:26:24,110 --> 00:26:25,360
પછી શું થાય?

570
00:26:25,360 --> 00:26:29,070

571
00:26:29,070 --> 00:26:32,530
>> અરે વાહ, તેથી તે વધુ જેથી કાઢી નાખવામાં આવે છે.

572
00:26:32,530 --> 00:26:37,660
પરંતુ શું થાય છે કે આ બધા છે.

573
00:26:37,660 --> 00:26:45,350
કમ્પ્યુટર જ્યાં forgets
resume.doc હતી.

574
00:26:45,350 --> 00:26:47,400
>> પરંતુ શું દેખીતી રીતે બદલાઈ નથી
ચિત્રમાં?

575
00:26:47,400 --> 00:26:51,390

576
00:26:51,390 --> 00:26:55,570
આ બીટ્સ, હું દાવો છે કે 0 સે અને 1 સે છે
કેટલાક ભૌતિક પાસા સાઇટ પર

577
00:26:55,570 --> 00:26:56,280
હાર્ડવેર.

578
00:26:56,280 --> 00:26:57,110
તેઓ હજુ પણ છો.

579
00:26:57,110 --> 00:26:58,930
તે માત્ર કમ્પ્યુટર છે ચોક્કો
ભૂલી શું તેઓ છે.

580
00:26:58,930 --> 00:27:03,160
>> તેથી તે અનિવાર્યપણે મુક્ત આ ફાઈલની
તેઓ ફરીથી ઉપયોગ કરી શકાય બીટ્સ કે જેથી.

581
00:27:03,160 --> 00:27:06,940
પરંતુ તમે વધુ ફાઈલો બનાવશો નહિં ત્યાં સુધી
અને વધુ ફાઇલો, અને વધારે ફાઇલો ચાલશે

582
00:27:06,940 --> 00:27:12,150
સંભવતઃ તે 0 સે અને 1 સે,
તે ચુંબકીય કણો, ફરીથી મળે છે,

583
00:27:12,150 --> 00:27:16,220
માટે ઊલટું અથવા જમણી બાજુ ઉપર,
અન્ય ફાઇલો, 0 સે અને 1 સે.

584
00:27:16,220 --> 00:27:17,980
>> તેથી તમે સમય આ વિંડો છે.

585
00:27:17,980 --> 00:27:19,860
અને તે ધારી ન ચોક્કો
લંબાઈ, ખરેખર.

586
00:27:19,860 --> 00:27:22,240
તે તમારી હાર્ડ માપ પર આધાર રાખે છે
ડ્રાઇવ અને કેટલી ફાઈલો તમારી પાસે અને

587
00:27:22,240 --> 00:27:23,490
કેવી રીતે ઝડપથી તમે નવા બનાવે છે.

588
00:27:23,490 --> 00:27:27,050
પરંતુ સમય ના આ વિંડો દરમિયાન ત્યાં છે
તે ફાઈલ સંપૂર્ણપણે હજુ પણ છે જે

589
00:27:27,050 --> 00:27:27,770
વસૂલ.

590
00:27:27,770 --> 00:27:31,050
>> તમે ક્યારેય મેકાફી જેવા કાર્યક્રમો વાપરે છે તેથી જો
અથવા નોર્ટન પુનઃપ્રાપ્ત કરવાનો પ્રયાસ

591
00:27:31,050 --> 00:27:35,680
ડેટા, તેઓ કરી રહ્યાં છો બધા માટે પ્રયાસ કરી રહ્યા છે
આ કહેવાતા ડિરેક્ટરીમાં પુનઃપ્રાપ્ત

592
00:27:35,680 --> 00:27:37,340
તમારી ફાઈલ હતી, જ્યાં બહાર આકૃતિ.

593
00:27:37,340 --> 00:27:40,605
અને ક્યારેક નોર્ટન અને કહે છે, રહેશે
ફાઈલ 93% વસૂલ છે.

594
00:27:40,605 --> 00:27:42,020
ઠીક છે, કે શું અર્થ છે?

595
00:27:42,020 --> 00:27:45,690
માત્ર અર્થ એ થાય કે કોઇ અન્ય ફાઇલ
સાંયોગિક રીતે જ કહે છે, મદદથી અંત

596
00:27:45,690 --> 00:27:48,920
તમારા મૂળ ફાઇલ બહાર તે બીટ્સ.

597
00:27:48,920 --> 00:27:51,950
>> તેથી ખરેખર શું સામેલ છે
માહિતી પુનઃસ્થાપન છે?

598
00:27:51,950 --> 00:27:55,720
વેલ, તમે કંઈક ન હોય તો
નોર્ટન, તમારા કમ્પ્યુટર પર પહેલેથી સ્થાપિત થયેલ છે

599
00:27:55,720 --> 00:27:59,510
તમે ક્યારેક કરી શકો છો શ્રેષ્ઠ જોવા છે
સમગ્ર હાર્ડ ડ્રાઈવ શોધી ખાતે

600
00:27:59,510 --> 00:28:00,510
બીટ્સ ઓફ પેટર્ન.

601
00:28:00,510 --> 00:28:05,350
અને સમસ્યા સેટ થીમ્સ એક
પાંચ તમે શોધી કરશે કે જે છે

602
00:28:05,350 --> 00:28:09,570
હાર્ડ ડ્રાઈવ સમકક્ષ છે, એક ફોરેન્સિક
એક એક કોમ્પેક્ટ ફ્લેશ કાર્ડ છબી

603
00:28:09,570 --> 00:28:13,660
જો 0 સે માટે શોધ ડિજિટલ કૅમેરા,
ઉચ્ચ સાથે સામાન્ય રીતે 1 સે,

604
00:28:13,660 --> 00:28:16,720
સંભાવના છે, એ પ્રતિનિધિત્વ
કોઈ JPEG છબી શરૂ કરો.

605
00:28:16,720 --> 00:28:21,120
>> અને તમે ગાય્ઝ દ્વારા તે છબીઓ પુનઃપ્રાપ્ત કરી શકાય છે
હું આ પેટર્ન જુઓ તો, એમ ધારી રહ્યા છીએ

606
00:28:21,120 --> 00:28:24,380
જો ફોરેન્સિક છબી પર બિટ્સ સાથે
ચિહ્નિત કરે છે કે જે ઉચ્ચ સંભાવના,

607
00:28:24,380 --> 00:28:25,650
કોઈ JPEG શરૂઆત.

608
00:28:25,650 --> 00:28:29,520
અને હું ફરીથી આ જ પેટર્ન જુઓ તો,
કે કદાચ શરૂઆતમાં ચિહ્નિત કરે છે

609
00:28:29,520 --> 00:28:32,440
અન્ય JPEG, અને અન્ય
JPEG, અને અન્ય JPEG.

610
00:28:32,440 --> 00:28:34,970
અને આ ખાસ કરીને કેવી રીતે
માહિતી પુનઃપ્રાપ્તિ કામ કરશે.

611
00:28:34,970 --> 00:28:37,870
શું JPEGs વિશે સરસ છે પણ તેમ છતાં છે
ફાઇલ ફોર્મેટ પોતે કંઈક છે

612
00:28:37,870 --> 00:28:44,400
દરેક જેમ કે જટીલ, શરૂઆત
ફાઈલ ખરેખર એકદમ ઓળખી છે

613
00:28:44,400 --> 00:28:47,370
, તમે જોશો તરીકે, અને સરળ
જો તમે પહેલાથી જ નથી કર્યું તો.

614
00:28:47,370 --> 00:28:50,270
>> તેથી માતાનો નીચે નજીકથી નજર નાંખો
કરવામાં આવી બરાબર શું તરીકે હૂડ

615
00:28:50,270 --> 00:28:53,360
ચાલુ છે, અને આ 0 સે અને 1 સે શું
જો તમે એક બીટ વધુ આપવા માટે છે,

616
00:28:53,360 --> 00:28:55,330
આ ચોક્કસ પડકાર માટે સંદર્ભ.

617
00:28:55,330 --> 00:28:55,510
>> [વિડિઓ પ્લેબેક]

618
00:28:55,510 --> 00:28:58,700
>> તમારા પીસી સૌથી ભંડાર ક્યાં
તેના કાયમી માહિતી છે.

619
00:28:58,700 --> 00:29:03,390
કે આમ કરવા માટે, માહિતી RAM ના પ્રવાસ
કહેવું છે કે જે સોફ્ટવેર સંકેતો સાથે

620
00:29:03,390 --> 00:29:06,110
કેવી રીતે કે ડેટા સ્ટોર કરવા માટે હાર્ડ ડ્રાઈવ.

621
00:29:06,110 --> 00:29:09,410
હાર્ડ ડ્રાઈવ સર્કિટ અનુવાદ
વોલ્ટેજ માં તે સંકેતો

622
00:29:09,410 --> 00:29:10,870
વધઘટ.

623
00:29:10,870 --> 00:29:14,970
આ વળાંક, હાર્ડ ડ્રાઈવ માતાનો નિયંત્રિત
ખસેડવાની ભાગોમાં, થોડા કેટલાક

624
00:29:14,970 --> 00:29:17,910
જો બાકી મૂવિંગ પાર્ટ્સ
આધુનિક કોમ્પ્યુટર.

625
00:29:17,910 --> 00:29:22,130
>> આ સંકેતો કેટલાક મોટર નિયંત્રણ
જે મેટલ સ્તરીય platters ચક્રીય.

626
00:29:22,130 --> 00:29:25,470
તમારો ડેટા ખરેખર સંગ્રહાયેલ છે
આ platters પર.

627
00:29:25,470 --> 00:29:28,610
અન્ય સંકેતો વાંચો / લખો ખસેડવા
વાંચી અથવા હેડ

628
00:29:28,610 --> 00:29:30,710
જો platters પર માહિતી લખો.

629
00:29:30,710 --> 00:29:35,450
આ મશીનરી જેથી ચોક્કસ માનવ કે
વાળ પણ વચ્ચે પસાર કરી શક્યું નથી

630
00:29:35,450 --> 00:29:37,280
હેડ અને સ્પિનિંગ platters.

631
00:29:37,280 --> 00:29:40,316
હજુ સુધી, તે બધા જબરદસ્ત ઝડપે કામ કરે છે.

632
00:29:40,316 --> 00:29:40,660
>> [END વિડિઓ પ્લેબેક]

633
00:29:40,660 --> 00:29:42,190
>> DAVID MALAN: થોડું ઝૂમ વધારો
ઊંડા હવે શું

634
00:29:42,190 --> 00:29:44,360
વાસ્તવમાં તે platters પર.

635
00:29:44,360 --> 00:29:44,720
>> [વિડિઓ પ્લેબેક]

636
00:29:44,720 --> 00:29:47,660
>> માતાનો જુઓ-ચાલો આપણે માત્ર પર
ધીમી ગતિએ થયો હતો.

637
00:29:47,660 --> 00:29:51,710
વીજળી સંક્ષિપ્ત પલ્સ હોય છે ત્યારે
flips, તો વાંચવા / લખવા વડા મોકલવામાં

638
00:29:51,710 --> 00:29:54,650
માટે એક નાના ઇલેક્ટ્રોમેગ્નેટિક પર
બીજા એક અપૂર્ણાંક.

639
00:29:54,650 --> 00:29:58,970
આ ચુંબક જે ક્ષેત્ર બનાવે છે
ફેરફારો નાના નાના ના વલણ

640
00:29:58,970 --> 00:30:02,850
મેટલ કણો ભાગ જે
કોટ દરેક platter સપાટી.

641
00:30:02,850 --> 00:30:05,940
>> આ નાના એક પેટર્ન શ્રેણી,
ડિસ્ક પર ચાર્જ અપ વિસ્તારોમાં

642
00:30:05,940 --> 00:30:08,470
એક બીટ રજૂ
બાઈનરી સંખ્યામાં માહિતી

643
00:30:08,470 --> 00:30:10,530
કમ્પ્યુટર્સ દ્વારા ઉપયોગમાં સિસ્ટમ.

644
00:30:10,530 --> 00:30:13,775
હવે, વર્તમાન મોકલવામાં આવે છે જો એક રસ્તો
રીડ દ્વારા / વિસ્તાર વડા લખી

645
00:30:13,775 --> 00:30:15,970
એક દિશામાં ધ્રુવીકરણ થાય છે.

646
00:30:15,970 --> 00:30:17,950
વર્તમાન માં મોકલવામાં આવે છે તો
વિરુદ્ધ દિશામાં, જો

647
00:30:17,950 --> 00:30:19,930
ધ્રુવીકરણ વિપરીત છે.

648
00:30:19,930 --> 00:30:22,370
>> તમે હાર્ડ ડિસ્ક બોલ માહિતી વિચાર કેટલો?

649
00:30:22,370 --> 00:30:24,090
જસ્ટ પ્રક્રિયા ઉલટાવી.

650
00:30:24,090 --> 00:30:26,550
તેથી તે ડિસ્ક પર કણો છે
કે માં વર્તમાન વિચાર

651
00:30:26,550 --> 00:30:27,960
વડા ખસેડવાની વાંચવા / લખવા.

652
00:30:27,960 --> 00:30:30,700
આ લાખો મળીને મૂકો
ચુંબકીય સેગમેન્ટો, અને

653
00:30:30,700 --> 00:30:32,160
તમે એક ફાઇલ મળી છે.

654
00:30:32,160 --> 00:30:36,060
>> હવે, એક ફાઈલ ટુકડાઓ કરી શકે છે
બધા ડ્રાઇવ માતાનો ફેલાયેલ કરી

655
00:30:36,060 --> 00:30:39,970
આ વાસણ જેવા પ્રકારની platters,
તમારા ડેસ્ક પર કાગળો.

656
00:30:39,970 --> 00:30:43,500
તેથી ખાસ વધારાની ફાઇલ ટ્રેક રાખે છે
બધું છે કે જ્યાં છે.

657
00:30:43,500 --> 00:30:45,985
શું તમે હતા ઈચ્છો નહિં,
કે કંઈક?

658
00:30:45,985 --> 00:30:46,470
>> [END વિડિઓ પ્લેબેક]

659
00:30:46,470 --> 00:30:47,820
>> DAVID MALAN: બરાબર, કદાચ નથી.

660
00:30:47,820 --> 00:30:52,070
તેથી તમે કેવી રીતે ઘણા ગાય્ઝ
આ સાથે થયો હતો?

661
00:30:52,070 --> 00:30:53,970
ઠીક છે, તેથી તેને ઓછા અને ઓછા છે
હાથ દર વર્ષે.

662
00:30:53,970 --> 00:30:56,550
પરંતુ હું તમને ઓછામાં ઓછા પરિચિત કરશો સંતુષ્ટ છું
તેમની સાથે, આ કારણ કે આપણા પોતાના

663
00:30:56,550 --> 00:31:00,520
પુસ્તક ડેમો, દુર્ભાગ્યે, ખૂબ જ મૃત્યુ થાય છે
પારિવારિકતા અહીં મૃત્યુ ધીમું.

664
00:31:00,520 --> 00:31:04,010
>> પરંતુ આ, ઓછામાં પાછળ, હું છે
હાઇ સ્કુલ, બેકઅપ માટે વપરાય ઉપયોગ.

665
00:31:04,010 --> 00:31:08,110
અને તે અમેઝિંગ હતો, કારણ કે તમે
પર 1.4 મેગાબાઇટ્સ સ્ટોર કરી શકે છે

666
00:31:08,110 --> 00:31:08,930
આ ચોક્કસ ડિસ્ક.

667
00:31:08,930 --> 00:31:12,260
અને આ ઉચ્ચ ઘનતા વર્ઝન હતું
ધરાવે છે જે એચડી, દ્વારા દર્શાવવામાં

668
00:31:12,260 --> 00:31:14,240
આજના HD વિડિઓઝ પહેલાં થાય છે.

669
00:31:14,240 --> 00:31:16,400
>> ધોરણ ઘનતા 800 કિલોબાઇટ હતી.

670
00:31:16,400 --> 00:31:18,640
અને તે પહેલાં, ત્યાં હતા
400 કિલોબાઈટ ડિસ્ક.

671
00:31:18,640 --> 00:31:23,120
અને તે પહેલાં, 5 અને 1/4 હતી
સાચી ફ્લોપી હતા, જે ઇંચ ડિસ્ક,,

672
00:31:23,120 --> 00:31:25,680
અને થોડી વિશાળ અને ઊંચી
અહીં આ વસ્તુઓ કરતાં.

673
00:31:25,680 --> 00:31:29,150
પરંતુ તમે ખરેખર કહેવાતા જોઈ શકો છો
આ ડિસ્કનો ફ્લોપી પાસા.

674
00:31:29,150 --> 00:31:32,630
>> અને વિધેયાત્મક રીતે, તેઓ ખરેખર છો
અંતે ઓફ હાર્ડ ડ્રાઈવો માટે ખૂબ સમાન

675
00:31:32,630 --> 00:31:33,570
ઓછામાં આ પ્રકાર.

676
00:31:33,570 --> 00:31:37,270
નવી કમ્પ્યુટર્સ ફરી, SSDs
અલગ થોડી કામ કરે છે.

677
00:31:37,270 --> 00:31:41,530
પરંતુ જો તમે તે થોડી મેટલ ટેબ ખસેડવા તો,
તમે ખરેખર, થોડું કૂકી જોઈ શકો છો

678
00:31:41,530 --> 00:31:42,560
અથવા platter.

679
00:31:42,560 --> 00:31:43,830
>> આ એક જેવી મેટલ નથી.

680
00:31:43,830 --> 00:31:46,000
આ એક ખરેખર કેટલાક સસ્તા છે
સામગ્રી પ્લાસ્ટિક.

681
00:31:46,000 --> 00:31:46,750
અને તમે વારંવાર હાલવું તે પ્રકારની કરી શકો છો.

682
00:31:46,750 --> 00:31:50,310
અને તમે trully માત્ર કેટલાક બંધ લૂછી કર્યું
બિટ્સ અથવા ચુંબકીય કણો નંબર

683
00:31:50,310 --> 00:31:51,220
આ ડિસ્કમાંથી.

684
00:31:51,220 --> 00:31:52,710
>> તેથી thankfully, તે કંઇ નથી.

685
00:31:52,710 --> 00:31:55,790
કે વસ્તુ રીતે તો - અને આવરી
તમારી આંખો અને તમારા પાડોશી તે -

686
00:31:55,790 --> 00:31:58,865
માત્ર પ્રકારની આ ખેંચવાનો તમે કરી શકો છો
કે જેમ સમગ્ર આવરણ બોલ.

687
00:31:58,865 --> 00:32:01,900
પરંતુ થોડી વસંત ત્યાં છે, તેથી
તમારી આંખો સાથે પરિચિત.

688
00:32:01,900 --> 00:32:03,620
તેથી હવે તમે સાચી ફ્લોપી ડિસ્ક છે.

689
00:32:03,620 --> 00:32:07,090
>> અને આ શું છે તે વિશે નોંધપાત્ર છે
આ છે કે જે ઘણી છે એક

690
00:32:07,090 --> 00:32:10,830
મોટા નાના પાયે પ્રતિનિધિત્વ
હાર્ડ ડ્રાઈવ, આ વસ્તુઓ, સુપર છે

691
00:32:10,830 --> 00:32:11,590
સુપર સરળ.

692
00:32:11,590 --> 00:32:15,170
તમે હવે તેને તળિયે ચૂંટવું કે જો
કે મેટલ વસ્તુ બંધ છે, અને છાલ

693
00:32:15,170 --> 00:32:20,990
તેમને ખોલવા છે, બધા બે ટુકડાઓ છે
લાગ્યું અને કહેવાતા ફ્લોપી ડિસ્ક

694
00:32:20,990 --> 00:32:22,930
અંદરની પર મેટલ એક ભાગ સાથે.

695
00:32:22,930 --> 00:32:25,990
>> અને અડધા ત્યાં જાય છે
મારા ડિસ્ક સમાવિષ્ટો.

696
00:32:25,990 --> 00:32:27,540
તેમને અન્ય અડધા ત્યાં જાય છે.

697
00:32:27,540 --> 00:32:31,375
પરંતુ તે અંદર ફરતો હતો તે બધા છે
યસ્ટરયર્સ માં તમારા કમ્પ્યુટરની.

698
00:32:31,375 --> 00:32:35,220

699
00:32:35,220 --> 00:32:38,310
>> અને ફરી, પરિપ્રેક્ષ્ય માં આ મૂકવા માટે
કેવી રીતે મોટું છે તમારા મોટા ભાગના

700
00:32:38,310 --> 00:32:39,560
હાર્ડ આ દિવસ નહીં?

701
00:32:39,560 --> 00:32:41,960

702
00:32:41,960 --> 00:32:46,230
500 ગીગાબાઇટ્સ, એક ટેરાબાઈટ, કદાચ માં
ડેસ્કટોપ કોમ્પ્યુટર, 2 terabytes, 3

703
00:32:46,230 --> 00:32:47,630
terabytes 4 terabytes, બરાબર ને?

704
00:32:47,630 --> 00:32:52,480
આ એક મેગાબાઇટ છે, આપવા અથવા લેવા
પણ એક લાક્ષણિક MP3 ફિટ કરી શકતા નથી કે જે

705
00:32:52,480 --> 00:32:55,310
હવે આ દિવસોમાં, અથવા અમુક
સમાન પ્રકારની સંગીત ફાઇલ.

706
00:32:55,310 --> 00:32:59,500
>> તેથી થોડું તમારા માટે સંભારણું આજે, અને
પણ શું contextualize મદદ કરવા માટે

707
00:32:59,500 --> 00:33:03,570
અમે મંજૂર માટે લઈ આવશે
હવે સમસ્યા પાંચ સુયોજિત કરો.

708
00:33:03,570 --> 00:33:04,820
તેથી તે રાખવા તમારામાં છે.

709
00:33:04,820 --> 00:33:07,340

710
00:33:07,340 --> 00:33:13,370
તેથી હશે જ્યાં મને સંક્રમણ દો
આગામી pset ખર્ચમાં તેમજ.

711
00:33:13,370 --> 00:33:18,470
તેથી અમે હવે આ પાનું માટે સુયોજિત કર્યા છે - ઓહ,
ઝડપથી જાહેરાત એક દંપતિ.

712
00:33:18,470 --> 00:33:21,730
>> આ શુક્રવાર, તમે ઈચ્છો તો CS50 જોડાવા
લંચ માટે, સામાન્ય સ્થળ પર જાઓ

713
00:33:21,730 --> 00:33:23,610
cs50.net/rsvp.

714
00:33:23,610 --> 00:33:25,100
અને અંતિમ પ્રોજેક્ટ -

715
00:33:25,100 --> 00:33:28,520
જેથી અભ્યાસક્રમ અનુસાર, અમે પોસ્ટ કરેલા
પહેલાથી જ અંતિમ પ્રોજેક્ટ સ્પષ્ટીકરણ.

716
00:33:28,520 --> 00:33:31,410
એનો અર્થ એ નથી કે ખ્યાલ
તે ખાસ કરીને તરત કારણે છે.

717
00:33:31,410 --> 00:33:33,990
તે માત્ર વિચાર, ખરેખર, પોસ્ટ કરી રહ્યું છે
તમે ગાય્ઝ તે વિશે વિચારવાનો.

718
00:33:33,990 --> 00:33:37,620
અને ખરેખર, એક સુપર નોંધપાત્ર
તમે ટકાવારી હાથ ધરવા આવશે

719
00:33:37,620 --> 00:33:40,780
સામગ્રી પર અંતિમ પ્રોજેક્ટ છે કે અમે
પણ વર્ગ માટે મેળવેલ નથી,

720
00:33:40,780 --> 00:33:42,730
પરંતુ શરૂઆતમાં આગામી સપ્તાહ તરીકે ચાલશે.

721
00:33:42,730 --> 00:33:45,530
>> સૂચના, જોકે, ઉલ્લેખનું માટે કહે છે કે
જો થોડા વિવિધ ઘટકો

722
00:33:45,530 --> 00:33:46,190
અંતિમ પ્રોજેક્ટ.

723
00:33:46,190 --> 00:33:49,590
પ્રથમ, થોડા અઠવાડિયામાં, એક
પૂર્વ દરખાસ્ત માટે એક સુંદર કેઝ્યુઅલ ઇમેઇલ

724
00:33:49,590 --> 00:33:52,760
તમારા તેમને કહેવું ટીએફ અથવા શું તમે છો
સાથે, તમારા પ્રોજેક્ટ માટે વિશે વિચારવાનો

725
00:33:52,760 --> 00:33:53,650
આ બોલ પર કોઈ પ્રતિબદ્ધતા.

726
00:33:53,650 --> 00:33:56,710
દરખાસ્ત તમારા ચોક્કસ હશે
પ્રતિબદ્ધતા, એમ કહીને, અહીં, આ શું છે

727
00:33:56,710 --> 00:33:57,770
હું મારા પ્રોજેક્ટ માટે કરવા માંગો છો.

728
00:33:57,770 --> 00:33:58,250
તમે શું વિચારો છો?

729
00:33:58,250 --> 00:33:58,650
ખૂબ મોટી?

730
00:33:58,650 --> 00:33:59,145
ખૂબ નાની?

731
00:33:59,145 --> 00:34:00,330
તે વ્યવસ્થા છે?

732
00:34:00,330 --> 00:34:02,230
અને તમે વધુ વિગતો માટે ઉલ્લેખનું જુઓ.

733
00:34:02,230 --> 00:34:05,060
>> અઠવાડિયા દંપતિ કે પછી સ્થિતિ છે
સમાન છે, જે અહેવાલ,

734
00:34:05,060 --> 00:34:08,260
માત્ર કેવી રીતે કહે છે તમારી ટીએફ માટે કેઝ્યુઅલ ઇમેઇલ
તમે તમારી અંતિમ છે અત્યાર સુધી પાછળ

735
00:34:08,260 --> 00:34:12,360
અનુસરતા પ્રોજેક્ટના અમલીકરણ,
જો CS50 Hackathon કે જે દરેક

736
00:34:12,360 --> 00:34:17,520
આમંત્રિત કર્યા છે, એક ઘટના હશે જે
7:00 સુધી એક સાંજે 8:00 PM પર પોસ્ટેડ

737
00:34:17,520 --> 00:34:19,150
આગામી સવારે પોસ્ટેડ.

738
00:34:19,150 --> 00:34:22,560
હું અઠવાડિયામાં ઉલ્લેખ કર્યો છે શકે પિઝા,
શૂન્ય, વિલ, 9:00 PM પર પોસ્ટેડ ખાતે સેવા અપાયેલ

739
00:34:22,560 --> 00:34:24,120
1:00 ખાતે ચિની ખોરાક પોસ્ટેડ.

740
00:34:24,120 --> 00:34:27,929
અને તમે 5:00 ખાતે હજુ પણ જાગતું કરશો તો પોસ્ટેડ,
અમે નાસ્તો માટે IHOP લઈ શકશો.

741
00:34:27,929 --> 00:34:31,310
>> તેથી Hackathon વધુ એક છે
વર્ગ માં યાદગાર અનુભવો.

742
00:34:31,310 --> 00:34:35,290
પછી અમલીકરણ કારણે છે, અને
પછી લક્ષણયુક્ત CS50 ફેર.

743
00:34:35,290 --> 00:34:38,070
આ બધી પર વધુ વિગતો
આ અઠવાડિયામાં આવે છે.

744
00:34:38,070 --> 00:34:40,739
>> પરંતુ માતાનો કંઈક પાછા જવા દો
જૂના શાળા -

745
00:34:40,739 --> 00:34:41,920
ફરીથી, એક એરે.

746
00:34:41,920 --> 00:34:45,040
તે નિવારે છે કારણ કે તેથી ઝાકઝમાળ, સરસ હતી
અમે જેવી સમસ્યાનો માત્ર એક જોયું

747
00:34:45,040 --> 00:34:49,290
વિદ્યાર્થી માળખાં સાથે પહેલા ક્ષણ
નિયંત્રણ થોડી બહાર મેળવવામાં જો આપણે

748
00:34:49,290 --> 00:34:52,405
વિદ્યાર્થી એક વિદ્યાર્થી બે, હોય માંગો છો
વિદ્યાર્થી ત્રણ, વિદ્યાર્થી પર કોઈ ટપકું ટપકું,

749
00:34:52,405 --> 00:34:54,400
અમુક વિદ્યાર્થીઓ મનસ્વી સંખ્યા.

750
00:34:54,400 --> 00:34:58,850
>> એરેને તેથી, થોડા અઠવાડિયા પહેલા માં પડયું
અને હલ અમારી સમસ્યાઓ નથી બધા

751
00:34:58,850 --> 00:35:03,340
અગાઉથી જાણીને કેવી રીતે ઘણી વસ્તુઓ
અમુક પ્રકારની અમે છો.

752
00:35:03,340 --> 00:35:07,390
અને અમે સ્ટ્ર્ક્ટ્સ અમને મદદ કરી શકો છો કે જે જોઈ કર્યું
વધુ અમારી કોડ આયોજન અને રાખવા

753
00:35:07,390 --> 00:35:11,660
જેમ કલ્પનાત્મક સમાન ચલો,
નામ અને ઘર, મળીને, કે જેથી અમે

754
00:35:11,660 --> 00:35:15,570
અંદર એક એન્ટિટી તરીકે, તેમને સારવાર કરી શકે છે
જે નાના ટુકડાઓ છે.

755
00:35:15,570 --> 00:35:17,810
>> પરંતુ કેટલાક ગેરફાયદા એરે છે.

756
00:35:17,810 --> 00:35:19,780
આ ગેરલાભ કેટલાક શું છે
અમે આવી

757
00:35:19,780 --> 00:35:22,320
સંગ્રહ સાથે આમ અત્યાર સુધી?

758
00:35:22,320 --> 00:35:23,450
કે શું?

759
00:35:23,450 --> 00:35:28,130
ચોક્કસ માપ - તેથી પણ તમે કદાચ છતાં
એક માટે મેમરીને ફાળવવા સમક્ષ રજુ કરવાનો પ્રયત્ન

760
00:35:28,130 --> 00:35:32,310
અરે, એક વાર તમે જાણતા કેવી રીતે ઘણા વિદ્યાર્થીઓ
તમે તમારી પાસે કેટલા અક્ષરો ધરાવે છે,

761
00:35:32,310 --> 00:35:35,460
વપરાશકર્તા માંથી, એક વાર તમે ફાળવવામાં કર્યું
એરે, તમે પ્રકારની દોરવામાં કર્યું

762
00:35:35,460 --> 00:35:36,740
એક ખૂણામાં માં જાતે.

763
00:35:36,740 --> 00:35:40,600
>> તમે નવા તત્વો સામેલ કરી શકતા નથી કારણ કે
એક એરે મધ્યમાં માં.

764
00:35:40,600 --> 00:35:43,660
તમે વધુ તત્વો સામેલ કરી શકતા નથી
એક એરે ઓવરને અંતે.

765
00:35:43,660 --> 00:35:47,750
ખરેખર, તમે બનાવવા માટે આશરો છે
અમે ચર્ચા કરી છે તેમ સમગ્ર નવી એરે,

766
00:35:47,750 --> 00:35:49,320
નવા માં જૂની નકલ.

767
00:35:49,320 --> 00:35:52,610
અને ફરી, કે માથાનો દુખાવો છે કે
તમે માટે સાથે સોદા GetString.

768
00:35:52,610 --> 00:35:56,170
>> પરંતુ ફરીથી, તમે પણ સામેલ કરી શકતા નથી
એરે મધ્યમાં માં કંઈક

769
00:35:56,170 --> 00:35:58,200
દર સંપૂર્ણપણે ભરવામાં ન હોય તો.

770
00:35:58,200 --> 00:36:03,010
હમણાં પૂરતું, આ એરે જો અહીં કદ
છ જ, તે પાંચ વસ્તુઓ છે

771
00:36:03,010 --> 00:36:06,080
વેલ, તમે માત્ર ખીલી શકે
ઓવરને પર કંઈક.

772
00:36:06,080 --> 00:36:08,200
પરંતુ તમે કંઈક દાખલ કરવા શું માંગો છો, તો
ના મધ્યમ માં

773
00:36:08,200 --> 00:36:11,280
અરે, તે હોઈ શકે છે, તેમ છતાં
તે છ વસ્તુઓ પાંચ બહાર?

774
00:36:11,280 --> 00:36:14,250
>> ઠીક છે, આપણે બધા હતી જ્યારે શું કર્યું
અમારા માનવ સ્વયંસેવકો સ્ટેજ માં

775
00:36:14,250 --> 00:36:15,110
અઠવાડિયા છેલ્લા?

776
00:36:15,110 --> 00:36:18,710
અમે અહીં કોઈને મૂકી કરવા ઈચ્છતો હોય તો, ક્યાંતો
આ ખસેડવા માટે કેવી રીતે આ લોકો

777
00:36:18,710 --> 00:36:22,540
માર્ગ, અથવા આ ખસેડવા માટે કેવી રીતે આ લોકો
માર્ગ છે, અને તે ખર્ચાળ બની ગઇ હતી.

778
00:36:22,540 --> 00:36:26,950
આ એક અંદર લોકો સ્થળાંતર
અરે ઉમેરો અને પડતર અંત

779
00:36:26,950 --> 00:36:31,240
અમને સમય, તેથી ઘણો અમારા એ સ્ક્વેર્ડ ઓફ
માટે, નિવેશ સોર્ટ જેવા વખત ચાલી

780
00:36:31,240 --> 00:36:32,550
હમણાં પૂરતું, સૌથી ખરાબ કિસ્સામાં.

781
00:36:32,550 --> 00:36:36,520
તેથી એરેને મહાન હોય છે, પરંતુ તમને હોય
તમે તેમને માંગો છો કેવી રીતે મોટા અગાઉથી ખબર.

782
00:36:36,520 --> 00:36:38,030
>> તેથી બરાબર, અહીં ઉકેલ છે.

783
00:36:38,030 --> 00:36:43,860
હું અગાઉથી ખબર ન હોય તો કેટલા
વિદ્યાર્થીઓ હું હોઈ શકે છે, અને હું એક વાર ખબર

784
00:36:43,860 --> 00:36:47,870
હું નક્કી, છતાં, હું સાથે અટવાઇ છું
, શા માટે હું માત્ર હંમેશા ઘણા વિદ્યાર્થીઓ નથી

785
00:36:47,870 --> 00:36:51,740
બે વખત તેટલી જગ્યા ફાળવો
મને લાગે છે તેમ હું જરૂર છે?

786
00:36:51,740 --> 00:36:54,450
કે વાજબી ઉકેલ નથી?

787
00:36:54,450 --> 00:36:58,240
>> વાસ્તવિકતાથી, હું અમે છો લાગતું નથી
50 થી વધુ સ્લોટ્સ જરૂર જવા

788
00:36:58,240 --> 00:37:02,190
મધ્યમ કદ વર્ગ માટે એક એરે માં,
જેથી માતાનો માત્ર ગિરફતારી દો.

789
00:37:02,190 --> 00:37:07,040
હું ફક્ત મારા એરે 100 સ્લોટ્સ બનાવવા પડશે
જેથી અમે ચોક્કસપણે વિચાર કરી શકો છો

790
00:37:07,040 --> 00:37:10,330
હું અપેક્ષા વિદ્યાર્થીઓ સંખ્યા
કેટલાક મધ્યમ કદના વર્ગ છે.

791
00:37:10,330 --> 00:37:14,320
તેથી શા માટે માત્ર ગિરફતારી અને ફાળવી નથી
એક એરે માટે વધુ મેમરી, ખાસ કરીને,

792
00:37:14,320 --> 00:37:16,290
તમે પણ જરૂર પડી શકે છે લાગે કરતાં?

793
00:37:16,290 --> 00:37:20,190
આ સરળ pushback શું છે
આ વિચાર માટે?

794
00:37:20,190 --> 00:37:21,440
>> તમે માત્ર મેમરી બગાડ કરી રહ્યા છીએ.

795
00:37:21,440 --> 00:37:25,350
પછી તમે લખવા શાબ્દિક દરેક કાર્યક્રમ
કદાચ બમણી બધી મેમરીનો ઉપયોગ કરે છે તરીકે

796
00:37:25,350 --> 00:37:26,680
તમે ખરેખર જરૂર છે.

797
00:37:26,680 --> 00:37:28,990
અને માત્ર એક જેવા લાગે છે નથી કે
ખાસ કરીને ભવ્ય ઉકેલ.

798
00:37:28,990 --> 00:37:31,990
વધુમાં, તે માત્ર ઘટે
સમસ્યા સંભાવના.

799
00:37:31,990 --> 00:37:35,300
જો તમે લોકપ્રિય કોર્સ હોય થાય છે
એક સત્ર અને તમે 101 છે

800
00:37:35,300 --> 00:37:39,610
વિદ્યાર્થીઓ, તમારા કાર્યક્રમ હજુ પણ છે
મૂળભૂત એ જ મુદ્દો સામનો.

801
00:37:39,610 --> 00:37:44,280
>> તેથી thankfully માટે ઉકેલ છે
સ્વરૂપમાં આ જાહેરાત બધા અમારી સમસ્યાઓ

802
00:37:44,280 --> 00:37:46,790
છે કે જે માહિતી માળખાં
રાશિઓ કરતાં વધુ જટિલ

803
00:37:46,790 --> 00:37:47,970
અમે આમ અત્યાર સુધી જોઇ છે.

804
00:37:47,970 --> 00:37:50,530
આ, હું દાવો, લિંક કરેલા યાદી છે.

805
00:37:50,530 --> 00:37:51,920
આ નંબરોની યાદી છે -

806
00:37:51,920 --> 00:37:54,970
9, 17, 22, 26, અને 34 -

807
00:37:54,970 --> 00:38:00,120
માર્ગ દ્વારા એકસાથે કડી થયેલ હોય છે કે જે
શું હું તીર તરીકે દોરેલા કર્યું છે.

808
00:38:00,120 --> 00:38:03,580
>> અન્ય શબ્દોમાં, જો હું રજૂ કરવા માગતા હતા
એક અરે, હું શું કરી શકે છે

809
00:38:03,580 --> 00:38:04,910
આ કંઈક.

810
00:38:04,910 --> 00:38:07,310
અને હું ઓવરહેડ પર આ મૂકીશું
માત્ર એક ક્ષણ.

811
00:38:07,310 --> 00:38:09,970
હું શું કરી શકે છે -

812
00:38:09,970 --> 00:38:12,520
હેલ્લો, બધા અધિકાર.

813
00:38:12,520 --> 00:38:14,470
દ્વારા ઊભા.

814
00:38:14,470 --> 00:38:17,360
અહીં નવા કમ્પ્યુટર, સ્પષ્ટ -

815
00:38:17,360 --> 00:38:18,090
બધા અધિકાર.

816
00:38:18,090 --> 00:38:21,730
>> તેથી હું એરે આ નંબરો હોય તો -

817
00:38:21,730 --> 00:38:28,880
9, 17, 22, 26, 24 -

818
00:38:28,880 --> 00:38:30,530
માપવાના જરૂરી નથી.

819
00:38:30,530 --> 00:38:33,730
બધા હક, તેથી અહીં મારા એરે છે -

820
00:38:33,730 --> 00:38:34,980
દેવ ઓહ.

821
00:38:34,980 --> 00:38:38,700

822
00:38:38,700 --> 00:38:40,395
બધા હક, તેથી અહીં મારા એરે છે.

823
00:38:40,395 --> 00:38:44,110

824
00:38:44,110 --> 00:38:45,050
દેવ મારા ઓહ.

825
00:38:45,050 --> 00:38:48,820
>> [હાસ્ય]

826
00:38:48,820 --> 00:38:49,440
>> DAVID MALAN: ડોળ કરવો.

827
00:38:49,440 --> 00:38:52,330
તે પાછળ જવા માટે ખૂબ પ્રયત્ન છે
અને તેથી ત્યાં, કે જે ઠીક -

828
00:38:52,330 --> 00:38:54,290
26.

829
00:38:54,290 --> 00:38:57,650
તેથી અમે આ ઍરેની છે
9, 17, 22, 26, અને 34.

830
00:38:57,650 --> 00:39:00,260
તમે તે જોઈ શકે છે માટે
મૂંઝવતી ભૂલ હું માત્ર બનાવવામાં આવે છે,

831
00:39:00,260 --> 00:39:00,830
ત્યાં તે છે.

832
00:39:00,830 --> 00:39:04,490
>> તેથી હું આ દાવો છે કે એક
ખૂબ જ કાર્યક્ષમ ઉકેલ.

833
00:39:04,490 --> 00:39:07,310
હું ઘણા ints તરીકે ફાળવવામાં કર્યું
હું જરૂર પડશે - એક, બે, ત્રણ,

834
00:39:07,310 --> 00:39:09,100
ચાર, પાંચ, છ -

835
00:39:09,100 --> 00:39:11,660
અને હું પછી નંબરો સ્ટોર કરી છે
આ ઍરેની પર આધારિત છે.

836
00:39:11,660 --> 00:39:15,220
પરંતુ ધારવું, તો પછી, હું સામેલ કરવા માંગો છો
નંબર 8 જેવા કિંમત?

837
00:39:15,220 --> 00:39:16,100
ઠીક છે, તે જ્યાં જાઓ નથી?

838
00:39:16,100 --> 00:39:18,530
હું સામેલ કરવા માંગો છો ધારવું
20 જેવો સંખ્યા.

839
00:39:18,530 --> 00:39:19,790
ઠીક છે, તે જ્યાં જાઓ નથી?

840
00:39:19,790 --> 00:39:23,160
ક્યાંક ત્યાં મધ્યમાં,
અથવા નંબર 35 પર જવા માટે છે

841
00:39:23,160 --> 00:39:24,010
ક્યાંક ઓવરને અંતે.

842
00:39:24,010 --> 00:39:25,320
પરંતુ હું જગ્યા બહાર છું.

843
00:39:25,320 --> 00:39:29,120
>> અને તેથી આ મૂળભૂત પડકાર છે
ઉકેલ છે નથી કે એરે છે.

844
00:39:29,120 --> 00:39:32,280
હું GetString, એક ક્ષણ પહેલા એવો દાવો કર્યો હતો
આ સમસ્યા નિવારે છે.

845
00:39:32,280 --> 00:39:37,380
જો તમે છઠ્ઠા નંબર દાખલ કરવા માંગો છો
આ એરે માં, ઓછામાં ઓછા એક શું છે

846
00:39:37,380 --> 00:39:40,090
ઉકેલ તમે ખાતરી માટે પર પાછા પડી શકે
માત્ર અમે GetString સાથે આવું જેવી?

847
00:39:40,090 --> 00:39:44,340

848
00:39:44,340 --> 00:39:46,030
કે શું?

849
00:39:46,030 --> 00:39:48,190
>> ઠીક છે, તે મોટી છે તેની ખાતરી
સરળ થાય કરતાં જણાવ્યું હતું કે,.

850
00:39:48,190 --> 00:39:52,810
અમે જરૂરી એરે બનાવી શકતા નથી
મોટા છે, પરંતુ આપણે શું કરી શકીએ?

851
00:39:52,810 --> 00:39:56,570
કદ મોટી છે કે નવી અરે, બનાવો
6, અથવા કદાચ કદ 10, અમે માંગતા હોય તો

852
00:39:56,570 --> 00:40:00,490
આગળ વસ્તુઓ વિચાર કરો અને પછી કૉપિ માટે
જૂના નવા માં અરે, અને પછી

853
00:40:00,490 --> 00:40:01,680
જૂના એરે મુક્ત.

854
00:40:01,680 --> 00:40:05,770
>> પરંતુ ચાલી સમય શું છે
હવે તે પ્રક્રિયાના?

855
00:40:05,770 --> 00:40:09,870
તે એ છે કે મોટા ગુમાવનારા કારણ કે કોપી
તમે કેટલાક એકમો ખર્ચ ચાલે છે

856
00:40:09,870 --> 00:40:13,480
અમે પાસે સમય છે, તેથી તેથી આદર્શ ન હોય તો
ચાલે છે, જે નવા અરે, ફાળવો

857
00:40:13,480 --> 00:40:15,610
બે વખત તરીકે ખૂબ ઉપયોગ કરવા માટે
અસ્થાયી મેમરી.

858
00:40:15,610 --> 00:40:16,660
નવી માં જૂની નકલ કરો -

859
00:40:16,660 --> 00:40:18,800
હું તેનો અર્થ છે, તે માત્ર એક માથાનો દુખાવો છે, જે
ફરીથી, શા માટે અમે લખ્યું છે

860
00:40:18,800 --> 00:40:19,920
જો તમે GetString.

861
00:40:19,920 --> 00:40:21,380
>> અમે બદલે તેથી શું શકે?

862
00:40:21,380 --> 00:40:25,000
ઠીક છે, શું અમારી માહિતી બંધારણ
વાસ્તવમાં તે gaps છે?

863
00:40:25,000 --> 00:40:30,790
હું કર્યા મારા ધ્યેય આરામ કે ધારવું
મેમરી સંલગ્ન હિસ્સામાં, જ્યાં 9

864
00:40:30,790 --> 00:40:34,500
છે, જે 17, અધિકાર આગામી છે
જમણી 22 આગામી, અને તેથી પર.

865
00:40:34,500 --> 00:40:39,570
>> અને 9 અહીં પર હોઇ શકે છે કે જે ધારવું
RAM, અને 17, RAM માં અહીં કરી શકો છો

866
00:40:39,570 --> 00:40:40,990
અને 22 RAM માં અહીં કરી શકો છો.

867
00:40:40,990 --> 00:40:43,610
અન્ય શબ્દોમાં, હું તેમને જરૂર નથી
પણ હવે પાછળ પાછળ.

868
00:40:43,610 --> 00:40:47,850
હું માત્ર અચાનક એક સોય થ્રેડ છે
આ નંબરો દરેક, અથવા દરેક મારફતે

869
00:40:47,850 --> 00:40:51,010
આ ગાંઠો છે, અમે ફોન કરો પડશે
હું તેમને દોરેલા છે તેમ લંબચોરસ માટે

870
00:40:51,010 --> 00:40:55,670
જો છેલ્લા મેળવવા માટે કેવી રીતે યાદ
પ્રથમ આવા નોડ.

871
00:40:55,670 --> 00:40:59,940
>> તેથી પ્રોગ્રામિંગ રચવું શું છે
અમે ખૂબ તાજેતરમાં જોયેલા કે જેની સાથે હું

872
00:40:59,940 --> 00:41:03,030
કે થ્રેડ અમલીકરણ, અથવા શકો છો
અહીં દોરેલા હું કરી શકો છો, જે સાથે

873
00:41:03,030 --> 00:41:05,430
તે તીર અમલ?

874
00:41:05,430 --> 00:41:06,500
તેથી પોઇન્ટર, અધિકાર?

875
00:41:06,500 --> 00:41:09,560
હું માત્ર નથી ફાળવી તો
Int, પરંતુ નોડ - અને દ્વારા

876
00:41:09,560 --> 00:41:10,810
નોડ, હું હમણાં જ કન્ટેનર અર્થ.

877
00:41:10,810 --> 00:41:12,900
અને દૃષ્ટિની, હું એક લંબચોરસ અર્થ.

878
00:41:12,900 --> 00:41:16,420
નોડ દેખીતી રીતે જરૂર તેથી
બે કિંમતો સમાવી માટે -

879
00:41:16,420 --> 00:41:21,490
જો ઈન્ પોતે, અને પછી, તરીકે દ્વારા સૂચિત
લંબચોરસમાં તળિયે અડધા,

880
00:41:21,490 --> 00:41:23,010
એક ઈન્ માટે પૂરતી જગ્યા નથી.

881
00:41:23,010 --> 00:41:26,130
>> તેથી, ફક્ત અહીં આગળ વિચારી
આ નોડ આ રીતે મોટી છે

882
00:41:26,130 --> 00:41:27,170
પ્રશ્ન માં કન્ટેનર?

883
00:41:27,170 --> 00:41:29,250
જો ઈન્ માટે કેટલા બાઇટ્સ?

884
00:41:29,250 --> 00:41:31,310
અનુમાન 4, તે તો
હંમેશની જેમ જ.

885
00:41:31,310 --> 00:41:33,270
અને પછી કેટલા બાઇટ્સ
પોઇન્ટર માટે?

886
00:41:33,270 --> 00:41:33,650
4.

887
00:41:33,650 --> 00:41:37,940
તેથી આ કન્ટેનર, અથવા આ નોડ છે,
8 બાઇટ માળખું હશે.

888
00:41:37,940 --> 00:41:41,760
ઓહ, અને તે ખુશ સંયોગ છે કે
આપણે આ વિચારને રજૂ કરવામાં

889
00:41:41,760 --> 00:41:44,400
એક સ્ટ્રક્ટ, અથવા એક સી માળખું.

890
00:41:44,400 --> 00:41:48,890
>> તેથી હું એક પગલું લેવા માંગો છો કે દાવો
આ વધુ આધુનિક તરફ

891
00:41:48,890 --> 00:41:52,560
નંબરોની યાદી, એક અમલીકરણ
નંબરો યાદીની લિંક, હું શું કરવાની જરૂર

892
00:41:52,560 --> 00:41:56,920
થોડી વધુ ફ્રન્ટ અપ વિચાર અને
માત્ર એક Int, પરંતુ સ્ટ્રક્ટ જાહેર

893
00:41:56,920 --> 00:41:58,620
હું કૉલ કરીશ કે, પરંપરાગત
અહીં, નોડ.

894
00:41:58,620 --> 00:42:01,630
અમે તે અમે માંગો કંઈપણ કૉલ, પરંતુ શકે છે
નોડ ઘણો માં વિષયવાર હોઈ ચાલે છે

895
00:42:01,630 --> 00:42:03,560
આ વસ્તુઓ આપણે હવે જોઈ શરૂ કરો.

896
00:42:03,560 --> 00:42:06,480
>> કે ગાંઠની અંદર એક ઈન્ એ છે.

897
00:42:06,480 --> 00:42:09,350
અને તે પછી આ વાક્યરચના, થોડું
પ્રથમ નજરમાં અલૌકિક -

898
00:42:09,350 --> 00:42:12,960
સ્ટ્રક્ટ નોડ * આગલા.

899
00:42:12,960 --> 00:42:16,900
વેલ pictorially કે, શું છે?

900
00:42:16,900 --> 00:42:21,000
કે તળિયે અડધા છે,
આપણે જોયું કે લંબચોરસ

901
00:42:21,000 --> 00:42:22,730
માત્ર એક ક્ષણ પહેલાં.

902
00:42:22,730 --> 00:42:27,600
>> પરંતુ શા માટે હું * સ્ટ્રક્ટ નોડ કહીને છું
તરીકે માત્ર નોડ * વિરોધ?

903
00:42:27,600 --> 00:42:31,370
કે નિર્દેશક પોઇન્ટ હોય તો કારણ કે
અન્ય નોડ પર, તે માત્ર છે

904
00:42:31,370 --> 00:42:32,760
નોડ ઓફ સરનામું.

905
00:42:32,760 --> 00:42:35,630
અમે કર્યું છે તે સાથે સુસંગત છે કે
આમ અત્યાર સુધી પોઇન્ટર વિશે ચર્ચા કરી છે.

906
00:42:35,630 --> 00:42:39,690
હું દાવો પરંતુ જો શા માટે, આ માળખું છે
નોડ કહે છે, હું સ્ટ્રક્ટ કહે છે નથી

907
00:42:39,690 --> 00:42:42,660
અહીં અંદર નોડ?

908
00:42:42,660 --> 00:42:43,190
>> બરાબર.

909
00:42:43,190 --> 00:42:46,490
તે સી એક મૂર્ખ વાસ્તવિકતાના સોર્ટ છે
આ typedef, તેથી વાત કરવા, બિન છે

910
00:42:46,490 --> 00:42:47,220
હજી સુધી થયું છે.

911
00:42:47,220 --> 00:42:48,510
સી શાબ્દિક સુપર છે.

912
00:42:48,510 --> 00:42:51,050
તે તમારો કોડ ટોચ પર વાંચો
તળિયે, ડાબેથી.

913
00:42:51,050 --> 00:42:54,930
અને ત્યાં સુધી તે પર કે અર્ધવિરામ સ્કોર
નીચે લીટી નથી શું ધારી

914
00:42:54,930 --> 00:42:57,590
ડેટા પ્રકાર તરીકે અસ્તિત્વ ધરાવે છે?

915
00:42:57,590 --> 00:42:59,060
નોડ, કંપની અવતરણ ચિહ્નો પૂરાં કરવાં નોડ.

916
00:42:59,060 --> 00:43:03,050
>> પરંતુ કારણ કે વધુ વર્બોઝ ઓફ
જાહેરાત હું પ્રથમ વાક્ય પર હતી -

917
00:43:03,050 --> 00:43:05,340
typedef સ્ટ્રક્ટ નોડ -

918
00:43:05,340 --> 00:43:08,790
કે પહેલાં, પ્રથમ આવી કારણ કે
સર્પાકાર કૌંસ જેવા પ્રકારની છે કે

919
00:43:08,790 --> 00:43:11,800
પૂર્વ શિક્ષણ રણકાર કે, તમે
શું ખબર છે, મને એક સ્ટ્રક્ટ આપી

920
00:43:11,800 --> 00:43:13,570
સ્ટ્રક્ટ નોડ કહે છે.

921
00:43:13,570 --> 00:43:16,270
પ્રમાણિકપણે, હું ફોન વસ્તુઓ ન ગમે
સ્ટ્રક્ટ નોડ, સ્ટ્રક્ટ નોડ બધા

922
00:43:16,270 --> 00:43:17,090
મારી કોડ દરમ્યાન.

923
00:43:17,090 --> 00:43:20,660
પરંતુ હું માત્ર, માત્ર અંદર એક વખત તેનો ઉપયોગ કરીશું
જેથી હું અસરકારક રીતે કરી શકે છે

924
00:43:20,660 --> 00:43:25,010
, ગોળ સંદર્ભ એક પ્રકારના નથી બનાવવા
એક સે દીઠ મને નિર્દેશક, પરંતુ

925
00:43:25,010 --> 00:43:29,400
અન્ય માટે નિર્દેશક
એક સમાન પ્રકાર.

926
00:43:29,400 --> 00:43:32,330
>> તેથી તે બહાર વળે કે એ માહિતી બંધારણ પર
આ જેમ, થોડા છે

927
00:43:32,330 --> 00:43:34,470
હોઈ શકે કે જે કામગીરી
અમને રસ છે.

928
00:43:34,470 --> 00:43:37,460
અમે સામેલ કરવા માંગો છો શકે છે
આ જેમ એક યાદી માં.

929
00:43:37,460 --> 00:43:39,850
અમે કાઢી શકો છો
આ જેમ યાદીમાંથી.

930
00:43:39,850 --> 00:43:43,490
અમે માટે યાદી શોધ કરવા માંગો છો શકે છે
કિંમત, અથવા વધુ સામાન્ય રીતે પસાર થાય છે.

931
00:43:43,490 --> 00:43:46,410
અને આડી રેખા માત્ર એક ફેન્સી માર્ગ છે
ડાબે પ્રારંભ કહીને અને બધા ખસેડવા

932
00:43:46,410 --> 00:43:47,650
જમણી માર્ગ.

933
00:43:47,650 --> 00:43:52,640
>> પણ આ થોડું વધારે સૂચના,
આધુનિક માહિતી માળખું, દો

934
00:43:52,640 --> 00:43:56,510
મને અમે કેટલાક ઉધાર શકે છે પ્રસ્તાવ
જો છેલ્લા બે અઠવાડિયા વિચારો અને

935
00:43:56,510 --> 00:43:58,410
કહેવાય છે એક કાર્ય અમલ
આ જેમ શોધો.

936
00:43:58,410 --> 00:44:01,360
તે અથવા સાચી પાછા જવા છે
, ખોટી સૂચવે છે, હા અથવા

937
00:44:01,360 --> 00:44:03,390
ના, એ યાદીમાં છે.

938
00:44:03,390 --> 00:44:05,960
તેના બીજા દલીલ એક નિર્દેશક છે
યાદીમાં પોતે, જેથી

939
00:44:05,960 --> 00:44:07,920
નોડ માટે પોઇન્ટર.

940
00:44:07,920 --> 00:44:10,350
>> હું પછી કરવા જઇ રહ્યો છું બધા જાહેર છે
કામચલાઉ ચલ.

941
00:44:10,350 --> 00:44:12,730
અમે સંમેલન દ્વારા તે ptr કૉલ પડશે
નિર્દેશક છે.

942
00:44:12,730 --> 00:44:15,220
અને હું તેને બરાબર સોંપી
યાદીની શરૂઆત.

943
00:44:15,220 --> 00:44:16,680
>> અને હવે જ્યારે લૂપ નોટિસ.

944
00:44:16,680 --> 00:44:20,640
તેથી લાંબા નિર્દેશક સમાન નથી તરીકે
null માં, હું ચેક કરવા જઇ રહ્યો છું.

945
00:44:20,640 --> 00:44:24,520
છે નિર્દેશક તીર એ બરાબર
માં પસાર કરવામાં આવ્યો કે એ?

946
00:44:24,520 --> 00:44:26,410
- નવા અને એક મિનિટ રાહ જુઓ
વાક્યરચના ભાગ.

947
00:44:26,410 --> 00:44:29,324
તીર અચાનક બધા શું છે?

948
00:44:29,324 --> 00:44:30,574
યાહ?

949
00:44:30,574 --> 00:44:34,200

950
00:44:34,200 --> 00:44:34,810
>> બરાબર.

951
00:44:34,810 --> 00:44:38,860
તેથી, જ્યારે મેટલ એક થોડા મિનિટ પહેલા, અમે ઉપયોગ
કંઈક ઍક્સેસ કરવા માટે કોઈ સંકેત

952
00:44:38,860 --> 00:44:43,080
એક સ્ટ્રક્ટ ની અંદર, જો ચલ જો
તમે સ્ટ્રક્ટ નથી છે

953
00:44:43,080 --> 00:44:47,420
પોતે, પરંતુ સ્ટ્રક્ટ માટે નિર્દેશક,
thankfully, વાક્યરચના એક ભાગ છે કે જે

954
00:44:47,420 --> 00:44:48,620
છેલ્લે સાહજિક અર્થમાં બનાવે છે.

955
00:44:48,620 --> 00:44:52,360
તીર, પોઇન્ટર અનુસરો અર્થ
અમારા તીર સામાન્ય રીતે અર્થ જેવા

956
00:44:52,360 --> 00:44:56,570
pictorially, અને જાઓ
માહિતી ક્ષેત્ર પર આધારિત છે.

957
00:44:56,570 --> 00:44:59,700
તેથી તીર પર કોઈ તરીકે જ વસ્તુ છે, પરંતુ
જો તમે નિર્દેશક હોય ત્યારે તમે તે વાપરો.

958
00:44:59,700 --> 00:45:05,270
>> તેથી, ફક્ત પછી રીકેપ માટે તો એ ક્ષેત્ર
જો સ્ટ્રક્ટ ની અંદર નિર્દેશક તરીકે ઓળખાય છે

959
00:45:05,270 --> 00:45:07,760
બરાબર એ બરાબર, સાચા આવો.

960
00:45:07,760 --> 00:45:11,970
નહિંતર, અહીં આ વાક્ય - નિર્દેશક
આગામી નિર્દેશક બરાબર.

961
00:45:11,970 --> 00:45:17,540
તેથી આ કરવાનું છે શું, સૂચના, તો હું
હાલમાં સ્ટ્રક્ટ તરફ સંકેત છું

962
00:45:17,540 --> 00:45:21,430
9, અને 9 સમાવતી નંબર નથી
હું શોધી રહ્યો છું - હું જોઈ રહ્યો છું ધારવું

963
00:45:21,430 --> 00:45:22,830
માટે એ 50 બરાબર -

964
00:45:22,830 --> 00:45:25,930
હું મારા કામચલાઉ નિર્દેશક અપડેટ કરવા માટે જઇ રહ્યો છું
આ ગાંઠ પર નિર્દેશ નથી

965
00:45:25,930 --> 00:45:31,190
હવે, પરંતુ નિર્દેશક તીર આગળ, જે
અહીં મને મૂકવામાં ચાલુ છે.

966
00:45:31,190 --> 00:45:34,270
>> હવે, હું એક વાવંટોળ છે સમજાયું
પરિચય.

967
00:45:34,270 --> 00:45:37,380
બુધવાર પર, અમે ખરેખર આ કરવા પડશે
કેટલાક માણસો સાથે અને કેટલાક વધુ

968
00:45:37,380 --> 00:45:38,900
ધીમી ગતિએ કોડ.

969
00:45:38,900 --> 00:45:42,990
પરંતુ ખ્યાલ, આપણે હવે અમારી માહિતી કરી રહ્યા છીએ
માળખાં વધુ જટિલ છે કે જેથી અમારી

970
00:45:42,990 --> 00:45:45,780
ગણતરીના વધુ કાર્યક્ષમ વિચાર કરી શકો છો કે જે
માટે જરૂરી હોઈ ચાલે છે

971
00:45:45,780 --> 00:45:50,500
pset છ, આપણે ફરીથી માં લોડ કરે છે, ત્યારે તે
150,000 શબ્દો છે, પરંતુ આવું કરવાની જરૂર

972
00:45:50,500 --> 00:45:55,650
અસરકારક રીતે, અને આદર્શ રીતે, એક બનાવો
અમારા વપરાશકર્તાઓને ન માટે બનાવ્યા છે કે જે કાર્યક્રમ

973
00:45:55,650 --> 00:46:00,460
રેખીય, બિન સ્ક્વેર્ડ n માં, પરંતુ
આદર્શ સતત સમય.

974
00:46:00,460 --> 00:46:02,300
>> અમે બુધવારે તમે જોશો.

975
00:46:02,300 --> 00:46:07,240
>> સ્પીકર: આગામી CS50, ડેવિડ મુ
તેના આધાર કેસ forgets.

976
00:46:07,240 --> 00:46:12,770
>> DAVID MALAN: અને છે કે જે તમે મોકલી કેવી રીતે
સાથે ટેક્સ્ટ મેસેજીસ સી શું -

977
00:46:12,770 --> 00:46:14,020
>> [વિવિધ ટેક્સ્ટ સંદેશ
NOTIFICATION અવાજો]

978
00:46:14,020 --> 00:46:19,734