1
00:00:00,000 --> 00:00:02,860
[Powered by Google Translate] [5 અઠવાડિયું]

2
00:00:02,860 --> 00:00:04,860
[ડેવિડ જે Malan - હાર્વર્ડ યુનિવર્સિટી]

3
00:00:04,860 --> 00:00:07,260
[આ CS50 છે. - CS50.TV]

4
00:00:07,260 --> 00:00:09,740
>> આ CS50, 5 અઠવાડિયું છે.

5
00:00:09,740 --> 00:00:12,900
આજે અને આ અઠવાડિયે, અમે વિદેશી વિશ્વના થોડો દાખલ

6
00:00:12,900 --> 00:00:14,850
સમસ્યા સંદર્ભમાં 4 સુયોજિત કરો.

7
00:00:14,850 --> 00:00:18,480
આજે એક સંક્ષિપ્ત વ્યાખ્યાન શકે છે કારણ કે ત્યાં અહીં એક ખાસ ઘટના પછીથી થશે.

8
00:00:18,480 --> 00:00:21,940
તેથી અમે એક ડોકિયું લેવા અને બંને વિદ્યાર્થીઓ અને આનંદદાયક માતા - પિતા આજે પીંજવું પડશે

9
00:00:21,940 --> 00:00:24,600
વસ્તુઓ કે જે ક્ષિતિજ પર છે કેટલાક.

10
00:00:24,600 --> 00:00:29,050
>> તેમની વચ્ચે, સોમવાર, તમે થોડા વધુ સહપાઠીઓને હશે.

11
00:00:29,050 --> 00:00:32,980
edX હાર્વર્ડ અને એમઆઇટી OpenCourseWare અને વધુ માટે નવો ઑનલાઇન પહેલ,

12
00:00:32,980 --> 00:00:36,730
છે સોમવાર, જે સોમવારે આવે અર્થ પર હાર્વર્ડ કેમ્પસ પર લોંચ

13
00:00:36,730 --> 00:00:40,930
તમે છેલ્લા કાઉન્ટની તરીકે હોય, 86,000 વધારાની સહપાઠીઓને કરશે

14
00:00:40,930 --> 00:00:43,680
માતાનો CS50 ભાષણો અને વિભાગો સાથે કોણ કરી સાથે નીચેના કરશે

15
00:00:43,680 --> 00:00:45,890
અને વૉકથ્રૂઝ અને સમસ્યા સમૂહો.

16
00:00:45,890 --> 00:00:51,870
અને આ ભાગ તરીકે, તમે CS50 અને હવે CS50x પ્રારંભિક વર્ગ સભ્યો બની જશે.

17
00:00:51,870 --> 00:00:56,150
આ ભાગ તરીકે હવે ખ્યાલ છે, કે જે અમુક upsides તેમજ હશે.

18
00:00:56,150 --> 00:01:00,620
આ માટે તૈયાર વિદ્યાર્થીઓ મોટા નંબર માટે, વિચાર,

19
00:01:00,620 --> 00:01:03,820
તે પૂરતો કહે છે કે ભલે અમે 108 TFs અને સીએએસ હોય છે,

20
00:01:03,820 --> 00:01:07,560
તે તદ્દન શ્રેષ્ઠ ગુણોત્તર વિદ્યાર્થી શિક્ષક-એકવાર અમે 80,000 વિદ્યાર્થીઓના ફટકો નથી.

21
00:01:07,560 --> 00:01:09,830
અમે ઘણા સમસ્યા વર્ગીકરણ કરી સુયોજિત કરે જાતે જઈ રહ્યાં છો,

22
00:01:09,830 --> 00:01:13,050
જેથી સમસ્યા સમૂહ આ સપ્તાહ રજૂઆત CS50 તપાસ થશે,

23
00:01:13,050 --> 00:01:15,410
જે ઉપયોગિતા આદેશ વાક્ય હોઈ શકે સાધન અંદર રહ્યું છે

24
00:01:15,410 --> 00:01:17,880
કે તમે એક વાર તમે આ સપ્તાહના પછી અપડેટ મળશે.

25
00:01:17,880 --> 00:01:21,030
તમે તમારા પોતાના pset પર આદેશ, check50, સ્કોર કરી શકશો,

26
00:01:21,030 --> 00:01:24,770
અને તમે તરીકે ઝટપટ પ્રતિસાદ વિચાર છે કે શું તમારી કાર્યક્રમ સાચું અથવા ખોટું છે પડશે

27
00:01:24,770 --> 00:01:27,980
વિવિધ ડિઝાઇન સ્પષ્ટીકરણો અનુસાર કે અમે પૂરી પાડવામાં આવી છે.

28
00:01:27,980 --> 00:01:30,310
સમસ્યા સેટ સ્પષ્ટીકરણમાં પર વધુ.

29
00:01:30,310 --> 00:01:34,220
આ CS50x સહપાઠીઓને આ ઉપયોગ કરીને કરવામાં આવશે છે.

30
00:01:34,220 --> 00:01:36,170
>> સમસ્યા 4 સેટ ફોરેન્સિક્સ વિશે બધા છે,

31
00:01:36,170 --> 00:01:38,630
અને આ pset ખરેખર કેટલીક સામગ્રી વાસ્તવિક જીવન દ્વારા પ્રેરણા આપી હતી

32
00:01:38,630 --> 00:01:41,210
જ્યારે હું ગ્રેજ્યુએટ સ્કૂલ હતી જેમાં હું હંમેશ માટે ઇન્ટર્ન

33
00:01:41,210 --> 00:01:45,270
મિડલસેક્સ કાઉન્ટીના ડિસ્ટ્રીક્ટ એટર્નીની ઓફિસ ફોરેન્સિક કાર્ય સાથે

34
00:01:45,270 --> 00:01:47,660
તેમના મુખ્ય ફોરેન્સિક તપાસનીસ સાથે.

35
00:01:47,660 --> 00:01:50,280
આ શું પૂરવાર છે, મને લાગે છે કે હું થોડા અઠવાડિયા ભૂતકાળ ઉલ્લેખ કર્યો છે,

36
00:01:50,280 --> 00:01:52,720
છે માસ રાજ્ય પોલીસ અથવા અન્ય માં આવશે,

37
00:01:52,720 --> 00:01:56,150
તેઓ બોલ હાર્ડ ડ્રાઈવો અને CD ઓ અને ફ્લોપી ડિસ્ક અને તેમના જેવા જેવી વસ્તુઓ છોડો છો,

38
00:01:56,150 --> 00:01:58,770
અને પછી વિદેશી ઓફિસ ધ્યેય સહમતી હતી

39
00:01:58,770 --> 00:02:01,470
કે શું ત્યાં હતી કે અમુક પ્રકારના પુરાવા ન હતા.

40
00:02:01,470 --> 00:02:04,730
આ સ્પેશિયલ ઈન્વેસ્ટીગેશન એકમ હતું, તેથી તેને સફેદ કોલર ગુનો હતો.

41
00:02:04,730 --> 00:02:10,949
તે ગુના વધુ મુશ્કેલીમાં સૉર્ટ કરો, ડિજિટલ મીડિયા અમુક પ્રકારના સંડોવતા કંઈપણ હતી.

42
00:02:10,949 --> 00:02:16,450
તે તારણ છે કે, નહીં કે ઘણા લોકો એવું કહેતા ઇમેઇલ લખવા "હું તે કર્યું હતું."

43
00:02:16,450 --> 00:02:20,490
તેથી ઘણી વાર, આ ફોરેન્સિક શોધ અપ કે બધા ખૂબ ફળ બંધ કર્યું નહોતું,

44
00:02:20,490 --> 00:02:22,820
પરંતુ ક્યારેક લોકો જેમ કે ઇમેઇલ્સ લખી હતી.

45
00:02:22,820 --> 00:02:25,240
તેથી, કેટલીકવાર પ્રયત્નો મળ્યા હતા.

46
00:02:25,240 --> 00:02:31,210
>> પરંતુ દોરી આ ફોરેન્સિક pset માટે, અમે pset4 માં દાખલ કરવામાં આવશે ગ્રાફિક્સ એક બીટ.

47
00:02:31,210 --> 00:02:35,410
તમે કદાચ ઓક્ટાવીયનને માટે આ વસ્તુઓ લઈ - આ દિવસોમાં - JPEGs, GIFs, અને જેમ.

48
00:02:35,410 --> 00:02:38,320
પરંતુ જો તમે ખરેખર તે વિશે વિચારો, ઇમેજ, મોટાભાગના રોબ ચહેરાની જેમ,

49
00:02:38,320 --> 00:02:41,270
ડોટ્સ અથવા પિક્સેલની હાર તરીકે રજૂ કરવામાં કરી શકાય છે.

50
00:02:41,270 --> 00:02:43,380
માતાનો રોબ ચહેરો કિસ્સામાં, ત્યાં રંગો તમામ પ્રકારના છે,

51
00:02:43,380 --> 00:02:46,760
અને અમે વ્યક્તિગત બિંદુઓ, અન્યથા પિક્સેલ્સ તરીકે ઓળખાય જુઓ શરૂ,

52
00:02:46,760 --> 00:02:48,610
એકવાર અમે સાઇન ઝૂમ શરૂ

53
00:02:48,610 --> 00:02:54,660
પરંતુ જો આપણે વિશ્વમાં થોડી સરળ અને માત્ર કહે છે કે આ અહીં કાળા અને સફેદ રોબ છે,

54
00:02:54,660 --> 00:02:57,490
કાળા અને સફેદ પ્રતિનિધિત્વ કરે છે, અમે માત્ર દ્વિસંગી વાપરી શકો છો.

55
00:02:57,490 --> 00:03:01,660
અને જો અમે દ્વિસંગી ઉપયોગ જઈ રહ્યાં છો, 1 અથવા 0, અમે આ જ ઇમેજ વ્યક્ત કરી શકો છો

56
00:03:01,660 --> 00:03:06,140
માતાનો રોબ બિટ્સ આ પેટર્ન સ્માઈલિંગ ચહેરો છે.

57
00:03:06,140 --> 00:03:12,100
11000011 સફેદ, સફેદ, કાળા, કાળા, કાળા, કાળા, સફેદ, સફેદ રજૂ કરે છે.

58
00:03:12,100 --> 00:03:16,150
અને તેથી તે એક વિશાળ કૂદકો પછી નથી માટે રંગબેરંગી ફોટોગ્રાફ્સ વિશે વાત શરૂ કરવા માટે,

59
00:03:16,150 --> 00:03:18,600
વસ્તુઓ છે કે જે તમને Facebook પર જોવા અથવા ડિજીટલ કેમેરા સાથે લઈ છો.

60
00:03:18,600 --> 00:03:21,410
પરંતુ ચોક્કસપણે જ્યારે તે રંગો માટે આવે છે, તમે વધુ બિટ્સ જરૂર છે.

61
00:03:21,410 --> 00:03:25,690
અને તદ્દન ફોટોગ્રાફ વિશ્વમાં સામાન્ય રંગ 1-bit ઉપયોગ ન હોય,

62
00:03:25,690 --> 00:03:29,560
કારણ કે આ સૂચવે છે, પણ 24-bit રંગ છે, જ્યાં તમે ખરેખર લાખો રંગ મળે છે.

63
00:03:29,560 --> 00:03:32,250
તેથી કિસ્સામાં જ્યારે અમે રોબ આંખ પર ઝૂમ કરેલું,

64
00:03:32,250 --> 00:03:36,370
કે વિવિધ રંગબેરંગી શક્યતાઓ લાખો કોઈપણ સંખ્યાની હતી.

65
00:03:36,370 --> 00:03:39,040
તેથી અમે સમસ્યા 4 સમૂહ માં તેમજ walkthrough આ રજૂઆત પડશે,

66
00:03:39,040 --> 00:03:43,370
જે આજે સામાન્ય 2:30 બદલે 3:30 ખાતે શુક્રવારે અહીં વ્યાખ્યાન કારણે હશે.

67
00:03:43,370 --> 00:03:46,620
પરંતુ વિડિઓ સામાન્ય કાલે તરીકે ઑનલાઇન થશે.

68
00:03:46,620 --> 00:03:48,820
>> અમે પણ તમે બીજી ફાઇલ ફોર્મેટમાં દાખલ પડશે.

69
00:03:48,820 --> 00:03:51,270
આ ઇરાદાપૂર્વક પ્રથમ લાવનારાઓ જોવા રાખવાનો છે,

70
00:03:51,270 --> 00:03:55,670
પરંતુ આ માત્ર એક સી સ્ટ્રક્ટ માટે કેટલાક દસ્તાવેજો છે.

71
00:03:55,670 --> 00:03:58,940
તે તારણ કે જે Microsoft વર્ષ પહેલાં આ બંધારણમાં લોકપ્રિય બનાવવામાં મદદ કરી

72
00:03:58,940 --> 00:04:05,150
આ બીટમેપ ફાઇલ ફોર્મેટ, BMP, અને આ એક સુપર સરળ, રંગબેરંગી ગ્રાફિકવાળા ફાઈલ બંધારણમાં હતી કહેવાય

73
00:04:05,150 --> 00:04:10,150
કે અમુક સમય માટે શાંત ઉપયોગ કરવામાં આવ્યો હતો અને ડેસ્કટોપ પર વોલપેપરો માટે ક્યારેક હજુ પણ.

74
00:04:10,150 --> 00:04:14,760
જો તમે Windows XP અને આ ટેકરીઓનો અને વાદળી આકાશમાં પાછા વિચારો,

75
00:04:14,760 --> 00:04:17,170
કે સામાન્ય રીતે એક bmp અથવા બીટમેપ છબી હતી.

76
00:04:17,170 --> 00:04:19,959
ત્યાર બાદ બીટમેપ આપણા માટે આનંદ છે કારણ કે તેઓ થોડી વધુ જટિલતા છે.

77
00:04:19,959 --> 00:04:22,610
તે ન 0s અને 1 સે આ ગ્રિડ તરીકે સરળ તદ્દન છે.

78
00:04:22,610 --> 00:04:27,510
તેની જગ્યાએ, તમે એક ફાઈલ શરૂઆતમાં હેડર જેવી વસ્તુઓ હોય છે.

79
00:04:27,510 --> 00:04:31,990
તેથી bmp. ફાઈલની અંદર બીજા શબ્દોમાં માં 0s અને 1 સે સંપૂર્ણ સમૂહ છે,

80
00:04:31,990 --> 00:04:34,910
પરંતુ કેટલીક વધારાની અને તેમાં 0s 1 સે છે.

81
00:04:34,910 --> 00:04:38,220
અને તે તારણ છે કે અમે શું કદાચ માટે વર્ષ માટે મંજુર ભર્યું છે -

82
00:04:38,220 --> 00:04:45,170
ડૉક. અથવા. xls અથવા mp3., જેમ કે ફાઈલ બંધારણો MP4., ફાઈલ બંધારણો ગમે

83
00:04:45,170 --> 00:04:48,480
કે તમે પરિચિત છો - તે શું પણ નથી ફાઈલ બંધારણમાં હોવો અર્થ,

