1
00:00:00,000 --> 00:00:02,760
[Powered by Google Translate] [5 અઠવાડિયાની]

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

3
00:00:04,760 --> 00:00:11,990
[આ CS50 છે.] [CS50.TV]

4
00:00:11,990 --> 00:00:17,780
[વુમન] તેમણે પડેલો છે; જે અંગે, મને ખબર નથી.

5
00:00:17,780 --> 00:00:20,300
[મેન] તેથી આપણે શું જાણો છો?

6
00:00:20,300 --> 00:00:24,120
[વુમન] તે 9:15 ખાતે, રે Santoya આ એટીએમ હતો.

7
00:00:24,120 --> 00:00:27,420
[મેન] તેથી પ્રશ્ન, તેણે કરવામાં આવી હતી 9:16 અંતે કરવાનું?

8
00:00:27,420 --> 00:00:29,980
[વુમન] કંઈક અંતે 9 એમએમની શૂટીંગ.

9
00:00:29,980 --> 00:00:31,900
કદાચ તેઓ સ્નાઈપર જોવા મળી હતી.

10
00:00:31,900 --> 00:00:34,000
[મેન] અથવા તેઓ તેમની સાથે કામ કરતો હતો.

11
00:00:34,000 --> 00:00:36,330
[વુમન] પ્રતીક્ષા. પાછળ એક જાઓ.

12
00:00:36,330 --> 00:00:38,330
[મેન] તમે શું જોશે?

13
00:00:38,330 --> 00:00:44,520
[♫ Suspenseful સંગીત ♫]

14
00:00:44,520 --> 00:00:48,320
[વુમન] તેના ચહેરા લાવો છે. સંપૂર્ણ સ્ક્રીન.

15
00:00:48,320 --> 00:00:51,230
[મેન] તેમનો ચશ્મા. >> એક પ્રતિબિંબ છે.

16
00:00:51,230 --> 00:01:00,810
[♫ Suspenseful સંગીત ♫]

17
00:01:00,810 --> 00:01:03,580
[મેન] તે આ Nuevita બેઝબોલ ટીમ છે. કે તેમના લોગો છે.

18
00:01:03,580 --> 00:01:07,790
[વુમન] અને ભલે કે જેકેટ પહેર્યા છે વાત છે.

19
00:01:07,790 --> 00:01:13,730
>> [ડેવિડ Malan] તેથી, આ CS50 5 સપ્તાહ છે, અને આજે તો અમે તમારા માટે ટેલિવિઝન અને ફિલ્મ એક બીટ વિનાશ.

20
00:01:13,730 --> 00:01:16,170
તેથી જ્યારે પણ તમે આ અહીં એક જેવા શો જોઈ રહ્યાં છો,

21
00:01:16,170 --> 00:01:19,910
અને કોપ્સ સે "છે કે જે તમને સાફ કરી શકાતી અપ?" અથવા "વિસ્તૃત"

22
00:01:19,910 --> 00:01:21,900
ત્યાં કોઈ વાસ્તવિક દુનિયામાં વિસ્તૃત છે.

23
00:01:21,900 --> 00:01:25,220
હકીકતમાં, તમે ખરેખર વિચાર શું આ જેવી થોડી સમસ્યા છે.

24
00:01:25,220 --> 00:01:27,570
હું એક પાનું ના સ્ટાફ ફોટા ખેંચી કર્યું છે.

25
00:01:27,570 --> 00:01:30,980
આ એક ફોટોશોપ નામના પ્રોગ્રામ છે. આ 1 2 Bowdens છે,

26
00:01:30,980 --> 00:01:36,300
1 3 ની વાસ્તવમાં Bowdens આજે, કારણ કે અમે શ્રીમતી બોડેન અહીં તેમજ રોબ અને પોલ સાથે હોય છે.

27
00:01:36,300 --> 00:01:41,950
પરંતુ અહીં સ્ક્રીન પર રોબ છે, અને જો અમે તે ઝળહળવું પર ઝૂમ તેણે હંમેશા આ આંખ હતી જાય,

28
00:01:41,950 --> 00:01:47,600
તમે ખરેખર શું છે કે તમે શું છે, તો તમે શું કરો.

29
00:01:47,600 --> 00:01:51,690
આ છે "ઉન્નત," જેથી "સીએસઆઇ" તે બીટ ખોટું છે.

30
00:01:51,690 --> 00:01:55,190
ત્યાં એક અન્ય ક્લિપ છે, જો આપણે માત્ર થોડો સમય સુધી "સીએસઆઇ" પર પસંદ કરી શકો છો.

31
00:01:55,190 --> 00:01:58,500
આ એક સરસ માટે અત્યારથી મૂક જો તમે કરવા માંગો છો શબ્દસમૂહ છે

32
00:01:58,500 --> 00:02:10,280
તમારા મિત્રો સાથે તકનિકી અવાજ, જ્યારે ખરેખર, તમે ચોક્કસપૂર્વક કશું કહી રહ્યાં છે.

33
00:02:10,280 --> 00:02:12,970
>> [મેન] અઠવાડિયા માટે હું આ ભાડૂતી ગાડીવાળો કિલર હત્યા કરવામાં આવી તપાસ કર્યા છે

34
00:02:12,970 --> 00:02:15,360
ચોક્કસ રોગિષ્ઠ આકર્ષણની સાથે.

