1
00:00:00,000 --> 00:00:02,490
[Powered by Google Translate] [CS50 લાયબ્રેરી]

2
00:00:02,490 --> 00:00:04,220
[Nate Hardison] [હાર્વર્ડ યુનિવર્સિટી]

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

4
00:00:07,260 --> 00:00:11,510
આ CS50 પુસ્તકાલય મદદરૂપ સાધન છે કે અમે ઉપકરણ પર સ્થાપિત કરેલ છે

5
00:00:11,510 --> 00:00:15,870
તેને સરળ માટે તમે કાર્યક્રમો લખવા માટે બનાવવા કે ઈનપુટ માટે પ્રોમ્પ્ટ વપરાશકર્તાઓ.

6
00:00:15,870 --> 00:00:21,670
આ વિડિઓ, અમે પાછા પડદો ખેંચી અને પડશે બરાબર શું CS50 પુસ્તકાલય છે જુઓ.

7
00:00:21,670 --> 00:00:25,520
>> સી લાઇબ્રેરીઓ પર વિડિઓ, અમે તમને કેવી રીતે # હેડરો ફાઇલો સમાવેશ અંગે વાત

8
00:00:25,520 --> 00:00:27,570
તમારી સ્રોત કોડ માં પુસ્તકાલય છે,

9
00:00:27,570 --> 00:00:31,150
અને તે પછી તમને લિંક તબક્કા દરમ્યાન દ્વિસંગી પુસ્તકાલય ફાઇલ સાથે લિંક

10
00:00:31,150 --> 00:00:33,140
સંકલન પ્રક્રિયા છે.

11
00:00:33,140 --> 00:00:36,440
હેડર ફાઈલો ગ્રંથાલયનો ઇન્ટરફેસ સ્પષ્ટ કરો.

12
00:00:36,440 --> 00:00:41,280
એટલે કે, તેઓ સ્ત્રોતોના તમામ કે પુસ્તકાલય ઉપલબ્ધ છે માટે તમે ઉપયોગ કરવા વિગત,

13
00:00:41,280 --> 00:00:45,250
કાર્ય ઘોષણાઓ, સ્થિરાંકો, અને ડેટા પ્રકારો જેમ.

14
00:00:45,250 --> 00:00:48,890
બાઈનરી ફાઈલ પુસ્તકાલય પુસ્તકાલય અમલીકરણ સમાવે છે,

15
00:00:48,890 --> 00:00:54,580
જે પુસ્તકાલય હેડર ફાઈલો અને લાઈબ્રેરી સી. સ્રોત કોડ ફાઈલો ના સંકલિત છે.

16
00:00:54,580 --> 00:00:59,820
>> બાઈનરી ફાઈલ પુસ્તકાલય ખૂબ જ જોવા કારણ કે તે છે, એ જ પ્રમાણે બાઈનરી માં, રસપ્રદ નથી.

17
00:00:59,820 --> 00:01:03,300
તેથી, ચાલો લાઈબ્રેરી માટે હેડર ફાઈલો બદલે પર એક નજર.

18
00:01:03,300 --> 00:01:07,710
આ કિસ્સામાં, ત્યાં માત્ર એક જ હેડર cs50.h. તરીકે ઓળખાતી ફાઈલ છે

19
00:01:07,710 --> 00:01:11,040
અમે તે વપરાશકર્તા માટે સ્થાપિત કર્યા છે ડિરેક્ટરીમાં સમાવેશ થાય છે

20
00:01:11,040 --> 00:01:15,150
સાથે અન્ય સિસ્ટમ 'લાઈબ્રેરીઓ હેડર ફાઈલો સાથે.

21
00:01:15,150 --> 00:01:21,530
>> એક પ્રથમ વસ્તુઓ તમે નોટિસ કરશો છે કે cs50.h # અન્ય લાઈબ્રેરીઓ માંથી હેડર ફાઈલો સમાવે છે -

22
00:01:21,530 --> 00:01:25,670
ફ્લોટ, મર્યાદા, પ્રમાણભૂત bool, અને પ્રમાણભૂત lib.

23
00:01:25,670 --> 00:01:28,800
ફરીથી, રિઈન્વાઈટિંગ ધ વ્હીલ ન સિદ્ધાંતનું પાલન,

24
00:01:28,800 --> 00:01:33,490
અમે CS0 સાધનો કે જે આપણા માટે અન્ય પૂરી પાડવામાં મદદથી પુસ્તકાલય નિર્માણ કર્યું છે.

25
00:01:33,490 --> 00:01:38,690
>> આગામી વસ્તુ તમે પુસ્તકાલયમાં જોશો છે કે અમે એક નવું કહેવાય પ્રકાર define "શબ્દમાળા."