84
00:04:48,480 --> 00:04:52,480
કારણ કે આ દિવસે ઓવરને અંતે આ બધી ફાઈલોને અમે 0s અને 1 સે હોય વાપરો.

85
00:04:52,480 --> 00:04:56,810
અને કદાચ તે 0s અને 1 સે ASCII મારફતે એબીસી અથવા જેમ પ્રતિનિધિત્વ કરે છે,

86
00:04:56,810 --> 00:04:58,820
પરંતુ દિવસ ઓવરને અંતે, તે હજુ પણ છે માત્ર 0s અને 1 સે.

87
00:04:58,820 --> 00:05:02,100
તેથી માનવીઓ માત્ર ક્યારેક ક્યારેક એક નવી ફાઇલ ફોર્મેટ શોધ નક્કી

88
00:05:02,100 --> 00:05:06,420
જ્યાં તેઓ પ્રમાણિત બિટ્સની પેટર્ન શું ખરેખર અર્થ કરશે.

89
00:05:06,420 --> 00:05:09,220
અને આ અહીં કિસ્સામાં, લોકો જેઓ બીટમેપ ફાઇલ ફોર્મેટ માટે રચાયેલ

90
00:05:09,220 --> 00:05:15,620
કહ્યું હતું કે એક બીટમેપ ફાઇલ માં પહેલીવાર બાઇટ ખાતે, ઓફસેટ ત્યાં 0 દ્વારા સૂચિત,

91
00:05:15,620 --> 00:05:18,940
ત્યાં કેટલાક રહસ્યમય નામવાળી ચલ કહેવાય bfType પ્રયત્ન રહ્યું છે,

92
00:05:18,940 --> 00:05:23,080
જે ફક્ત બીટમેપ ફાઇલ પ્રકાર માટે વપરાય છે, બીટમેપ ફાઇલ પ્રકાર આ શું છે.

93
00:05:23,080 --> 00:05:27,700
તમે કદાચ બીજા પંક્તિ કે 2 સરભર બાઇટ 2 નંબર અટકળ બાંધવી કરી શકો છો,

94
00:05:27,700 --> 00:05:33,740
0s અને 1 સે એક પેટર્ન છે કે શું પ્રતિનિધિત્વ ધરાવે છે? કંઈક માપ.

95
00:05:33,740 --> 00:05:35,310
અને તેને ત્યાંથી પર કોઈ રન નોંધાયો નહીં.

96
00:05:35,310 --> 00:05:37,410
તેથી સમસ્યા 4 સમૂહ, તમે આ કેટલીક બાબતો દ્વારા ચાલ્યો આવશે.

97
00:05:37,410 --> 00:05:39,520
અમે સમાપ્ત તેમને બધા અંગે સંભાળ કરશે.

98
00:05:39,520 --> 00:05:47,510
નોટિસ પરંતુ તે 54 બાઇટ આસપાસ રસપ્રદ વિચાર થાય છે: rgbtBlue, ગ્રીન, અને Red.

99
00:05:47,510 --> 00:05:52,110
જો તમે ક્યારેય સાંભળ્યું કરેલા ટૂંકાક્ષર RGB - લાલ, લીલો, વાદળી - આ છે કે જે એક સંદર્ભ છે

100
00:05:52,110 --> 00:05:54,610
કારણ કે તે તારણ તમે સપ્તરંગી તમામ રંગો ચિતરવાનો કરી શકો છો

101
00:05:54,610 --> 00:05:58,180
લાલ અને વાદળી અને લીલા કેટલાક મિશ્રણ છે.

102
00:05:58,180 --> 00:06:03,320
અને હકીકતમાં, રૂમ માં માતા - પિતા વહેલામાં પ્રોજેક્ટરો કેટલાક યાદ શકે છે.

103
00:06:03,320 --> 00:06:05,890
આ દિવસોમાં, તમે માત્ર એક તેજસ્વી પ્રકાશ એક લેન્સ બહાર આવતા જોવા માટે,

104
00:06:05,890 --> 00:06:09,800
પરંતુ એક દિવસ પાછા તમે લાલ લેન્સ, વાદળી લેન્સ, અને ગ્રીન લેન્સ હતી,

105
00:06:09,800 --> 00:06:13,380
અને સાથે સાથે તેઓ સ્ક્રીન ધ્યાનમાં રાખીને અને એક રંગીન ચિત્ર રચના કરી હતી.

106
00:06:13,380 --> 00:06:16,270
અને ઘણી વાર, માધ્યમિક શાળાઓ અને ઉચ્ચ શાળાઓમાં તે લેન્સ હશે

107
00:06:16,270 --> 00:06:19,720
અત્યાર સુધીમાં સહેજ વાંકું, તેથી તમે ડબલ અથવા ટ્રિપલ છબીઓ દેખાય જેવું હતા.

108
00:06:19,720 --> 00:06:24,100
પણ જે વિચાર હતો. તમે લાલ અને લીલો અને વાદળી ચિત્રો પ્રકાશ હતી.

109
00:06:24,100 --> 00:06:26,590
અને તે જ સિદ્ધાંત કમ્પ્યુટર્સ ઉપયોગ થાય છે.

110
00:06:26,590 --> 00:06:30,230
>> તેથી તમારા માટે પછી પ્રોબ્લેમ માં પડકારો વચ્ચે 4 સેટ કરવા માટે અમુક વસ્તુઓ હશે આવે છે.

111
00:06:30,230 --> 00:06:34,800
એક ખરેખર એક છબી માપ બદલવાનું હોય છે, માટે 0s અને 1 સે એક પેટર્ન લઇ,

112
00:06:34,800 --> 00:06:40,200
બહાર આકૃતિ જે 0s અને 1 સે ઓફ હિસ્સામાં આ જેવા માળખામાં શું પ્રતિનિધિત્વ કરે છે,

113
00:06:40,200 --> 00:06:43,630
અને પછી બહાર આકૃતિ કેવી રીતે પિક્સેલ્સ નકલ કરવા માટે છે - રેડ્સ, બ્લૂઝ, તો ગ્રીન્સ -

114
00:06:43,630 --> 00:06:46,660
અંદર તેથી કે જે, જ્યારે એક ચિત્ર આ જેવા શરૂઆતમાં દેખાય છે

115
00:06:46,660 --> 00:06:49,210
આ જેવા કે પછી તેની જગ્યાએ જોવા શકે છે.

116
00:06:49,210 --> 00:06:53,640
અન્ય પડકારો વચ્ચે ખૂબ પ્રયત્ન કરો કે તમે ફોરેન્સિક છબી સોંપવામાં આવશે રહ્યું છે

117
00:06:53,640 --> 00:06:56,030
ડિજિટલ કૅમેરા એક વાસ્તવિક ફાઇલ.

118
00:06:56,030 --> 00:06:58,960
અને તે કેમેરા પર, એક વખત સમય પર, ફોટા સંપૂર્ણ સમૂહ હતા.

119
00:06:58,960 --> 00:07:03,760
આ સમસ્યા અમે આકસ્મિક ભૂંસી છે અથવા હતો ઇમેજ કોઈક બગડી.

120
00:07:03,760 --> 00:07:05,750
ખરાબ વસ્તુઓ ડિજિટલ કેમેરા સાથે થાય છે.

121
00:07:05,750 --> 00:07:09,150
અને તેથી અમે ઝડપથી તમારા માટે કે કાર્ડ 0s અને 1 સે બોલ તમામ નકલ,

122
00:07:09,150 --> 00:07:13,610
એક મોટા ફાઈલ તેમને બધા સેવ કરો, અને પછી અમે તેમને પ્રોબ્લેમ માં તમે સોંપવાની પડશે 4 સેટ કરો

123
00:07:13,610 --> 00:07:19,320
જેથી તમે સી એક કાર્યક્રમ કે જેની સાથે તે JPEGs તમામ પુનઃપ્રાપ્ત લખી, આદર્શ રીતે કરી શકે છે.

124
00:07:19,320 --> 00:07:23,330
અને તે તારણ છે કે JPEGs છે, તેમ છતાં તેઓ એક જટિલ ફાઇલ ફોર્મેટ કંઈક અંશે છો -

125
00:07:23,330 --> 00:07:26,360
તેઓ વધુ આ સ્માઈલિંગ અહીં ચહેરો કરતાં જટિલ ખૂબ છો -

126
00:07:26,360 --> 00:07:31,160
તે તારણ છે કે જે દરેક JPEG 0s અને 1 સે સમાન તરાહો સાથે શરૂ થાય છે.

127
00:07:31,160 --> 00:07:35,630
તેથી વાપરી રહ્યા હોય, છેવટે, જ્યારે કે લૂપ અથવા સમાન માટે લૂપ એક,

128
00:07:35,630 --> 00:07:38,880
તમે બધા 0s અને 1 સે પર આ ફોરેન્સિક છબી ફરી વળવું કરી શકો છો,

129
00:07:38,880 --> 00:07:43,150
અને દરેક વખતે જ્યારે તમે વિશિષ્ટ પેટર્ન કે જે સમસ્યા સેટ સ્પષ્ટીકરણમાં વ્યાખ્યાયિત છે જુઓ,

130
00:07:43,150 --> 00:07:47,880
તમે અહીં ધારે ઘણી ઊંચી સંભાવના સાથે છે, કોઈ JPEG શરૂઆત કરી શકે છે.

131
00:07:47,880 --> 00:07:51,230
અને તરત જ તમે જ પેટર્ન બાઇટ્સ કેટલાક નંબર શોધવા

132
00:07:51,230 --> 00:07:55,430
અથવા કિલોબાઈટોમાં અથવા મેગાબાઇટ્સ પછી, તમે અહીં ધારણ કરી શકે છે બીજી JPEG છે,

133
00:07:55,430 --> 00:07:57,380
ફોટો I એ પ્રથમ એક પછી લીધો હતો.

134
00:07:57,380 --> 00:08:01,370
મને કે પ્રથમ ફાઈલ વાંચવાથી બંધ, આ એક નવી લેખિત શરૂ કરવા માટે,

135
00:08:01,370 --> 00:08:06,310
અને pset4 માટે તમારા કાર્યક્રમ નું આઉટપુટ ઘણા 50 તરીકે JPEGs પ્રયત્ન રહ્યું છે.

136
00:08:06,310 --> 00:08:09,270
અને જો તે 50 JPEGs નથી, તમે એક લૂપ એક બીટ છે.

137
00:08:09,270 --> 00:08:12,490
જો તમે JPEGs એક અનંત નંબર હોય, તમે એક અનંત લૂપ છે.

138
00:08:12,490 --> 00:08:14,910
જેથી પણ તદ્દન સામાન્ય કેસ હશે.

139
00:08:14,910 --> 00:08:16,600
જેથી શું ક્ષિતિજ પર છે.

140
00:08:16,600 --> 00:08:21,310
>> અમને પાછળ 0 ક્વિઝ, મારા ઇમેઇલ દીઠ ખ્યાલ કે અચૂકપણે ત્યાં લોકો જેઓ બન્ને ખુશ છે,

141
00:08:21,310 --> 00:08:23,640
તટસ્થ અને ક્વિઝ આસપાસ ઉદાસી 0 સમય સૉર્ટ કરો.

142
00:08:23,640 --> 00:08:26,800
કૃપા કરીને અને મને બહાર પહોંચે છે, માથા ટીએફ Zamyla, તમારી પોતાની ટીએફ નથી,

143
00:08:26,800 --> 00:08:31,180
અથવા સીએએસ એક કે તમે જાણો છો જો તમે ચર્ચા વસ્તુઓ કેવી ગયા માંગો છો.

144
00:08:31,180 --> 00:08:35,539
>> જેથી માતા - પિતા ઓરડામાં અહીં પ્રભાવિત છે, CS50 પુસ્તકાલય શું છે?

145
00:08:36,429 --> 00:08:40,390
[અટ્ટહાસ્ય] ગુડ કામ.

146
00:08:40,390 --> 00:08:48,340
આ CS50 પુસ્તકાલય શું છે? યાહ. >> [વિદ્યાર્થી] તે કોડ સમૂહ પૂર્વ લેખિત છે [અશ્રાવ્ય]

147
00:08:48,340 --> 00:08:49,750
ઠીક છે, સારુ.

148
00:08:49,750 --> 00:08:53,240
તે કોડ સમૂહ પૂર્વ લેખિત કે સ્ટાફ લખ્યું કે, અમે તમને પૂરી પાડે છે,

149
00:08:53,240 --> 00:08:55,030
કે અમુક સામાન્ય કાર્યક્ષમતા પૂરી પાડે છે,

150
00:08:55,030 --> 00:08:59,020
મને શબ્દમાળા મેળવવા જેવી સામગ્રી, મને વિચાર પૂર્ણાંક - જે કાર્યોને અંહિ યાદી થયેલ છે બધી.

151
00:08:59,020 --> 00:09:02,260
>> હવે શરૂ કરી રહ્યા છીએ, અમે ખરેખર આ તાલીમ વ્હીલ્સ લઇ બોલ શરૂ કરો.

152
00:09:02,260 --> 00:09:05,050
અમે દૂર તમે એક શબ્દમાળા લેવા શરૂ જઈ રહ્યાં છો,

153
00:09:05,050 --> 00:09:08,870
સ્મૃતિ કે જે શું વાસ્તવિક માહિતી પ્રકાર માટે માત્ર એક પર્યાય હતો? >> [બહુવિધ વિદ્યાર્થીઓ] ચાર *.

154
00:09:08,870 --> 00:09:12,730
ચાર *. માતા - પિતા માટે, કે કદાચ [બનાવે whooshing અવાજ] હતો. કે સારા હોય છે.

155
00:09:12,730 --> 00:09:17,550
ચાર * અમે તમામ વધુ સ્ક્રીન પર જોવા તરીકે અમે અમારા શબ્દભંડોળ માંથી શબ્દમાળા દૂર શરૂ કરી શકશો,

156
00:09:17,550 --> 00:09:19,730
ઓછામાં ઓછું જ્યારે તે વાસ્તવમાં કોડ લખવા માટે આવે છે.

157
00:09:19,730 --> 00:09:22,840
એ જ રીતે, અમે આ વિધેયો કેટલાકનો ઉપયોગ કરીને ખૂબ તરીકે બંધ થશે

158
00:09:22,840 --> 00:09:25,280
કારણ કે અમારા કાર્યક્રમોનું વધુ વ્યવહારદક્ષ વિચાર થશે.

159
00:09:25,280 --> 00:09:28,480
બદલે માત્ર કાર્યક્રમો કે જે પ્રોમ્પ્ટ ખીલેલું સાથે ત્યાં બેસવા લખો,

160
00:09:28,480 --> 00:09:31,870
વપરાશકર્તા માટે રાહ કંઈક લખો, તમે બીજે ક્યાંકથી તમારી ઇનપુટ્સ મળશે.

161
00:09:31,870 --> 00:09:35,490
હમણાં પૂરતું, તમે તેમને સ્થાનિક હાર્ડ ડ્રાઇવ પર બિટ્સ શ્રેણીમાંથી મળશે.

162
00:09:35,490 --> 00:09:38,580
તમે તેને બદલે ભવિષ્યમાં નેટવર્ક જોડાણ તેમને મળશે,