35
00:02:15,360 --> 00:02:17,160
[વુમન # 1] આ વાસ્તવિક સમય છે.

36
00:02:17,160 --> 00:02:22,930
[વુમન # 2] હું એ GUI વિઝ્યુઅલ બેઝિકનો ઉપયોગ કરીને ઇન્ટરફેસ બનાવો, જુઓ જો હું IP સરનામા ટ્રેક કરી શકો છો.

37
00:02:22,930 --> 00:02:29,570
>> [Malan] તેથી એકાંતે સમન્વયન સમાપ્ત ઓડિયો, એ GUI વિઝ્યુઅલ બેઝિકનો ઉપયોગ કરીને ઈન્ટરફેસ બનાવવા

38
00:02:29,570 --> 00:02:31,820
માટે IP સરનામા ટ્રેક સંપૂર્ણપણે નકામુ છે.

39
00:02:31,820 --> 00:02:33,840
આ દિવસોમાં તમે વિઝ્યુઅલ બેઝિક ઉપયોગ ન હો,

40
00:02:33,840 --> 00:02:38,920
ત્યાં એ GUI માટે આ બોલ પર કોઈ જરૂર નથી, અને IP સરનામું તકનીકી ચોક્કસ શબ્દ હતો.

41
00:02:38,920 --> 00:02:41,730
તેથી નજર રાખો આ માટે, અને મારા એક લોકપ્રિય:

42
00:02:41,730 --> 00:02:45,070
આ એક થોડી વધુ arcane છે, કારણ કે તમે એક અલગ ભાષા જાણવાની જરૂર છે.

43
00:02:45,070 --> 00:02:47,860
ત્યાં એક ઉદ્દેશ C-કહેવાય ભાષા છે, જે સી એક superset છે છે

44
00:02:47,860 --> 00:02:51,960
જે તે સી પ્લસ કેટલીક વધારાની સુવિધાઓ તેમના પ્રોગ્રામિંગ પદાર્થ આધારિત વચ્ચે થાય છે.

45
00:02:51,960 --> 00:02:55,070
અને આ ભાષા કે એપલે આઇઓએસ પ્રોગ્રામિંગ માટે પ્રખ્યાત છે.

46
00:02:55,070 --> 00:02:58,760
અને તેથી અહીં એક અલગ એકસાથે શો ક્લિપ છે, માંથી "નંબર"

47
00:02:58,760 --> 00:03:02,450
કે જો તમે ખરેખર તમારા TiVo અને વિરામ પર નજીકથી અધિકાર ક્ષણે જુઓ,

48
00:03:02,450 --> 00:03:07,700
તમે જોશો કે તેઓ અંતે શોધી રહ્યાં છો તે શું ન તદ્દન શું વર્ણવામાં આવ્યું છે.

49
00:03:07,700 --> 00:03:11,170
દો અને મને એક અલગ ઓડિયો કનેક્ટર અહીં પ્રયત્ન કરો અને જુઓ અમે શકતો નથી જો

50
00:03:11,170 --> 00:03:13,780
સુમેળ ઑડિયો આ સમય રાખો.

51
00:03:13,780 --> 00:03:20,530
હું તમે "નંબર્સ." આપે છે

52
00:03:20,530 --> 00:03:23,240
>> [મૅન # 1] તે 32-bit IPv4 સરનામું છે.

53
00:03:23,240 --> 00:03:38,930
[2 # મેન] IP, કે જે ઈન્ટરનેટ છે. >> ખાનગી નેટવર્ક. તે અનિતા ખાનગી નેટવર્ક છે.

54
00:03:38,930 --> 00:03:43,810
[Malan] ઠીક. આ ઉદ્દેશ C-છે, અને તે અમુક બાળક રંગ કાર્યક્રમ માટે છે,

55
00:03:43,810 --> 00:03:51,140
જેમ તમે કદાચ ત્યાં ચલ નામ પરથી અનુમાન દોરવું કરી શકો છો.

56
00:03:51,140 --> 00:03:54,410
જેથી, પછી તેને "નંબર્સ." આજે અને આ અઠવાડિયે જેથી અમે રજૂઆત

57
00:03:54,410 --> 00:03:57,740
વિદેશી અને તેથી સમસ્યાઓ સંદર્ભમાં વિશ્વના થોડો.

58
00:03:57,740 --> 00:04:00,590
આજે એક સંક્ષિપ્ત વ્યાખ્યાન શકે છે કારણ કે ત્યાં અહીં એક ખાસ ઘટના થશે

59
00:04:00,590 --> 00:04:05,530
પછીથી, તેથી અમે એક ડોકિયું લે છે, અને પડશે બન્ને વિદ્યાર્થીઓ અને આનંદદાયક માતા - પિતા આજે પીંજવું

60
00:04:05,530 --> 00:04:07,420
વસ્તુઓ કે જે ક્ષિતિજ પર છે કેટલાક.

61
00:04:07,420 --> 00:04:12,240
તેમની વચ્ચે, સોમવાર, તમે થોડા વધુ સહપાઠીઓને હશે.

62
00:04:12,240 --> 00:04:16,050
EdX હાર્વર્ડ અને ખુલ્લા courseware માટે એમઆઇટીએસ નવા ઑનલાઇન પહેલ

63
00:04:16,050 --> 00:04:19,120
અને વધુ, હાર્વર્ડના કેમ્પસ પર સોમવારે શરૂ થયેલ છે.

64
00:04:19,120 --> 00:04:21,490
છેલ્લા ગણતરી મુજબ, - જે આવે સોમવાર અર્થ છે કે તમે પડશે

65
00:04:21,490 --> 00:04:26,210
86,000 વધારાની સહપાઠીઓને હિસ્સો CS50 વ્યાખ્યાન સાથે સાથે નીચેની કરશે

66
00:04:26,210 --> 00:04:29,170
અને વિભાગો અને વૉકથ્રૂઝ અને સમસ્યા સમૂહો.

67
00:04:29,170 --> 00:04:32,350
અને આ ભાગ તરીકે, તમે પ્રારંભિક વર્ગ સભ્યો બની જશે

68
00:04:32,350 --> 00:04:35,090
CS50 અને હવે CS50x.

69
00:04:35,090 --> 00:04:39,310
>> આ ભાગ તરીકે, હવે ખ્યાલ છે, કે જે અમુક upsides તેમજ હશે.

70
00:04:39,310 --> 00:04:43,790
આ માટે તૈયાર વિદ્યાર્થીઓ મોટા નંબર માટે, વિચાર,

71
00:04:43,790 --> 00:04:47,180
તે પૂરતો કહે છે કે ભલે અમે 108 TFs અને સીએએસ હોય છે,

72
00:04:47,180 --> 00:04:50,790
ન તદ્દન શ્રેષ્ઠ ગુણોત્તર / વિદ્યાર્થી શિક્ષક એકવાર અમે 80,000 અન્ય વિદ્યાર્થીઓ નહીં.

73
00:04:50,790 --> 00:04:52,850
તેથી અમે ઘણા સમસ્યા વર્ગીકરણ શકાતી નથી જઈ રહ્યાં છો જાતે સુયોજિત કરે છે.

74
00:04:52,850 --> 00:04:55,920
જેથી સમસ્યા સમૂહ આ સપ્તાહ રજૂઆત CS50 તપાસ થશે,

75
00:04:55,920 --> 00:04:58,450
જે આદેશ વાક્ય ઉપયોગીતા જે ઉપકરણ અંદર રહ્યું છે

76
00:04:58,450 --> 00:05:01,200
કે તમે એક વાર તમે આ સપ્તાહના પછી અપડેટ મળશે,

77
00:05:01,200 --> 00:05:03,200
અને તમે આદેશ ચલાવો કરવાનો પ્રયત્ન કરીશું, 50 ચકાસવા માટે,

78
00:05:03,200 --> 00:05:06,500
તમારા પોતાના pset પર, અને તમે કે તમારી કાર્યક્રમ છે કે કેટલીક પ્રતિસાદ મળશે

79
00:05:06,500 --> 00:05:11,160
સાચું અથવા ખોટું અનુસાર વિવિધ ડિઝાઇન સ્પષ્ટીકરણો કે અમે પ્રદાન કરેલા.

80
00:05:11,160 --> 00:05:13,580
જેથી પર વધુ અને સમસ્યા સેટ સ્પષ્ટીકરણ અને

81
00:05:13,580 --> 00:05:17,240
આ CS50x સહપાઠીઓને આ ઉપયોગ કરીને કરવામાં આવશે છે.

82
00:05:17,240 --> 00:05:19,230
>> તેથી સમસ્યા 4 સમૂહ ફોરેન્સિક્સ વિશે બધું છે.

83
00:05:19,230 --> 00:05:21,940
અને આ ભાગ કેટલીક સામગ્રી વાસ્તવિક જીવન દ્વારા પ્રેરણા આપી હતી,

84
00:05:21,940 --> 00:05:24,620
જેમાં જ્યારે હું ગ્રેજ્યુએટ સ્કૂલ હતી, હું સાથે હંમેશ માટે ઇન્ટર્ન

85
00:05:24,620 --> 00:05:28,650
આ મિડલસેક્સ કાઉન્ટીના ડિસ્ટ્રીક્ટ એટર્નીની ઓફિસ ફોરેન્સિક કાર્ય

86
00:05:28,650 --> 00:05:31,650
તેમના મુખ્ય ફોરેન્સિક તપાસનીસ સાથે, અને આ શું પૂરવાર

87
00:05:31,650 --> 00:05:35,260
છે, મને લાગે છે કે હું થોડા સપ્તાહની ભૂતકાળ ઉલ્લેખ કર્યો, ધી માસ રાજ્ય પોલીસ અથવા અન્ય છે

88
00:05:35,260 --> 00:05:39,000
આવે છો, તો તેઓ આ બોલ પર હાર્ડ ડ્રાઈવો અને CD ઓ અને ફ્લોપી ડિસ્ક જેવી વસ્તુઓ ડ્રોપ કરશે

89
00:05:39,000 --> 00:05:42,340
અને જેમ, અને પછી વિદેશી ઓફિસ ધ્યેય સહમતી હતી કે શું

90
00:05:42,340 --> 00:05:44,600
ત્યાં હતો કે અમુક પ્રકારના પુરાવા ન હતા.

91
00:05:44,600 --> 00:05:48,010
આ સ્પેશિયલ ઈન્વેસ્ટીગેશન એકમ હતું, તેથી તેને સફેદ કોલર ગુનો હતો,

92
00:05:48,010 --> 00:05:52,350
તે ગુના વધુ મુશ્કેલીમાં પ્રકારનો કાર્યક્રમ હતો,

93
00:05:52,350 --> 00:05:55,990
ડિજિટલ મીડિયા અમુક પ્રકારના સંડોવતા કંઈપણ; તારણ આપે છે કે નહીં કે ઘણા લોકો

94
00:05:55,990 --> 00:05:59,370
એક કહેતા ઇમેઇલ લખવા "હું તે કર્યું હતું."

95
00:05:59,370 --> 00:06:03,290
તેથી ઘણી વાર આ વિદેશી શોધ અપ કે બધા ખૂબ ફળ બંધ કર્યું નહોતું,

96
00:06:03,290 --> 00:06:05,850
પરંતુ ક્યારેક લોકો જેમ કે ઇમેઇલ્સ લખી હતી.

97
00:06:05,850 --> 00:06:08,490
તેથી કેટલીક વાર પ્રયત્નો મળ્યા હતા.

98
00:06:08,490 --> 00:06:14,420
>> પરંતુ આ ફોરેન્સિક pset સુધી દોરી જાય છે, અમે 4 ગ્રાફિક્સ એક બીટ pset માં દાખલ કરવામાં આવશે.

99
00:06:14,420 --> 00:06:18,260
તેથી તમે કદાચ મંજૂર JPEGs GIFs, અને આ દિવસોમાં જેમ આ વસ્તુઓ લે છે,

100
00:06:18,260 --> 00:06:21,640
પરંતુ જો તમે ખરેખર તે વિશે વિચારો, ઇમેજ, મોટાભાગના રોબ ચહેરાની જેમ,

101
00:06:21,640 --> 00:06:24,430
બિંદુઓને શ્રેણી છે, અથવા પિક્સેલ્સ તરીકે રજૂ કરવામાં કરી શકાય છે.

102
00:06:24,430 --> 00:06:26,680
હવે, જે રોબ ચહેરો કિસ્સામાં, ત્યાં રંગો તમામ પ્રકારના છે,

103
00:06:26,680 --> 00:06:29,940
અને અમે વ્યક્તિગત બિંદુઓ, otherwide પિક્સેલ્સ તરીકે ઓળખાય જુઓ શરૂ,

104
00:06:29,940 --> 00:06:31,610
એકવાર અમે સાઇન ઝૂમ શરૂ

105
00:06:31,610 --> 00:06:35,590
પરંતુ જો આપણે વિશ્વમાં થોડી સરળ અને માત્ર કહે છે કે અહીં આ રોબ છે

106
00:06:35,590 --> 00:06:40,560
કાળા અને સફેદ, તેમજ માટે પ્રતિનિધિત્વ કાળા અને સફેદ આપણે માત્ર દ્વિસંગી વાપરી શકો છો.

107
00:06:40,560 --> 00:06:44,960
અને જો અમે દ્વિસંગી ઉપયોગ જઈ રહ્યાં છો, 1 અથવા 0, અમે આ જ ઇમેજ વ્યક્ત કરી શકો છો

108
00:06:44,960 --> 00:06:51,970
માતાનો રોબ બિટ્સ આ પેટર્ન સ્માઈલિંગ ચહેરો: 11000011 પ્રતિનિધિત્વ

109
00:06:51,970 --> 00:06:55,160
સફેદ, સફેદ, કાળા, કાળા, કાળા, કાળા, સફેદ સફેદ.

110
00:06:55,160 --> 00:06:59,290
અને તેથી તે એક વિશાળ કૂદકો, પછી નથી, માટે રંગબેરંગી ફોટોગ્રાફ્સ વિશે વાત કરવાનું શરૂ કરો.

111
00:06:59,290 --> 00:07:01,920
વસ્તુઓ છે કે જે તમને Facebook પર જોવા અથવા ડિજીટલ કેમેરા સાથે લઈ જતા,

112
00:07:01,920 --> 00:07:04,730
પરંતુ, ચોક્કસપણે, જ્યારે તે રંગો માટે આવે છે, તમે વધુ બિટ્સ જરૂર છે.

113
00:07:04,730 --> 00:07:08,470
અને તદ્દન ફોટોગ્રાફ વિશ્વમાં સામાન્ય રંગ 1-bit ઉપયોગ ન હોય,

114
00:07:08,470 --> 00:07:12,730
કારણ કે આ સૂચવે છે, પણ 24-bit રંગ છે, જ્યાં તમે ખરેખર લાખો રંગ મળે છે.

115
00:07:12,730 --> 00:07:15,430
તેથી કિસ્સામાં જ્યારે અમે રોબ આંખ પર ઝૂમ કરેલું,

116
00:07:15,430 --> 00:07:19,270
કે વિવિધ રંગબેરંગી શક્યતાઓ લાખો કોઈપણ સંખ્યાની હતી.

117
00:07:19,270 --> 00:07:22,260
>> તેથી અમે સમસ્યા 4 સેટ તેમજ walkthrough આ રજૂઆત પડશે,

118
00:07:22,260 --> 00:07:27,050
જે આજે સામાન્ય 2:30 બદલે 3:30 ખાતે શુક્રવારે અહીં વ્યાખ્યાન કારણે હશે.

119
00:07:27,050 --> 00:07:29,930
પરંતુ વિડિઓ ઓનલાઈન હંમેશની જેમ, કાલે આવશે.

120
00:07:29,930 --> 00:07:31,880
અમે પણ તમે બીજી ફાઇલ ફોર્મેટમાં દાખલ પડશે.

121
00:07:31,880 --> 00:07:34,150
તેથી આ ઇરાદાપૂર્વક પ્રથમ લાવનારાઓ જોવા રાખવાનો છે,

122
00:07:34,150 --> 00:07:38,980
પરંતુ આ માત્ર એક સી સ્ટ્રક્ટ માટે કેટલાક દસ્તાવેજો છે.

123
00:07:38,980 --> 00:07:42,280
તે તારણ કે જે Microsoft, વર્ષો પહેલા આ ફોર્મેટમાં લોકપ્રિય બનાવવામાં મદદ કરી,

124
00:07:42,280 --> 00:07:46,630
આ બીટમેપ ફાઇલ ફોર્મેટ, BMP, અને આ સુપર સરળ હતું કહેવાય છે,

125
00:07:46,630 --> 00:07:50,390
રંગબેરંગી ગ્રાફિકવાળા ફાઈલ બંધારણમાં કે અમુક સમય માટે શાંત ઉપયોગ કરવામાં આવ્યો હતો

126
00:07:50,390 --> 00:07:53,640
અને ક્યારેક હજુ પણ ડેસ્કટોપ પર વોલપેપરો છે.

127
00:07:53,640 --> 00:07:57,410
જો તમે Windows XP અને આ ટેકરીઓનો અને વાદળી આકાશમાં પાછા વિચારો,

128
00:07:57,410 --> 00:08:00,660
જે સામાન્ય હતી BMP, અથવા બીટમેપ ઈમેજ, અને ત્યાર બાદ બીટમેપ

129
00:08:00,660 --> 00:08:03,340
આપણા માટે આનંદ છે કારણ કે તેઓ થોડી વધુ જટિલતા છે.

130
00:08:03,340 --> 00:08:05,640
તે તદ્દન તરીકે 0 અને 1 ની આ ગ્રિડ તરીકે સરળ નથી;

131
00:08:05,640 --> 00:08:10,680
ને બદલે, તમે ફાઈલ શરૂઆતમાં હેડર જેવી વસ્તુઓ હોય છે.

132
00:08:10,680 --> 00:08:15,520
તેથી અન્ય શબ્દોમાં, એક bmp. ફાઈલ અંદર 0 અને 1 ની સંપૂર્ણ સમૂહ છે,

133
00:08:15,520 --> 00:08:18,070
પરંતુ કેટલીક વધારાની 0 અને 1 ત્યાં માં છે.

134
00:08:18,070 --> 00:08:21,450
અને તે તારણ છે કે અમે શું કદાચ માટે વર્ષ માટે મંજુર ભર્યું છે,

135
00:08:21,450 --> 00:08:27,040
ડૉક. અથવા. xls અથવા mp3. અથવા MP4. જેમ ફાઈલ બંધારણો,

136
00:08:27,040 --> 00:08:29,910
ફાઈલ બંધારણો કે જે તમે પરિચિત છો.

137
00:08:29,910 --> 00:08:31,900
વેલ, તે શું પણ નથી ફાઈલ બંધારણમાં હોવો અર્થ આ છે?

138
00:08:31,900 --> 00:08:35,740
દિવસ ના અંતે, કારણ કે આ બધી ફાઈલોને અમે ઉપયોગ કરે છે માત્ર 0 અને 1 ની

139
00:08:35,740 --> 00:08:39,950
અને કદાચ તે 0 અને 1 ની a, b, c ASCII અથવા જેમ દ્વારા પ્રતિનિધિત્વ

140
00:08:39,950 --> 00:08:42,030
પરંતુ દિવસના અંતે મારફતે, તે ફક્ત 0 અને 1 ની.

141
00:08:42,030 --> 00:08:45,300
>> તેથી માનવીઓ માત્ર ક્યારેક ક્યારેક એક નવી ફાઇલ ફોર્મેટ શોધ નક્કી

142
00:08:45,300 --> 00:08:49,420
જ્યાં તેઓ પ્રમાણિત બિટ્સની પેટર્ન શું ખરેખર અર્થ કરશે.

143
00:08:49,420 --> 00:08:52,790
અને આ અહીં કિસ્સામાં, લોકો જેઓ બીટમેપ ફાઇલ ફોર્મેટ માટે રચાયેલ

144
00:08:52,790 --> 00:08:58,260
કહ્યું હતું કે એક બીટમેપ ફાઇલ માં પહેલીવાર બાઇટ ખાતે, 0 ઓફસેટ દ્વારા સૂચિત, ત્યાં,

145
00:08:58,260 --> 00:09:02,320
ત્યાં કેટલાક રહસ્યમય નામવાળી ચલ કહેવાય bfType જ હશે,

146
00:09:02,320 --> 00:09:06,510
જે ફક્ત બીટમેપ ફાઇલ પ્રકાર માટે વપરાય છે; બીટમેપ ફાઇલ પ્રકાર આ શું છે.

147
00:09:06,510 --> 00:09:10,780
તમે અટકળ બાંધવી, કદાચ બીજા પંક્તિ કે 2 સરભર બાઇટ 2 નંબર કરી શકો છો,

148
00:09:10,780 --> 00:09:15,980
0 અને 1 ની છે કે શું પ્રતિનિધિત્વ એક પેટર્ન છે?

149
00:09:15,980 --> 00:09:18,320
કંઈક કદ, તે અને ત્યાંથી જાય છે.

150
00:09:18,320 --> 00:09:20,660
તેથી સમસ્યા 4 સમૂહ, તમે આ કેટલીક બાબતો દ્વારા ચાલ્યો આવશે.

151
00:09:20,660 --> 00:09:24,480
>> અમે સમાપ્ત તે બધા વિશે caring, પરંતુ નોટિસ તે રસપ્રદ વિચાર શરૂ થાય છે

152
00:09:24,480 --> 00:09:30,780
રેખા અથવા 54 બાઇટ, rgbtBlue લીલા, અને Red આસપાસ.

153
00:09:30,780 --> 00:09:35,280
જો તમે ક્યારેય ટૂંકાક્ષર RGB, લાલ લીલા વાદળી સાંભળ્યું કર્યું છે, તો આ સંદર્ભ છે.

154
00:09:35,280 --> 00:09:37,840
કારણ કે તે તારણ તમે સપ્તરંગી તમામ રંગો ચિતરવાનો કરી શકો છો

155
00:09:37,840 --> 00:09:41,580
લાલ અને વાદળી અને લીલા કેટલાક મિશ્રણ છે.

156
00:09:41,580 --> 00:09:46,560
અને હકીકતમાં, આ રૂમ માં માતા - પિતા વહેલામાં પ્રોજેક્ટરો કેટલાક યાદ શકે છે.

157
00:09:46,560 --> 00:09:49,360
આ દિવસોમાં, તો તમે માત્ર 1 તેજસ્વી પ્રકાશ એક લેન્સ બહાર આવતા જુઓ.

158
00:09:49,360 --> 00:09:52,870
પરંતુ એક દિવસ પાછા, તમે લાલ લેન્સ, વાદળી લેન્સ, અને ગ્રીન લેન્સ હતી

159
00:09:52,870 --> 00:09:56,620
અને સાથે સાથે તેઓ સ્ક્રીન ધ્યાનમાં રાખીને અને એક રંગીન ચિત્ર રચના કરી હતી.

160
00:09:56,620 --> 00:09:59,590
અને ઘણી વાર મધ્યમ શાળાઓ અને ઉચ્ચ શાળાઓમાં તે લેન્સ હશે

161
00:09:59,590 --> 00:10:02,680
વાંકું હંમેશા જેથી-સહેજ, તેથી તમે ડબલ અથવા ટ્રિપલ છબીઓ દેખાય જેવું હતા,

162
00:10:02,680 --> 00:10:07,500
પણ જે વિચાર હતો. તમે લાલ અને લીલો અને વાદળી ચિત્રો પ્રકાશ હતી.

163
00:10:07,500 --> 00:10:09,570
અને તે જ સિદ્ધાંત કમ્પ્યુટર્સ ઉપયોગ થાય છે.

164
00:10:09,570 --> 00:10:12,000
>> તેથી પડકારો વચ્ચે, પછી, તમારા માટે સમસ્યા માં 4 સેટ

165
00:10:12,000 --> 00:10:16,080
છે અમુક વસ્તુઓ હશે; એક ખરેખર એક છબી માપ બદલવાનું છે.

166
00:10:16,080 --> 00:10:18,050
માટે 0 અને 1 ની એક પેટર્ન લઇ,

167
00:10:18,050 --> 00:10:22,840
બહાર આંકડો 0 અને 1 ના હિસ્સામાં આ જેવા માળખામાં શું પ્રતિનિધિત્વ કરે છે,

168
00:10:22,840 --> 00:10:26,800
અને પછી બહાર આકૃતિ કેવી રીતે પિક્સેલ્સ નકલ કરવા માટે: આ રેડ્સ, બ્લૂઝ, તો ગ્રીન્સ

169
00:10:26,800 --> 00:10:32,460
જેથી અંદર જ્યારે ચિત્ર આ જેવા શરૂઆતમાં લાગે છે, આ જેવા કે પછી તેની જગ્યાએ જોવા શકે છે.

170
00:10:32,460 --> 00:10:35,590
અન્ય પડકારો વચ્ચે પણ હોય છે કે જે તમને સોંપી પડશે રહ્યું છે

171
00:10:35,590 --> 00:10:38,900
ડિજિટલ કૅમેરા એક એક વાસ્તવિક ફાઇલ ફોરેન્સિક છબી

172
00:10:38,900 --> 00:10:42,410
અને તે કેમેરા પર, એક વખત સમય પર, ફોટા સંપૂર્ણ સમૂહ હતા.

173
00:10:42,410 --> 00:10:47,030
આ સમસ્યા, અમે છે આકસ્મિક ભૂંસી અથવા હતી ઇમેજ કોઈક બગડી.

174
00:10:47,030 --> 00:10:51,040
ખરાબ વસ્તુઓ ડિજિટલ કેમેરા સાથે થાય છે, અને તેથી અમે ઝડપથી 0 અને 1 ના તમામ નકલ

175
00:10:51,040 --> 00:10:55,410
આ બોલ પર તમારા માટે કે કાર્ડ, 1 મોટી ફાઈલ તેમને બધા સેવ કરો, અને પછી અમે તેમને તમે સોંપવાની પડશે

176
00:10:55,410 --> 00:11:00,000
સમસ્યા માં 4 સેટ છે કે જેથી તમે સી એક કાર્યક્રમ કે જેની સાથે પુનઃપ્રાપ્ત લખી શકો છો

177
00:11:00,000 --> 00:11:02,660
તે JPEGs તમામ, આદર્શ.

178
00:11:02,660 --> 00:11:06,280
અને તે તારણ છે કે JPEGs છે, તેમ છતાં તેઓ એક જટિલ ફાઇલ ફોર્મેટ કંઈક અંશે કરશો,

179
00:11:06,280 --> 00:11:09,580
તેઓ વધુ આ સ્માઈલિંગ અહીં ચહેરો કરતાં જટિલ ખૂબ છો.

180
00:11:09,580 --> 00:11:14,320
તે તારણ છે કે જે દરેક JPEG 0 અને 1 ના જ તરાહો સાથે શરૂ થાય છે.

181
00:11:14,320 --> 00:11:18,820
તેથી, જ્યારે કે લૂપ અથવા સમાન માટે લૂપ ઉપયોગ કરીને,

182
00:11:18,820 --> 00:11:22,350
તમે બધા 0 અને આ ફોરેન્સિક છબી 1 ની ઉપર ફરી વળવું કરી શકો છો

183
00:11:22,350 --> 00:11:26,670
અને દરેક વખતે જ્યારે તમે વિશિષ્ટ પેટર્ન કે જે સમસ્યા હિસ્સો સેટ સ્પષ્ટીકરણમાં વ્યાખ્યાયિત છે જુઓ,

184
00:11:26,670 --> 00:11:29,770
તમે 'ઓહ, અહીં છે, ઘણી ઊંચી સંભાવના સાથે ધારણ કરી શકે છે,

185
00:11:29,770 --> 00:11:33,520
કોઈ JPEG શરૂઆત અને, 'જલદી તમે શોધી જ પેટર્ન,

186
00:11:33,520 --> 00:11:36,050
બાઇટ્સ અથવા કિલોબાઈટોમાં અથવા મેગાબાઇટ્સ કેટલાક પાછળથી નંબર,

187
00:11:36,050 --> 00:11:40,550
તમે ધારે Ooh, 'કરી શકો છો! અહીં એક બીજા JPEG, ફોટો હું પ્રથમ એક પછી લીધો છે.

188
00:11:40,550 --> 00:11:44,720
મને કે પ્રથમ ફાઈલ વાંચવાથી બંધ, આ એક નવી લેખિત શરૂ કરો. '

189
00:11:44,720 --> 00:11:49,980
અને 4 pset માટે તમારા કાર્યક્રમ નું આઉટપુટ ઘણા 50 તરીકે JPEGs પ્રયત્ન રહ્યું છે.

190
00:11:49,980 --> 00:11:52,400
અને જો તે 50 JPEGs નથી, તમે એક લૂપ એક બીટ છે.

191
00:11:52,400 --> 00:11:55,580
જો તમે JPEGs એક અનંત નંબર હોય, તમે એક અનંત લૂપ છે.

192
00:11:55,580 --> 00:11:58,280
જેથી, પણ, એક તદ્દન સામાન્ય કિસ્સો હશે.

193
00:11:58,280 --> 00:12:00,280
કે શું ક્ષિતિજ પર છે.

194
00:12:00,280 --> 00:12:03,740
>> 0 અમને પાછળ, ક્વિઝ. સમજો, મારા ઇમેઇલ દીઠ કે, અચૂક ત્યાં લોકો છે

195
00:12:03,740 --> 00:12:06,820
બંને તટસ્થ ખુશ સૉર્ટ કરો, અને ક્વિઝ આસપાસ ઉદાસી 0 સમય કોણ છે.

196
00:12:06,820 --> 00:12:10,160
કૃપા કરીને અને મને બહાર પહોંચે છે, માથા TFs, Zamyla, તમારી પોતાની ટીએફ નથી

197
00:12:10,160 --> 00:12:14,120
અથવા સીએએસ એક કે તમે જાણો છો જો તમે ચર્ચા વસ્તુઓ કેવી ગયા માંગો છો.

198
00:12:14,120 --> 00:12:16,460
>> જેથી માતા - પિતા પ્રભાવિત કરવા માટે અહીં ઓરડામાં,

199
00:12:16,460 --> 00:12:23,990
આ CS50 પુસ્તકાલય શું છે? ગુડ કામ.

200
00:12:23,990 --> 00:12:32,280
આ CS50 પુસ્તકાલય શું છે? યાહ? [વિદ્યાર્થી જવાબો, દુર્બોધ]

201
00:12:32,280 --> 00:12:35,730
>> ઠીક છે, સારુ. તેથી તે કોડ એક prewritten સમૂહ છે કે અમે તો, સ્ટાફ, લખ્યું હતું કે,

202
00:12:35,730 --> 00:12:38,460
અમે તમને પૂરી પાડે છે, માટે અમુક સામાન્ય કાર્યો પૂરા પાડે છે.

203
00:12:38,460 --> 00:12:42,290
સામગ્રી મને શબ્દમાળા મેળવવા ગમશે; મને પૂર્ણાંક વિચાર, જે કાર્યોને અંહિ યાદી થયેલ છે બધી.

204
00:12:42,290 --> 00:12:45,260
હવે શરૂ કરી રહ્યા છીએ, અમે ખરેખર આ તાલીમ વ્હીલ્સ લઇ બોલ શરૂ કરો.

205
00:12:45,260 --> 00:12:48,230
તેથી અમે દૂર તમે એક "શબ્દમાળા" લેવાની શરૂ જઈ રહ્યાં છો,

206
00:12:48,230 --> 00:12:52,790
જે, સ્મૃતિ, જે વાસ્તવિક માહિતી પ્રકાર માટે માત્ર એક પર્યાય હતો? ઘરનાં પરચૂરણ કામો *.

207
00:12:52,790 --> 00:12:57,020
જેથી માતા - પિતા માટે, તે કદાચ હતી - અને તે સારી છે, તેથી ઘરનાં પરચૂરણ કામો * અમે જોવા માટે શરૂ કરી શકશો

208
00:12:57,020 --> 00:13:00,810
સ્ક્રીન પર બધી વધુ આપણે શબ્દભંડોળ માંથી "શબ્દમાળા" દૂર કરવા માટે,

209
00:13:00,810 --> 00:13:02,760
ઓછામાં ઓછું જ્યારે તે વાસ્તવમાં કોડ લખવા માટે આવે છે.

210
00:13:02,760 --> 00:13:06,240
તેવી જ રીતે, અમે ખૂબ તરીકે આ વિધેયો કેટલાકનો ઉપયોગ કરીને બંધ થશે,

211
00:13:06,240 --> 00:13:08,390
કારણ કે અમારા કાર્યક્રમોનું વધુ વ્યવહારદક્ષ વિચાર જવું છે

212
00:13:08,390 --> 00:13:11,370
બદલે માત્ર કાર્યક્રમો કે જે પ્રોમ્પ્ટ ખીલેલું સાથે ત્યાં બેસવા લખો,

213
00:13:11,370 --> 00:13:13,580
વપરાશકર્તા માટે રાહ જોઈ રહ્યું સાઇન કંઈક લખો

214
00:13:13,580 --> 00:13:15,220
તમે બીજે ક્યાંકથી તમારી ઇનપુટ્સ મળશે.

215
00:13:15,220 --> 00:13:18,720
હમણાં પૂરતું, તમે તેમને સ્થાનિક હાર્ડ ડ્રાઇવ પર બિટ્સ શ્રેણીમાંથી મળશે.

216
00:13:18,720 --> 00:13:23,340
તમે તેના બદલે તેમને ભવિષ્યમાં મળશે નેટવર્ક જોડાણ છે, અમુક વેબસાઈટ ક્યાંક.

217
00:13:23,340 --> 00:13:27,460
તેથી પ્રથમ વખત આ સ્તર છાલ ચાલો, અને જે CS50 સાધન ખેંચવાનો

218
00:13:27,460 --> 00:13:32,300
અને આ CS50.h તરીકે ઓળખાતી ફાઈલ છે, કે જે તમે અઠવાડિયા માટે સહિત તીક્ષ્ણ હતા.

219
00:13:32,300 --> 00:13:34,380
>> દો પરંતુ ખરેખર શું આ અંદર છે.

220
00:13:34,380 --> 00:13:38,250
તેથી વાદળી માં ફાઇલ ટોચ માત્ર ટિપ્પણીઓ સંપૂર્ણ સમૂહ છે,

221
00:13:38,250 --> 00:13:41,340
વોરંટી માહિતી અને લાયસન્સ. આ એક સામાન્ય ફેરફાર જેવું છે

222
00:13:41,340 --> 00:13:44,600
સોફ્ટવેર, કારણ કે સોફ્ટવેર ઘણો આ દિવસોમાં છે જેને છે "ઓપન સોર્સ"

223
00:13:44,600 --> 00:13:46,940
જેનો અર્થ છે કે કોઈ વ્યક્તિ કોડ લખ્યું છે

224
00:13:46,940 --> 00:13:50,060
અને તે મુક્ત રીતે ઉપલબ્ધ કરવામાં, નહિં કે ખાલી સ્કોર અને ઉપયોગ કરવા માટે,

225
00:13:50,060 --> 00:13:53,660
પરંતુ ખરેખર વાંચવા અને બદલવા અને તમારું કામ સંકલિત.

226
00:13:53,660 --> 00:13:55,790
જેથી તમે શું ઉપયોગ કરી રહ્યો છું, ઓપન સોર્સ સોફ્ટવેર,

227
00:13:55,790 --> 00:13:58,030
જોકે ખૂબ જ નાના સ્વરૂપ છે.

228
00:13:58,030 --> 00:14:01,860
જો હું ટિપ્પણીઓ ભૂતકાળ સરકાવો, જોકે, અમે કેટલાક વધુ પરિચિત વસ્તુઓ જોવાનું શરૂ કરશો.

229
00:14:01,860 --> 00:14:08,090
તેથી અહીં ટોચ પર નોટિસ કે, CS50.h ફાઈલ હેડર ફાઈલો સંપૂર્ણ સમૂહ સમાવે છે.

230
00:14:08,090 --> 00:14:11,160
હવે, આ સૌથી અમે પહેલાં જોઈ છે, પરંતુ એક છે

231
00:14:11,160 --> 00:14:15,640
પરિચિત; આ જે અમે કરેલ છે, સંક્ષિપ્તમાં જોકે જોવા મળે છે, આમ અત્યાર સુધી?

232
00:14:15,640 --> 00:14:18,720
અરે વાહ, પ્રમાણભૂત લાઈબ્રેરીઓ. Stdlib.h malloc છે,

233
00:14:18,720 --> 00:14:21,590
તેથી એક વખત અમે ગતિશીલ મેમરી ફાળવણી વિશે વાત શરૂ કરી,

234
00:14:21,590 --> 00:14:24,960
જે અમે પાછા આગામી સપ્તાહ માટે પણ આવી પડશે, અમે તે ફાઈલ સહિત શરૂઆત કરી હતી.

235
00:14:24,960 --> 00:14:29,660
તે તારણ આપે છે કે bool અને સાચા અને ખોટા વાસ્તવમાં સી અસ્તિત્વમાં નથી, દીઠ સે,

236
00:14:29,660 --> 00:14:32,460
જ્યાં સુધી તમે આ ફાઇલને અહીં સમાવેશ થાય છે.

237
00:14:32,460 --> 00:14:35,770
તેથી અમે, અઠવાડિયા માટે, કરવામાં આવી પ્રમાણભૂત bool.h સહિત

238
00:14:35,770 --> 00:14:39,020
જેથી તમે એક bool, જે સાચું અથવા ખોટું. વિચારને ઉપયોગ કરી શકો છો

239
00:14:39,020 --> 00:14:41,830
આ વિના, તો તમે તેને નકલી ઓફ સૉર્ટ અને પૂર્ણાંક ઉપયોગ હશે

240
00:14:41,830 --> 00:14:45,920
અને માત્ર આપખુદ ધારે છે કે 0 ખોટું છે અને 1 સાચું છે.

241
00:14:45,920 --> 00:14:49,980
>> હવે, જો આપણે નીચે વધુ સ્ક્રોલ, અહીં શબ્દમાળા અમારી વ્યાખ્યા છે.

242
00:14:49,980 --> 00:14:54,820
તે તારણ, કારણ કે અમે પહેલાં જણાવ્યું હતું કે, કરી લીધી છે, કે જ્યાં આ * છે ખરેખર તો કોઈ વાંધો નથી.

243
00:14:54,820 --> 00:14:56,750
તમે પણ જગ્યા તમામ આસપાસ હોઈ શકે છે.

244
00:14:56,750 --> 00:15:01,550
અમે, આ સત્ર, આ આવ્યા છે તે પ્રોત્સાહન સ્પષ્ટ કરે છે કે જે * આ પ્રકાર સાથે કરી છે.

245
00:15:01,550 --> 00:15:05,370
પરંતુ ખ્યાલ, જેમ સામાન્ય, થોડું વધારે સામાન્ય હોય, તો તેને ત્યાં મૂકી છે

246
00:15:05,370 --> 00:15:07,480
પરંતુ વિધેયાત્મક રીતે તે જ વાત છે.

247
00:15:07,480 --> 00:15:11,070
પરંતુ હવે, જો આપણે નીચે વધુ વાંચો, ચાલો સકેં પર એક નજર GetInt લે છે,

248
00:15:11,070 --> 00:15:15,350
કારણ કે અમે તે કરવા માટે વપરાય છે, કદાચ બીજું કંઇ આ સત્ર પહેલાં.

249
00:15:15,350 --> 00:15:19,620
અને અહીં GetInt છે. આ શું છે?

250
00:15:19,620 --> 00:15:24,650
આ પ્રોટોટાઇપ છે. વારંવાર, અમે અમારી ની ટોચે પહોંચી અને અંતે પ્રોટોટાઇપ મૂકેલ છે કૈચ ફાઈલો.

251
00:15:24,650 --> 00:15:28,190
પરંતુ તમે પણ હેડર ફાઈલો, એચ. ફાઈલોમાં પ્રોટોટાઇપ મૂકી શકે છે,

252
00:15:28,190 --> 00:15:32,110
આ અહીં એક જેવી, કે જેથી જ્યારે તમે કેટલાક કાર્યો લખી

253
00:15:32,110 --> 00:15:36,790
કે જે તમે અન્ય લોકોને ઉપયોગ કરવાનો પ્રયત્ન કરવા માંગો છો, કે જે ચોક્કસ CS50 લાઇબ્રેરી સાથે કેસ છે,

254
00:15:36,790 --> 00:15:40,900
તમે માત્ર CS50.c કંઈક તમારા કાર્યો અમલમાં મૂકવા માટે,

255
00:15:40,900 --> 00:15:46,720
તમે પણ છે કે ફાઈલ ટોચ પર નથી પ્રોટોટાઇપ મૂકવા, પરંતુ એક હેડર ફાઈલ ટોચ પર,

256
00:15:46,720 --> 00:15:50,810
પછી તે હેડર ફાઈલ છે મિત્રો અને સહકર્મીઓ શું સમાવેશ થાય છે,

257
00:15:50,810 --> 00:15:52,800
તીક્ષ્ણ સાથે તેમના પોતાના કોડ માં સમાવેશ થાય છે.

258
00:15:52,800 --> 00:15:55,440
આ બધા સમય તેથી તમે આ પ્રોટોટાઇપ તમામ કરવામાં સહિત કર્યા છે

259
00:15:55,440 --> 00:15:59,870
અસરકારક રીતે તમારી ફાઈલ ટોચ પર છે, પરંતુ આ તીવ્ર રીતે પદ્ધતિ સમાવેશ થાય છે

260
00:15:59,870 --> 00:16:03,320
કે અનિવાર્યપણે નકલો અને pastes તમારા પોતાના આ ફાઇલ.

261
00:16:03,320 --> 00:16:06,400
હવે, અહીં કેટલીક એકદમ વિગતવાર દસ્તાવેજીકરણ છે.

262
00:16:06,400 --> 00:16:08,880
>> અમે ખૂબ ખૂબ માટે મંજૂર છે કે GetInt પૂર્ણાંક નોંધાયો ભર્યું છે,

263
00:16:08,880 --> 00:16:10,740
પરંતુ તે કેટલાક કિસ્સાઓમાં ખૂણે છે વળે અધિકાર?

264
00:16:10,740 --> 00:16:14,320
શું એ સંખ્યા છે કે રસ્તો ખૂબ મોટી છે જેમાં વપરાશકર્તા પ્રકારો જો?

265
00:16:14,320 --> 00:16:17,350
Quintillion એ, કે જે હમણાં જ પૂર્ણાંક ની અંદર ફિટ ન કરી શકે?

266
00:16:17,350 --> 00:16:21,180
અપેક્ષિત વર્તણૂક શું છે? વેલ, આદર્શ રીતે, તે ધારી છે.

267
00:16:21,180 --> 00:16:23,460
તેથી આ કિસ્સામાં, જો તમે વાસ્તવમાં સુંદર પ્રિન્ટ વાંચવા,

268
00:16:23,460 --> 00:16:27,850
તમે કે જો રેખા વાંચી શકાતી નથી, આ વળતર INT_MAX જોશો.

269
00:16:27,850 --> 00:16:30,800
અમે આ વિશે ક્યારેય વાત કરી, કર્યા છે, પરંતુ તેના કેપિટલાઈઝેશન પર આધારિત,

270
00:16:30,800 --> 00:16:33,030
તે શું કદાચ?

271
00:16:33,030 --> 00:16:36,610
તે સતત છે, તેથી તેમાં કેટલીક ખાસ સતત કે કદાચ જાહેર કરવામાં આવ્યું છે તે છે

272
00:16:36,610 --> 00:16:39,460
એક તે હેડર ફાઈલો છે કે જે ફાઈલ ઉચ્ચ અપ છે માં,

273
00:16:39,460 --> 00:16:43,400
અને INT_MAX કદાચ આશરે, જેમ 2 અબજ કંઈક છે.

274
00:16:43,400 --> 00:16:48,160
તે છે, કારણ કે અમે કોઈક કે જે કંઈક સૂચક જરૂર વિચાર ખોટું થયું,

275
00:16:48,160 --> 00:16:51,090
અમે, હા, અમારા નિકાલ અંતે 4 અબજ નંબરો છે,

276
00:16:51,090 --> 00:16:53,980
2 અબજ સુધી નેગેટિવ 2 બિલિયન આપવાનું અથવા લો.

277
00:16:53,980 --> 00:16:58,030
વેલ, પ્રોગ્રામિંગ સામાન્ય છે શું છે તમે માત્ર એક તે નંબરો ચોરી.

278
00:16:58,030 --> 00:17:02,250
0 કદાચ, કદાચ અબજ 2, કદાચ નકારાત્મક 2 અબજ.

279
00:17:02,250 --> 00:17:06,720
જેથી તમે તમારા એક શક્ય કિંમતો વિતાવે છે કે જેથી તમે વિશ્વને મોકલવું કરી શકો છો

280
00:17:06,720 --> 00:17:10,089
તે જો કંઈક ખોટું થાય, હું આ કિંમત સુપર મોટું આપશે.

281
00:17:10,089 --> 00:17:13,329
પરંતુ તમે વપરાશકર્તાને જેવા ભેદી કંઈક લખીને ન માંગતા "2, 3, 4 ..." નથી

282
00:17:13,329 --> 00:17:17,079
ખરેખર મોટી સંખ્યામાં છે, જ્યાં તમે સતત તરીકે બદલે સામાન્ય.

283
00:17:17,079 --> 00:17:19,380
તેથી ખરેખર, જો તમે ગુદા કરવામાં આવી રહી હતી, છેલ્લા થોડા અઠવાડિયા,

284
00:17:19,380 --> 00:17:23,800
ગમે ત્યારે, તમે GetInt કહી, તો તમે શરત જો સાથે કરવામાં આવી ચકાસણી કરીશું.

285
00:17:23,800 --> 00:17:27,109
INT_MAX માં વપરાશકર્તા પ્રકાર કર્યું, અથવા વધારે ચોક્કસ રીતે,

286
00:17:27,109 --> 00:17:29,900
GetInt વળતર INT_MAX હતી? કારણ કે જો તે કર્યું,

287
00:17:29,900 --> 00:17:35,140
કે જે વાસ્તવમાં એટલે તેઓ તેને ન લખો નહોતા; કંઈક આ કિસ્સામાં ખોટું થયું.

288
00:17:35,140 --> 00:17:38,970
તેથી આ એ છે જે સામાન્ય રીતે "સંત્રી" કિંમત છે, કે જે ફક્ત ખાસ અર્થ છે તરીકે ઓળખાય છે.

289
00:17:38,970 --> 00:17:41,020
>> વેલ, ચાલો હવે સી. ફાઈલો માટે બંધ છે.

290
00:17:41,020 --> 00:17:44,500
C ની ફાઈલ સાધન કેટલાક સમયથી અસ્તિત્વમાં છે,

291
00:17:44,500 --> 00:17:47,540
અને હકીકતમાં, આ સાધન તમારા માટે તે precompiled છે

292
00:17:47,540 --> 00:17:49,720
કે વસ્તુ માં અમે "પદાર્થ કોડ છે," કહેવાય છે

293
00:17:49,720 --> 00:17:52,940
પરંતુ તે માત્ર તમે નથી વાંધો જ્યાં તે છે, કારણ કે સિસ્ટમ જાણે નથી,

294
00:17:52,940 --> 00:17:54,780
આ કિસ્સામાં, જ્યાં તે છે, સાધન.

295
00:17:54,780 --> 00:18:00,620
દો પરંતુ નીચે હવે સરકાવવા માટે GetInt, અને જુઓ કે કેવી રીતે GetInt આ બધા સમય કાર્ય છે.

296
00:18:00,620 --> 00:18:02,380
અહીં અમે પહેલાં સમાન ટિપ્પણીઓ.

297
00:18:02,380 --> 00:18:04,930
દો મને ફક્ત કોડ ભાગ પર ઝૂમ,

298
00:18:04,930 --> 00:18:07,410
અને અમે GetInt માટે હોય શું નીચેના છે.

299
00:18:07,410 --> 00:18:12,770
તેને કોઈ ઇનપુટ લે છે અને તે પૂર્ણાંક આપે છે, જ્યારે (સત્ય) છે, તેથી અમે એક ઇરાદાપૂર્વકની અનંત લૂપ છે

300
00:18:12,770 --> 00:18:16,560
પરંતુ, કદાચ, અમે આ કોઈક ભંગ પડશે અથવા આ અંદર આવો.

301
00:18:16,560 --> 00:18:19,890
તેથી આપણે આ કેવી રીતે કામ કરે છે જુઓ. વેલ, અમે GetString ઉપયોગ કરી લાગે છે

302
00:18:19,890 --> 00:18:22,550
આ લૂપની, 166 અંદર આ પ્રથમ વાક્ય છે.

303
00:18:22,550 --> 00:18:25,320
આ હવે સારું આચરણ છે કારણ કે સંજોગો શું હેઠળ

304
00:18:25,320 --> 00:18:30,820
GetString આ ખાસ કીવર્ડ NULL, પરત કરી શકે છે?

305
00:18:30,820 --> 00:18:38,460
જો કશું ખોટું. શું ખોટું જાઓ ત્યારે તમે GetString કંઈક કહી શકે છે?

306
00:18:38,460 --> 00:18:42,550
યાહ? [વિદ્યાર્થી જવાબ, દુર્બોધ] >> યાહ. તેથી કદાચ malloc નિષ્ફળ જાય છે.

307
00:18:42,550 --> 00:18:45,310
હૂડ GetString નીચે ક્યાંક malloc કૉલ કરે છે,

308
00:18:45,310 --> 00:18:48,210
જે મેમરી ફાળવે છે, જે કોમ્પ્યુટર સ્ટોર કરવા દે છે

309
00:18:48,210 --> 00:18:50,950
અક્ષરો તમામ કીબોર્ડ માં વપરાશકર્તા પ્રકારો.

310
00:18:50,950 --> 00:18:53,270
ધારવું અને વપરાશકર્તા મફત સમય સંપૂર્ણ ઘણો હતો

311
00:18:53,270 --> 00:18:56,470
અને વધુ 2 અબજ અક્ષરો કરતાં દાખલા તરીકે, લખ્યો.

312
00:18:56,470 --> 00:18:59,600
કમ્પ્યુટર કરતા વધુ અક્ષરો પણ રેમ છે.

313
00:18:59,600 --> 00:19:02,350
વેલ, GetString માટે તમે તે દર્શાવવા કરવાનો પ્રયત્ન છે,

314
00:19:02,350 --> 00:19:05,650
પણ જો આ સુપર, સુપર અસાધારણ ખૂણા કેસ છે.

315
00:19:05,650 --> 00:19:08,490
તે કોઈક આ હેન્ડલ કરવાનો પ્રયત્ન હોય છે, અને તેથી GetString,

316
00:19:08,490 --> 00:19:11,850
જો અમે પાછા જાઓ અને તેના દસ્તાવેજો વાંચવા માટે, હકીકતમાં નથી, NULL આવો.

317
00:19:11,850 --> 00:19:16,150
હવે જો GetString NULL પરત દ્વારા કરવામાં નિષ્ફળ જાય, GetInt નિષ્ફળ રહ્યું છે

318
00:19:16,150 --> 00:19:19,370
INT_MAX એક સંત્રી તરીકે જ પરત દ્વારા.

319
00:19:19,370 --> 00:19:22,650
આ ફક્ત માનવ પ્રણાલિકા છે. આ માત્ર રસ્તો તમને આ ખબર હોત કિસ્સો છે

320
00:19:22,650 --> 00:19:24,840
દસ્તાવેજીકરણ વાંચન દ્વારા છે.

321
00:19:24,840 --> 00:19:28,200
તેથી આપણે જ્યાં પૂર્ણાંક ખરેખર છે GotInt સુધી સરકાવો.

322
00:19:28,200 --> 00:19:34,220
>> તેથી જો હું થોડુ વધુ સ્ક્રોલ, 170 લીટી માં અમે આ રેખાઓ ઉપર કોઈ ટિપ્પણી છે.

323
00:19:34,220 --> 00:19:38,470
તેથી અમે 172 માં જાહેર, n એ પૂર્ણાંક છે અને કોલસો બનાવો કેચ, અને પછી આ નવા કાર્ય

324
00:19:38,470 --> 00:19:41,870
જે તમને કેટલાક પહેલાં સમગ્ર ગયા છે, પરંતુ sscanf.

325
00:19:41,870 --> 00:19:44,190
આ શબ્દમાળા સ્કેન એફ માટે વપરાય છે.

326
00:19:44,190 --> 00:19:48,580
બીજા શબ્દોમાં કહીએ તો, મને શબ્દમાળા આપે છે અને હું તેને રસ માહિતી ટુકડાઓ માટે સ્કેન કરશે.

327
00:19:48,580 --> 00:19:53,820
જેથી શું અર્થ છે? વેલ ધારવું, કે હું કીબોર્ડ પર, શાબ્દિક, 2 1 3 લખો

328
00:19:53,820 --> 00:19:59,730
અને પછી દાખલ નહીં. 1 2 3 માહિતી પ્રકાર જ્યારે GetString દ્વારા પરત શું છે?

329
00:19:59,730 --> 00:20:05,010
તે દેખીતી રીતે શબ્દમાળા છે અધિકાર? હું એક શબ્દમાળા મળ્યું, જેથી 1 2 3 ખરેખર "1 2 3"

330
00:20:05,010 --> 00:20:07,260
આ \ તે ઓવરને અંતે 0 સાથે. કે પૂર્ણાંક નથી.

331
00:20:07,260 --> 00:20:10,420
કે જે નંબર નથી. તે નંબર જેવી લાગે છે, પરંતુ તે ખરેખર નથી.

332
00:20:10,420 --> 00:20:14,680
તેથી GetInt શું છે? તે કે ડાબેથી જમણે શબ્દમાળા સ્કેન ધરાવે છે,

333
00:20:14,680 --> 00:20:19,010
1 2 3 0 \, અને કોઈક તે વાસ્તવિક પૂર્ણાંક રૂપાંતરિત કરો.

334
00:20:19,010 --> 00:20:21,010
હવે, તમે આકૃતિ આ કેવી રીતે કરવું શકે છે.

335
00:20:21,010 --> 00:20:24,240
જો તમે 2 pset પાછા લાગે, તો તમે કદાચ થોડો આરામદાયક મળ્યું

336
00:20:24,240 --> 00:20:26,810
સીઝર અથવા vigenere સાથે જેથી તમે ઉપર શબ્દમાળા ફરી વળવું કરી શકો છો,

337
00:20:26,810 --> 00:20:29,800
તમે અક્ષરો પિક સાથે ints કન્વર્ટ કરી શકો છો. જે કામ સંપૂર્ણ ઘણું.

338
00:20:29,800 --> 00:20:32,800
Sscanf જેમ કાર્ય કરે છે જે તમારા માટે કરે છે જે કેમ નથી કહી?

339
00:20:32,800 --> 00:20:37,520
તેથી sscanf આ વાક્ય કહેવાય કેસ છે, કે જે શબ્દમાળા છે એક દલીલ, અપેક્ષા રાખી છે.

340
00:20:37,520 --> 00:20:41,310
પછી તમે અવતરણ માં સ્પષ્ટ, ખૂબ printf માટે સમાન,

341
00:20:41,310 --> 00:20:44,960
તમે શું આ શબ્દમાળાને જુઓ અપેક્ષા છે?

342
00:20:44,960 --> 00:20:52,980
હું અહીં કહી રહ્યો છું શું છે, મને અક્ષાંશ નંબર અને કદાચ એક અક્ષર જુઓ અપેક્ષા.

343
00:20:52,980 --> 00:20:54,990
અને અમે શા માટે આ માત્ર એક ક્ષણ માં કેસ છે જોશો.

344
00:20:54,990 --> 00:20:58,440
તે તારણ આપે છે કે આ સંકેત હવે સામગ્રી યાદ અપાવે

345
00:20:58,440 --> 00:21:00,840
અમે ફક્ત પહેલા એક અઠવાડિયા વિશે વાત શરૂ કરી.

346
00:21:00,840 --> 00:21:05,430
>> શું છે અને n અને કેચ એન્ડ અમને માટે અહીં કરી? [વિદ્યાર્થી જવાબો, દુર્બોધ]

347
00:21:05,430 --> 00:21:07,610
>> યાહ. તે મને અને સી એન સરનામું સરનામા આપ્યા છે.

348
00:21:07,610 --> 00:21:10,440
હવે, કે જે મહત્વપૂર્ણ શા માટે છે? સારું, તમે જાણો છો કે સી માં વિધેયો સાથે

349
00:21:10,440 --> 00:21:13,440
તમે હંમેશા અથવા કોઈ કિંમત કિંમત પરત ફરી શકે છે.

350
00:21:13,440 --> 00:21:16,630
તમે પૂર્ણાંક, શબ્દમાળા, એક ફ્લોટ, ચાર રચે છે, ગમે પાછા આવી શકો છો.

351
00:21:16,630 --> 00:21:21,150
અથવા તમે રદબાતલ પરત શકો છો, પરંતુ માત્ર 1 વસ્તુ વધુમાં પાછા આવી શકો છો.

352
00:21:21,150 --> 00:21:26,100
પરંતુ, અહીં આપણે sscanf મને પાછા કદાચ પૂર્ણાંક, એક અક્ષાંશ નંબર માંગો છો,

353
00:21:26,100 --> 00:21:29,240
અને પણ ચાર રચે છે, અને હું એક ક્ષણ માં શા માટે ઘરનાં પરચૂરણ કામો સમજાવવું પડશે.

354
00:21:29,240 --> 00:21:34,250
તેથી તમે અસરકારક રીતે એફ 2 વસ્તુઓ પરત કરવા માંગો છો, તે સી માં ફક્ત શક્ય નથી

355
00:21:34,250 --> 00:21:38,460
તેથી કે જે તમને આસપાસ 2 સરનામાંઓ માં પસાર કરીને કામ કરી શકે છે,

356
00:21:38,460 --> 00:21:43,710
કારણ કે વહેલી તકે તમે એક કાર્ય 2 સરનામાં હાથથી, કે જે કાર્ય તેમની સાથે કરી શકો છો?

357
00:21:43,710 --> 00:21:49,880
તે પેલા સરનામાં પર લખી શકો છો. તમે * કામગીરી ઉપયોગ કરે છે અને તે દરેક સરનામાંને "ત્યાં જાઓ" કરી શકે છે.

358
00:21:49,880 --> 00:21:54,320
આ ગુપ્ત પદ્ધતિ જેવું છે, પરંતુ ખૂબ વેરિયેબલ્સ કિંમતો બદલવા માટે સામાન્ય

359
00:21:54,320 --> 00:21:58,020
આ 2 કેસ માં ફક્ત 1 સ્થળ કરતાં વધુ છે.

360
00:21:58,020 --> 00:22:04,590
હવે, હું to1 == માટે ચકાસે છું, અને પછી n પરત જો કે, વાસ્તવમાં નથી, સાચી માટે મૂલ્યાંકન નોટિસ.

361
00:22:04,590 --> 00:22:09,340
તેથી શું થઈ રહ્યું છે? વેલ, ટેકનીકલી, બધા અમે ખરેખર GetInt માં થાય છે કરવા માંગો છો આ છે.

362
00:22:09,340 --> 00:22:12,340
અમે પાર્સ, તેથી વાત કરવા માંગો છો; અમે શબ્દમાળા વાંચી માંગો છો

363
00:22:12,340 --> 00:22:16,210
"1 2 3" અને લાગે છે કે ત્યાં એક નંબર હોય,

364
00:22:16,210 --> 00:22:21,360
અમે sscanf કહેવાની રહ્યા છો શું મારા માટે આ ચલ n એ છે કે નંબર, 2 3 1, મૂકી છે.

365
00:22:21,360 --> 00:22:26,060
શા માટે, તે પછી, હું આ જ રીતે મળી?

366
00:22:26,060 --> 00:22:33,750
પણ જણાવ્યું હતું કે, sscanf, તમે પણ એક અક્ષર અહીં વિચાર શકે ભૂમિકા શું છે.

367
00:22:33,750 --> 00:22:36,890
[વિદ્યાર્થી બોલવા, દુર્બોધ] જવાબ નથી >> - એક દશાંશ બિંદુ કામ કરી શકે છે.

368
00:22:36,890 --> 00:22:40,650
ચાલો માને છે કે એક ક્ષણ માટે આવે છે. બીજું શું?

369
00:22:40,650 --> 00:22:42,570
[વિદ્યાર્થી, દુર્બોધ] તેથી >>, સારા વિચાર, તે NULL પાત્ર હોઈ શકે છે.

370
00:22:42,570 --> 00:22:44,970
આ કેસમાં ખરેખર નથી. યાહ? [વિદ્યાર્થી, દુર્બોધ]

371
00:22:44,970 --> 00:22:47,100
>> >> ASCII. અથવા દો, મને પણ વધુ સામાન્ય રીતે.

372
00:22:47,100 --> 00:22:49,670
આ% ત્યાં કો ભૂલ ચકાસણી માટે જ છે.

373
00:22:49,670 --> 00:22:52,510
અમે ત્યાં ન કરવા માંગો છો સંખ્યા પછી પાત્ર નથી,

374
00:22:52,510 --> 00:22:54,980
પરંતુ આ મને શું કરવા માટે પરવાનગી આપે શું નીચેના છે:

375
00:22:54,980 --> 00:23:01,270
તે તારણ આપે છે કે sscanf, n અને c કિંમતો આ અહીં ઉદાહરણમાં, સ્ટોર ઉપરાંત,

376
00:23:01,270 --> 00:23:08,170
તે શું છે પણ એ નથી કે તે ચલો સંખ્યા આપે છે તે ચકાસણી કિંમતો મૂકી

377
00:23:08,170 --> 00:23:13,330
તેથી જો તમે માત્ર 1 2 3 લખો, પછી માત્ર% d સાથે મેળ રહ્યું છે

378
00:23:13,330 --> 00:23:18,830
અને માત્ર n 1 2 3 જેવી કિંમત સાથે સંગ્રહિત નહીં અને કંઈ કેચ મૂકવા નહીં;

379
00:23:18,830 --> 00:23:20,870
કૈચ એક કચરો કિંમત રહે છે, તેથી વાત કરવા માટે.

380
00:23:20,870 --> 00:23:23,550
કચરો કારણ કે તેમાં કેટલીક કિંમત તરીકે ક્યારેય આરંભ છે.

381
00:23:23,550 --> 00:23:29,390
જેથી કિસ્સામાં, sscanf 1 આપે છે, કારણ કે હું એક તે પોઇંટરો ઓફ રચાયેલ,

382
00:23:29,390 --> 00:23:33,650
, કે જે કિસ્સામાં મહાન. હું પૂર્ણાંક હોય છે, તેથી હું રેખા મુક્ત કરવા માટે મેમરી મુક્ત

383
00:23:33,650 --> 00:23:37,150
GetString કે વાસ્તવમાં ફાળવવામાં અને પછી હું n આવો.

384
00:23:37,150 --> 00:23:42,210
બાકી, જો તમે ક્યારેય વિસ્મય જ્યાં કે ફરી પ્રયાસ નિવેદન પરથી આવે છે, અહીં આવે છે.

385
00:23:42,210 --> 00:23:45,770
જો તેનાથી વિપરિત, હું 2 3 1 foo માં લખો

386
00:23:45,770 --> 00:23:48,640
ફક્ત ટેક્સ્ટ કેટલાક રેન્ડમ ક્રમ, sscanf જોવા માટે રહ્યું છે,

387
00:23:48,640 --> 00:23:51,500
ooh, નંબર, ooh, નંબર, ooh, નંબર, ooh - એફ.

388
00:23:51,500 --> 00:23:54,190
અને તે n માંના 1 2 3 મૂકી રહ્યું છે.

389
00:23:54,190 --> 00:23:59,970
તે કેચ માં એફ મૂકી, અને પછી 2 પરત ચાલી રહ્યું છે.

390
00:23:59,970 --> 00:24:02,980
તેથી અમે હોય છે, ફક્ત scanf વર્તન મૂળ વ્યાખ્યા વાપરી રહ્યા હોય,

391
00:24:02,980 --> 00:24:06,170
ખૂબ જ સરળ રીત છે -, પ્રથમ નજરમાં જટિલ છે, પરંતુ દિવસ ઓવરને અંતે,

392
00:24:06,170 --> 00:24:11,460
કહેતા એકદમ સરળ પદ્ધતિ, પૂર્ણાંક ત્યાં છે, અને તેથી જો હોય છે, તે જ વસ્તુ કે હું મળ્યું?

393
00:24:11,460 --> 00:24:14,950
અને સફેદ અહીં જગ્યા ઇરાદાપૂર્વકની છે. જો તમે sscanf માટે દસ્તાવેજીકરણ વાંચો,

394
00:24:14,950 --> 00:24:18,690
તે છે કે જે તમને જો તમે શરૂઆત અથવા ઓવરને અંતે સફેદ જગ્યા એક ટુકડો સમાવેશ થાય છે, તે કહે છે

395
00:24:18,690 --> 00:24:24,990
sscanf ખૂબ વપરાશકર્તા માટે પરવાનગી આપે છે, કારણ ગમે તે માટે કરશે, 2 3 1 spacebar ફટકો છે, અને તે કાયદેસર હશે.

396
00:24:24,990 --> 00:24:28,310
તે વપરાશકર્તા નથી કિકિયારી માત્ર કારણ કે તેઓ શરૂઆતમાં અથવા અંતે spacebar ફટકો પડશે,

397
00:24:28,310 --> 00:24:32,160
જે થોડી વપરાશકર્તા મૈત્રીપૂર્ણ વધુ છે.

398
00:24:32,160 --> 00:24:34,160
>> કોઈપણ પ્રશ્નો હોય, તો પછી, GetInts પર? યાહ?

399
00:24:34,160 --> 00:24:36,820
[વિદ્યાર્થી પ્રશ્ન, દુર્બોધ]

400
00:24:36,820 --> 00:24:40,740
>> ગુડ પ્રશ્ન. જો તમે માત્ર એક કોલસો બનાવો માં લખ્યો, એફ સફળતા, અને જેમ દાખલ

401
00:24:40,740 --> 00:24:47,830
અત્યાર 1 2 3 લખીને વિના; તમે શું વિચારો છો કોડ આ વાક્ય વર્તણૂક પછી હશે?

402
00:24:47,830 --> 00:24:50,500
તેથી sscanf કે ખૂબ આવરી શકે છે, કારણ કે તે કિસ્સામાં,

403
00:24:50,500 --> 00:24:56,280
તે n અથવા કેચ ભરી નથી ચાલી રહ્યું છે; તે જગ્યાએ 0 પાછા જવાનું છે.

404
00:24:56,280 --> 00:25:01,540
જે કિસ્સામાં, હું પણ છે કે જે પરિસ્થિતિ મોહક છું, કારણ કે અપેક્ષિત કિંમત હું માંગો છો 1 છે.

405
00:25:01,540 --> 00:25:07,310
હું માત્ર 1 માંગો છો, અને ફક્ત 1 વસ્તુ ભરી શકાય છે. પ્રશ્ન સારું. અન્ય?

406
00:25:07,310 --> 00:25:09,610
>> બધા હક છે, તેથી દો અહીં ના બધા વિધેયોને પસાર છે નથી,

407
00:25:09,610 --> 00:25:11,820
પરંતુ એક કે જે હોઇ શકે છે, કદાચ બાકી રસ, લાગે છે

408
00:25:11,820 --> 00:25:14,530
છે GetString કારણ કે તે તારણ આપે છે કે GetFloat, GetInt,

409
00:25:14,530 --> 00:25:19,490
GetDouble, બધા વાંસડા વડે એવી હોડી ચલાવવી તેમના GetString માટે વિધેય ઘણો GetLongLong.

410
00:25:19,490 --> 00:25:22,860
તેથી આપણે કેવી રીતે તેઓ અહીં અમલમાં મૂકાયેલ છે પર એક નજર.

411
00:25:22,860 --> 00:25:27,040
આ એક થોડો જટિલ લાગે છે પરંતુ તે જ ફંડામેન્ટલ્સ ઉપયોગ કરે છે

412
00:25:27,040 --> 00:25:29,680
કે અમે છેલ્લા અઠવાડિયે વાત શરૂ કરી. તેથી GetString માં,

413
00:25:29,680 --> 00:25:32,670
જે રદબાતલ દીઠ કોઇ દલીલ અહીં લે છે,

414
00:25:32,670 --> 00:25:37,110
અને તે શબ્દમાળા આપે છે; જેથી હું એક બફર તરીકે ઓળખાય શબ્દમાળા જાહેર છું.

415
00:25:37,110 --> 00:25:39,670
હું ખરેખર છે કે શું હજી માટે ઉપયોગ કરી રહ્યું છે તે ખબર નથી, પરંતુ અમે જોશો.

416
00:25:39,670 --> 00:25:42,950
ક્ષમતા જેવા દેખાવની મૂળભૂત 0 છે, છે; ખાતરી જ્યાં આ રહ્યું છે તદ્દન.

417
00:25:42,950 --> 00:25:44,920
ખાતરી કરો n શું હજી માટે ઉપયોગ કરી રહ્યું છે તે નથી.

418
00:25:44,920 --> 00:25:47,860
પરંતુ હવે તે થોડું વધુ રસપ્રદ દર્શાશે 243 લીટી તેથી,

419
00:25:47,860 --> 00:25:51,760
અમે પૂર્ણાંક કેચ, આ મૂર્ખ વિગતવાર જેવું છે જાહેર.

420
00:25:51,760 --> 00:25:58,080
એક કોલસો બનાવો 8 બીટ્સ છે, અને 8 બીટ્સ કેટલા અલગ અલગ કિંમતો સ્ટોર કરી શકો છો?

421
00:25:58,080 --> 00:26:03,310
256. સમસ્યા એ છે કે, જો તમે 256 વિવિધ ASCII અક્ષરો માંગો છો,

422
00:26:03,310 --> 00:26:06,210
જે ત્યાં છે, જો તમે પાછા લાગે છે, અને આ માટે યાદ કંઈક નથી.

423
00:26:06,210 --> 00:26:09,100
પરંતુ જો તમે કે મોટા ASCII ચાર્ટ પર પાછા લાગે છે અમે અઠવાડિયા પહેલા હતી,

424
00:26:09,100 --> 00:26:13,780
ત્યાં તે કિસ્સામાં, 128 અથવા 256 ASCII અક્ષરો હતા.

425
00:26:13,780 --> 00:26:16,220
અમે 0 ની તમામ નમૂનાઓ અને 1 અપ છે વપરાય છે.

426
00:26:16,220 --> 00:26:19,410
કે સમસ્યા છે જો તમે કોઈ ભૂલ શોધવા કરવાનો પ્રયત્ન કરવા માંગો છો.

427
00:26:19,410 --> 00:26:23,290
જો તમે પહેલાથી જ તમારી અક્ષરો માટે કરી રહ્યાં છો 256 કિંમતો મદદથી કારણ કે,

428
00:26:23,290 --> 00:26:26,390
તમે ખરેખર આગળ યોજના ઘડી ન હતી, કારણ કે હવે તમે કહેતા કોઈ રીત નથી,

429
00:26:26,390 --> 00:26:29,750
"આ એક વંચાય અક્ષર નથી; આ અમુક ભૂલભરેલા સંદેશ છે."

430
00:26:29,750 --> 00:26:32,430
તેથી વિશ્વ કરે છે શું છે તેઓ આગામી સૌથી મોટી કિંમત ઉપયોગ,

431
00:26:32,430 --> 00:26:35,790
પૂર્ણાંક કંઈક છે કે જેથી તમે બીટ્સ એક ઉન્મત્ત નંબર હોય,

432
00:26:35,790 --> 00:26:39,610
32 4 અબજ શક્ય કિંમતો માટે, જેથી તમે ખાલી અંત મદદથી કરી શકો છો,

433
00:26:39,610 --> 00:26:44,800
અનિવાર્યપણે, 257 તેમાંના, 1 જે ભૂલ તરીકે અમુક ખાસ અર્થ હોય છે.

434
00:26:44,800 --> 00:26:49,190
>> તેથી આપણે આ કેવી રીતે કામ કરે છે જુઓ. 246 લીટી માં, હું આ મોટા જ્યારે લૂપ છે

435
00:26:49,190 --> 00:26:54,530
કે fgetc કૉલ કરે છે; એફ અર્થ ફાઇલ, getc અને પછી stdin ની.

436
00:26:54,530 --> 00:26:59,030
બહાર ફેંકે છે આ માત્ર કહેતા વધુ ચોક્કસ માર્ગ છે "કીબોર્ડ તરફથી ઇનપુટ વાંચો."

437
00:26:59,030 --> 00:27:02,730
માનક ઇનપુટ અર્થ કીબોર્ડ, પ્રમાણભૂત આઉટપુટ સ્ક્રીન અર્થ થાય છે,

438
00:27:02,730 --> 00:27:06,920
અને પ્રમાણભૂત ભૂલ છે, કે જે અમે 4 pset માં જોશો, સ્ક્રિન અર્થ થાય છે,

439
00:27:06,920 --> 00:27:09,670
પરંતુ સ્ક્રીન એક ખાસ ભાગ કે જેથી તે ન સંકલિત છે

440
00:27:09,670 --> 00:27:13,760
ખરેખર ઉત્પાદન કે તમે છાપવાનો ઈરાદો સાથે; પણ ભવિષ્યમાં પર વધુ.

441
00:27:13,760 --> 00:27:19,430
તેથી fgetc માત્ર અર્થ એ થાય કે કીબોર્ડ એક અક્ષર વાંચી, અને તે સ્ટોર જ્યાં?

442
00:27:19,430 --> 00:27:24,000
તે કેચ માં સ્ટોર કરો, અને પછી તપાસો, જેથી હું માત્ર કેટલાક બુલિયન conjunctions છું અહીં વાપરી રહ્યા હોય,

443
00:27:24,000 --> 00:27:28,430
તપાસો કે તે \ સમાન n એ, જેથી વપરાશકર્તા દાખલ ફટકારી છે નથી.

444
00:27:28,430 --> 00:27:31,510
અમે તે બિંદુ, લૂપની ઓવરને અંતે રોકવા માંગો છો, અને અમે પણ તપાસો કરવા માંગો છો

445
00:27:31,510 --> 00:27:36,170
માટે ખાસ સતત, EOF છે, કે જે જો તમને ખબર હોય અથવા ધારી - તે શું માટે ઊભા કરે છે?

446
00:27:36,170 --> 00:27:39,860
ફાઇલ અંત થાય છે. તેથી આ વાહિયાત પ્રકારની હોય છે, કારણ કે જો હું કીબોર્ડ લખીને છું,

447
00:27:39,860 --> 00:27:41,900
ત્યાં ખરેખર કોઈ આ સામેલ ફાઈલ છે,

448
00:27:41,900 --> 00:27:44,330
પરંતુ આ માત્ર સામાન્ય અર્થ ઉપયોગ ગાળાની સૉર્ટ છે

449
00:27:44,330 --> 00:27:50,320
કે બીજું કંઇ તે માનવ આંગળીઓમાંથી આવી રહ્યું છે. EOF. ફાઇલ અંત થાય છે.

450
00:27:50,320 --> 00:27:52,600
એક અલગ તરીકે, જો તમે ક્યારેય તમારા કીબોર્ડ પર કર્યું છે અંકુશ ડી દબાવો,

451
00:27:52,600 --> 00:27:54,680
તમે હજુ સુધી કે નહિ; તમે નિયંત્રણ કો હિટ થઈ છે.

452
00:27:54,680 --> 00:27:57,920
પરંતુ નિયંત્રણ ડી આ ખાસ સતત કહેવાય EOF મોકલે છે.

453
00:27:57,920 --> 00:28:03,100
>> તેથી હવે અમે માત્ર કેટલાક ગતિશીલ મેમરી ફાળવણી છે.

454
00:28:03,100 --> 00:28:06,460
તેથી જો n + 1 ક્ષમતા> છે, હવે હું n એ સમજાવવું પડશે.

455
00:28:06,460 --> 00:28:09,380
n એ માત્ર કેટલા બાઇટ્સ એ બફર છે હાલમાં,

456
00:28:09,380 --> 00:28:11,970
શબ્દમાળા કે જે તમે હાલમાં વપરાશકર્તા હોવ મકાન.

457
00:28:11,970 --> 00:28:16,240
જો તમે તમારા બફર વધુ અક્ષરો હોવા કરતાં તમે બફર માં ક્ષમતા છે,

458
00:28:16,240 --> 00:28:20,760
તર્ક, અમે તો પછી જરૂર શું વધુ ક્ષમતા ફાળવી છે.

459
00:28:20,760 --> 00:28:24,490
હું ઉપર અંકગણિત કેટલાક અહીં મલાઈહીન જાઉં છું

460
00:28:24,490 --> 00:28:26,900
અને આ કાર્ય પર જ ધ્યાન કેન્દ્રિત અહીં.

461
00:28:26,900 --> 00:28:29,170
તમે જાણો છો malloc શું છે, અથવા ઓછામાં ઓછા સામાન્ય રીતે પરિચિત.

462
00:28:29,170 --> 00:28:32,380
એક અનુમાન realloc શું કરે છે લો. [વિદ્યાર્થી જવાબ, દુર્બોધ]

463
00:28:32,380 --> 00:28:35,690
>> યાહ. અને તે તદ્દન મેમરી નથી ઉમેરીને છે, તે નીચે પ્રમાણે મેમરી reallocates:

464
00:28:35,690 --> 00:28:40,530
જો હજી પણ શબ્દમાળા ઓવરને અંતે રૂમ છે કે જે તમને મેમરી વધુ આપી છે

465
00:28:40,530 --> 00:28:43,370
કરતાં તે મૂળ તમને, તો પછી તમે તે વધારાના મેમરી મળશે.

466
00:28:43,370 --> 00:28:46,640
જેથી તમે માત્ર શબ્દમાળાઓ અક્ષરો પાછા મૂકવા શકે છે માટે બેકઅપ બેકઅપ બેક.

467
00:28:46,640 --> 00:28:49,290
પરંતુ જો કે આ કેસ નથી, કારણ કે તમે ખૂબ લાંબો સમય waited

468
00:28:49,290 --> 00:28:51,700
અને રેન્ડમ કંઈક મળી મેમરીમાં ત્યાં plopped, પરંતુ વધારે છે

469
00:28:51,700 --> 00:28:56,480
અહીં નીચે મેમરી, કે ઠીક છે. Realloc માટે તમે બધી ભારે પ્રશિક્ષણ કરી રહ્યું છે,

470
00:28:56,480 --> 00:28:58,810
શબ્દમાળા તમે વાંચ્યા છે તેથી અહીં દૂર ખસેડવા માટે,

471
00:28:58,810 --> 00:29:02,550
તે મૂકી નીચે ત્યાં અને પછી તમે તે સમયે કેટલાક વધુ રનવે આપે છે.

472
00:29:02,550 --> 00:29:05,610
જેથી હાથ પ્રવાહ સાથે દો, મને કહે છે કે શું GetString કરી છે

473
00:29:05,610 --> 00:29:09,540
છે તે એક નાના બફર, કદાચ 1 એકલ અક્ષર સાથે શરૂ છે,

474
00:29:09,540 --> 00:29:12,300
અને 2 અક્ષરો વપરાશકર્તા પ્રકારો જો, GetString થાય

475
00:29:12,300 --> 00:29:15,210
realloc ફોન છે અને કહે છે, 'Ooh, 1 અક્ષર પૂરતા ન હતા.

476
00:29:15,210 --> 00:29:18,480
મને 2 અક્ષરો આપો. ' પછી જો તમે લૂપની તર્ક દ્વારા વાંચી,

477
00:29:18,480 --> 00:29:21,070
તે કહે છે, 'Ooh, આ 3 અક્ષરો ટાઇપ વપરાશકર્તા બનશે.

478
00:29:21,070 --> 00:29:25,690
મને આપો હવે 2 પરંતુ 4 અક્ષરો, પછી મને 8 આપો, પછી મને 16 અને 32 આપે છે. '

479
00:29:25,690 --> 00:29:28,180
હકીકત એ છે કે હું ક્ષમતા દરેક સમય બમણો છું

480
00:29:28,180 --> 00:29:30,320
અર્થ એ થાય કે બફર ધીમે ધીમે વિકસતું નથી જઈ રહ્યા છે.

481
00:29:30,320 --> 00:29:35,870
તે સુપર ઝડપી વૃદ્ધિ પામે ચાલી રહ્યું છે, અને તે શું છે તે લાભ હોઇ શકે?

482
00:29:35,870 --> 00:29:38,540
હું બફર માપ શા બમણી છું, તેમ છતાં વપરાશકર્તા

483
00:29:38,540 --> 00:29:41,450
ફક્ત 1 કીબોર્ડ માંથી વધારાના પાત્ર કરવાની જરૂર પડી શકે?

484
00:29:41,450 --> 00:29:44,830
[વિદ્યાર્થી જવાબ, દુર્બોધ]. >> શું કે શું છે?

485
00:29:44,830 --> 00:29:46,750
બરાબર. તમે તેને ઘણી વાર વધવા નથી.

486
00:29:46,750 --> 00:29:48,870
અને આ એક માત્ર પ્રકારની છે - you're તમારા બેટ્સ અહીં હેજિંગ.

487
00:29:48,870 --> 00:29:54,150
આ વિચાર એ હતો કે તમે ખૂબ realloc કહી ન માગો કારણ કે તે ધીમું હોઈ શકે છે.

488
00:29:54,150 --> 00:29:56,840
કોઈપણ સમયે તમે મેમરી માટે ઓપરેટિંગ સિસ્ટમ પૂછો, જેમ તમે જલદી જોઈ શકશો

489
00:29:56,840 --> 00:30:00,620
ભવિષ્યના સમસ્યા સમૂહ, તે થોડો સમય લે છે.

490
00:30:00,620 --> 00:30:04,980
સમય કે રકમ ઘટાડીને, જો તમે અમુક જગ્યા બગાડ કરી રહ્યાં છીએ તેથી, માટે સારી વાત હોય શકે છે.

491
00:30:04,980 --> 00:30:07,250
>> પરંતુ જો આપણે GetString અંતિમ ભાગ મારફતે અહીં વાંચો,

492
00:30:07,250 --> 00:30:10,880
અને ફરી, દરેક એક વાક્ય અહીં સમજવા જેથી મહત્વપૂર્ણ આજે નથી.

493
00:30:10,880 --> 00:30:14,830
નોટિસ પણ છે કે તે આખરે malloc ફરીથી કહે છે, અને તે ફાળવે છે

494
00:30:14,830 --> 00:30:16,980
બરાબર ઘણા બાઇટ્સ તરીકે તે શબ્દમાળા માટે જરૂર છે

495
00:30:16,980 --> 00:30:21,620
અને પછી મફત ફોન દ્વારા દૂર ફેંકી દે છે, જે વધુ પડતી મોટી બફર,

496
00:30:21,620 --> 00:30:23,510
જો તે ખરેખર ઘણી વાર બમણી મળ્યો છે.

497
00:30:23,510 --> 00:30:25,970
ટૂંકમાં, કે કેવી રીતે GetString આ બધા સમય કાર્ય છે.

498
00:30:25,970 --> 00:30:30,100
બધા તેને એક સમયે એક અક્ષર વંચાય છે ફરી અને ફરી ફરી

499
00:30:30,100 --> 00:30:37,930
અને દર વખતે તે કેટલીક વધારાની મેમરી જરૂર છે, તેને માટે realloc ફોન દ્વારા ઓપરેટિંગ સિસ્ટમ પૂછે છે.

500
00:30:37,930 --> 00:30:41,660
કોઈપણ પ્રશ્ન છે? અધિકાર છે.

501
00:30:41,660 --> 00:30:45,220
>> હુમલો. હવે અમે પોઇંટરો સમજવા, અથવા ઓછામાં ઓછું

502
00:30:45,220 --> 00:30:47,560
પોઇન્ટર સાથે વધુને વધુ પરિચિત હોય છે,

503
00:30:47,560 --> 00:30:50,020
ચાલો ધ્યાનમાં કેવી રીતે સમગ્ર વિશ્વમાં તૂટી શરૂ થાય છે

504
00:30:50,020 --> 00:30:53,160
જો તમે તદ્દન વિરોધી વપરાશકર્તાઓ સામે નથી કોઈ રન નોંધાયો નહીં નથી,

505
00:30:53,160 --> 00:30:55,180
જે લોકો તમારી સિસ્ટમ માં હેક કરવાનો પ્રયાસ કરવામાં આવે છે.

506
00:30:55,180 --> 00:31:00,260
જે લોકો માટે કેટલીક નોંધણી કોડ circumventing દ્વારા તમારા સોફ્ટવેર ચોરી કરવાનો પ્રયાસ કરી રહ્યા છે

507
00:31:00,260 --> 00:31:02,150
કે તેઓ અન્યથા સાઇન લખો હોય શકે છે

508
00:31:02,150 --> 00:31:04,860
આ ઉદાહરણમાં પર એક નજર અહીં લો, જે ફક્ત સી કોડ છે

509
00:31:04,860 --> 00:31:07,920
કે તળિયે મુખ્ય કાર્ય છે, કે જે કાર્ય foo કહે છે,

510
00:31:07,920 --> 00:31:12,100
અને તે શું foo માટે પસાર થાય છે? એક દલીલ [વિદ્યાર્થી].

511
00:31:12,100 --> 00:31:15,660
>> બનાવ્યો દલીલ. તેથી argv [1] છે, કે જે પ્રથમ શબ્દ વપરાશકર્તા ટાઇપ અર્થ થાય છે

512
00:31:15,660 --> 00:31:19,150
a.out અથવા જે પછી આદેશ વાક્ય પર કાર્યક્રમ તરીકે ઓળખાય છે.

513
00:31:19,150 --> 00:31:24,920
Foo તેથી, ટોચ પર, ચાર રચે છે * લે છે, પરંતુ ઘરનાં પરચૂરણ કામો * ફક્ત શું છે?

514
00:31:24,920 --> 00:31:28,860
સ્ટ્રિંગ. તેમાં નવા કશું અહીં છે, અને કે જેઓ શબ્દમાળા આપખુદ બાર છે કહેવાય રહ્યું છે.

515
00:31:28,860 --> 00:31:36,090
આ અહીં લીટી માં, ચાર કેચ [12], અર્ધ તકનીકી ઇંગલિશ જેવું માં, આ લીટી શું કરે છે?

516
00:31:36,090 --> 00:31:40,640
અરે -? અક્ષરો. મને 12 અક્ષરો ઝાકઝમાળ આપો.

517
00:31:40,640 --> 00:31:44,970
તેથી અમે એક બફર આ કૉલ શકે છે. તે ટેકનિકલી કેચ કહેવાય છે, પરંતુ પ્રોગ્રામિંગ એક બફર

518
00:31:44,970 --> 00:31:47,890
માત્ર જગ્યા સમૂહ છે કે જે તમને કેટલીક સામગ્રી સાઇન મૂકી શકો છો એનો અર્થ એ થાય

519
00:31:47,890 --> 00:31:49,940
>> પછી છેલ્લે memcpy, અમે પહેલાં ઉપયોગ કર્યો છે.

520
00:31:49,940 --> 00:31:52,380
પરંતુ તમે કદાચ ધારી તે શું કરે છે કરી શકો છો. તે મેમરી નકલ કરે છે.

521
00:31:52,380 --> 00:31:58,790
તે શું કરે છે? વેલ, તે દેખીતી રીતે બાધ નકલ કરે છે, તેના ઇનપુટ કો માં,

522
00:31:58,790 --> 00:32:03,420
પરંતુ માત્ર અપ બાર લંબાઈ છે.

523
00:32:03,420 --> 00:32:07,440
પરંતુ અહીં એક ભૂલ છે.

524
00:32:07,440 --> 00:32:14,500
ઠીક છે, તેથી અમે તકનીકી ખરેખર strlen કરવું (બાર) કરીશું એક્સ (કોલસો) sizeof, તે સાચું છે.

525
00:32:14,500 --> 00:32:17,920
પરંતુ ખરાબ અહીં કિસ્સામાં, ચાલો કે that's ધારે છે - તેથી, ઠીક છે.

526
00:32:17,920 --> 00:32:23,760
તો પછી ત્યાં 2 ભૂલો છે. તેથી (કોલસો) sizeof, બધા અધિકાર, ચાલો આ થોડું વિશાળ બનાવે છે.

527
00:32:23,760 --> 00:32:28,860
તેથી હવે ત્યાં હજી પણ ભૂલ, કે જે શું છે શું છે?

528
00:32:28,860 --> 00:32:31,630
[વિદ્યાર્થી જવાબ, દુર્બોધ] શું >> તપાસ? ઠીક છે, તેથી અમે ચકાસણી થવી જોઈએ

529
00:32:31,630 --> 00:32:35,010
NULL માટે, કારણ કે ખરાબ વસ્તુઓ થાય છે જ્યારે તમારું નિર્દેશક NULL છે,

530
00:32:35,010 --> 00:32:38,490
કારણ કે તમે અંત ત્યાં જઈ, શકે અને તમે ક્યારેય નહીં કરી શકે નલ જઈને જોઈએ

531
00:32:38,490 --> 00:32:40,890
તે * ઓપરેટર સાથે dereferencing દ્વારા.

532
00:32:40,890 --> 00:32:45,250
જેથી સારી છે, અને બીજું શું આપણે કરી રહ્યા છે? તાર્કિક રીતે ત્યાં ભૂલ અહીં પણ છે.

533
00:32:45,250 --> 00:32:47,650
[વિદ્યાર્થી જવાબ, દુર્બોધ]

534
00:32:47,650 --> 00:32:51,340
>> તેથી જો argc ≥ 2 તપાસો?

535
00:32:51,340 --> 00:32:54,130
ઠીક છે, જેથી આ કાર્યક્રમમાં 3 ભૂલો અહીં છે.

536
00:32:54,130 --> 00:33:00,080
અમે જો વપરાશકર્તા ખરેખર [1] argv સારું, માં કંઈપણ માં ટાઇપ નથી ચકાસણી કરી રહ્યા છીએ.

537
00:33:00,080 --> 00:33:02,240
તેથી ત્રીજા ભૂલ શું છે? યાહ?

538
00:33:02,240 --> 00:33:04,420
[વિદ્યાર્થી જવાબ, દુર્બોધ] ગુડ. >>

539
00:33:04,420 --> 00:33:09,590
તેથી અમે એક દૃશ્ય ચકાસાયેલ. અમે સર્વથા ચકાસાયેલ નથી વધુ મેમરી નકલ નથી

540
00:33:09,590 --> 00:33:12,800
કરતાં બાર લંબાઈ કરતાં વધી જશે.

541
00:33:12,800 --> 00:33:15,720
તેથી શબ્દમાળા જો માં લખ્યો વપરાશકર્તા 10 અક્ષરો લાંબો છે,

542
00:33:15,720 --> 00:33:18,260
આ કહેતા છે, 'માત્ર 10 અક્ષરો નકલ કરો.'

543
00:33:18,260 --> 00:33:21,140
અને તે ઠીક છે, પરંતુ જો આ પ્રોમ્પ્ટ પર એક શબ્દ માં લખ્યો વપરાશકર્તા

544
00:33:21,140 --> 00:33:29,360
એક 20 અક્ષર શબ્દ છે; આ છે, પટ્ટીમાંથી શું માં નકલ 20 અક્ષરો કહેતા?

545
00:33:29,360 --> 00:33:32,840
કૈચ, અન્યથા અમારા બફર તરીકે ઓળખાય છે, જેનો અર્થ છે તમે હમણાં જ માહિતી લખ્યું હતું

546
00:33:32,840 --> 00:33:35,950
8 બાઇટ સ્થળો કે જે તમે પોતાની ન કરવું,

547
00:33:35,950 --> 00:33:38,320
અને તમે તેમને સૂઝ કે તમે ફાળવવામાં તેમને ક્યારેય નહીં માલિકી નથી.

548
00:33:38,320 --> 00:33:41,190
તેથી આ એ છે જે સામાન્ય રીતે બફર ઓવરફ્લો હુમલા તરીકે ઓળખાય છે,

549
00:33:41,190 --> 00:33:46,650
અથવા બફર રોળાઈ હુમલો, અર્થમાં અને તે હુમલો કે જો વપરાશકર્તાને

550
00:33:46,650 --> 00:33:50,650
અથવા કાર્યક્રમ છે કે જે તમારા કાર્ય ફોન છે આ દ્વેષપૂર્વક કરી છે,

551
00:33:50,650 --> 00:33:53,780
શું ખરેખર આગામી તદ્દન ખરાબ હોઇ શકે છે બને છે.

552
00:33:53,780 --> 00:33:55,690
>> ચાલો આ ચિત્ર પર એક નજર અહીં લે છે.

553
00:33:55,690 --> 00:33:59,070
આ ચિત્ર મેમરી તમારા સ્ટેક રજૂ કરે છે.

554
00:33:59,070 --> 00:34:01,050
યાદ છે અને તે દરેક સમયે તમે એક કાર્ય કહી,

555
00:34:01,050 --> 00:34:04,520
તમે સ્ટેક પર આ થોડો ફ્રેમ વિચાર અને અન્ય પછી અને પછી બીજા અને પછી બીજા.

556
00:34:04,520 --> 00:34:07,250
અને આમ જ્યાં સુધી આપણે માત્ર પ્રકારની કરેલા આ લંબચોરસ તરીકે દૂર શૂન્યમનસ્ક

557
00:34:07,250 --> 00:34:09,380
ક્યાં તો બોર્ડ પર અથવા અહીં સ્ક્રીન પર.

558
00:34:09,380 --> 00:34:12,219
પરંતુ જો આપણે એક તે ચોરસ આકારની પર ઝૂમ,

559
00:34:12,219 --> 00:34:16,460
જ્યારે તમે કાર્ય foo કહી, તે તારણ કે સ્ટેક પર વધુ છે

560
00:34:16,460 --> 00:34:18,739
કે ફ્રેમ અને તે લંબચોરસ ની અંદર

561
00:34:18,739 --> 00:34:23,370
કરતાં માત્ર એક્સ અને વાય અને a અને b, જેમ કે અમારી સ્વેપ વિશે વાત ન હતી.

562
00:34:23,370 --> 00:34:25,949
તે તારણ કે ત્યાં અમુક નીચી કક્ષાની વિગતો છે,

563
00:34:25,949 --> 00:34:27,780
તેમની વચ્ચે સરનામા આવો.

564
00:34:27,780 --> 00:34:33,020
તેથી તે તારણ જ્યારે મુખ્ય foo કહે છે, મુખ્ય foo જાણ છે

565
00:34:33,020 --> 00:34:36,760
ની મુખ્ય સરનામા શું કમ્પ્યુટરની મેમરી છે.

566
00:34:36,760 --> 00:34:40,659
અન્યથા, કારણ તરીકે foo જલદી આ અહીં કિસ્સામાં ચલાવી કરવામાં આવે છે,

567
00:34:40,659 --> 00:34:43,790
એકવાર તમે foo ઓવરને અંતે આ બંધ સર્પાકાર તાણવું પહોંચે છે,

568
00:34:43,790 --> 00:34:48,860
કેવી રીતે હેક foo જ્યાં કાર્યક્રમ નિયંત્રણ પર જાઓ માનવામાં આવે છે ખબર નથી?

569
00:34:48,860 --> 00:34:52,460
તે તારણ કે જે પ્રશ્નનો જવાબ છે કે લાલ અહીં લંબચોરસ છે.

570
00:34:52,460 --> 00:34:56,130
આ એક નિર્દેશક રજૂ કરે છે, અને તે કમ્પ્યુટર પર છે સંગ્રહવા માટે, કામચલાઉ,

571
00:34:56,130 --> 00:35:00,250
સ્ટેક કહેવાતા પર મુખ્ય ના જેથી તરીકે foo જલદી સરનામા ચલાવવા કરવામાં આવે છે,

572
00:35:00,250 --> 00:35:04,110
કમ્પ્યુટર જ્યાં અને મુખ્ય માં લીટી શું પાછળ જવા માટે જાણે છે.

573
00:35:04,110 --> 00:35:06,900
સાચવેલા ફ્રેમ નિર્દેશક આ જ સંબંધિત છે.

574
00:35:06,900 --> 00:35:09,620
ચાર * અહીં બાર શું પ્રતિનિધિત્વ?

575
00:35:09,620 --> 00:35:14,740
ઠીક છે, હવે આ વાદળી સેગમેન્ટમાં અહીં માતાનો foo ફ્રેમ હોય છે, બાધ શું છે?

576
00:35:14,740 --> 00:35:18,300
ઠીક છે, જેથી બાર ફક્ત foo કામ કરવા માટે દલીલ છે.

577
00:35:18,300 --> 00:35:20,720
>> તેથી હવે અમે પરિચિત ચિત્ર પર પાછા આવ્યા.

578
00:35:20,720 --> 00:35:22,960
ત્યાં વધુ અને સ્ક્રીન પર સામગ્રી વધુ વિક્ષેપોમાં છે

579
00:35:22,960 --> 00:35:27,490
પરંતુ આ આછો વાદળી સેગમેન્ટ છે, આપણે શું સ્વેપ કંઈક માટે કરેલા chalkboard પર રેખાંકન.

580
00:35:27,490 --> 00:35:31,890
કે foo અંતર્ગત ફ્રેમ અને તેને માત્ર એક જ વસ્તુ અધિકાર હવે બાર છે,

581
00:35:31,890 --> 00:35:34,630
જે આ પરિમાણ છે.

582
00:35:34,630 --> 00:35:39,840
પરંતુ બીજું શું સ્ટેક આ અહીં કોડ અનુસાર, હોવું જોઈએ?

583
00:35:39,840 --> 00:35:44,280
ચાર કો. [12] તેથી અમે પણ મેમરી 12 ચોરસ જોઈ શકવા જોઈએ,

584
00:35:44,280 --> 00:35:46,260
એક કેચ કહેવાય ચલ માટે ફાળવવામાં આવે છે.

585
00:35:46,260 --> 00:35:48,340
અને ખરેખર અમે સ્ક્રીન પર નથી.

586
00:35:48,340 --> 00:35:51,650
એકદમ ટોચ છે કૈચ પછી, અને આ રેખાકૃતિ લેખક [0]

587
00:35:51,650 --> 00:35:55,130
નહોતી સંતાપ પરંતુ વર્ગની તમામ ચિત્રકામ ત્યાં ખરેખર છે 12 ​​ત્યાં

588
00:35:55,130 --> 00:36:00,120
કારણ કે જો તમે નીચે જમણા ખૂણે જુઓ, કો [11], જો તમે 0 થી ગણતરી, 12 જેવી બાઇટ્સ છે.

589
00:36:00,120 --> 00:36:06,190
પરંતુ અહીં સમસ્યા છે: દિશામાં જેમાં કેચ વધતી જાય છે?

590
00:36:06,190 --> 00:36:10,390
નીચે ટોચના સૉર્ટ કરો, અધિકાર? જો તે ટોચ પર શરૂ થાય છે અને નીચે સુધી વિકાસ પામે છે,

591
00:36:10,390 --> 00:36:13,480
નથી નજર નથી જેવી અમે જાતને ખૂબ રનવે બાકી અહીં બધા છે.

592
00:36:13,480 --> 00:36:15,320
અમે પ્રકારની એક ખૂણામાં આવી છે જાતને પેઇન્ટિંગ,

593
00:36:15,320 --> 00:36:20,210
અને તે કેચ [11] બાર છે, કે જે સ્ટેક ફ્રેમ નિર્દેશક સામે અધિકાર છે સામે અધિકાર છે,

594
00:36:20,210 --> 00:36:23,800
જે પરત સરનામા સામે અધિકાર છે; ત્યાં વધુ જગ્યા નથી.

595
00:36:23,800 --> 00:36:26,100
તેથી સૂચિતાર્થ શું છે, તે પછી, જો તમે સ્ક્રૂ,

596
00:36:26,100 --> 00:36:30,460
અને તમે એક બફર 12-બાઇટ માં 20 બાઇટ્સ reading પ્રયાસ?

597
00:36:30,460 --> 00:36:33,460
તે 8 વધારાના બાઇટ્સ પર જાઓ જ્યાં જવું છે?

598
00:36:33,460 --> 00:36:36,370
બાકીનું બધું અંદર છે, કે જે અમુક મહત્વપૂર્ણ સુપર છે.

599
00:36:36,370 --> 00:36:40,480
અને સૌથી મહત્વની વસ્તુ, સંભવિત, લાલ બોક્સ ત્યાં છે, વળતર સરનામું.

600
00:36:40,480 --> 00:36:44,720
કારણ કે ધારો કે તમે ક્યાં તો અકસ્માતે કે adversarially છે

601
00:36:44,720 --> 00:36:48,040
તે 4 બાઇટ્સ, કે નિર્દેશક સરનામા પર ફરીથી લખી,

602
00:36:48,040 --> 00:36:53,190
માત્ર કચરો છે, પરંતુ એ સંખ્યા છે કે મેમરી એક વાસ્તવિક સરનામા પ્રતિનિધિત્વ બને તે નથી?

603
00:36:53,190 --> 00:36:55,930
આ implicaiton શું તાર્કિક રીતે?

604
00:36:55,930 --> 00:36:59,080
[વિદ્યાર્થી જવાબો, દુર્બોધ] ચોક્કસ. >> જ્યારે foo આપે છે

605
00:36:59,080 --> 00:37:03,560
અને હિટ સર્પાકાર તાણવું કે, આ કાર્યક્રમ માટે મુખ્ય પરત ન આગળ વધવું રહ્યું છે,

606
00:37:03,560 --> 00:37:08,320
તે સરનામું છે કે જે લાલ બોક્સમાં છે પાછા જવાનું છે.

607
00:37:08,320 --> 00:37:11,560
>> હવે, circumventing સોફ્ટવેર રજીસ્ટ્રેશન કિસ્સામાં,

608
00:37:11,560 --> 00:37:14,400
શું સરનામા માટે કરવામાં આવી રહી છે ફર્યા કાર્ય છે

609
00:37:14,400 --> 00:37:18,820
કે જે સામાન્ય પછી તમે સોફ્ટવેર માટે ચૂકવણી કરી છે કહેવાય નહીં અને તમારી નોંધણી કોડ ઇનપુટ?

610
00:37:18,820 --> 00:37:23,160
તમે કોમ્પ્યુટર યુક્તિ ઓફ જઈને અહીં પ્રવેશ સૉર્ટ આપી શકે, પરંતુ તેના બદલે, અહીં જઈ રહી છે.

611
00:37:23,160 --> 00:37:27,950
અથવા, જો તમે ખરેખર છો હોંશિયારીથી, વિરોધી ખરેખર કીબોર્ડ પર ટાઇપ કરી શકો છો,

612
00:37:27,950 --> 00:37:32,500
ઉદાહરણ માટે, વાસ્તવિક, એક શબ્દ ન બોલ્યા 20 ન અક્ષરો છે, પરંતુ કદાચ તે અથવા તેણી

613
00:37:32,500 --> 00:37:36,200
કેટલાક અક્ષરો કોડ પ્રતિનિધિત્વ પ્રકારો?

614
00:37:36,200 --> 00:37:38,860
અને તે માટે સી કોડ નથી ચાલી રહ્યું છે, તે અક્ષરો જ હશે

615
00:37:38,860 --> 00:37:42,920
કે દ્વિસંગી મશીન કોડ્સ 0 અને 1 ની પ્રતિનિધિત્વ કરે છે.

616
00:37:42,920 --> 00:37:46,740
ધારવું પરંતુ તેઓ પૂરતી હોંશિયાર કરવા કે, કોઈક તો GetString પ્રોમ્પ્ટ પેસ્ટ કરવા માટે કરશો

617
00:37:46,740 --> 00:37:49,460
કંઈક કે અનિવાર્યપણે કોડ કમ્પાઈલ છે,

618
00:37:49,460 --> 00:37:56,900
અને છેલ્લા 4 બાઇટ્સ કે વળતર સરનામા પર ફરીથી લખી છે, અને સરનામા શું કે ઇનપુટ શું કરે છે?

619
00:37:56,900 --> 00:38:01,860
આ લાલ લંબચોરસ એ બફર પ્રથમ બાઇટ ની સરનામું સંગ્રહ કરે છે.

620
00:38:01,860 --> 00:38:04,270
જેથી તમે ખરેખર હોંશિયાર હોય છે, અને આ અજમાયશ અને ભૂલની ઘણો છે

621
00:38:04,270 --> 00:38:08,500
ત્યાં બહાર ખરાબ લોકો છે, પરંતુ, જો તમે બહાર આકૃતિ મોટું કેવી રીતે આ બફર છે માટે

622
00:38:08,500 --> 00:38:12,170
જેમ કે ઇનપુટ છેલ્લા થોડા બાઇટ્સ કે તમે કાર્યક્રમ માટે પૂરી પાડે છે

623
00:38:12,170 --> 00:38:15,970
તમારા બફર શરૂઆત ના સરનામા માટે સમકક્ષ હોઈ થાય છે,

624
00:38:15,970 --> 00:38:22,270
તમે આ કરી શકો છો. જો આપણે કહેવું, સામાન્ય રીતે, હેલ્લો, અને 0 \, કે શું બફર માં પૂર્ણ થાય છે.

625
00:38:22,270 --> 00:38:27,860
પરંતુ જો આપણે વધુ હોંશિયાર છીએ, અને અમે અમે શું સામાન્ય હુમલો કોડ કહી શકશો કે બફર ભરી,

626
00:38:27,860 --> 00:38:31,920
એ, એ, એ, જ: હુમલો, હુમલો, હુમલો, હુમલો, જ્યાં આ માત્ર કંઈક છે જે કંઈ ખરાબ કરે છે.

627
00:38:31,920 --> 00:38:35,190
વેલ, શું થાય છે જો તમે ખરેખર છો હોંશિયારીથી, તમે આ કરી શકે છે:

628
00:38:35,190 --> 00:38:41,740
80, CO, 35, 08: લાલ અહીં બૉક્સમાં ક્રમાંકોની શ્રેણી છે.

629
00:38:41,740 --> 00:38:44,890
નોંધ કરો કે કે નંબર છે કે જે અહીં મેળ ખાય છે.

630
00:38:44,890 --> 00:38:47,280
તે રિવર્સ ક્રમમાં છે, પરંતુ તે અન્ય કેટલાક સમય પર વધારે.

631
00:38:47,280 --> 00:38:51,430
નોંધ કરો કે આ વળતર સરનામા ઇરાદાપૂર્વક બદલાઈ ગયેલ છે

632
00:38:51,430 --> 00:38:54,970
આ સરનામાંને જેટલી અહીં, મુખ્ય નથી સરનામું.

633
00:38:54,970 --> 00:39:00,170
તેથી જો ખરાબ વ્યક્તિ સુપર સ્માર્ટ છે, તે અથવા તેણી સમાવેશ થાય છે કે હુમલો કોડ થઇ રહ્યું છે

634
00:39:00,170 --> 00:39:02,890
કંઈક જેમ, 'વપરાશકર્તાની બધી ફાઈલોને કાઢી નાખો.'

635
00:39:02,890 --> 00:39:06,320
અથવા 'પાસવર્ડ નકલ કરો,' અથવા 'વપરાશકર્તા ખાતું કે હું પ્રવેશી શકે છે.'

636
00:39:06,320 --> 00:39:10,130
બધા અંતે કંઈપણ; અને આ બંને જોખમ અને સી શક્તિ છે

637
00:39:10,130 --> 00:39:12,900
કારણ કે તમે પોઇંટરો મારફતે મેમરી વપરાશ હોય છે

638
00:39:12,900 --> 00:39:15,950
અને તમે તેથી જો તમે કંઈપણ એક કમ્પ્યુટર મેમરીમાં માંગો છો લખી શકો છો.

639
00:39:15,950 --> 00:39:19,290
તમે કરી શકો છો કમ્પ્યુટર કંઈપણ તમે ખાલી કરવા માંગો છો દ્વારા કરવું

640
00:39:19,290 --> 00:39:22,780
એવું તેની પોતાની મેમરી જગ્યા અંદર આસપાસ કૂદી.

641
00:39:22,780 --> 00:39:27,230
અને તેથી, આ દિવસ માટે, જેથી ઘણા પ્રોગ્રામો અને ઘણા વેબસાઇટ્સ કે ગડબડ છે

642
00:39:27,230 --> 00:39:29,730
આ લાભ લેતા લોકો માટે ઉકાળીને પ્રમાણ ઘટાડવું.

643
00:39:29,730 --> 00:39:32,510
અને આ હુમલો સુપર વ્યવહારદક્ષ જેવી લાગે,

644
00:39:32,510 --> 00:39:34,220
પરંતુ તે હંમેશા કે માર્ગ શરૂ થતું નથી.

645
00:39:34,220 --> 00:39:36,770
>> આ વાસ્તવિકતા એ છે કે ખરાબ લોકો ખાસ કરીને કરશે શું છે,

646
00:39:36,770 --> 00:39:41,470
શું તે આદેશ વાક્ય પર એક કાર્યક્રમ અથવા GUI કાર્યક્રમ અથવા વેબસાઇટ છે,

647
00:39:41,470 --> 00:39:43,290
છે તમે હમણાં નોનસેન્સ પૂરી કરવાનું શરૂ કરો.

648
00:39:43,290 --> 00:39:46,940
તમે શોધ ક્ષેત્ર દાખલ કરો અને સફળ એક ખરેખર મોટી શબ્દ લખો,

649
00:39:46,940 --> 00:39:49,030
અને તમે તે જોવા માટે વેબસાઇટ ક્રેશ થઈ જાય તો રાહ જુઓ.

650
00:39:49,030 --> 00:39:53,270
અથવા તમે એ જોવા માટે જો કાર્યક્રમ કેટલાક ભૂલ સંદેશો મેનીફેસ્ટ રાહ જુઓ.

651
00:39:53,270 --> 00:39:55,480
જો તમે નસીબદાર વિચાર તરીકે, કારણ કે ખરાબ વ્યક્તિ,

652
00:39:55,480 --> 00:39:59,610
અને તમે કેટલીક ઉન્મત્ત ઇનપુટ કે કાર્યક્રમ ક્રેશ પૂરી પાડે છે,

653
00:39:59,610 --> 00:40:02,280
તેનો અર્થ એ કે એ પ્રોગ્રામર તમારા ખરાબ વર્તન પૂર્વાનુમાન ન હતી

654
00:40:02,280 --> 00:40:05,420
જે તમને કદાચ કરી શકો છો પર્યાપ્ત પ્રયાસ સાથે, એનો અર્થ એ થાય

655
00:40:05,420 --> 00:40:09,870
પર્યાપ્ત ટ્રાયલ અને ભૂલ, બહાર આકૃતિ કેવી રીતે વધુ ચોક્કસ હુમલો વિશે છે.

656
00:40:09,870 --> 00:40:15,900
જેથી ખૂબ સુરક્ષા એક ભાગ માત્ર આ હુમલાઓને ટાળવા નથી છે એકસાથે, પરંતુ તેમને શોધવા

657
00:40:15,900 --> 00:40:20,250
અને ખરેખર લોગ્સ પર નજર અને જોયા ઉન્મત્ત ઇનપુટ્સ શું તમારી વેબસાઇટ પર ટાઇપ કરવામાં આવતું લોકો હોય છે.

658
00:40:20,250 --> 00:40:26,040
શોધ શબ્દો શું કેટલાક બફર વહેતું આશા લોકો તમારી વેબસાઇટ પર ટાઇપ કરવામાં આવતું?

659
00:40:26,040 --> 00:40:28,900
અને આ શું ઝાકઝમાળ છે, જે માટે સામાન્ય મૂળભૂતો બધા નીચે ઉકળે,

660
00:40:28,900 --> 00:40:32,510
અને તે શું માટે ફાળવો અને મેમરીનો ઉપયોગ અર્થ છે?

661
00:40:32,510 --> 00:40:34,920
અને તે સંબંધિત, પણ, આ છે.

662
00:40:34,920 --> 00:40:37,520
>> તેથી આપણે માત્ર એક હાર્ડ ડ્રાઈવ ની અંદર હજુ સુધી ફરી ચમકારો કરવો.

663
00:40:37,520 --> 00:40:40,190
તેથી તમે યાદ પહેલા અઠવાડિયામાં એક અથવા બે કે જ્યારે તમે ફાઇલોને ખેંચો

664
00:40:40,190 --> 00:40:45,470
તમારા રીસાઇકલ બિન અથવા કચરો કરી શકો છો, શું થાય છે?

665
00:40:45,470 --> 00:40:47,850
[વિદ્યાર્થી] કંઈ નથી. >> અરે વાહ, સંપૂર્ણપણે કંઈ નથી. આખરે જો તમે નીચા સ્કોર

666
00:40:47,850 --> 00:40:51,370
ડિસ્ક જગ્યા પર, વિન્ડોઝ અથવા મેક ઓએસ તમે ફાઇલો માટે કાઢી નાંખવા શરૂ થશે.

667
00:40:51,370 --> 00:40:53,670
પરંતુ જો તમે ત્યાં કંઈક ખેંચો, પછી તે તમામ સલામત ન હતું.

668
00:40:53,670 --> 00:40:56,550
તમારા roomate મિત્ર, અથવા કુટુંબ સભ્ય કરવું બધા ડબલ ક્લિક કરો છે અને વોઇલા Query.

669
00:40:56,550 --> 00:40:59,720
ત્યાં બધા ઉપરછલ્લા ફાઈલો કે જે તમે કાઢી નાંખવા પ્રયાસ કર્યો છે.

670
00:40:59,720 --> 00:41:02,840
અમને મોટા ભાગના જેથી ઓછામાં ઓછા જાણે છે કે તમે યોગ્ય ક્લિક કરો અથવા ક્લિક કરો નિયંત્રણ છે

671
00:41:02,840 --> 00:41:05,320
અને ખાલી ટ્રૅશમાં, અથવા તે કંઈક.

672
00:41:05,320 --> 00:41:07,900
પણ પછી, તે તદ્દન યુક્તિ કરતું નથી.

673
00:41:07,900 --> 00:41:11,340
કારણ કે શું થાય છે જ્યારે તમે તમારી હાર્ડ ડ્રાઇવ પર ફાઇલ હોય

674
00:41:11,340 --> 00:41:14,590
કે અમુક શબ્દ દસ્તાવેજ અથવા અમુક JPEG રજૂ?

675
00:41:14,590 --> 00:41:18,820
અને આ તમારી હાર્ડ ડ્રાઈવ રજૂ કરે છે, અને આપણે કહેવું આ અહીં sliver કે ફાઈલ રજૂ કરે છે,

676
00:41:18,820 --> 00:41:21,640
અને તે 0 અને 1 ની સંપૂર્ણ જથ્થો બનેલા છે.

677
00:41:21,640 --> 00:41:25,470
શું થાય છે જ્યારે તમે કચરાપેટી Name અથવા રીસાઇકલ બિન કે ફાઈલ માત્ર નથી ખેંચો,

678
00:41:25,470 --> 00:41:30,390
પણ તે ખાલી?

679
00:41:30,390 --> 00:41:32,820
કશું ના ક્રમમાં ગોઠવો. તે સંપૂર્ણપણે કશું હવે નથી.

680
00:41:32,820 --> 00:41:37,630
હવે તે ફક્ત કશું, કારણ કે થોડા કંઈક આ ટેબલ સ્વરૂપમાં થાય છે.

681
00:41:37,630 --> 00:41:41,170
તેથી ત્યાં એક કમ્પ્યુટર મેમરી ની અંદર ડેટાબેઝ અથવા ટેબલ કેટલાક પ્રકારની છે

682
00:41:41,170 --> 00:41:44,470
કે અનિવાર્યપણે ફાઈલો નામો માટે 1 સ્તંભ છે,

683
00:41:44,470 --> 00:41:50,550
અને ફાઈલ સ્થાન છે, જ્યાં આ 123 સ્થાન, ફક્ત રેન્ડમ નંબર હોઇ શકે છે માટે 1 સ્તંભ.

684
00:41:50,550 --> 00:41:58,270
તેથી અમે x.jpg કંઈક, અને 123 સ્થાન હોય છે.

685
00:41:58,270 --> 00:42:02,870
અને શું તે પછી શું થાય છે, જ્યારે તમે તમારી ટ્રૅશમાં ખાલી?

686
00:42:02,870 --> 00:42:06,720
કે દૂર જાય છે. પરંતુ દૂર જવા નથી શું 0 અને 1 ની છે.

687
00:42:06,720 --> 00:42:09,690
>> તેથી શું, પછી, આ જોડાણ માટે 4 pset?

688
00:42:09,690 --> 00:42:13,460
વેલ 4 pset સાથે, માત્ર કારણ કે અમે આકસ્મિક ભૂંસી કર્યા છે

689
00:42:13,460 --> 00:42:15,890
કોમ્પેક્ટ ફ્લેશ કાર્ડ છે કે આ બધા ફોટા હતા,

690
00:42:15,890 --> 00:42:18,710
અથવા માત્ર કારણ કે તે ખરાબ નસીબ દ્વારા દૂષિત બની હતી,

691
00:42:18,710 --> 00:42:21,170
નથી તેનો અર્થ નથી કે 0 અને 1 ની હજુ પણ ત્યાં નથી.

692
00:42:21,170 --> 00:42:23,920
કદાચ થોડા કારણ કે કંઈક બગડી ગયું છે ખોવાઈ જાય છે

693
00:42:23,920 --> 00:42:26,530
અર્થમાં કે અમુક 0 હિસ્સો 1 અને 1 હિસ્સો બની 0 હિસ્સો બની ગયા.

694
00:42:26,530 --> 00:42:30,460
ખરાબ વસ્તુઓ બગડેલ સોફ્ટવેર અથવા હાર્ડવેર ખામીયુક્ત કારણે થાય છે.

695
00:42:30,460 --> 00:42:33,510
પરંતુ તે બિટ્સ ઘણા, કદાચ તેમને 100% પણ હજુ ત્યાં છે,

696
00:42:33,510 --> 00:42:38,330
તે ફક્ત કમ્પ્યૂટર અથવા કૅમેરા જ્યાં JPEG 1 શરૂ ખબર નથી

697
00:42:38,330 --> 00:42:41,660
અને જ્યાં JPEG 2 શરૂ જો, પરંતુ તમે, પ્રોગ્રામર,

698
00:42:41,660 --> 00:42:45,800
સમજશકિત એક બીટ છે, જ્યાં તે JPEGs છે અથવા તેઓ શું દેખાશે સાથે ખબર છે,

699
00:42:45,800 --> 00:42:49,570
તમે 0 અને 1 ની વિશ્લેષણ અને કહે છે, 'Ooh કરી શકો છો. JPEG. Ooh, JPEG. '

700
00:42:49,570 --> 00:42:52,830
તમે અનિવાર્યપણે માટે માત્ર એક સાથે એક પ્રોગ્રામ લખવા કરી શકો છો અથવા જ્યારે લૂપ

701
00:42:52,830 --> 00:42:56,100
કે જે તે ફાઈલો દરેક અને દરેક એક ધક્કામાંથી.

702
00:42:56,100 --> 00:42:59,360
તેથી પાઠ પછી, શરૂ કરવા "સુરક્ષિત" તમારી ફાઇલોને ભૂંસી નાખી છે

703
00:42:59,360 --> 00:43:01,720
જો તમે આ સંપૂર્ણપણે ટાળવા માંગો છો. હા?

704
00:43:01,720 --> 00:43:06,940
[વિદ્યાર્થી પ્રશ્ન, દુર્બોધ]

705
00:43:06,940 --> 00:43:11,150
>> વધુ મેમરી કરતાં તમે પહેલા કરી હતી છે -

706
00:43:11,150 --> 00:43:14,790
ઓહ! પ્રશ્ન સારું. શા માટે તેથી, તો પછી ટ્રૅશ ખાલી પછી,

707
00:43:14,790 --> 00:43:18,300
નથી તમારા કમ્પ્યુટર તમે કહો કે તમે વધુ મુક્ત જગ્યા કરતાં તમે પહેલાં કર્યું છે?

708
00:43:18,300 --> 00:43:22,450
ટૂંકમાં, કારણ કે તે પડેલો છે. વધુ તકનીકી, તમે વધુ જગ્યા નથી.

709
00:43:22,450 --> 00:43:26,720
કારણ કે હવે તમે કહ્યું હોય, તો તમે અન્ય સામગ્રી મૂકવામાં જ્યાં તે ફાઇલ એક વખત થઇ હતી,

710
00:43:26,720 --> 00:43:28,930
પરંતુ તેનો અર્થ એ નથી કે બિટ્સ દૂર જવું છે,

711
00:43:28,930 --> 00:43:33,070
અને એનો અર્થ એ નથી કે બિટ્સ બધા 0 હિસ્સો બદલાઈ રહ્યાં છે, દાખલા તરીકે તમારા રક્ષણ માટે.

712
00:43:33,070 --> 00:43:37,520
તેનાથી વિરુદ્ધ, જો તમે "સુરક્ષિત" ભૂંસી ફાઈલો, અથવા ભૌતિક ઉપકરણ નષ્ટ

713
00:43:37,520 --> 00:43:40,810
કે ખરેખર માત્ર રસ્તો છે, ક્યારેક કે આસપાસ.

714
00:43:40,810 --> 00:43:45,300
તેથી અમે નોંધ અર્ધ ડરામણી પર શા માટે છોડી નથી, અને અમે તમને સોમવાર પર જોશે.

715
00:43:45,300 --> 00:43:52,810
CS50.TV