26
00:01:38,690 --> 00:01:42,330
આ રેખા ખરેખર માત્ર કોલસો બનાવો * પ્રકાર માટે ઉપનામ બનાવે છે,

27
00:01:42,330 --> 00:01:46,000
તેથી તે જાદુઇ લક્ષણો સાથે નવા શબ્દમાળા પ્રકાર નથી ભીંજવવું નથી

28
00:01:46,000 --> 00:01:49,650
સામાન્ય રીતે અન્ય ભાષાઓમાં શબ્દમાળા વસ્તુઓ સાથે સંકળાયેલ,

29
00:01:49,650 --> 00:01:50,850
જેમ કે લંબાઈ છે.

30
00:01:50,850 --> 00:01:55,180
કારણ અમે આ કર્યું છે તે લોહીલુહાણ વિગતો નવી પ્રોગ્રામરો રક્ષણ છે

31
00:01:55,180 --> 00:01:57,580
પોઇન્ટર ઓફ ત્યાં સુધી તેઓ તૈયાર છો.

32
00:01:57,580 --> 00:02:00,130
>> હેડર ફાઈલ આગળના ભાગ વિધેયોને જાહેરાત છે

33
00:02:00,130 --> 00:02:04,410
કે CS50 પુસ્તકાલય દસ્તાવેજીકરણ સાથે પૂરી પાડે છે.

34
00:02:04,410 --> 00:02:06,940
અહીં ટિપ્પણીઓ વિગતવાર સ્તર નોટિસ.

35
00:02:06,940 --> 00:02:10,560
આ અગત્યનું સુપર થાય છે જેથી લોકોને ખબર કેવી રીતે આ વિધેયોને વાપરવાનું.

36
00:02:10,560 --> 00:02:19,150
અમે બદલામાં જાહેર, વપરાશકર્તા અને વળતર અક્ષરો, ડબલ્સમાં, ફ્લોટ્સ, ints પૂછવા કાર્ય કરે છે,

37
00:02:19,150 --> 00:02:24,160
લાંબા લોન્ગ્સ, અને શબ્દમાળાઓ, આપણા પોતાના શબ્દમાળા પ્રકાર મદદથી.

38
00:02:24,160 --> 00:02:26,260
માહિતી છુપાવવામાં સિદ્ધાંત બાદ,

39
00:02:26,260 --> 00:02:31,640
. અમે અલગ કેચ અમલીકરણ ફાઈલ અમારા વ્યાખ્યા મૂકી છે - cs50.c -

40
00:02:31,640 --> 00:02:35,110
વપરાશકર્તા સ્રોત ડિરેક્ટરીમાં સ્થિત થયેલ છે.

41
00:02:35,110 --> 00:02:38,040
અમે તે ફાઇલ પ્રદાન કરેલો છે કે જેથી તમે તેને પર એક નજર કરી શકો છો,

42
00:02:38,040 --> 00:02:41,490
તે જાણવા માટે, અને તે વિવિધ મશીનો પર પુનઃકમ્પાઈલ જો તમે ઈચ્છો,

43
00:02:41,490 --> 00:02:45,510
ભલે અમે લાગે છે કે તે સારું આ વર્ગ માટે સાધન પર કામ કરે છે.

44
00:02:45,510 --> 00:02:47,580
કોઈપણ રીતે, ચાલો તે પર એક નજર હવે લો.

45
00:02:49,020 --> 00:02:54,620
>> આ GetChar, GetDouble, GetFloat, GetInt, કાર્યો અને GetLongLong

46
00:02:54,620 --> 00:02:58,160
છે બધા GetString કાર્ય ટોચ પર બાંધવામાં આવે છે.

47
00:02:58,160 --> 00:03:01,510
તે તારણ આપે છે કે તેઓ તમામ આવશ્યક સમાન પેટર્ન અનુસરો.

48
00:03:01,510 --> 00:03:04,870
તેઓ જ્યારે લૂપ વાપરવા માટે ઇનપુટ એક વાક્ય માટે વપરાશકર્તા પૂછવા.

49
00:03:04,870 --> 00:03:08,430
તેઓ વપરાશકર્તા એ ખાલી લીટી ઇનપુટ્સ જો એક ખાસ મૂલ્ય આવો.

50
00:03:08,430 --> 00:03:11,750
તેઓ યોગ્ય પ્રકાર તરીકે વપરાશકર્તાની ઇનપુટ પાર્સ પ્રયત્ન કરે છે,

51
00:03:11,750 --> 00:03:15,010
તે ચાર રચે છે, ડબલ, એક ફ્લોટ, વગેરે હોવું