163
00:09:38,580 --> 00:09:40,230
કેટલાક ક્યાંક વેબસાઇટ.

164
00:09:40,230 --> 00:09:44,110
>> જેથી પ્રથમ વખત પાછળ આ સ્તર છાલ અને દો અપ CS50 ઉપકરણ ખેંચવાનો

165
00:09:44,110 --> 00:09:49,010
અને આ cs50.h તરીકે ઓળખાતી ફાઈલ છે, કે જે તમે # થઈ અઠવાડિયા માટે સમાવેશ થાય છે,

166
00:09:49,010 --> 00:09:51,140
દો પરંતુ ખરેખર શું આ અંદર છે.

167
00:09:51,140 --> 00:09:54,430
વાદળી માં ફાઇલ ટોચ માત્ર ટિપ્પણીઓ સંપૂર્ણ સમૂહ છે:

168
00:09:54,430 --> 00:09:57,050
વોરંટી માહિતી અને લાયસન્સ.

169
00:09:57,050 --> 00:09:59,050
આ સોફ્ટવેર એક સામાન્ય ફેરફાર જેવું છે

170
00:09:59,050 --> 00:10:01,580
કારણ કે સોફ્ટવેર ઘણો આ દિવસોમાં એ છે જે ઓપન સોર્સ કહેવાય છે,

171
00:10:01,580 --> 00:10:05,220
જેનો અર્થ છે કે કોઈ વ્યક્તિ કોડ લખ્યું છે અને તે મુક્ત રીતે ઉપલબ્ધ કરવામાં

172
00:10:05,220 --> 00:10:10,470
માત્ર સ્કોર અને ઉપયોગ કરવા માટે, પરંતુ વાસ્તવમાં વાંચી અને બદલવા અને તમારું કામ સંકલિત.

173
00:10:10,470 --> 00:10:14,660
જેથી તમે શું ઉપયોગ કરી રહ્યો છું, ખૂબ જ નાના સ્વરૂપ ધરાવે ઓપન સોર્સ સોફ્ટવેર,.

174
00:10:14,660 --> 00:10:18,560
જો હું ટિપ્પણીઓ ભૂતકાળ સરકાવો, જોકે, અમે કેટલાક વધુ પરિચિત વસ્તુઓ જોવાનું શરૂ કરશો.

175
00:10:18,560 --> 00:10:25,010
અહીં ટોચ કે cs50.h ફાઈલ હેડર ફાઈલો સંપૂર્ણ સમૂહ સમાવે છે ખાતે નોટિસ.

176
00:10:25,010 --> 00:10:28,560
આમાંથી મોટા ભાગના, અમે પહેલાં જોઈ છે, પરંતુ એક પરિચિત છે.

177
00:10:28,560 --> 00:10:32,270
આ જે અમે કરેલ છે, સંક્ષિપ્તમાં જોકે જોવા મળે છે, આમ અત્યાર સુધી? >> [વિદ્યાર્થી] સ્ટાન્ડર્ડ લાઇબ્રેરી.

178
00:10:32,270 --> 00:10:35,810
અરે વાહ, સ્ટાન્ડર્ડ લાઇબ્રેરી. stdlib.h malloc છે.

179
00:10:35,810 --> 00:10:38,320
એકવાર અમે ગતિશીલ મેમરી ફાળવણી વિશે વાત શરૂ કરી,

180
00:10:38,320 --> 00:10:41,650
જે અમે પાછા આગામી સપ્તાહ માટે પણ આવી પડશે, અમે તે ફાઈલ સહિત શરૂઆત કરી હતી.

181
00:10:41,650 --> 00:10:46,640
તે તારણ આપે છે કે bool અને સાચા અને ખોટા વાસ્તવમાં સી દીઠ સે અસ્તિત્વમાં નથી

182
00:10:46,640 --> 00:10:49,440
જ્યાં સુધી તમે આ ફાઇલને અહીં સમાવેશ થાય છે.

183
00:10:49,440 --> 00:10:52,710
અમે અઠવાડિયા માટે stdbool.h છે પણ સમાવેશ થાય

184
00:10:52,710 --> 00:10:55,620
જેથી તમે એક bool, જે સાચું અથવા ખોટું. વિચારને ઉપયોગ કરી શકો છો

185
00:10:55,620 --> 00:10:58,620
આ વિના, તો તમે તેને નકલી ઓફ સૉર્ટ અને પૂર્ણાંક ઉપયોગ હશે

186
00:10:58,620 --> 00:11:02,610
અને માત્ર આપખુદ ધારે છે કે 0 ખોટું છે અને 1 સાચું છે.

187
00:11:02,610 --> 00:11:07,150
જો અમે નીચે વધુ સ્ક્રોલ, અહીં શબ્દમાળા અમારી વ્યાખ્યા છે.

188
00:11:07,150 --> 00:11:11,390
તે તારણ, કારણ કે અમે પહેલાં જણાવ્યું હતું કે, કરી લીધી છે, કે જ્યાં આ તારો છે ખરેખર તો કોઈ વાંધો નથી.

189
00:11:11,390 --> 00:11:13,720
તમે પણ જગ્યા તમામ આસપાસ હોઈ શકે છે.

190
00:11:13,720 --> 00:11:16,740
અમે આ સત્ર આ આવ્યા છે તે પ્રોત્સાહન સ્પષ્ટ કરે છે

191
00:11:16,740 --> 00:11:18,620
કે તારો આ પ્રકાર સાથે કરી છે,

192
00:11:18,620 --> 00:11:21,700
પરંતુ જેમ સામાન્ય ખ્યાલ, થોડી વધુ એક સામાન્ય જો,

193
00:11:21,700 --> 00:11:24,430
તેને ત્યાં મૂકી છે, પરંતુ વિધેયાત્મક રીતે તે જ વાત છે.

194
00:11:24,430 --> 00:11:27,720
પરંતુ હવે જો આપણે નીચે વધુ વાંચો, ચાલો GetInt પર એક નજર

195
00:11:27,720 --> 00:11:32,190
કારણ કે અમે જે કંઈપણ આ સત્ર પહેલાં કે કદાચ પ્રથમ ઉપયોગ થાય છે.

196
00:11:32,190 --> 00:11:37,440
અહીં GetInt છે. આ શું છે? >> [વિદ્યાર્થી] એક પ્રોટોટાઇપ. >> આ માત્ર એક પ્રોટોટાઇપ છે.

197
00:11:37,440 --> 00:11:41,410
ઘણી વખત, અમે અમારી ની ટોચે પહોંચી અને અંતે પ્રોટોટાઇપ મૂકેલ છે કૈચ ફાઈલો.

198
00:11:41,410 --> 00:11:46,690
પરંતુ તમે પણ હેડર ફાઈલો, એચ. ફાઇલો, આ અહીં એક જેવી પ્રોટોટાઇપ મૂકી શકો છો

199
00:11:46,690 --> 00:11:50,840
જેથી જ્યારે તમે કેટલાક કાર્યો લખે છે કે, તમે અન્ય લોકો માટે ઉપયોગ કરવાનો પ્રયત્ન કરવા માંગો છો,

200
00:11:50,840 --> 00:11:53,550
જે બરાબર CS50 લાઇબ્રેરી સાથે કેસ છે,

201
00:11:53,550 --> 00:11:57,040
તમે માત્ર cs50.c કંઈક તમારા કાર્યો અમલમાં મૂકવા માટે,

202
00:11:57,040 --> 00:12:02,790
તમે પણ છે કે ફાઈલ ટોચ પર નથી, પરંતુ એક હેડર ફાઈલ ટોચ પર પ્રોટોટાઇપ મૂકો.

203
00:12:02,790 --> 00:12:07,170
પછી તે હેડર ફાઈલ છે મિત્રો અને સહકર્મીઓ શું સમાવેશ થાય છે

204
00:12:07,170 --> 00:12:09,760
સાથે # તેમના પોતાના કોડ માં સમાવેશ થાય છે.

205
00:12:09,760 --> 00:12:12,210
આ બધા સમય તેથી, તમે આ પ્રોટોટાઇપ તમામ કરવામાં સહિત કર્યું છે,

206
00:12:12,210 --> 00:12:16,580
અસરકારક રીતે તમારી ફાઈલ ટોચ પરંતુ આ માર્ગ દ્વારા # પદ્ધતિ સમાવેશ થાય છે,

207
00:12:16,580 --> 00:12:20,070
તમારા પોતાના માં અનિવાર્યપણે નકલો અને pastes આ ફાઈલ છે.

208
00:12:20,070 --> 00:12:23,070
અહીં કેટલીક એકદમ વિગતવાર દસ્તાવેજીકરણ છે.

209
00:12:23,070 --> 00:12:25,640
અમે ખૂબ ખૂબ માટે મંજૂર છે કે GetInt પૂર્ણાંક નોંધાયો ભર્યું છે,

210
00:12:25,640 --> 00:12:27,640
પરંતુ તે વળે બહાર અમુક ખૂણામાં કેસો છે.

211
00:12:27,640 --> 00:12:31,810
શું એ સંખ્યા છે કે રસ્તો ખૂબ મોટી છે જેમાં વપરાશકર્તા પ્રકારો જો, quintillion એક,

212
00:12:31,810 --> 00:12:35,490
કે જે હમણાં જ પૂર્ણાંક ની અંદર ફિટ ન કરી શકે? અપેક્ષિત વર્તણૂક શું છે?

213
00:12:35,490 --> 00:12:38,020
આદર્શ રીતે, તે ધારી છે.

214
00:12:38,020 --> 00:12:40,280
તેથી આ કિસ્સામાં, જો તમે વાસ્તવમાં સુંદર પ્રિન્ટ વાંચવા,

215
00:12:40,280 --> 00:12:44,500
તમે ખરેખર કે જો રેખા વાંચી શકાતી નથી, આ વળતર INT_MAX જોશો.

216
00:12:44,500 --> 00:12:48,320
અમે આ વિશે ક્યારેય વાત કરી, કર્યા છે, પરંતુ તેના કેપિટલાઈઝેશન પર આધારિત છે, શું તે સંભવિત છે કદાચ?

217
00:12:48,320 --> 00:12:50,640
[વિદ્યાર્થી] એ સતત. >> તે સતત છે.

218
00:12:50,640 --> 00:12:54,770
કેટલાક ખાસ સતત કે કદાચ એક તે હેડર ફાઈલો જાહેર કરવામાં આવ્યું છે તે છે

219
00:12:54,770 --> 00:13:00,090
કે જે ફાઈલ ઉચ્ચ અપ, અને INT_MAX કદાચ 2 આશરે અબજ કંઈક છે,

220
00:13:00,090 --> 00:13:04,990
તે છે, કારણ કે અમે કોઈક કે જે કંઈક સૂચક જરૂર વિચાર ખોટું થયું,

221
00:13:04,990 --> 00:13:10,700
અમે, હા, અમારા નિકાલ અંતે 4 અબજ નંબરો છે: અબજ માટે 2 પર અબજ -2 આપે છે અથવા લો.

222
00:13:10,700 --> 00:13:14,710
વેલ, પ્રોગ્રામિંગ સામાન્ય છે શું છે તમે માત્ર એક તે નંબરો ચોરી,

223
00:13:14,710 --> 00:13:18,920
0 કદાચ, કદાચ અબજ 2, -2 કદાચ ડોલર,

224
00:13:18,920 --> 00:13:23,280
જેથી તમે તમારા એક શક્ય કિંમતો વિતાવે છે કે જેથી તમે વિશ્વને મોકલવું કરી શકો છો

225
00:13:23,280 --> 00:13:26,820
તે જો કંઈક ખોટું થાય, હું આ સુપર મોટી કિંમત આપશે.

226
00:13:26,820 --> 00:13:31,030
પરંતુ તમે વપરાશકર્તાને 234 જેવા ભેદી કંઈક લખીને ન માંગતા ... નથી, ખરેખર મોટી સંખ્યા.

227
00:13:31,030 --> 00:13:34,060
તમે તેના બદલે સામાન્ય રીતે સતત તરીકે.

228
00:13:34,060 --> 00:13:38,060
તેથી ખરેખર, જો તમે ગુદા કરવામાં આવી રહી હતી, છેલ્લા થોડા અઠવાડિયા, કોઈપણ સમયે તમે GetInt કહેવાય છે,

229
00:13:38,060 --> 00:13:42,900
તમે એક સાથે કરવામાં આવી ચકાસણી જોઈએ જો શરત INT_MAX માં વપરાશકર્તા પ્રકાર હતી,

230
00:13:42,900 --> 00:13:46,590
અથવા, વધુ સ્પષ્ટપણે GetInt વળતર INT_MAX હતી, કારણ કે જો તે કર્યું,

231
00:13:46,590 --> 00:13:51,830
કે જે વાસ્તવમાં એટલે તેઓ તેને ન લખો નહોતો. કંઈક આ કિસ્સામાં ખોટું થયું.

232
00:13:51,830 --> 00:13:56,080
તેથી આ એ છે જે સામાન્ય રીતે એક સંત્રી કિંમત છે, કે જે ફક્ત ખાસ અર્થ છે તરીકે ઓળખાય છે.

233
00:13:56,080 --> 00:13:58,120
>> હિસ્સો હવે દો સી. ફાઇલમાં કરો.

234
00:13:58,120 --> 00:14:01,340
C ની ફાઈલ સાધન કેટલાક સમયથી અસ્તિત્વમાં છે.

235
00:14:01,340 --> 00:14:06,840
અને હકીકતમાં, સાધન આ પૂર્વ સંકલિત કે વસ્તુ અમે પદાર્થ કોડ તરીકે ઓળખાય માં તમારા માટે છે,

236
00:14:06,840 --> 00:14:09,540
પરંતુ તે માત્ર તમે નથી વાંધો જ્યાં તે છે, કારણ કે સિસ્ટમ જાણે નથી

237
00:14:09,540 --> 00:14:11,730
આ ઉપકરણ: આ સ્થિતિમાં જ્યાં તે છે.

238
00:14:11,730 --> 00:14:17,400
ચાલો હવે નીચે સરકાવવા માટે GetInt અને જુઓ કે કેવી રીતે GetInt કામ કરવામાં આવ્યું છે આ બધા સમય.

239
00:14:17,400 --> 00:14:19,460
અહીં અમે પહેલાં સમાન ટિપ્પણીઓ.

240
00:14:19,460 --> 00:14:21,660
દો મને ફક્ત કોડ ભાગ પર ઝૂમ.

241
00:14:21,660 --> 00:14:23,900
અને અમે GetInt માટે હોય શું નીચેના છે.

242
00:14:23,900 --> 00:14:25,700
તેને કોઈ ઇનપુટ લે છે.

243
00:14:25,700 --> 00:14:29,510
તે પૂર્ણાંક આપે છે, જ્યારે (સત્ય) છે, તેથી અમે એક ઇરાદાપૂર્વકની અનંત લૂપ છે,

244
00:14:29,510 --> 00:14:33,180
પરંતુ કદાચ અમે આ કોઈક ભંગ અથવા પડશે આ અંદર આવો.

245
00:14:33,180 --> 00:14:34,870
>> ચાલો આ કેવી રીતે કામ કરે છે જુઓ.

246
00:14:34,870 --> 00:14:39,240
અમે લૂપ અંદર આ પ્રથમ વાક્ય માં GetString ઉપયોગ કરી, 166 લાગે છે.

247
00:14:39,240 --> 00:14:43,780
આ હવે સારું આચરણ છે કારણ કે સંજોગો શું હેઠળ GetString પરત કરી શકે છે

248
00:14:43,780 --> 00:14:47,660
ખાસ કીવર્ડ NULL? >> [વિદ્યાર્થી] જો કંઈક ખોટું.

249
00:14:47,660 --> 00:14:51,630
જો કશું ખોટું. અને શું ખોટું જાઓ ત્યારે તમે GetString કંઈક કહી શકે છે?

250
00:14:54,960 --> 00:14:57,640
યાહ. >> [વિદ્યાર્થી] Malloc તેને ints આપવા નિષ્ફળ જાય છે.

251
00:14:57,640 --> 00:14:59,150
યાહ. કદાચ malloc નિષ્ફળ જાય છે.

252
00:14:59,150 --> 00:15:03,190
હૂડ નીચે ક્યાંક, GetString malloc, કે જે મેમરી ફાળવે કૉલ કરે છે,

253
00:15:03,190 --> 00:15:06,020
જે કોમ્પ્યુટર સ્ટોર કરવા દે અક્ષરો તમામ

254
00:15:06,020 --> 00:15:07,750
કે કીબોર્ડ માં વપરાશકર્તા પ્રકારો.

255
00:15:07,750 --> 00:15:11,590
ધારવું અને વપરાશકર્તા મફત સમય સંપૂર્ણ ઘણો હતો અને વધુ દાખલા તરીકે, ટાઇપ,

256
00:15:11,590 --> 00:15:16,160
માં, કમ્પ્યૂટર કરતાં વધુ અક્ષરો અબજ કરતાં 2 અક્ષરો પણ રેમ છે.

257
00:15:16,160 --> 00:15:19,250
GetString માટે તમે તે દર્શાવવા કરવાનો પ્રયત્ન છે.

258
00:15:19,250 --> 00:15:22,560
જો આ એક સુપર, સુપર અસાધારણ ખૂણા કેસ છે,

259
00:15:22,560 --> 00:15:24,340
તે કોઈક આ હેન્ડલ કરવાનો પ્રયત્ન છે,

260
00:15:24,340 --> 00:15:28,750
અને તેથી GetString, જો અમે પાછા ગયા અને તેના દસ્તાવેજો વાંચવા માટે, હકીકત વળતર NULL માં કરે છે.

261
00:15:28,750 --> 00:15:34,460
તેથી હવે જો GetString NULL પરત દ્વારા કરવામાં નિષ્ફળ જાય, GetInt માટે INT_MAX પરત દ્વારા નિષ્ફળ રહ્યું છે

262
00:15:34,460 --> 00:15:37,690
માત્ર એક સંત્રી તરીકે. આ ફક્ત માનવ પ્રણાલિકા છે.

263
00:15:37,690 --> 00:15:41,450
આ માત્ર રસ્તો તમને ખબર હોત આ કિસ્સો હોય દસ્તાવેજીકરણ વાંચન દ્વારા છે.

264
00:15:41,450 --> 00:15:45,040
>> ચાલો જ્યાં પૂર્ણાંક ખરેખર મેળવેલ છે સરકાવો.

265
00:15:45,040 --> 00:15:51,160
જો હું થોડુ વધુ સ્ક્રોલ, 170 લીટી માં, અમે આ રેખાઓ ઉપર કોઈ ટિપ્પણી છે.

266
00:15:51,160 --> 00:15:55,100
અમે 172 માં પૂર્ણાંક, n અને ચાર રચે છે, સી, અને પછી આ નવા કાર્ય જાહેર,

267
00:15:55,100 --> 00:15:58,930
જે તમને કેટલાક sscanf, પહેલાં આખા ગયા છે.

268
00:15:58,930 --> 00:16:00,870
આ શબ્દમાળા scanf માટે વપરાય છે.

269
00:16:00,870 --> 00:16:05,700
બીજા શબ્દોમાં કહીએ તો, મને શબ્દમાળા આપે છે અને હું તેને રસ માહિતી ટુકડાઓ માટે સ્કેન કરશે.

270
00:16:05,700 --> 00:16:07,360
કે શું અર્થ છે?

271
00:16:07,360 --> 00:16:11,800
ધારો કે હું કીબોર્ડ પર, શાબ્દિક, 123 લખો અને પછી Enter દબાવો.

272
00:16:11,800 --> 00:16:16,470
123 ના દશાંશ માહિતી પ્રકાર જ્યારે GetString દ્વારા પરત શું છે? >> [વિદ્યાર્થી] શબ્દમાળા.

273
00:16:16,470 --> 00:16:18,380
તે દેખીતી રીતે શબ્દમાળા છે અધિકાર? હું એક શબ્દમાળા મળ્યો હતો.

274
00:16:18,380 --> 00:16:23,220
જેથી 123 ખરેખર છે, ક્વોટ-અવતરણ ચિહ્નો પૂરાં કરવાં, 123 એ \ તે ઓવરને અંતે 0 સાથે.

275
00:16:23,220 --> 00:16:27,110
કે પૂર્ણાંક નથી. કે જે નંબર નથી. તે નંબર જેવી લાગે છે, પરંતુ તે ખરેખર નથી.

276
00:16:27,110 --> 00:16:29,080
તેથી GetInt શું છે?

277
00:16:29,080 --> 00:16:35,750
123 0 \ - - અને કોઈક એક વાસ્તવિક પૂર્ણાંક રૂપાંતરિત તે કે ડાબેથી જમણે શબ્દમાળા સ્કેન ધરાવે છે.

278
00:16:35,750 --> 00:16:37,850
તમે આકૃતિ આ કેવી રીતે કરવું શકે છે.

279
00:16:37,850 --> 00:16:41,450
જો તમે pset2 પાછા લાગે, તો તમે કદાચ થોડો સીઝર સાથે આરામદાયક મળ્યું

280
00:16:41,450 --> 00:16:44,820
અથવા Vigenere છે, જેથી તમે એક શબ્દમાળા ઉપર ફરી વળવું કરી શકો છો, તમે અક્ષરો ints કન્વર્ટ કરી શકો છો.

281
00:16:44,820 --> 00:16:46,710
પરંતુ હેક, તે કામ સંપૂર્ણ ઘણું.

282
00:16:46,710 --> 00:16:49,860
Sscanf જેમ કાર્ય કરે છે જે તમારા માટે કરે છે જે કેમ નથી કહી?

283
00:16:49,860 --> 00:16:54,230
તેથી sscanf એક દલીલ અપેક્ષા - આ કિસ્સામાં રેખા કહેવામાં આવે છે, જે એક શબ્દમાળા છે.

284
00:16:54,230 --> 00:17:01,840
પછી તમે અવતરણ માં સ્પષ્ટ છે, ખૂબ સમાન printf, તમે શું આ શબ્દમાળાને જુઓ અપેક્ષા.

285
00:17:01,840 --> 00:17:09,000
અને હું અહીં કહી રહ્યો છું શું છે મને અક્ષાંશ નંબર અને કદાચ એક અક્ષર જુઓ અપેક્ષા.

286
00:17:09,000 --> 00:17:12,000
અને અમે શા માટે આ માત્ર એક ક્ષણ માં કેસ છે જોશો.

287
00:17:12,000 --> 00:17:15,869
અને તે તારણ છે કે આ સંકેત હવે સામગ્રી યાદ અપાવે અમે વિશે વાત શરૂ

288
00:17:15,869 --> 00:17:17,619
ફક્ત પહેલા એક અઠવાડિયા.

289
00:17:17,619 --> 00:17:21,740
શું છે અને n અને કેચ એન્ડ અમને માટે અહીં કરી? >> [વિદ્યાર્થી] n ના સરનામું અને સી સરનામું.

290
00:17:21,740 --> 00:17:25,400
યાહ. તે મને અને સી એન સરનામું સરનામા આપ્યા છે. કે શા માટે અગત્યનું છે?

291
00:17:25,400 --> 00:17:30,220
તમે જાણો છો કે સી માં વિધેયો સાથે, તમે હંમેશા કિંમત અથવા કોઈ કિંમત પરત ફરી શકે છે.

292
00:17:30,220 --> 00:17:34,530
તમે પૂર્ણાંક, શબ્દમાળા, એક ફ્લોટ, ચાર રચે છે, ગમે, અથવા તમે રદબાતલ પાછા આવી શકો છો પરત ફરી શકે છે,

293
00:17:34,530 --> 00:17:38,030
પરંતુ તમે માત્ર એક વસ્તુ વધુમાં પાછા આવી શકો છો.

294
00:17:38,030 --> 00:17:42,760
પરંતુ, અહીં આપણે sscanf મને પાછા કદાચ પૂર્ણાંક, એક અક્ષાંશ નંબર માંગો છો,

295
00:17:42,760 --> 00:17:46,220
અને પણ ચાર રચે છે, અને હું એક ક્ષણ માં શા માટે ઘરનાં પરચૂરણ કામો સમજાવવું પડશે.

296
00:17:46,220 --> 00:17:51,460
તમે અસરકારક રીતે sscanf બે વસ્તુઓ પરત કરવા માંગો છો, પરંતુ તે સી માં ફક્ત શક્ય નથી

297
00:17:51,460 --> 00:17:55,200
તમે કે આસપાસ બે સરનામાં માં પસાર કરીને કામ કરી શકે છે

298
00:17:55,200 --> 00:17:57,370
કારણ કે વહેલી તકે તમે એક કાર્ય બે સરનામાં હાથથી,

299
00:17:57,370 --> 00:18:00,470
કે કાર્ય તેમની સાથે કરી શકો છો? >> [વિદ્યાર્થી] તે સરનામાઓ પર લખો.

300
00:18:00,470 --> 00:18:02,010
તે પેલા સરનામાં પર લખી શકો છો.

301
00:18:02,010 --> 00:18:05,770
તમે તારો કામગીરી ઉપયોગ કરે છે અને ત્યાં તે દરેક સરનામાંને, જઇ શકો છો.

302
00:18:05,770 --> 00:18:11,260
તે વેરિયેબલ્સ કિંમતો બદલવા માટે સૉર્ટ કરો કે આ પદ્ધતિ બેક ડોર પરંતુ ખૂબ જ સામાન્ય છે

303
00:18:11,260 --> 00:18:14,870
આ કિસ્સામાં, બે - એક માત્ર સ્થળ કરતાં વધુ.

304
00:18:14,870 --> 00:18:21,340
હવે હું 1 == માટે ચકાસે છું અને પછી n પરત જો કે, વાસ્તવમાં નથી, સાચી માટે મૂલ્યાંકન નોટિસ.

305
00:18:21,340 --> 00:18:26,170
તેથી શું થઈ રહ્યું છે? પારિભાષિક રીતે, તમામ અમે ખરેખર GetInt માં થાય છે કરવા માંગો છો આ છે.

306
00:18:26,170 --> 00:18:30,740
123 ક્વોટ-અવતરણ ચિહ્નો પૂરાં કરવાં - અમે પાર્સ, તેથી વાત કરવા માંગો છો, અમે શબ્દમાળા વાંચી માંગો છો -

307
00:18:30,740 --> 00:18:34,560
અને જો લાગે છે કે ત્યાં એક નંબર, અમે શું કરી રહ્યાં છો sscanf કહેવાની કરવા છે

308
00:18:34,560 --> 00:18:38,190
આ ચલ માં n એ મારા માટે - 123 - છે કે જે નંબર મૂકો.

309
00:18:38,190 --> 00:18:42,090
તેથી શા માટે તે પછી હું ખરેખર નહોતી પણ આ જ છે?

310
00:18:42,090 --> 00:18:48,220
Sscanf ભૂમિકા કહેતા તમે પણ એક અક્ષર અહીં વિચાર શકે શું છે?

311
00:18:48,220 --> 00:18:53,470
[અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] >> અ દશાંશ બિંદુ ખરેખર કામ કરી શકે છે.

312
00:18:53,470 --> 00:18:56,330
ચાલો માને છે કે એક ક્ષણ માટે આવે છે. બીજું શું?

313
00:18:56,330 --> 00:18:59,270
[વિદ્યાર્થી] એવું NULL હોઈ શકે છે. >> ગુડ થોટ. તે નલ પાત્ર હોઈ શકે છે.

314
00:18:59,270 --> 00:19:01,660
તે વાસ્તવમાં આ કિસ્સામાં નથી. યાહ. >> [વિદ્યાર્થી] ASCII.

315
00:19:01,660 --> 00:19:04,340
તે ASCII. દો અથવા મને પણ વધુ સામાન્ય રીતે.

316
00:19:04,340 --> 00:19:06,640
આ% ત્યાં કો ભૂલ ચકાસણી માટે જ છે.

317
00:19:06,640 --> 00:19:09,300
અમે ત્યાં ન કરવા માંગો છો સંખ્યા પછી એક અક્ષર હોવો નથી,

318
00:19:09,300 --> 00:19:11,870
પરંતુ આ મને શું કરવા માટે પરવાનગી આપે શું નીચેના છે.

319
00:19:11,870 --> 00:19:18,210
તે તારણ આપે છે કે sscanf, આ ઉદાહરણમાં n અને c કિંમતો અહીં સ્ટોર ઉપરાંત,

320
00:19:18,210 --> 00:19:24,890
તે શું છે પણ એ નથી કે તે ચલો સંખ્યા આપે છે તે ચકાસણી કિંમતો મૂકી

321
00:19:24,890 --> 00:19:30,260
તેથી જો તમે માત્ર 123 માં ટાઇપ કરો, તે પછી ફક્ત% d સાથે મેળ રહ્યું છે,

322
00:19:30,260 --> 00:19:33,880
અને માત્ર n એ 123 જેવા કિંમત સાથે સંગ્રહિત નહીં,

323
00:19:33,880 --> 00:19:35,640
અને કંઈ કેચ મૂકવા નહીં.

324
00:19:35,640 --> 00:19:37,620
સી એક કચરો કિંમત રહે છે, તેથી વાત કરવા માટે -

325
00:19:37,620 --> 00:19:40,730
કચરો કારણ કે તેમાં કેટલીક કિંમત કરવામાં ક્યારેય આરંભ છે.

326
00:19:40,730 --> 00:19:45,520
જેથી કિસ્સામાં, sscanf 1 આપે છે કારણ કે હું તે 1 પોઇંટરો ઓફ રચાયેલ,

327
00:19:45,520 --> 00:19:50,190
મહાન, કે જે કિસ્સામાં હું પૂર્ણાંક હોય છે તેથી હું રેખા મુક્ત કરવા માટે મેમરી મુક્ત

328
00:19:50,190 --> 00:19:54,000
કે GetString ખરેખર ફાળવવામાં અને પછી હું n પાછા,

329
00:19:54,000 --> 00:19:58,500
બીજું જો તમે ક્યારેય વિસ્મય જ્યાં કે પુનઃપ્રયાસ નિવેદન પરથી આવે છે, તે અહીં આવે છે.