52
00:03:15,010 --> 00:03:18,710
અને પછી તેઓ ક્યાં તો પરિણામ આપશે જો ઇનપુટ સફળતાપૂર્વક પદચ્છેદન કરવામાં આવી હતી

53
00:03:18,710 --> 00:03:21,330
અથવા તેઓ વપરાશકર્તા reprompt.

54
00:03:21,330 --> 00:03:24,230
>> ઊંચા સ્તરે, ત્યાં ખરેખર મુશ્કેલ કશું અહીં છે.

55
00:03:24,230 --> 00:03:28,760
તમે જેમ જ સંગઠિત કોડ હોય શકે જાતને ભૂતકાળમાં.

56
00:03:28,760 --> 00:03:34,720
કદાચ વિસ્મૃત દેખાવ સૌથી ભાગ sscanf કોલ કે જે વપરાશકર્તા ઈનપુટ parses છે.

57
00:03:34,720 --> 00:03:38,160
Sscanf ઇનપુટ ફોર્મેટ કન્વર્ઝન કુટુંબ ભાગ છે.

58
00:03:38,160 --> 00:03:42,300
તે પ્રમાણભૂત io.h માં રહે છે, અને તેના કામ માટે એક સી શબ્દમાળા પાર્સ છે,

59
00:03:42,300 --> 00:03:46,520
ચોક્કસ બંધારણ અનુસાર, ચલ માં વિશ્લેષણ પરિણામો સ્ટોર

60
00:03:46,520 --> 00:03:48,720
આ કોલર દ્વારા પૂરી પાડવામાં આવેલ.

61
00:03:48,720 --> 00:03:53,570
કારણ કે ઇનપુટ ફોર્મેટ કન્વર્ઝન કાર્યો ખૂબ ઉપયોગી છે, બહોળી રીતે ઉપયોગમાં લેવાતી વિધેયો છે

62
00:03:53,570 --> 00:03:56,160
કે સાહજિક સુપર પ્રથમ નથી,

63
00:03:56,160 --> 00:03:58,300
અમે ઉપર જવા કેવી રીતે કામ કરે છે sscanf પડશે.

64
00:03:58,300 --> 00:04:03,330
>> Sscanf પ્રથમ દલીલ ચાર રચે છે * છે - એક અક્ષર માટે એક નિર્દેશક.

65
00:04:03,330 --> 00:04:05,150
માટે કાર્ય યોગ્ય રીતે કામ કરવા માટે,

66
00:04:05,150 --> 00:04:08,340
કે અક્ષર એક સી શબ્દમાળા પ્રથમ અક્ષર હોવો જોઈએ,

67
00:04:08,340 --> 00:04:12,270
આ નલ \ 0 પાત્ર સાથે સમાપ્ત.

68
00:04:12,270 --> 00:04:15,120
આ પદચ્છેદ શબ્દમાળા છે

69
00:04:15,120 --> 00:04:18,269
Sscanf બીજી દલીલ બંધારણમાં શબ્દમાળા છે,

70
00:04:18,269 --> 00:04:20,839
સામાન્ય રીતે એક શબ્દમાળા સતત તરીકે પસાર થયો,

71
00:04:20,839 --> 00:04:24,040
અને તમે જ્યારે printf ઉપયોગ કરતા પહેલા આ જેવી શબ્દમાળા જોઈ હોય શકે છે.

72
00:04:24,040 --> 00:04:28,650
બંધારણ શબ્દમાળા માં ટકા સાઇન રૂપાંતરણ specifier સૂચવે છે.

73
00:04:28,650 --> 00:04:30,850
આ પાત્ર તાત્કાલિક ટકા સાઇન બાદ,

74
00:04:30,850 --> 00:04:35,430
C ની પ્રકાર કે અમે રૂપાંતરિત કરવા માંગો છો sscanf સૂચવે છે.

75
00:04:35,430 --> 00:04:40,090
GetInt, તમે જુઓ કે ત્યાં% d અને% C છે.

76
00:04:40,090 --> 00:04:48,690
આનો અર્થ એ થાય કે sscanf એક અક્ષાંશ int પર પ્રયાસ કરશે - આ% d - અને ચાર રચે છે -% c.

77
00:04:48,690 --> 00:04:51,510
બંધારણ શબ્દમાળા દરેક રૂપાંતર specifier માટે,

78
00:04:51,510 --> 00:04:56,620
sscanf તેની દલીલ યાદીમાં અનુરૂપ દલીલ પછી અપેક્ષા રાખી છે.

79
00:04:56,620 --> 00:05:00,850
કે દલીલ યોગ્ય લખેલા સ્થાન માટે નિર્દેશ જ જોઈએ

80
00:05:00,850 --> 00:05:04,000
જેમાં રૂપાંતર પરિણામ સંગ્રહવા માટે.