330
00:19:58,500 --> 00:20:04,390
તેથી, જો તેનાથી વિપરીત, હું 123foo લખો - માત્ર પાઠ્ય કેટલાક રેન્ડમ ક્રમ -

331
00:20:04,390 --> 00:20:08,490
sscanf સંખ્યા, સંખ્યા, સંખ્યા, એફ જુઓ રહ્યું છે,

332
00:20:08,490 --> 00:20:16,410
અને તે દ્વારા n એ 123 મૂકી રહ્યું છે, તે માટે કેચ માં એફ મૂકી અને પછી 2 પરત ચાલી રહ્યું છે.

333
00:20:16,410 --> 00:20:20,640
તેથી અમે હોય છે, ફક્ત sscanf વર્તન, એક ખૂબ સરળ માર્ગ એ મૂળભૂત વ્યાખ્યા મદદથી -

334
00:20:20,640 --> 00:20:23,900
સાથે સાથે, પ્રથમ નજરમાં પરંતુ દિવસ એકદમ સરળ પદ્ધતિ ઓવરને અંતે જટિલ -

335
00:20:23,900 --> 00:20:28,320
કહેતા ત્યાં પૂર્ણાંક છે અને તેથી જો હોય છે, તે જ વસ્તુ કે હું મળ્યું?

336
00:20:28,320 --> 00:20:29,860
અને અહીં સફેદજગ્યાના ઇરાદાપૂર્વકની છે.

337
00:20:29,860 --> 00:20:34,000
જો તમે sscanf માટે દસ્તાવેજીકરણ વાંચી, તો તે તમને કહે છે કે જો તમે સફેદજગ્યાના એક ટુકડો સમાવેશ થાય છે

338
00:20:34,000 --> 00:20:38,810
શરૂઆતમાં અથવા ઓવરને અંતે, sscanf પણ કારણ ગમે તે માટે વપરાશકર્તા, પરવાનગી આપશે,

339
00:20:38,810 --> 00:20:41,860
માટે જગ્યા પટ્ટી 123 ફટકો અને તે કાયદેસર હશે.

340
00:20:41,860 --> 00:20:44,150
તમે વપરાશકર્તા નથી કિકિયારી માત્ર કારણ કે તેઓ જગ્યા પટ્ટી ફટકો પડશે

341
00:20:44,150 --> 00:20:48,640
શરૂઆતમાં અથવા ઓવરને અંતે, જે થોડી વપરાશકર્તા મૈત્રીપૂર્ણ વધુ છે.

342
00:20:48,640 --> 00:20:52,300
>> કોઈપણ પછી પ્રશ્નો GetInt પર? યાહ. >> [વિદ્યાર્થી] જો તમે માત્ર એક કોલસો બનાવો મૂકવા?

343
00:20:52,300 --> 00:20:54,030
પ્રશ્ન સારું.

344
00:20:54,030 --> 00:20:59,890
જો તમે માત્ર એફ જેવા ઘરનાં પરચૂરણ કામો માં લખ્યો અને ક્યારેય 123 લખીને વિના દાખલ ફટકો?

345
00:20:59,890 --> 00:21:02,420
તમે શું વિચારો છો કોડ આ વાક્ય વર્તણૂક પછી હશે?

346
00:21:02,420 --> 00:21:04,730
[અશ્રાવ્ય વિદ્યાર્થી જવાબ]

347
00:21:04,730 --> 00:21:08,790
અરે વાહ, જેથી sscanf કે ખૂબ આવરી કારણ કે તે કિસ્સામાં, તે n અથવા કેચ ભરી નથી ચાલી રહ્યું છે કરી શકો છો.

348
00:21:08,790 --> 00:21:15,310
તે જગ્યાએ 0 પાછા, જેમાં કેસ હું પણ છે કે જે પરિસ્થિતિ મોહક છું રહ્યું છે

349
00:21:15,310 --> 00:21:18,750
કારણ કે અપેક્ષિત કિંમત હું માંગો છો 1 છે.

350
00:21:18,750 --> 00:21:22,000
હું માત્ર એક કરવા માંગો છો અને માત્ર એક વસ્તુ ભરી શકાય છે. પ્રશ્ન સારું.

351
00:21:22,000 --> 00:21:24,290
>> અન્ય? અધિકાર છે.

352
00:21:24,290 --> 00:21:26,250
>> માતાનો અહીં ના બધા વિધેયોને મારફતે જવા ન દો,

353
00:21:26,250 --> 00:21:29,500
પરંતુ એક કે બાકી રસ કદાચ લાગે GetString છે

354
00:21:29,500 --> 00:21:32,790
કારણ કે તે તારણ આપે છે કે GetFloat, GetInt, GetDouble, GetLongLong

355
00:21:32,790 --> 00:21:36,260
બધા વાંસડા વડે એવી હોડી ચલાવવી તેમના GetString માટે વિધેય ઘણો.

356
00:21:36,260 --> 00:21:39,750
તેથી આપણે કેવી રીતે તેઓ અહીં અમલમાં મૂકાયેલ છે પર એક નજર.

357
00:21:39,750 --> 00:21:43,630
આ એક થોડો જટિલ લાગે છે, પરંતુ તે જ ફંડામેન્ટલ્સ ઉપયોગ કરે છે

358
00:21:43,630 --> 00:21:45,670
કે અમે છેલ્લા અઠવાડિયે વાત શરૂ કરી.

359
00:21:45,670 --> 00:21:49,490
GetString, જેને રદબાતલ દીઠ કોઇ દલીલ અહીં લે છે

360
00:21:49,490 --> 00:21:53,730
અને તે શબ્દમાળા આપે છે, હું દેખીતી રીતે એક બફર તરીકે ઓળખાય શબ્દમાળા જાહેર છું.

361
00:21:53,730 --> 00:21:56,270
હું ખરેખર છે કે શું હજી માટે ઉપયોગ કરી રહ્યું છે તે ખબર નથી, પરંતુ અમે જોશો.

362
00:21:56,270 --> 00:21:58,390
એવું લાગે છે કે ક્ષમતા 0 મૂળભૂત છે.

363
00:21:58,390 --> 00:22:01,350
તદ્દન ખાતરી જ્યાં આ તો, ખાતરી કરો n શું માટે વાપરી શકાય હજુ સુધી જવું છે ન જતા,

364
00:22:01,350 --> 00:22:03,590
પરંતુ હવે તે થોડું વધુ રસપ્રદ દર્શાશે.

365
00:22:03,590 --> 00:22:06,520
243 રેખા, અમે પૂર્ણાંક, સી જાહેર.

366
00:22:06,520 --> 00:22:08,800
આ એક મૂર્ખ વિગતવાર જેવું છે.

367
00:22:08,800 --> 00:22:15,820
એક કોલસો બનાવો 8 બીટ્સ છે, અને 8 બીટ્સ કેટલા અલગ અલગ કિંમતો સ્ટોર કરી શકો છો? >> [વિદ્યાર્થી] 256. >> 256.

368
00:22:15,820 --> 00:22:20,730
આ સમસ્યા છે જો તમે 256 વિવિધ ASCII અક્ષરો છે, જે ત્યાં હોય છે માંગો છો

369
00:22:20,730 --> 00:22:23,340
જો તમે પાછા લાગે છે - અને આ યાદ કંઈક નથી.

370
00:22:23,340 --> 00:22:25,710
પરંતુ જો તમે કે મોટા ASCII ચાર્ટ પર પાછા લાગે છે અમે અઠવાડિયા પહેલા હતી,

371
00:22:25,710 --> 00:22:30,600
ત્યાં કે કેસ હતા 128 અથવા 256 ASCII અક્ષરો.

372
00:22:30,600 --> 00:22:32,940
અમે 0s અને 1 સે ઉપર તમામ પેટર્ન વપરાય છે.

373
00:22:32,940 --> 00:22:36,210
કે સમસ્યા છે જો તમે કોઈ ભૂલ શોધવા કરવાનો પ્રયત્ન કરવા માંગો છો

374
00:22:36,210 --> 00:22:40,190
જો તમે પહેલાથી જ તમારી અક્ષરો માટે કરી રહ્યાં છો 256 કિંમતો મદદથી કારણ કે,

375
00:22:40,190 --> 00:22:43,050
તમે ખરેખર આગળ યોજના ઘડી ન હતી કારણ કે હવે તમે કહેતા કોઈ રીત નથી,

376
00:22:43,050 --> 00:22:46,270
આ વંચાય અક્ષર નથી, આ અમુક ભૂલભરેલા સંદેશ છે.

377
00:22:46,270 --> 00:22:50,270
તેથી વિશ્વ કરે છે શું છે તેઓ આગામી સૌથી મોટી કિંમત, પૂર્ણાંક કંઈક ઉપયોગ કરો છો,

378
00:22:50,270 --> 00:22:54,720
જેથી તમે 4 અબજ શક્ય કિંમતો માટે બીટ્સ, 32 એક ઉન્મત્ત નંબર ધરાવે છે,

379
00:22:54,720 --> 00:22:58,860
જેથી તમે ખાલી અંત તેમાંથી 257 અનિવાર્યપણે ઉપયોગ કરીને કરી શકો છો,

380
00:22:58,860 --> 00:23:01,720
1 જેમાં ભૂલ તરીકે અમુક ખાસ અર્થ હોય છે.

381
00:23:01,720 --> 00:23:03,120
>> તેથી આપણે આ કેવી રીતે કામ કરે છે જુઓ.

382
00:23:03,120 --> 00:23:07,760
246 લીટી માં, હું આ મોટા જ્યારે લૂપ કે fgetc ફોન છે,

383
00:23:07,760 --> 00:23:11,090
એફ અર્થ ફાઈલ છે, તેથી getc અને પછી stdin ની.

384
00:23:11,090 --> 00:23:15,520
તે તારણ આ માત્ર કહેતા કીબોર્ડ તરફથી ઇનપુટ વાંચો વધુ ચોક્કસ માર્ગ છે.

385
00:23:15,520 --> 00:23:19,300
માનક ઇનપુટ અર્થ કીબોર્ડ, પ્રમાણભૂત આઉટપુટ સ્ક્રીન અર્થ થાય છે,

386
00:23:19,300 --> 00:23:23,310
અને પ્રમાણભૂત ભૂલ છે, કે જે અમે pset4 માં જોશો, સ્ક્રિન અર્થ થાય છે

387
00:23:23,310 --> 00:23:27,490
પરંતુ સ્ક્રીન એક ખાસ ભાગ કે જેથી તે ખરેખર ઉત્પાદન સાથે સંકલિત છે

388
00:23:27,490 --> 00:23:30,750
કે તમે છાપવાનો ઈરાદો હતો. પરંતુ ભવિષ્યમાં પર વધુ.

389
00:23:30,750 --> 00:23:34,440
તેથી fgetc માત્ર અર્થ એ થાય કે કીબોર્ડ એક અક્ષર વાંચી અને તે સ્ટોર જ્યાં?

390
00:23:34,440 --> 00:23:37,350
તે કેચ માં સ્ટોર કરો.

391
00:23:37,350 --> 00:23:41,360
અને પછી તપાસો - તેથી હું માત્ર કેટલાક બુલિયન conjunctions છું અહીં મદદથી -

392
00:23:41,360 --> 00:23:46,000
તપાસો કે તે સમાન નથી - \ n એ, જેથી વપરાશકર્તા નામ લખો હિટ છે, અમે તે સમયે રોકવા માંગો છો,

393
00:23:46,000 --> 00:23:49,850
લૂપની અંત - અને આપણે પણ ખાસ સતત EOF ચકાસવા માટે કરવા માંગો છો,

394
00:23:49,850 --> 00:23:53,610
જે જો તમને ખબર હોય અથવા ધારી, તે શું માટે ઊભા કરે છે? >> [વિદ્યાર્થી] ફાઈલ અંતે. ફાઇલ >> અંતે.

395
00:23:53,610 --> 00:23:56,560
આ પ્રકારની છે વાહિયાત કારણ કે, જો હું કીબોર્ડ લખીને છું

396
00:23:56,560 --> 00:23:58,870
ત્યાં ખરેખર કોઈ આ સામેલ ફાઈલ છે,

397
00:23:58,870 --> 00:24:01,150
પરંતુ આ માત્ર સામાન્ય અર્થ ઉપયોગ ગાળાની સૉર્ટ છે

398
00:24:01,150 --> 00:24:04,220
કે બીજું કંઇ તે માનવ આંગળીઓમાંથી આવી રહ્યું છે.

399
00:24:04,220 --> 00:24:06,460
EOF - ફાઈલ અંત.

400
00:24:06,460 --> 00:24:09,920
એક અલગ રીતે, જો તમે ક્યારેય તમારા કીબોર્ડ પર કર્યું છે નિયંત્રણ ડી દબાવો, તમે હજુ સુધી કે નહિ -

401
00:24:09,920 --> 00:24:15,230
તમે નિયંત્રણ સી ફટકો કર્યું છે - નિયંત્રણ ડી આ ખાસ EOF કહેવાય સતત મોકલે છે.

402
00:24:15,230 --> 00:24:19,850
તેથી હવે અમે માત્ર કેટલાક ગતિશીલ મેમરી ફાળવણી છે.

403
00:24:19,850 --> 00:24:23,440
>> તેથી જો (n + 1> ક્ષમતા). હવે હું n એ સમજાવવું પડશે.

404
00:24:23,440 --> 00:24:26,100
એન માત્ર કેટલા બાઇટ્સ એ બફર છે હાલમાં,

405
00:24:26,100 --> 00:24:28,620
શબ્દમાળા કે જે તમે હાલમાં વપરાશકર્તા હોવ મકાન.

406
00:24:28,620 --> 00:24:33,450
જો તમે તમારા બફર વધુ અક્ષરો હોવા કરતાં તમે બફર માં ક્ષમતા છે,

407
00:24:33,450 --> 00:24:37,410
તર્ક અમે શું કરીએ તો પછી જરૂર વધુ ક્ષમતા ફાળવી છે.

408
00:24:37,410 --> 00:24:43,330
તેથી હું પર અહીં અંકગણિત કેટલાક મલાઈહીન અને આ કાર્ય પર જ ધ્યાન કેન્દ્રિત અહીં જાઉં છું.

409
00:24:43,330 --> 00:24:46,070
તમે જાણો છો malloc શું છે અથવા ઓછામાં ઓછા સામાન્ય રીતે પરિચિત છે.

410
00:24:46,070 --> 00:24:48,970
એક અનુમાન realloc શું કરે છે લો. >> [વિદ્યાર્થી] મેમરી ઉમેરે છે.

411
00:24:48,970 --> 00:24:52,920
તે તદ્દન મેમરી નથી ઉમેરીને છે. તે નીચે પ્રમાણે મેમરી reallocates.

412
00:24:52,920 --> 00:24:57,220
જો હજી પણ શબ્દમાળા ઓવરને અંતે રૂમ છે કે જે તમને મેમરી વધુ આપી છે

413
00:24:57,220 --> 00:25:00,000
કરતાં તે મૂળ તમને, તો પછી તમે તે વધારાના મેમરી મળશે.