81
00:05:04,000 --> 00:05:08,910
>> આમ લાક્ષણિક રીતે sscanf કોલ પહેલાં સ્ટેક પર એક ચલ બનાવો

82
00:05:08,910 --> 00:05:11,440
દરેક વસ્તુ કે જે તમે શબ્દમાળા માંથી પદચ્છેદ કરવા માંગો છો માટે

83
00:05:11,440 --> 00:05:15,520
આ & "અને" નું ચિહ્ન - - અને પછી સરનામા ઓપરેટર વાપરવા માટે પોઇંટરો પસાર

84
00:05:15,520 --> 00:05:19,100
આ sscanf કૉલ કરવા માટે તે ચલો છે.

85
00:05:19,100 --> 00:05:22,720
તમે જોઈ શકો છો કે GetInt આપણે બરાબર આવું.

86
00:05:22,720 --> 00:05:28,240
આ sscanf કોલ પહેલાં અધિકાર, અમે એક n એ પૂર્ણાંક તરીકે ઓળખાય છે અને સ્ટેક પર ચાર રચે કૉલ કો ઘોષિત કર્યા,

87
00:05:28,240 --> 00:05:32,340
અને અમે sscanf કોલ માં તેમને પોઇંટરો પસાર કરે છે.

88
00:05:32,340 --> 00:05:35,800
સ્ટેક પર આ ચલો પુટિંગ જગ્યાને મદદથી ઉપર પ્રાધાન્ય આપવામાં આવે છે

89
00:05:35,800 --> 00:05:39,350
malloc સાથે ઢગલો છે, કારણ કે તમે malloc કોલ ઓવરહેડ ટાળવા પર,

90
00:05:39,350 --> 00:05:43,060
અને તમે મેમરી લીક અંગે ચિંતા કરવાની જરૂર નથી.

91
00:05:43,060 --> 00:05:47,280
એક ટકા સાઇન દ્વારા નથી પ્રિફિક્સ અક્ષરો રૂપાંતર ન પૂછવા નથી.

92
00:05:47,280 --> 00:05:50,380
ઊલટાનું તેઓ માત્ર ફોર્મેટ સ્પષ્ટતા ઉમેરો.

93
00:05:50,380 --> 00:05:56,500
>> ઉદાહરણ તરીકે, જો GetInt બંધારણમાં સ્ટ્રિંગ% d ને બદલે હતા

94
00:05:56,500 --> 00:05:59,800
sscanf અક્ષર એક પૂર્ણાંક દ્વારા અનુસરવામાં જોવા માટે કરશે,

95
00:05:59,800 --> 00:06:04,360
અને જ્યારે તે પૂર્ણાંક રૂપાંતરિત કરવાનો પ્રયાસ કરશે, તો તે સાથે જે કંઈપણ નથી કરશે.

96
00:06:04,360 --> 00:06:07,440
આ માત્ર અપવાદ સફેદજગ્યાના છે.

97
00:06:07,440 --> 00:06:11,030
બંધારણ શબ્દમાળા સફેદ જગ્યા અક્ષરો સફેદજગ્યાના કોઈપણ રકમ સાથે મેળ -

98
00:06:11,030 --> 00:06:12,890
બધા પણ નથી.

99
00:06:12,890 --> 00:06:18,100
તેથી, કે શા માટે ટિપ્પણી અગ્રણી અને / અથવા સફેદજગ્યાના પાછળનો સાથે કદાચ ઉલ્લેખ કર્યો છે.

100
00:06:18,100 --> 00:06:22,910
તેથી, આ બિંદુએ તે અમારી sscanf કોલ જેવું દેખાય પર વપરાશકર્તાની ઇનપુટ શબ્દમાળા પાર્સ પ્રયત્ન કરશે

101
00:06:22,910 --> 00:06:25,380
શક્ય અગ્રણી સફેદજગ્યાના ચકાસીને,

102
00:06:25,380 --> 00:06:29,300
એક પૂર્ણાંક છે કે જે રૂપાંતરિત કરવામાં આવશે પૂર્ણાંક ચલ n માં સ્ટોર દ્વારા અનુસરવામાં

103
00:06:29,300 --> 00:06:33,090
સફેદજગ્યાના કેટલાક જથ્થો અનુસરતા, અને એક અક્ષર દ્વારા અનુસરવામાં

104
00:06:33,090 --> 00:06:35,810
આ ઘરનાં પરચૂરણ કામો ચલ કેચ સંગ્રહ થાય છે.

105
00:06:35,810 --> 00:06:37,790
>> પરત કિંમત વિશે શું?

106
00:06:37,790 --> 00:06:41,560
Sscanf શરૂ ના ઈનપુટ લીટી પદચ્છેદ સમાપ્ત કરવા માટે કરશે,

107
00:06:41,560 --> 00:06:44,860
જ્યારે તે અંત સુધી પહોંચે અટકાવવા અથવા જ્યારે ઇનપુટ એક પાત્ર

108
00:06:44,860 --> 00:06:49,320
નથી મેળ ખાતા નથી અથવા બંધારણમાં અક્ષર જ્યારે તે રૂપાંતર કરી શકતા નથી.

109
00:06:49,320 --> 00:06:52,690
તે વળતર કિંમત એક જ્યારે તે રોકી માટે વપરાય છે.

110
00:06:52,690 --> 00:06:55,670
જો તે બંધ કરી દીધું, કારણ કે તે ઇનપુટ શબ્દમાળાને અંતે પહોંચી

111
00:06:55,670 --> 00:07:00,630
કોઈપણ રૂપાંતરણો કરવા પહેલાં અને ફોર્મેટ સ્ટ્રિંગ ભાગ સાથે મેળ નિષ્ફળ પહેલાં,

112
00:07:00,630 --> 00:07:04,840
પછી ખાસ સતત EOF ફર્યા છે.

113
00:07:04,840 --> 00:07:08,200
નહિંતર, તે સફળ રૂપાંતરણો આપે,

114
00:07:08,200 --> 00:07:14,380
જે 0, 1, અથવા 2 હોઇ શકે, કારણ કે અમે બે રૂપાંતરણ માટે પૂછ્યું છે શકે છે.

115
00:07:14,380 --> 00:07:19,000
અમારા કિસ્સામાં, અમે ખાતરી કરો કે વપરાશકર્તા પૂર્ણાંક અને માત્ર પૂર્ણાંક માં ટાઇપ બનાવવા માંગો છો.

116
00:07:19,000 --> 00:07:23,370
>> તેથી, અમે sscanf 1 પરત કરવા માંગો છો. શા માટે જુઓ છો?

117
00:07:23,370 --> 00:07:26,850
જો sscanf 0 પરત ફર્યા, પછી કોઈ રૂપાંતરણ કરવામાં આવ્યા હતા,

118
00:07:26,850 --> 00:07:31,690
જેથી વપરાશકર્તા ઈનપુટ શરૂઆતમાં પૂર્ણાંક સિવાયના અન્ય લખ્યો.

119
00:07:31,690 --> 00:07:37,100
જો sscanf 2 આપે છે, પછી વપરાશકર્તા યોગ્ય રીતે તેને ટાઇપ નહોતી ઇનપુટ શરૂઆતમાં માં,

120
00:07:37,100 --> 00:07:41,390
પરંતુ તેઓ પછી કેટલાક પાત્ર બિન સફેદજગ્યાના માં પછીથી લખ્યો

121
00:07:41,390 --> 00:07:44,940
આ% થી કેચ રૂપાંતર સફળ રહ્યા હતા.

122
00:07:44,940 --> 00:07:49,570
વાહ, કે તે તદ્દન એક ફંક્શન કોલ માટે એક લાંબી સમજૂતી છે.

123
00:07:49,570 --> 00:07:53,460
કોઈપણ રીતે, જો તમે sscanf અને તેના અન્ય ભાઇ બહેન પર વધુ જાણકારી માંગો છો,

124
00:07:53,460 --> 00:07:57,130
બહાર મદદ પાનાંઓ, ગૂગલ, અથવા બંને તપાસો.

125
00:07:57,130 --> 00:07:58,780
ત્યાં ફોર્મેટ સ્ટ્રિંગ વિકલ્પો ઘણાં હોય છે,

126
00:07:58,780 --> 00:08:03,830
અને આ તમે મજૂર ઘણો સેવ જ્યારે સી માં શબ્દમાળાઓ પાર્સ કરવાનો પ્રયાસ કરી શકો છો

127
00:08:03,830 --> 00:08:07,180
>> ગ્રંથાલયનો આ અંતિમ કાર્ય માટે જોવા GetString છે.

128
00:08:07,180 --> 00:08:10,310
તે તારણ આપે છે કે GetString એક કપટી યોગ્ય રીતે લખી કાર્ય છે,

129
00:08:10,310 --> 00:08:14,290
ભલે તે આવા સરળ, સામાન્ય કાર્ય જેવા લાગે છે.

130
00:08:14,290 --> 00:08:16,170
આ કેમ બને છે?

131
00:08:16,170 --> 00:08:21,380
વેલ, ચાલો અમે રેખા સ્ટોર કેવી રીતે જઈ રહ્યાં છો તે વિશે વિચારે છે કે લોગ વપરાશકર્તા પ્રકારો