414
00:25:00,000 --> 00:25:03,460
તેથી તમે ફક્ત શબ્દમાળા અક્ષરો પાછા મૂકવા માટે પાછળ પાછળ પાછળ રાખી શકો છો.

415
00:25:03,460 --> 00:25:05,830
પરંતુ જો કે આ કેસ નથી કારણ કે તમે ખૂબ લાંબો સમય waited

416
00:25:05,830 --> 00:25:07,940
અને રેન્ડમ કંઈક મેમરીમાં ત્યાં plopped મળ્યો

417
00:25:07,940 --> 00:25:10,290
પરંતુ અહીં નીચે વધારાની મેમરી છે, કે જે ઠીક છે.

418
00:25:10,290 --> 00:25:13,100
Realloc માટે તમે બધી ભારે પ્રશિક્ષણ કરી રહ્યું છે,

419
00:25:13,100 --> 00:25:16,750
શબ્દમાળા તમે વાંચ્યા છે તેથી અહીં દૂર ખસેડવા માટે, તેને મૂકી નીચે ત્યાં,

420
00:25:16,750 --> 00:25:19,460
અને પછી તમે તે સમયે કેટલાક વધુ રનવે આપે છે.

421
00:25:19,460 --> 00:25:22,550
>> જેથી હાથ પ્રવાહ સાથે દો, મને કહે છે કે શું GetString કરી છે

422
00:25:22,550 --> 00:25:26,330
છે તે એક નાના બફર, કદાચ એક જ અક્ષર સાથે શરૂ છે,

423
00:25:26,330 --> 00:25:30,820
અને બે અક્ષરો માં વપરાશકર્તા પ્રકારો જો, GetString realloc ફોન થાય છે અને કહે છે

424
00:25:30,820 --> 00:25:33,150
એક અક્ષર પૂરતો ન હતો; મને બે અક્ષરો આપે છે.

425
00:25:33,150 --> 00:25:35,950
પછી જો તમે લૂપની તર્ક દ્વારા વાંચી, તો તે કહેવું રહ્યું છે

426
00:25:35,950 --> 00:25:39,600
આ 3 અક્ષરો ટાઇપ વપરાશકર્તા; મને હવે 2 પરંતુ 4 અક્ષરો આપી,

427
00:25:39,600 --> 00:25:42,320
પછી મને 8 આપો, પછી મને 16 અને 32 આપે છે.

428
00:25:42,320 --> 00:25:45,000
હકીકત એ છે કે હું ક્ષમતા દરેક સમય બમણો છું

429
00:25:45,000 --> 00:25:48,570
અર્થ એ થાય કે બફર ધીમે ધીમે વધવા ન રહ્યું છે, તે માટે સુપર ઝડપી વૃદ્ધિ પામે બનશે.

430
00:25:48,570 --> 00:25:51,380
અને તે શું છે તે લાભ હોઇ શકે?

431
00:25:51,380 --> 00:25:54,600
હું બફર માપ શા બમણી છું

432
00:25:54,600 --> 00:25:58,020
તેમ છતાં વપરાશકર્તા માત્ર એક કીબોર્ડ માંથી વધારાના પાત્ર કરવાની જરૂર પડી શકે?

433
00:25:58,020 --> 00:26:01,750
[અશ્રાવ્ય વિદ્યાર્થી પ્રતિભાવ] >> કે શું છે? >> [વિદ્યાર્થી] તમે તેને ઘણી વખત વધવા નથી.

434
00:26:01,750 --> 00:26:03,300
બરાબર. તમે તેને ઘણી વાર વધવા નથી.

435
00:26:03,300 --> 00:26:05,510
અને આ માત્ર તમે પ્રકારની છે તમારી બેટ્સ અહીં હેજિંગ કરી રહ્યાં છો,

436
00:26:05,510 --> 00:26:10,850
આ વિચાર એ હતો કે તમે ખૂબ realloc કહી ન માંગતા કારણ કે તે ધીમું હોઈ શકે છે નથી.

437
00:26:10,850 --> 00:26:12,910
કોઈપણ સમયે તમે મેમરી માટે ઓપરેટિંગ સિસ્ટમ પૂછો,

438
00:26:12,910 --> 00:26:16,990
જેમ તમે તરત જ ભાવિ સમસ્યા સેટ જોશો, તે થોડો સમય લાગી શકે છે.

439
00:26:16,990 --> 00:26:20,010
તેથી સમય કે રકમ ઘટાડીને, જો તમે અમુક જગ્યા બગાડ કરી રહ્યાં છો,

440
00:26:20,010 --> 00:26:21,900
માટે સારી વાત હોય શકે છે.

441
00:26:21,900 --> 00:26:24,060
>> પરંતુ જો આપણે અહીં GetString અંતિમ ભાગ દ્વારા વાંચી -

442
00:26:24,060 --> 00:26:27,950
અને ફરીથી દરેક એક વાક્ય અહીં સમજવા જેથી મહત્વપૂર્ણ આજે નથી -

443
00:26:27,950 --> 00:26:30,530
નોંધ્યું છે કે તે આખરે malloc ફરીથી કહે છે

444
00:26:30,530 --> 00:26:33,880
અને તે અનેક બાઇટ્સ તરીકે બરાબર ફાળવે છે, કારણ કે તે શબ્દમાળા માટે જરૂર છે

445
00:26:33,880 --> 00:26:38,060
અને પછી મફત અતિશય મોટા બફર ફોન દ્વારા દૂર ફેંકી દે છે

446
00:26:38,060 --> 00:26:40,080
જો તે ખરેખર ઘણી વાર બમણી મળ્યો છે.

447
00:26:40,080 --> 00:26:42,730
તેથી ટૂંકા, તે કેવી રીતે GetString આ બધા સમય કાર્ય છે.

448
00:26:42,730 --> 00:26:47,060
તે બધા એક સમયે છે નથી એક અક્ષર ફરીથી અને ફરીથી અને ફરીથી વાંચી,

449
00:26:47,060 --> 00:26:50,750
અને દર વખતે તે કેટલીક વધારાની મેમરી જરૂર છે, તેને માટે ઓપરેટીંગ સિસ્ટમ પૂછે છે

450
00:26:50,750 --> 00:26:53,670
realloc ફોન દ્વારા.

451
00:26:53,670 --> 00:26:57,890
>> કોઈપણ પ્રશ્ન છે? અધિકાર છે.

452
00:26:57,890 --> 00:26:59,270
>> હુમલો.

453
00:26:59,270 --> 00:27:04,060
હવે અમે પોઇંટરો સમજવા અથવા ઓછામાં ઓછું વધુને વધુ પોઇન્ટર સાથે પરિચિત હોય છે,

454
00:27:04,060 --> 00:27:06,700
ચાલો ધ્યાનમાં કેવી રીતે સમગ્ર વિશ્વમાં તૂટી શરૂ થાય છે

455
00:27:06,700 --> 00:27:10,030
જો તમે તદ્દન વિરોધી વપરાશકર્તાઓ સામે નથી કોઈ રન નોંધાયો નહીં નથી,

456
00:27:10,030 --> 00:27:11,850
જે લોકો તમારી સિસ્ટમ માં હેક કરવાનો પ્રયાસ કરી રહ્યા હોય,

457
00:27:11,850 --> 00:27:16,890
જે લોકો કેટલાક નોંધણી કોડ circumventing દ્વારા તમારા સોફ્ટવેર ચોરી કરવાનો પ્રયાસ કરી રહ્યા છે

458
00:27:16,890 --> 00:27:19,090
કે તેઓ અન્યથા સાઇન લખો હોય શકે છે

459
00:27:19,090 --> 00:27:22,990
>> આ ઉદાહરણમાં પર એક નજર અહીં લો, જે ફક્ત સી કોડ કે જે તળિયે મુખ્ય કાર્ય છે

460
00:27:22,990 --> 00:27:26,380
કે જે કાર્ય foo કહે છે. અને તે શું foo માટે પસાર થાય છે?

461
00:27:26,380 --> 00:27:29,680
એક દલીલ [વિદ્યાર્થી]. >> [Malan] એક દલીલ.

462
00:27:29,680 --> 00:27:33,450
તેથી argv [1], જે પ્રથમ શબ્દ છે કે જેને વપરાશકર્તા આદેશ વાક્ય પર લખ્યો અર્થ થાય છે

463
00:27:33,450 --> 00:27:36,360
a.out અથવા જે પછી કાર્યક્રમ તરીકે ઓળખાય છે.

464
00:27:36,360 --> 00:27:41,680
તેથી ટોચ પર foo એ ઘરનાં પરચૂરણ કામો * લે. પરંતુ ઘરનાં પરચૂરણ કામો * શું માત્ર છે? >> [વિદ્યાર્થી] એક સ્ટ્રિંગ.

465
00:27:41,680 --> 00:27:43,350
[Malan] એક શબ્દમાળા તેથી, ત્યાં નવી કંઇ અહીં છે.

466
00:27:43,350 --> 00:27:45,420
શબ્દમાળા કે આપખુદ બાર છે કહેવાય રહ્યું છે.

467
00:27:45,420 --> 00:27:51,430
આ અહીં લીટી માં, ચાર કેચ [12]; અર્ધ તકનીકી ઇંગલિશ જેવું માં, આ લીટી શું કરે છે?

468
00:27:51,430 --> 00:27:55,220
[વિદ્યાર્થી] એક એરે - ઓફ >> અરે! >> [વિદ્યાર્થી] અક્ષરો. >> અક્ષરો.

469
00:27:55,220 --> 00:27:58,870
મને 12 અક્ષરો ઝાકઝમાળ આપો. તેથી અમે એક બફર આ કૉલ શકે છે.

470
00:27:58,870 --> 00:28:02,920
તે ટેકનિકલી કેચ કહેવાય છે, પરંતુ પ્રોગ્રામિંગ એક બફર માત્ર જગ્યા સમૂહ અર્થ થાય છે

471
00:28:02,920 --> 00:28:04,800
કે તમે અમુક સામગ્રી સાઇન મૂકી શકો છો

472
00:28:04,800 --> 00:28:07,940
પછી છેલ્લે memcpy અમે પહેલાં વપરાય છે, કર્યા છે, પરંતુ તમે કદાચ ધારી તે શું કરે છે કરી શકો છો.

473
00:28:07,940 --> 00:28:10,480
તે મેમરી નકલ કરે છે. તે શું કરે છે?

474
00:28:10,480 --> 00:28:19,270
તે દેખીતી રીતે બાધ નકલ કરે છે, તેના ઇનપુટ, સી માં પણ માત્ર બાર નોંધાયો નહીં.

475
00:28:19,270 --> 00:28:24,930
પરંતુ અહીં એક ભૂલ છે. >> [વિદ્યાર્થી] તમે sizeof અક્ષર જરૂર છે. ઠીક છે. >>

476
00:28:24,930 --> 00:28:30,860
ટેક્નિકલ, અમે ખરેખર strlen કરવું (બાર) કરીશું * sizeof (કોલસો)). કે સાચું છે.

477
00:28:30,860 --> 00:28:33,930
પરંતુ ખરાબ અહીં કિસ્સામાં, ચાલો કે that's ધારે -

478
00:28:33,930 --> 00:28:35,950
ઠીક છે. તો પછી ત્યાં બે ભૂલો છે.

479
00:28:35,950 --> 00:28:39,160
તેથી (કોલસો) sizeof);

480
00:28:39,160 --> 00:28:41,290
ચાલો આ થોડું વિશાળ બનાવે છે.

481
00:28:41,290 --> 00:28:44,910
તેથી હવે ત્યાં હજી પણ ભૂલ, કે જે શું છે શું છે? >> [અશ્રાવ્ય વિદ્યાર્થી જવાબ]

482
00:28:44,910 --> 00:28:46,990
શું માટે તપાસો? >> [વિદ્યાર્થી] NULL માટે તપાસો.

483
00:28:46,990 --> 00:28:50,270
અમે સામાન્ય રીતે NULL માટે ચકાસે જોઈએ કારણ કે ખરાબ વસ્તુઓ થાય છે

484
00:28:50,270 --> 00:28:53,200
જ્યારે તમારા નિર્દેશક NULL છે કારણ કે તમે અંત ત્યાં જઈને શકે છે,

485
00:28:53,200 --> 00:28:57,630
અને તમે ક્યારેય નહીં કરી શકે તે તારો ઓપરેટર સાથે dereferencing દ્વારા નલ જઈને કરીશું.

486
00:28:57,630 --> 00:29:01,050
જેથી સારી છે. અને બીજું શું આપણે કરી રહ્યા છે? તાર્કિક, ત્યાં ભૂલ અહીં પણ છે.

487
00:29:01,050 --> 00:29:04,450
[વિદ્યાર્થી] તપાસો જો argc => માટે 2 છે.

488
00:29:04,450 --> 00:29:10,550
તેથી તપાસ જો argc> = 2 છે. ઠીક છે, જેથી આ કાર્યક્રમ ત્રણ ભૂલો અહીં છે.

489
00:29:10,550 --> 00:29:16,630
હવે અમે જો વપરાશકર્તા ખરેખર argv માં કંઈપણ માં લખ્યો ચકાસણી કરી રહ્યા છીએ. [1] ગુડ.

490
00:29:16,630 --> 00:29:20,950
તેથી ત્રીજા ભૂલ શું છે? યાહ. >> [વિદ્યાર્થી] સી પ્રયત્ન પૂરતી મોટી નથી શકે છે.

491
00:29:20,950 --> 00:29:23,320
ગુડ. અમે એક દૃશ્ય ચકાસાયેલ.

492
00:29:23,320 --> 00:29:29,520
અમે સર્વથા ચકાસાયેલ નથી વધુ મેમરી કરતાં બાર લંબાઈ ઓળંગાઈ જશે પણ નકલ કરશો નહિં.

493
00:29:29,520 --> 00:29:32,510
તેથી શબ્દમાળા જો માં લખ્યો વપરાશકર્તા 10 અક્ષરો લાંબો છે,

494
00:29:32,510 --> 00:29:36,020
આ કહેતા છે માત્ર 10 અક્ષરો નકલ કરો. અને તે ઠીક છે.

495
00:29:36,020 --> 00:29:39,940
પરંતુ જો વપરાશકર્તા શબ્દ 20-અક્ષર જેવા પ્રોમ્પ્ટ પર એક શબ્દ માં લખ્યો?

496
00:29:39,940 --> 00:29:44,900
આ પટ્ટી માંથી શું માં 20 અક્ષરો નકલ કહેતા છે?

497
00:29:44,900 --> 00:29:49,750
સી, અન્યથા અમારા બફર તરીકે ઓળખાય છે, જેનો અર્થ છે તમે હમણાં જ માહિતી લખ્યું હતું

498
00:29:49,750 --> 00:29:52,540
8 બાઇટ સ્થળો કે જે તમે પોતાની ન કરવું,

499
00:29:52,540 --> 00:29:54,870
અને તમે તેમને સૂઝ કે તમે ફાળવવામાં તેમને ક્યારેય નહીં માલિકી નથી.

500
00:29:54,870 --> 00:30:00,370
તેથી આ એ છે જે સામાન્ય રીતે બફર ઓવરફ્લો હુમલો અથવા બફર રોળાઈ હુમલા તરીકે ઓળખાય છે.