132
00:08:21,380 --> 00:08:23,880
કારણ કે શબ્દમાળા અક્ષરો ક્રમ છે,

133
00:08:23,880 --> 00:08:26,430
અમે સ્ટેક પર ઝાકઝમાળ તેને સંગ્રહવા માંગો છો શકે છે,

134
00:08:26,430 --> 00:08:31,250
પરંતુ અમે જાણતા કેટલા એરે માટે પ્રયત્ન રહ્યું છે ત્યારે અમે તેને જાહેર જરૂર છે.

135
00:08:31,250 --> 00:08:34,030
તેવી જ રીતે, જો આપણે તેને ઢગલો પર મૂકવા માંગો છો,

136
00:08:34,030 --> 00:08:38,090
અમે malloc માટે બાઇટ્સ સંખ્યા અમે અનામત કરવા માંગો છો પસાર કરવાની જરૂર છે,

137
00:08:38,090 --> 00:08:39,730
પરંતુ આ અશક્ય છે.

138
00:08:39,730 --> 00:08:42,760
અમે કોઇ વિચાર કેટલા અક્ષરો વપરાશકર્તા લખો કરશે

139
00:08:42,760 --> 00:08:46,590
પહેલાં વપરાશકર્તા ખરેખર તેમને લખો નથી.

140
00:08:46,590 --> 00:08:50,720
>> આ સમસ્યા માટે સરળ ઉકેલ માત્ર જગ્યા એક મોટા ભાગ અનામત, કહે છે,

141
00:08:50,720 --> 00:08:54,540
આ વપરાશકર્તા ઈનપુટ માટે 1000 અક્ષરો એક બ્લોક,

142
00:08:54,540 --> 00:08:57,980
એમ ધારી રહ્યા છીએ કે જે વપરાશકર્તા શબ્દમાળા કે લાંબા ક્યારેય લખો કરશે.

143
00:08:57,980 --> 00:09:00,810
આ બે કારણોસર ખરાબ વિચાર છે.

144
00:09:00,810 --> 00:09:05,280
પ્રથમ એમ ધારી રહ્યા છીએ, કે જે વપરાશકર્તાઓને ખાસ શબ્દમાળાઓ કે લાંબા સમય સુધી ન લખો નથી,

145
00:09:05,280 --> 00:09:07,610
તમે મેમરીની જરુર કચરો શકે છે.

146
00:09:07,610 --> 00:09:10,530
આધુનિક મશીનો પર, આ એક મુદ્દો ન હોઇ શકે જો તમે આ કરો છો શકે છે

147
00:09:10,530 --> 00:09:13,890
એક અથવા બે અલગ કિસ્સાઓમાં,

148
00:09:13,890 --> 00:09:17,630
પરંતુ જો તમારી પાસે લુપમાં વપરાશકર્તાની ઇનપુટ લઇ રહ્યા છીએ અને પછી ઉપયોગ માટે સ્ટોર,

149
00:09:17,630 --> 00:09:20,870
તમે ઝડપથી ઉપર મેમરી એક ટન suck કરી શકો છો.

150
00:09:20,870 --> 00:09:24,450
વધુમાં, જો કાર્યક્રમ તમે લખી રહ્યાં નાના કમ્પ્યુટર માટે છે -

151
00:09:24,450 --> 00:09:28,100
એક અથવા મર્યાદિત મેમરી સાથે કંઈક બીજું સ્માર્ટફોન જેવા ઉપકરણ -

152
00:09:28,100 --> 00:09:32,060
આ ઉકેલ સમસ્યાઓ ખૂબ ઝડપથી થાય છે.

153
00:09:32,060 --> 00:09:36,450
બીજો, વધુ ગંભીર માટે આ નથી કારણ એ છે કે તે તમારા કાર્યક્રમ નહીં નિર્બળ

154
00:09:36,450 --> 00:09:39,710
શું બફર ઓવરફ્લો હુમલો કહેવાય છે માટે.

155
00:09:39,710 --> 00:09:45,840
પ્રોગ્રામિંગ, એક બફર કામચલાઉ ઇનપુટ કે આઉટપુટ માહિતી સંગ્રહવા માટે વાપરવામાં મેમરી છે,

156
00:09:45,840 --> 00:09:48,980
જે આ કિસ્સામાં અમારા બ્લોક 1000 કોલસો બનાવો છે.

157
00:09:48,980 --> 00:09:53,370
એક બફર ઓવરફ્લો ત્યારે થાય છે જ્યારે માહિતી બ્લોક ઓવરને ભૂતકાળ લખાયેલ છે.

158
00:09:53,370 --> 00:09:57,790
>> ઉદાહરણ તરીકે, જો વપરાશકર્તા ખરેખર 1000 કરતાં વધુ અક્ષરો ટાઇપ કરે છે.

159
00:09:57,790 --> 00:10:01,570
તમે આ અનુભવ હોઈ શકે છે આકસ્મિક જ્યારે સંગ્રહ સાથે પ્રોગ્રામિંગ.

160
00:10:01,570 --> 00:10:05,620
જો તમે 10 ints ઝાકઝમાળ છે, કંઇ તમે વાંચી અથવા લખવાનો પ્રયાસ માંથી સ્ટોપ્સ

161
00:10:05,620 --> 00:10:07,810
15 ઈન્.

162
00:10:07,810 --> 00:10:10,000
ત્યાં કોઈ કમ્પાઇલર ચેતવણીઓ અથવા ભૂલો છે.

163
00:10:10,000 --> 00:10:13,250
આ કાર્યક્રમ માત્ર સીધા આગળ ભૂલો અને મેમરી ઍક્સેસ

164
00:10:13,250 --> 00:10:18,150
જ્યાં તે એમ વિચારે છે કે 15 પૂર્ણાંક હોવી જોઈએ, અને આ તમારા અન્ય ચલો પર ફરીથી લખી શકો છો.

165
00:10:18,150 --> 00:10:22,040
સૌથી ખરાબ કિસ્સામાં, તમે તમારા કાર્યક્રમ આંતરિક કેટલાક પર ફરીથી લખી શકો છો

166
00:10:22,040 --> 00:10:26,820
નિયંત્રણ પદ્ધતિઓ, તમારા કાર્યક્રમ પરિણમે છે વાસ્તવમાં વિવિધ સૂચનો ચલાવવા માટે

167
00:10:26,820 --> 00:10:28,340
કરતાં તમે ઈરાદો હતો.

168
00:10:28,340 --> 00:10:31,360
>> હવે, તે આ આકસ્મિક કરવું સામાન્ય નથી,

169
00:10:31,360 --> 00:10:35,150
પરંતુ આ રીતે સામાન્ય તરકીબ કે ખરાબ ગાય્ઝ માટે કાર્યક્રમો તોડી ઉપયોગ

170
00:10:35,150 --> 00:10:39,080
અને અન્ય લોકોના કમ્પ્યુટર્સ પર મલીન કોડ મૂકો.

171
00:10:39,080 --> 00:10:42,910
તેથી, અમે અમારા નિષ્કપટ ઉકેલ ન વાપરી શકો છો.

172
00:10:42,910 --> 00:10:45,590
અમને સંવેદનશીલ હોવા અમારા કાર્યક્રમોનું અટકાવવા માર્ગ જરૂર

173
00:10:45,590 --> 00:10:47,880
બફર ઓવરફ્લો હુમલો છે.

174
00:10:47,880 --> 00:10:51,430
આ કરવા માટે, અમે ખાતરી કરવા માટે કે જે અમારા બફર તરીકે અમે વાંચી પ્રગતિ કરી શકે છે કરવાની જરૂર છે

175
00:10:51,430 --> 00:10:53,850
વપરાશકર્તા પાસેથી વધુ ઇનપુટ.

176
00:10:53,850 --> 00:10:57,440
ઉકેલ? અમે ઢગલો ફાળવવામાં બફર વાપરો.

177
00:10:57,440 --> 00:10:59,950
કારણ કે આપણે માપ બદલે તે પુન: માપ એ realloc ફંક્શનનો ઉપયોગ કરીને,

178
00:10:59,950 --> 00:11:04,580
અને અમે બે નંબર સાચવી રાખે છે - બફર આગામી ખાલી સ્લોટ ની અનુક્રમણિકા

179
00:11:04,580 --> 00:11:08,390
અને લંબાઈ અથવા બફર ક્ષમતા.

180
00:11:08,390 --> 00:11:13,210
અમે એક fgetc ફંક્શનનો ઉપયોગ કરીને સમયે એક વપરાશકર્તા પાસેથી અક્ષરો માં વાંચો.

181
00:11:13,210 --> 00:11:19,360
આ દલીલ fgetc કાર્ય લે - stdin ની - પ્રમાણભૂત ઈનપુટ શબ્દમાળા સંદર્ભ છે,

182
00:11:19,360 --> 00:11:23,810
જે preconnected ઇનપુટ ચેનલ છે કે જે વપરાશકર્તાની ઇનપુટ પરિવહન કરવા માટે વપરાય છે

183
00:11:23,810 --> 00:11:26,270
ટર્મિનલ ના કાર્યક્રમ છે.

184
00:11:26,270 --> 00:11:29,890
>> જ્યારે પણ નવા પાત્રની માં વપરાશકર્તા પ્રકારો, અમે જોવા માટે ચકાસો જો અનુક્રમણિકા