501
00:30:00,370 --> 00:30:05,580
અને તે અર્થમાં હુમલો છે કે જો વપરાશકર્તા અથવા કાર્યક્રમ છે કે જે તમારા કાર્ય ફોન છે

502
00:30:05,580 --> 00:30:10,490
આ દ્વેષપૂર્વક કરવું, શું ખરેખર આગળ શું થશે વાસ્તવમાં ખૂબ ખરાબ હોઇ શકે છે.

503
00:30:10,490 --> 00:30:12,450
>> તેથી આપણે આ ચિત્ર પર એક નજર અહીં લે છે.

504
00:30:12,450 --> 00:30:16,060
આ ચિત્ર મેમરી તમારા સ્ટેક રજૂ કરે છે.

505
00:30:16,060 --> 00:30:19,580
જણાવ્યું હતું કે દર વખતે તમે એક કાર્ય કૉલ તમે સ્ટેક પર આ થોડો ફ્રેમ વિચાર

506
00:30:19,580 --> 00:30:21,520
અને અન્ય પછી અને પછી બીજા અને અન્ય.

507
00:30:21,520 --> 00:30:24,300
અને આમ અત્યાર સુધી, અમે હમણાં જ પ્રકારની કરેલા આ લંબચોરસ તરીકે શૂન્યમનસ્ક

508
00:30:24,300 --> 00:30:26,290
ક્યાં તો બોર્ડ પર અથવા અહીં સ્ક્રીન પર.

509
00:30:26,290 --> 00:30:30,580
પરંતુ જો આપણે તે લંબચોરસ એક, જ્યારે તમે કાર્ય foo કૉલ પર ઝૂમ,

510
00:30:30,580 --> 00:30:35,880
તે તારણ કે એ ફ્રેમ ને સ્ટેક અંદર પર વધુ કે લંબચોરસ માં છે

511
00:30:35,880 --> 00:30:40,060
કરતાં માત્ર એક્સ અને વાય અને a અને b, જેમ કે અમારી સ્વેપ વિશે વાત ન હતી.

512
00:30:40,060 --> 00:30:44,410
તે તારણ કે ત્યાં અમુક નીચી કક્ષાની વિગતો છે, તેમની વચ્ચે રીટર્ન સરનામું.

513
00:30:44,410 --> 00:30:49,550
તેથી તે તારણ જ્યારે મુખ્ય foo કહે છે, મુખ્ય foo જાણ છે

514
00:30:49,550 --> 00:30:53,520
ની મુખ્ય સરનામા શું કોમ્પ્યુટરની મેમરીમાં છે

515
00:30:53,520 --> 00:30:57,770
અન્યથા, કારણ તરીકે foo જલદી આ અહીં કિસ્સામાં ચલાવી કરવામાં આવે છે,

516
00:30:57,770 --> 00:31:00,830
એકવાર તમે foo ઓવરને અંતે આ બંધ સર્પાકાર તાણવું પહોંચે છે,

517
00:31:00,830 --> 00:31:05,310
કેવી રીતે હેક foo જ્યાં કાર્યક્રમ અંકુશ પર જાઓ માનવામાં આવે છે ખબર નથી?

518
00:31:05,310 --> 00:31:08,970
તે તારણ કે જે પ્રશ્નનો જવાબ આ લાલ અહીં લંબચોરસ છે.

519
00:31:08,970 --> 00:31:12,670
આ એક નિર્દેશક રજૂ કરે છે, અને તે કમ્પ્યુટર પર છે કામચલાઉ સ્ટોર

520
00:31:12,670 --> 00:31:17,030
સ્ટેક કહેવાતા પર મુખ્ય ના જેથી તરીકે foo જલદી સરનામા ચલાવવા કરવામાં આવે છે,

521
00:31:17,030 --> 00:31:21,120
કમ્પ્યુટર જ્યાં અને મુખ્ય માં લીટી શું પાછળ જવા માટે જાણે છે.

522
00:31:21,120 --> 00:31:23,940
સાચવેલા ફ્રેમ નિર્દેશક આ જ સંબંધિત છે.

523
00:31:23,940 --> 00:31:26,310
ચાર * અહીં બાર શું પ્રતિનિધિત્વ?

524
00:31:26,310 --> 00:31:31,350
હવે આ વાદળી સેગમેન્ટમાં અહીં માતાનો foo ફ્રેમ હોય છે. બાર શું છે?

525
00:31:31,570 --> 00:31:35,010
બાર ફક્ત foo કામ કરવા માટે દલીલ છે.

526
00:31:35,010 --> 00:31:37,500
તેથી હવે અમે પરિચિત ચિત્ર જેવું અંતે પાછા આવ્યા.

527
00:31:37,500 --> 00:31:39,850
ત્યાં વધુ અને સ્ક્રીન પર સામગ્રી વધુ વિક્ષેપોમાં છે,

528
00:31:39,850 --> 00:31:43,380
પરંતુ આ આછો વાદળી સેગમેન્ટમાં માત્ર છે અમે શું chalkboard પર ચિત્રકામ કર્યું છે

529
00:31:43,380 --> 00:31:45,790
સ્વેપ કંઈક છે. કે foo અંતર્ગત ફ્રેમ હોય છે.

530
00:31:45,790 --> 00:31:51,490
અને તેને જ વસ્તુ હમણાં બાર છે, કે જે આ પરિમાણ છે.

531
00:31:51,490 --> 00:31:55,220
પરંતુ બીજું શું સ્ટેક આ અહીં કોડ મુજબ રહેવું જોઈએ?

532
00:31:55,220 --> 00:31:57,760
[વિદ્યાર્થી] ઘરનાં પરચૂરણ કામો કો. [12] >> [Malan] ઘરનાં પરચૂરણ કામો કો. [12]

533
00:31:57,760 --> 00:32:02,810
અમે પણ મેમરી 12 ચોરસ એક કેચ કહેવાય ચલ ફાળવવામાં જોઈ શકવા જોઈએ,

534
00:32:02,810 --> 00:32:04,970
અને ખરેખર અમે સ્ક્રીન પર નથી.

535
00:32:04,970 --> 00:32:08,480
એકદમ ટોચ છે કૈચ પછી, અને આ રેખાકૃતિ લેખક [0]

536
00:32:08,480 --> 00:32:11,850
નહોતી સંતાપ નથી, આ વર્ગની તમામ ચિત્રકામ પરંતુ ખરેખર છે 12 ​​ત્યાં

537
00:32:11,850 --> 00:32:16,590
કારણ કે જો તમે નીચે જમણા ખૂણે જુઓ, કો [11] જો તમે 0 થી ગણતરી 12 જેવા બાઇટ છે.

538
00:32:16,590 --> 00:32:18,400
પરંતુ અહીં સમસ્યા છે.

539
00:32:18,400 --> 00:32:22,390
જે દિશામાં કેચ વધતી જાય છે?

540
00:32:22,390 --> 00:32:27,080
સૉર્ટ કરો નીચે ટોચ જો તે ટોચ પર શરૂ થાય છે અને નીચે સુધી વિકાસ પામે છે.

541
00:32:27,080 --> 00:32:30,110
તે જેમ આપણે આપણી જાતને ખૂબ રનવે બાકી અહીં બધા લાગતું નથી.

542
00:32:30,110 --> 00:32:32,090
અમે પ્રકારની એક ખૂણામાં આવી છે જાતને પેઇન્ટિંગ,

543
00:32:32,090 --> 00:32:36,940
અને તે કેચ [11] બાર છે, કે જે સાચવેલા ફ્રેમ નિર્દેશક સામે અધિકાર છે સામે અધિકાર છે,

544
00:32:36,940 --> 00:32:39,960
જે રીટર્ન સરનામું સામે અધિકાર છે. કોઈ વધુ ખંડ છે.

545
00:32:39,960 --> 00:32:42,810
તેથી સૂચિતાર્થ શું પછી છે જો તમે સ્ક્રૂ

546
00:32:42,810 --> 00:32:46,500
અને તમે એક બફર 12-બાઇટ માં 20 બાઇટ્સ reading પ્રયાસ?

547
00:32:46,500 --> 00:32:50,060
તે 8 વધારાના બાઇટ્સ પર જાઓ જ્યાં જવું છે? >> [વિદ્યાર્થી] - ઇનસાઇડ

548
00:32:50,060 --> 00:32:53,200
બાકીનું બધું અંદર છે, કે જે અમુક મહત્વપૂર્ણ સુપર છે.

549
00:32:53,200 --> 00:32:57,260
અને સૌથી મહત્વની વસ્તુ, સંભવિત, લાલ બોક્સ ત્યાં છે, રીટર્ન સરનામું,

550
00:32:57,260 --> 00:33:03,560
કારણ કે ધારો કે તમે ક્યાં તો અકસ્માતે કે adversarially તે 4 બાઇટ્સ પર ફરીથી લખી,

551
00:33:03,560 --> 00:33:07,260
માત્ર કચરો છે, પરંતુ એક નંબર સાથે નિર્દેશક સરનામું,

552
00:33:07,260 --> 00:33:09,810
કે મેમરી એક વાસ્તવિક સરનામા પ્રતિનિધિત્વ થાય છે.

553
00:33:09,810 --> 00:33:13,880
ઉદભવે શું તાર્કિક રીતે? >> [વિદ્યાર્થી] કાર્ય માટે એક અલગ સ્થાન પર પાછા જઈ રહ્યું છે.

554
00:33:13,880 --> 00:33:15,250
બરાબર.

555
00:33:15,250 --> 00:33:19,170
જ્યારે foo વળતર અને હિટ સર્પાકાર તાણવું કે, આ કાર્યક્રમ આગળ વધવા માટે થઇ રહ્યું છે

556
00:33:19,170 --> 00:33:25,060
મુખ્ય પરત ન હોય, તો તે સરનામા ગમે કે લાલ બોક્સમાં છે પાછા જવાનું છે.

557
00:33:25,060 --> 00:33:28,600
>> Circumventing સોફ્ટવેર રજીસ્ટ્રેશન કિસ્સામાં,

558
00:33:28,600 --> 00:33:32,260
જો સરનામા સાથે રહી પરત છે કાર્ય કરે છે જે સામાન્ય રીતે કહેવાય નહીં હોય

559
00:33:32,260 --> 00:33:35,690
પછી તમે સોફ્ટવેર માટે ચૂકવણી કરી છે અને તમારી નોંધણી કોડ ઇનપુટ?

560
00:33:35,690 --> 00:33:39,870
તમે કોમ્પ્યુટર યુક્તિ ઓફ જઈને અહીં પ્રવેશ સૉર્ટ પરંતુ તેના બદલે અહીં જઈને કરી શકો છો.

561
00:33:39,870 --> 00:33:45,100
અથવા જો તમે ખરેખર છો હોંશિયારીથી, વિરોધી ખરેખર કીબોર્ડ પર ટાઈપ કરી શકો છો, હમણાં પૂરતું,

562
00:33:45,100 --> 00:33:50,690
વાસ્તવિક, એક શબ્દ ન બોલ્યા 20 ન અક્ષરો છે, પરંતુ કદાચ તે અથવા તેણી ખરેખર માં પ્રકારો

563
00:33:50,690 --> 00:33:52,770
કેટલાક અક્ષરો કોડ પ્રતિનિધિત્વ કરે છે.

564
00:33:52,770 --> 00:33:55,320
અને તે માટે સી કોડ નથી ચાલી રહ્યું છે, તે ખરેખર અક્ષરો જ હશે

565
00:33:55,320 --> 00:33:59,290
કે દ્વિસંગી મશીન કોડ છે, અને 0s 1 સે પ્રતિનિધિત્વ કરે છે.

566
00:33:59,290 --> 00:34:01,290
પરંતુ કદાચ તેઓ પૂરતી હોંશિયાર છે કે શું કરશો,

567
00:34:01,290 --> 00:34:06,500
માટે કોઈક તો GetString પ્રોમ્પ્ટ કંઈક છે જે અનિવાર્યપણે સંકલિત કોડ છે પેસ્ટ,

568
00:34:06,500 --> 00:34:09,980
અને છેલ્લા 4 બાઇટ્સ કે વળતર સરનામા પર ફરીથી લખી.

569
00:34:09,980 --> 00:34:13,360
અને સરનામા શું કે ઇનપુટ શું કરે છે?

570
00:34:13,360 --> 00:34:18,630
તે વાસ્તવમાં આ લાલ લંબચોરસ એ બફર પ્રથમ બાઇટ ની સરનામું સંગ્રહ કરે છે.

571
00:34:18,630 --> 00:34:23,070
જેથી તમે ખરેખર હોંશિયાર હોય છે, અને આ અને ખરાબ લોકો માટે ટ્રાયલ ભૂલ ઘણો બહાર ત્યાં છે,

572
00:34:23,070 --> 00:34:25,639
પરંતુ જો તમે બહાર આકૃતિ મોટું કેવી રીતે આ બફર છે

573
00:34:25,639 --> 00:34:28,820
જેમ કે ઇનપુટ છેલ્લા થોડા બાઇટ્સ તમે કાર્યક્રમ માટે પૂરી પાડે છે

574
00:34:28,820 --> 00:34:33,540
તમારા બફર શરૂઆત ના સરનામા માટે સમકક્ષ હોઈ થાય, તો તમે આ કરી શકો છો.

575
00:34:33,540 --> 00:34:39,320
જો અમે સામાન્ય રીતે હેલ્લો અને 0 \ કહે છે કે શું આ બફર માં પૂર્ણ થાય છે.

576
00:34:39,320 --> 00:34:44,420
પરંતુ જો આપણે વધુ હોશિયાર છો અને અમે અમે શું સામાન્ય હુમલો કોડ કહી શકશો કે બફર ભરી -

577
00:34:44,420 --> 00:34:48,860
એએએ, હુમલો, હુમલો, હુમલો - જ્યાં આ કંઇક ખરાબ કંઈક કરે છે,

578
00:34:48,860 --> 00:34:51,820
શું થાય છે જો તમે ખરેખર છો હોંશિયારીથી, તમે આ કરી શકો છો.

579
00:34:51,820 --> 00:34:58,610
80, C0, 35, 08 - એ લાલ અહીં બૉક્સમાં ક્રમાંકોની શ્રેણી છે.

580
00:34:58,610 --> 00:35:01,610
નોંધ કરો કે કે નંબર છે કે જે અહીં મેળ ખાય છે.

581
00:35:01,610 --> 00:35:04,430
તે રિવર્સ ક્રમમાં છે, પરંતુ તે અન્ય કેટલાક સમય પર વધારે.

582
00:35:04,430 --> 00:35:08,140
નોંધ કરો કે આ વળતર સરનામા ઇરાદાપૂર્વક બદલાઈ ગયેલ છે

583
00:35:08,140 --> 00:35:12,020
આ સરનામાંને જેટલી અહીં, મુખ્ય નથી સરનામું.

584
00:35:12,020 --> 00:35:17,500
તેથી જો ખરાબ વ્યક્તિ સુપર સ્માર્ટ છે, તે અથવા તેણી સમાવેશ થાય છે કે હુમલો કોડ થઇ રહ્યું છે

585
00:35:17,500 --> 00:35:20,930
કંઈક જેવા વપરાશકર્તાના બધી ફાઈલોને કાઢી શકો અથવા પાસવર્ડો નકલ

586
00:35:20,930 --> 00:35:24,680
અથવા વપરાશકર્તા ખાતું બનાવવું કે હું પછી લૉગ ઇન કરી શકો છો - કંઈપણ બધા છે.

587
00:35:24,680 --> 00:35:26,950
>> અને આ બંને જોખમ અને સી શક્તિ છે

588
00:35:26,950 --> 00:35:29,840
કારણ કે તમે પોઇંટરો મારફતે મેમરી વપરાશ હોય છે

589
00:35:29,840 --> 00:35:32,520
અને તમે તેથી એક કમ્પ્યુટર મેમરીમાં કંઈપણ તમે ઇચ્છો લખી શકો છો,

590
00:35:32,520 --> 00:35:35,080
તમે કરી શકો છો કમ્પ્યુટર કંઈપણ તમે કરવા માંગો છો કરવું

591
00:35:35,080 --> 00:35:39,550
દ્વારા ફક્ત તેની પોતાની મેમરી જગ્યા અંદર એવું આસપાસ કૂદી.

592
00:35:39,550 --> 00:35:44,650
અને તેથી આ દિવસ માટે ઘણા કાર્યક્રમો અને ઘણા વેબસાઇટ્સ કે ગડબડ છે

593
00:35:44,650 --> 00:35:46,200
આ લાભ લેતા લોકો માટે ઉકાળીને પ્રમાણ ઘટાડવું.

594
00:35:46,200 --> 00:35:50,760
અને આ એક સુપર વ્યવહારદક્ષ હુમલો જેવા જણાય છે, પણ શકે તે હંમેશા કે માર્ગ શરૂ થતું નથી.

595
00:35:50,760 --> 00:35:53,560
આ વાસ્તવિકતા એ છે કે ખરાબ લોકો ખાસ કરીને કરશે શું છે,

596
00:35:53,560 --> 00:35:58,200
શું તે આદેશ વાક્ય પર એક કાર્યક્રમ અથવા GUI કાર્યક્રમ અથવા વેબસાઇટ છે,

597
00:35:58,200 --> 00:35:59,940
તમે હમણાં નોનસેન્સ પૂરી કરવાનું શરૂ કરો.

598
00:35:59,940 --> 00:36:03,980
તમે શોધ ક્ષેત્ર અને Enter હિટ એક ખરેખર મોટી શબ્દ લખો,

599
00:36:03,980 --> 00:36:05,780
અને તમે તે જોવા માટે જો વેબસાઇટ ક્રેશ રાહ

600
00:36:05,780 --> 00:36:09,990
અથવા તમે એ જોવા માટે જો કાર્યક્રમ કેટલાક ભૂલ સંદેશો મેનીફેસ્ટ રાહ

601
00:36:09,990 --> 00:36:14,330
કારણ કે જો તમે ખરાબ વ્યક્તિ તરીકે નસીબદાર વિચાર અને તમને કેટલીક ઉન્મત્ત ઇનપુટ પૂરું પાડવા

602
00:36:14,330 --> 00:36:18,980
કે કાર્યક્રમ, તેનો અર્થ એ કે એ પ્રોગ્રામર તમારા ખરાબ વર્તન પૂર્વાનુમાન ન હતી ક્રેશ,

603
00:36:18,980 --> 00:36:23,630
જેનો અર્થ છે કે તમે કદાચ આ કરી શકો છો પર્યાપ્ત પ્રયત્ન, પર્યાપ્ત અજમાયશ અને ભૂલની સાથે,

604
00:36:23,630 --> 00:36:26,650
બહાર આકૃતિ કેવી રીતે વધુ ચોક્કસ હુમલો વિશે છે.

605
00:36:26,650 --> 00:36:31,410
જેથી ખૂબ સુરક્ષા એક ભાગ માત્ર આ હુમલા એકસાથે ન અવગણી છે

606
00:36:31,410 --> 00:36:34,100
પરંતુ તેમને શોધવા અને ખરેખર લોગ્સ પર નજર

607
00:36:34,100 --> 00:36:36,780
અને જોયા ઉન્મત્ત ઇનપુટ્સ શું તમારી વેબસાઇટ પર ટાઇપ કરવામાં આવતું લોકો હોય છે,

608
00:36:36,780 --> 00:36:38,960
શોધ શબ્દો શું તમારી વેબસાઇટ પર લોકો લખ્યો છે

609
00:36:38,960 --> 00:36:42,870
કેટલાક બફર વહેતું આશા છે.

610
00:36:42,870 --> 00:36:45,500
અને આ શું સરળ મૂળભૂતો બધા નીચે ઉકળે ઝાકઝમાળ છે

611
00:36:45,500 --> 00:36:49,080
અને તે શું માટે ફાળવો અને મેમરીનો ઉપયોગ અર્થ નથી.

612
00:36:49,080 --> 00:36:51,710
>> પછી પણ આ એ છે કે સંબંધિત.

613
00:36:51,710 --> 00:36:54,280
ચાલો માત્ર એક હાર્ડ ડ્રાઈવ ની અંદર હજુ સુધી ફરી ચમકારો કરવો.

614
00:36:54,280 --> 00:36:58,440
તમે એક અથવા બે સપ્તાહ પહેલા થી યાદ છે કે જ્યારે તમે તમારા રીસાઇકલ બિન અથવા કચરો કરી શકો છો ફાઈલો ખેંચો

615
00:36:58,440 --> 00:37:03,710
શું થાય છે? >> [વિદ્યાર્થી] કંઈ નથી. >> ચોક્કસ કશું, અધિકાર?

616
00:37:03,710 --> 00:37:05,740
આખરે જો તમે ડિસ્ક જગ્યા પર ચલાવવા માટે,

617
00:37:05,740 --> 00:37:08,190
વિન્ડોઝ અથવા મેક ઓએસ તમે ફાઇલો માટે કાઢી નાંખવા શરૂ થશે.

618
00:37:08,190 --> 00:37:10,390
પરંતુ જો તમે ત્યાં કંઈક ખેંચો, તે તમામ સલામત નથી.

619
00:37:10,390 --> 00:37:13,800
તમારા રૂમમેટ અથવા મિત્ર અથવા કુટુંબના સભ્ય કરવું બધા ડબલ ક્લિક કરો અને છે, વોઇલા Query,

620
00:37:13,800 --> 00:37:16,310
ત્યાં બધા ઉપરછલ્લા ફાઈલો કે જે તમે કાઢી નાંખવા પ્રયાસ કર્યો છે.

621
00:37:16,310 --> 00:37:19,590
અમને મોટા ભાગના ઓછામાં ઓછું જાણીએ છીએ કે તમે જમણી ક્લિક કરો અથવા ક્લિક કરો નિયંત્રિત હોય છે

622
00:37:19,590 --> 00:37:22,310
અને ખાલી અથવા જેમ કચરો કંઈક.

623
00:37:22,310 --> 00:37:25,000
પણ પછી તે તદ્દન યુક્તિ કરતું નથી

624
00:37:25,000 --> 00:37:28,010
કારણ કે શું થાય છે જ્યારે તમે તમારી હાર્ડ ડ્રાઇવ પર ફાઇલ હોય

625
00:37:28,010 --> 00:37:32,770
કે અમુક વર્ડ દસ્તાવેજ અથવા અમુક JPEG રજૂ કરે છે, અને આ તમારી હાર્ડ ડ્રાઈવ રજૂ કરે છે,

626
00:37:32,770 --> 00:37:35,350
અને ચાલો કહેવું આ અહીં sliver કે ફાઈલ રજૂ કરે છે,

627
00:37:35,350 --> 00:37:38,390
અને તે 0s અને 1 સે સંપૂર્ણ જથ્થો બનેલા છે.

628
00:37:38,390 --> 00:37:42,470
ત્યારે શું તમે ટ્રૅશમાં છે કે ફાઈલ માત્ર નથી ખેંચો થાય છે અથવા બિન રિસાયકલ કરી શકો છો

629
00:37:42,470 --> 00:37:48,020
પણ તે ખાલી? કશું ના ક્રમમાં ગોઠવો.

630
00:37:48,020 --> 00:37:49,640
તે સંપૂર્ણપણે કશું હવે નથી.

631
00:37:49,640 --> 00:37:54,290
હવે તે માત્ર કશું જ નથી કારણ કે થોડા કંઈક આ ટેબલ સ્વરૂપમાં થાય છે.

632
00:37:54,290 --> 00:37:58,370
તેથી ત્યાં એક કમ્પ્યુટર મેમરી ની અંદર ડેટાબેઝ અથવા ટેબલ કેટલાક પ્રકારની છે

633
00:37:58,370 --> 00:38:03,850
કે અનિવાર્યપણે ફાઈલો માટે એક સ્તંભ 'નામો અને ફાઈલો માટે એક સ્તંભ' સ્થાન ધરાવે છે,

634
00:38:03,850 --> 00:38:07,720
આ 123 સ્થાન, ફક્ત રેન્ડમ નંબર જ્યાં હોઈ શકે છે.

635
00:38:07,720 --> 00:38:14,560
તેથી અમે x.jpeg અને 123 સ્થાન કંઈક હોય શકે છે.

636
00:38:14,560 --> 00:38:18,800
શું પછી જ્યારે તમે વાસ્તવમાં તમારા કચરો ખાલી?

637
00:38:18,800 --> 00:38:20,330
કે દૂર જાય છે.

638
00:38:20,330 --> 00:38:23,610
પરંતુ દૂર જવા નથી શું 0s અને 1 સે છે.

639
00:38:23,610 --> 00:38:26,270
>> તેથી શું પછી pset4 જોડાણ છે?

640
00:38:26,270 --> 00:38:31,240
વેલ, pset4 સાથે, માત્ર કારણ કે અમે આકસ્મિક કોમ્પેક્ટ ફ્લેશ કાર્ડ દૂર કર્યા છે

641
00:38:31,240 --> 00:38:35,750
ખરાબ નસીબ દ્વારા આ ફોટા બધા અથવા ફક્ત કારણ કે હતી દૂષિત બની હતી

642
00:38:35,750 --> 00:38:38,000
નથી તેનો અર્થ નથી કે 0s અને 1 સે હજુ પણ ત્યાં નથી.

643
00:38:38,000 --> 00:38:40,410
કદાચ થોડા કારણ કે કંઈક બગડી ગયું છે ખોવાઈ જાય છે

644
00:38:40,410 --> 00:38:43,320
અર્થમાં કે અમુક 0s 1 સે બની હતી અને 1 સે 0s બની.

645
00:38:43,320 --> 00:38:47,240
ખરાબ વસ્તુઓ બગડેલ સોફ્ટવેર અથવા હાર્ડવેર ખામીયુક્ત કારણે થાય છે.

646
00:38:47,240 --> 00:38:50,370
પરંતુ તે બિટ્સ ઘણા, કદાચ તેમને 100 પણ%, હજી પણ ત્યાં હોય છે.

647
00:38:50,370 --> 00:38:55,050
તે ફક્ત કમ્પ્યૂટર અથવા કૅમેરા જ્યાં JPEG1 શરૂ ખબર નથી

648
00:38:55,050 --> 00:38:56,910
અને JPEG2 જ્યાં શરૂ કરી હતી.

649
00:38:56,910 --> 00:39:01,070
પરંતુ તમે જો, તો પ્રોગ્રામર, સમજશકિત એક બીટ જ્યાં તે JPEGs છે સાથે ખબર

650
00:39:01,070 --> 00:39:06,010
અથવા તેઓ જેમ દેખાય છે શું જેથી તમે 0s અને 1 સે અને કહે JPEG, JPEG વિશ્લેષણ કરી શકે છે,

651
00:39:06,010 --> 00:39:09,440
તમે અનિવાર્યપણે માટે માત્ર એક સાથે એક પ્રોગ્રામ લખવા કરી શકો છો અથવા જ્યારે લૂપ

652
00:39:09,440 --> 00:39:12,820
કે જે તે ફાઈલો દરેક એક ધક્કામાંથી.

653
00:39:12,820 --> 00:39:16,030
તેથી પાઠ પછી સુરક્ષિત તમારી ફાઇલોને ભૂંસી નાખી શરૂ છે

654
00:39:16,030 --> 00:39:18,340
જો તમે આ સંપૂર્ણપણે ટાળવા માંગો છો. હા.

655
00:39:18,340 --> 00:39:21,010
>> [વિદ્યાર્થી] કેવી રીતે આવે છે તેને તમારા કમ્પ્યુટર પર કહે છે

656
00:39:21,010 --> 00:39:23,550
કે તમને વધુ મેમરી કરતાં તમે પહેલાં કર્યું છે?

657
00:39:23,550 --> 00:39:27,820
વધુ મેમરી કરતાં તમે પહેલાં કર્યું છે - >> [વિદ્યાર્થી] વધુ ઉપલબ્ધ મેમરી.

658
00:39:27,820 --> 00:39:29,630
ઓહ. પ્રશ્ન સારું.

659
00:39:29,630 --> 00:39:32,360
તેથી પછી શા માટે ટ્રૅશ ખાલી પછી તમારા કમ્પ્યુટર તમને કહી નથી

660
00:39:32,360 --> 00:39:34,910
કે તમને વધુ મુક્ત જગ્યા કરતાં તમે પહેલાં કર્યું છે?

661
00:39:34,910 --> 00:39:36,770
ટૂંકમાં, કારણ કે તે પડેલો છે.

662
00:39:36,770 --> 00:39:40,740
વધુ તકનીકી, તમે વધુ જગ્યા હોય છે કારણ કે હવે તમે કહ્યું છે

663
00:39:40,740 --> 00:39:43,680
તમે અન્ય સામગ્રી મૂકવામાં જ્યાં તે ફાઇલ એક વખત થઇ હતી.

664
00:39:43,680 --> 00:39:45,450
પરંતુ તેનો અર્થ એ નથી કે બિટ્સ દૂર જવું છે,

665
00:39:45,450 --> 00:39:48,590
અને એનો અર્થ એ નથી કે બિટ્સ તમામ 0s માટે બદલાઈ રહ્યાં છે, હમણાં પૂરતું,

666
00:39:48,590 --> 00:39:50,150
તમારી સુરક્ષા માટે.

667
00:39:50,150 --> 00:39:54,640
તેથી વિપરીત, જો તમે સુરક્ષિત રીતે ફાઈલો ભૂંસવું કે ભૌતિક ઉપકરણ નાશ કરે છે,

668
00:39:54,640 --> 00:39:57,300
કે ખરેખર કે આસપાસ માત્ર ક્યારેક માર્ગ છે.

669
00:39:57,300 --> 00:40:02,020
>> તેથી અમે નોંધ અર્ધ ડરામણી પર શા માટે છોડી નથી, અને અમે તમને સોમવાર પર જોશે.

670
00:40:02,020 --> 00:40:07,000
[વધાવી]

671
00:40:07,780 --> 00:40:10,000
>> [CS50.TV]