185
00:11:29,890 --> 00:11:35,810
આગામી મફત સ્લોટ ઓફ વત્તા 1 છે બફર ક્ષમતા કરતાં વધારે હોય છે.

186
00:11:35,810 --> 00:11:39,690
+1 ને કારણ કે જો આગામી મફત ઇન્ડેક્સ 5 છે આવે છે,

187
00:11:39,690 --> 00:11:44,150
પછી અમારી બફર લંબાઈ 6 0 ઈન્ડેક્સીંગ માટે આભાર હોવા જ જોઈએ.

188
00:11:44,150 --> 00:11:48,350
જો અમે જગ્યા બફર ચલાવવા કર્યો છે, તો અમે તેનો આકાર બદલવા માટે પ્રયત્ન કરે છે,

189
00:11:48,350 --> 00:11:51,690
તે બમણો કે જેથી અમે વખત સંખ્યા પર કાપવામાં કે અમે માપ બદલો

190
00:11:51,690 --> 00:11:54,760
જો વપરાશકર્તા એ ખરેખર લાંબા શબ્દમાળા માં લખી રહ્યા છે.

191
00:11:54,760 --> 00:11:57,950
જો શબ્દમાળા ખૂબ લાંબુ મેળવેલ છે અથવા જો અમે ઢગલો મેમરી રન આઉટ,

192
00:11:57,950 --> 00:12:01,350
અમે અમારા બફર અને વળતર નલ મુક્ત.

193
00:12:01,350 --> 00:12:04,170
>> છેલ્લે, અમે બફર કરવા માટે ઘરનાં પરચૂરણ કામો જોડો.

194
00:12:04,170 --> 00:12:08,200
એકવાર વપરાશકર્તા હિટ દાખલ કરો અથવા પાછા ફરવા માટે, નવી લાઇન સંકેત,

195
00:12:08,200 --> 00:12:12,050
અથવા ખાસ ઘરનાં પરચૂરણ કામો - નિયંત્રણ ડી - જે ઇનપુટ એક ઓવરને નહીં,

196
00:12:12,050 --> 00:12:16,240
અમે જોવા માટે જો વપરાશકર્તા ખરેખર કંઈપણ બધી અંતે લખ્યો ચેક કરવું.

197
00:12:16,240 --> 00:12:18,820
જો નહિં, તો અમે નલ આવો.

198
00:12:18,820 --> 00:12:22,280
નહિંતર, કારણ કે અમારા બફર કદાચ મોટી કરતાં અમે જરૂર છે,

199
00:12:22,280 --> 00:12:24,830
સૌથી ખરાબ કિસ્સામાં તે લગભગ બમણી મોટી આપણે જરૂર છે

200
00:12:24,830 --> 00:12:27,830
કારણ કે અમે દર વખતે અમે ફરીથી કદમાં બે વાર,

201
00:12:27,830 --> 00:12:31,840
અમે ફક્ત જગ્યાનો જથ્થો છે કે અમે જરૂર મદદથી શબ્દમાળા એક નવી કૉપિ બનાવો.

202
00:12:31,840 --> 00:12:34,220
અમે malloc કોલ વધારાનો 1 ઉમેરવા માટે,

203
00:12:34,220 --> 00:12:37,810
0 ની \ - કે તેથી ખાસ નલ ટર્મીનેટર પાત્ર માટે જગ્યા છે

204
00:12:37,810 --> 00:12:41,990
અમે શબ્દમાળાને ઉમેરી એકવાર અમે અક્ષરો બાકીના નકલ કે જે,

205
00:12:41,990 --> 00:12:45,060
strcpy બદલે strncpy મદદથી

206
00:12:45,060 --> 00:12:48,830
તેથી અમે સ્પષ્ટ કરી શકો છો ચોક્કસ કેટલી અક્ષરો આપણે નકલ કરવા માંગો છો.

207
00:12:48,830 --> 00:12:51,690
Strcpy નકલ કરે છે જ્યાં સુધી તે \ 0 બનાવ્યા.

208
00:12:51,690 --> 00:12:55,740
તો પછી અમે અમારી બફર મુક્ત અને કોલર માટે નકલ આવો.

209
00:12:55,740 --> 00:12:59,840
>> કોણ જાણતા આવા કાર્ય સરળ ઉપલક જેથી જટિલ થઈ શકે છે?

210
00:12:59,840 --> 00:13:02,820
હવે તમને ખબર શું CS50 પુસ્તકાલય જાય.

211
00:13:02,820 --> 00:13:06,470
>> મારું નામ Nate Hardison છે, અને આ CS50 છે.

212
00:13:06,470 --> 00:13:08,350
[CS50.TV]