1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [ફાઇલ I / O]

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

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

4
00:00:07,000 --> 00:00:11,000
જ્યારે અમે ફાઈલ લાગે છે, શું વાંધો આવે માઇક્રોસોફ્ટ વર્ડ દસ્તાવેજ છે,

5
00:00:11,000 --> 00:00:14,000
એક JPEG છબી, અથવા MP3 ગીત,

6
00:00:14,000 --> 00:00:17,000
અને અમે અલગ અલગ રીતે ફાઈલો આ પ્રકારના દરેક સાથે ક્રિયાપ્રતિક્રિયા કરે છે.

7
00:00:17,000 --> 00:00:20,000
ઉદાહરણ તરીકે, વર્ડ દસ્તાવેજ આપણે લખાણ ઉમેરો

8
00:00:20,000 --> 00:00:24,000
જ્યારે JPEG છબી સાથે અમે ધાર કાપવા અથવા કદાચ રંગો નવી છટાઓ આપીને સુધારવું.

9
00:00:24,000 --> 00:00:28,000
હજુ સુધી હૂડ હેઠળ અમારી કોમ્પ્યુટર માં બધી ફાઈલોને વધુ કશું છે

10
00:00:28,000 --> 00:00:31,000
zeros અને શૈલીઓનો લાંબા ક્રમ કરતાં.

11
00:00:31,000 --> 00:00:33,000
તે ચોક્કસ કાર્યક્રમ છે કે જે આ ફાઇલ સાથે સંપર્ક કરે છે અપ કરવા માટે છે

12
00:00:33,000 --> 00:00:38,000
નક્કી આ કેવી રીતે લાંબા ક્રમ પર પ્રક્રિયા કરવા માટે અને તેને વપરાશકર્તા માટે રજૂ કરે છે.

13
00:00:38,000 --> 00:00:41,000
એક તરફ, એક દસ્તાવેજ માત્ર એક બાઈટ જોવા શકે છે,

14
00:00:41,000 --> 00:00:45,000
કે 8 zeros અને પ્રવર્તે છે અને સ્ક્રીન પર એક ASCII અક્ષર દર્શાવે છે.

15
00:00:45,000 --> 00:00:48,000
બીજી બાજુ, એક બીટમેપ છબી 3 બાઇટ્સ જોવા શકે છે,

16
00:00:48,000 --> 00:00:50,000
અથવા 24 zeros અને પ્રવર્તે

17
00:00:50,000 --> 00:00:53,000
અને તેમને 3 હેક્સાડેસિમલ નંબર તરીકે અર્થઘટન

18
00:00:53,000 --> 00:00:56,000
કે લાલ, લીલો અને વાદળી માટે મૂલ્યો પ્રતિનિધિત્વ

19
00:00:56,000 --> 00:00:58,000
એક છબી એક પિક્સેલ છે.

20
00:00:58,000 --> 00:01:01,000
તેઓ જે જેવી તમારી સ્ક્રીન પર તેમના કોર પર, જુઓ શકે છે,

21
00:01:01,000 --> 00:01:05,000
ફાઈલો કશું છે zeros અને શૈલીઓનો હાર કરતાં વધુ.

22
00:01:05,000 --> 00:01:08,000
તેથી ચાલો માં ડાઇવ અને અમે કેવી રીતે વાસ્તવમાં આ zeros અને મુદ્દાઓ ચાલાકી જોવા

23
00:01:08,000 --> 00:01:12,000
જ્યારે તે લખવાનું અને ફાઈલ માંથી વાંચવા માટે આવે છે.

24
00:01:12,000 --> 00:01:15,000
>> હું તેને સરળ પ્રક્રિયા 3-ભાગ ફેરવાઇ ભંગ દ્વારા શરૂ કરી શકશો.

25
00:01:15,000 --> 00:01:19,000
આગલું, હું બે કોડ ઉદાહરણો છે કે આ ત્રણ ભાગો દર્શાવે છે માં ડાઇવ પડશે.

26
00:01:19,000 --> 00:01:23,000
છેલ્લે, હું પ્રક્રિયા સમીક્ષા અને તેના સૌથી મહત્વપૂર્ણ વિગતો કેટલાક પડશે.

27
00:01:23,000 --> 00:01:25,000
કોઇ પણ ફાઇલ તમારા ડેસ્કટોપ પર બેસે છે,

28
00:01:25,000 --> 00:01:28,000
પ્રથમ બાબત તેને ખોલવા છે.

29
00:01:28,000 --> 00:01:31,000
સી અમે પૂર્વનિર્ધારિત સ્ટ્રક્ટ માટે નિર્દેશક જાહેર કરીને આ કરવા માટે

30
00:01:31,000 --> 00:01:33,000
કે ડિસ્ક પર ફાઇલ પ્રતિનિધિત્વ કરે છે.

31
00:01:33,000 --> 00:01:38,460
આ ફંક્શન કોલ, અમે પણ નક્કી કરો કે શું અમે લખી અથવા ફાઇલને વાંચવામાં કરવા માંગો છો.

32
00:01:38,460 --> 00:01:41,660
પછી, આપણે વાસ્તવિક વાંચન અને લેખન કરવું.

33
00:01:41,660 --> 00:01:44,800
ત્યાં ખાસ કાર્યો સંખ્યાબંધ અમે આ ભાગ માં ઉપયોગ કરી શકે છે,

34
00:01:44,800 --> 00:01:48,790
અને તેમને લગભગ તમામ પત્ર એફ, જે ફાઈલ માટે વપરાય સાથે શરૂ કરો.

35
00:01:48,790 --> 00:01:53,560
છેલ્લા ફાઈલો ટોચ ખૂણામાં નાના લાલ X સમાન તમારા કમ્પ્યુટર પર ખોલવા માટે,

36
00:01:53,560 --> 00:01:56,680
અમે અંતિમ વિધેય કોલ સાથે ફાઈલ બંધ કરો.

37
00:01:56,680 --> 00:01:59,540
હવે અમે અમે શું જઈ રહ્યાં છો એક સામાન્ય વિચાર છે,

38
00:01:59,540 --> 00:02:02,000
માતાનો કોડ માં ડાઈવ દો.

39
00:02:02,000 --> 00:02:06,100
>> આ ડિરેક્ટરીમાં, અમે બે સી ફાઇલો અને તેમના લગતાવળગતા એક્ઝેક્યુટેબલ ફાઈલો હોય.

40
00:02:06,100 --> 00:02:09,710
આ ટાઇપરાઇટર કાર્યક્રમ એક આદેશ વાક્ય દલીલ લે છે,

41
00:02:09,710 --> 00:02:12,060
દસ્તાવેજનું નામ અમે બનાવવા માંગો છો.

42
00:02:12,060 --> 00:02:16,160
આ કિસ્સામાં, અમે તેને doc.txt કહી શકશો.

43
00:02:16,160 --> 00:02:19,080
ચાલો કાર્યક્રમ ચલાવો અને લીટીઓ એક દંપતી દાખલ કરો.

44
00:02:19,080 --> 00:02:23,660
હાય. મારું નામ જેસન છે.

45
00:02:23,660 --> 00:02:26,710
છેલ્લે, અમે લખો "છોડી દીધું." પડશે

46
00:02:26,710 --> 00:02:29,720
જો આપણે હવે આ ડિરેક્ટરીમાં ફાઈલોની યાદી,

47
00:02:29,720 --> 00:02:33,770
અમે જુઓ કે એક નવો દસ્તાવેજ doc.txt કહેવાય અસ્તિત્વમાં છે.

48
00:02:34,190 --> 00:02:36,110
કે ફાઈલ આ માત્ર બનાવનાર કાર્યક્રમ છે.

49
00:02:36,110 --> 00:02:40,520
અલબત્ત, તે ખૂબ zeros અને શૈલીઓનો લાંબા ક્રમ કરતાં વધુ કંઈ નથી.

50
00:02:41,100 --> 00:02:43,260
જો અમે આ નવી ફાઈલ ખોલવા માટે,

51
00:02:43,260 --> 00:02:45,870
અમે કોડ ઓફ 3 રેખાઓ અમે અમારા કાર્યક્રમ દાખલ જુઓ -

52
00:02:46,060 --> 00:02:49,060
હાય. મે નામ જેસન છે.

53
00:02:49,580 --> 00:02:52,090
પરંતુ શું ખરેખર જ્યારે typewriter.c સ્કોર પર ચાલી રહ્યું છે?

54
00:02:52,810 --> 00:02:55,520
અમારા માટે આ રસ પ્રથમ વાક્ય 24 રેખા છે.

55
00:02:55,560 --> 00:02:58,490
આ રેખા, અમે અમારી ફાઈલ નિર્દેશક જાહેર.

56
00:02:59,080 --> 00:03:03,140
કાર્ય કે આ નિર્દેશક, fopen આપે છે, બે દલીલો લે છે.

57
00:03:03,140 --> 00:03:07,440
પ્રથમ ફાઈલ ફાઈલ જો યોગ્ય વિસ્તરણ સહિત નામ છે.

58
00:03:07,440 --> 00:03:10,980
યાદ છે કે જે ફાઈલ એક્સટેન્સન તેના સૌથી નીચા સ્તરે ફાઈલ પર અસર કરતું નથી.

59
00:03:10,980 --> 00:03:14,640
અમે હંમેશા zeros અને શૈલીઓનો લાંબા ક્રમ સાથે વ્યવહાર કરી રહ્યા છો.

60
00:03:14,640 --> 00:03:19,630
પરંતુ તે પ્રભાવ કરે છે કે કેવી રીતે ફાઈલો અર્થઘટન કરવામાં આવે છે અને શું કાર્યક્રમોને તેમને ખોલવા માટે ઉપયોગ થાય છે.

61
00:03:19,630 --> 00:03:22,290
Fopen બીજી દલીલ એ એક પત્ર છે

62
00:03:22,290 --> 00:03:25,300
કે અમે શું પછી અમે ફાઇલ ખોલવા કરવાની યોજના માટે વપરાય છે.

63
00:03:25,300 --> 00:03:30,630
ડબલ્યુ, આર, અને એ - આ દલીલ માટે ત્રણ વિકલ્પો છે

64
00:03:30,630 --> 00:03:34,900
અમે આ કિસ્સામાં વાઇડ કરવાનું પસંદ કર્યું છે કારણ કે અમે ફાઈલમાં લખો કરવા માંગો છો.

65
00:03:34,900 --> 00:03:38,820
આર, તરીકે તમે કદાચ ધારી શકો છો, ફાઈલ વાંચવા માટે છે.

66
00:03:38,820 --> 00:03:41,760
અને એક ફાઈલમાં ઉમેરીને માટે છે.

67
00:03:41,760 --> 00:03:44,960
જ્યારે બંને વાઇડ અને એક ફાઈલો લખવા માટે ઉપયોગ થઇ શકે છે,

68
00:03:44,960 --> 00:03:47,460
વાઇડ ફાઈલની શરૂઆતથી લખવાનું શરૂ કરશે

69
00:03:47,460 --> 00:03:50,810
અને સંભવિત કોઈપણ માહિતી કે જે પહેલાં સંગ્રહિત કરવામાં આવી પર ફરીથી લખી.

70
00:03:50,810 --> 00:03:54,070
મૂળભૂત રીતે, ફાઈલ અમે ખોલવા માટે, જો તે પહેલાથી જ હાજર નહિં હોય,

71
00:03:54,070 --> 00:03:57,180
તે અમારા હાજર કામ કરતી ડિરેક્ટરીમાં બનાવેલ છે.

72
00:03:57,180 --> 00:04:00,540
જો કે, અમે ઍક્સેસ અથવા એક અલગ સ્થાન એક ફાઈલ બનાવવા માંગો છો,

73
00:04:00,540 --> 00:04:02,650
fopen પ્રથમ દલીલ છે,

74
00:04:02,650 --> 00:04:05,840
અમે ફાઇલ નામ ઉપરાંત એક ફાઈલ પાથ સ્પષ્ટ કરી શકો છો.

75
00:04:05,840 --> 00:04:09,490
જ્યારે આ પ્રક્રિયાના પ્રથમ ભાગ માત્ર લાંબા કોડ એક વાક્ય છે,

76
00:04:09,490 --> 00:04:12,350
તે હંમેશા સારો વ્યવહાર કરવા માટે રેખાઓ અન્ય સમૂહ સમાવેશ થાય છે

77
00:04:12,350 --> 00:04:15,930
કે તેની ખાતરી કરવા માટે કે જે ફાઈલ સફળતાપૂર્વક અથવા ખોલવામાં આવી હતી બનાવનાર તપાસો.

78
00:04:15,930 --> 00:04:20,300
જો fopen નલ આપે છે, અમે અમારા કાર્યક્રમ સાથે આગળ સ્થાપશે માગતા નથી,

79
00:04:20,300 --> 00:04:23,270
અને આ જો ઓપરેટિંગ સિસ્ટમ મેમરી બહાર છે થઈ શકે છે

80
00:04:23,270 --> 00:04:27,940
અથવા જો અમે એ ડિરેક્ટરી છે કે જે માટે અમે યોગ્ય પરવાનગીઓ ન હતી એક ફાઇલ ખોલવા પ્રયાસ કરો.

81
00:04:27,940 --> 00:04:31,780
>> આ પ્રક્રિયા બે ભાગ ની ટાઇપરાઇટર જ્યારે લૂપ માં ઉજવાય છે.

82
00:04:31,780 --> 00:04:35,000
અમે એક પુસ્તકાલય CS50 કાર્ય વાપરવા માટે વપરાશકર્તા તરફથી ઇનપુટ વિચાર,

83
00:04:35,000 --> 00:04:37,190
એમ ધારી રહ્યા છીએ અને તેઓ કાર્યક્રમ બહાર નીકળવા માંગો નહિં,

84
00:04:37,190 --> 00:04:41,940
અમે કાર્ય fputs વાપરવા માટે શબ્દમાળા લાગી અને તે ફાઈલમાં લખો.

85
00:04:41,940 --> 00:04:46,700
fputs માત્ર ઘણા કાર્યો એક અમે ફાઈલમાં લખો ઉપયોગ કરી શકો છે.

86
00:04:46,700 --> 00:04:51,920
અન્ય fwrite, fputc, અને તે પણ fprintf સમાવેશ થાય છે.

87
00:04:51,920 --> 00:04:54,840
અનુલક્ષીને ચોક્કસ કાર્યમાં આપણે મદદથી જોકે અંત,

88
00:04:54,840 --> 00:04:57,480
તેમને બધી ખબર તેમની દલીલો મારફતે, જરૂર છે,

89
00:04:57,480 --> 00:04:59,670
ઓછામાં ઓછા બે વસ્તુઓ -

90
00:04:59,670 --> 00:05:03,140
શું હોય તેવા પરચૂરણ ખર્ચ અને જ્યાં તે માટે તેવા પરચૂરણ ખર્ચ કરવાની જરૂર જરૂર છે.

91
00:05:03,140 --> 00:05:07,240
અમારા કિસ્સામાં, ઇનપુટ શબ્દમાળા કે જે તેવા પરચૂરણ ખર્ચ કરવાની જરૂર છે

92
00:05:07,240 --> 00:05:11,290
અને fp પોઇન્ટર છે કે અમને જ્યાં અમે લખી રહ્યાં માટે દિશામાન છે.

93
00:05:11,290 --> 00:05:15,330
આ કાર્યક્રમ માં, પ્રક્રિયા બે ભાગ બદલે સીધું છે.

94
00:05:15,330 --> 00:05:17,360
અમે ફક્ત વપરાશકર્તાના છો શબ્દમાળા લેતી

95
00:05:17,360 --> 00:05:22,120
અને તે સીધી રીતે ઉમેરીને સાથે અમારી ફાઈલ થોડું થી કોઈ ઇનપુટ માન્યતા અથવા સુરક્ષા તપાસોને.

96
00:05:22,120 --> 00:05:26,160
જોકે, ઘણી વાર બે ભાગ તમારી કોડ બલ્ક લેશે.

97
00:05:26,160 --> 00:05:30,580
છેલ્લે, ત્રણ ભાગ 58 ​​લીટી પર છે, જ્યાં અમે ફાઇલ બંધ કરો.

98
00:05:30,580 --> 00:05:34,860
અહીં અમે fclose અને તેને પસાર અમારા મૂળ ફાઈલ નિર્દેશક કૉલ કરો.

99
00:05:34,860 --> 00:05:39,500
અનુગામી રેખા, અમે શૂન્ય પરત, અમારા કાર્યક્રમ ઓવરને સંકેત આપે છે.

100
00:05:39,500 --> 00:05:42,630
અને, હા, ત્રણ ભાગ તરીકે કે સરળ છે.

101
00:05:42,630 --> 00:05:45,260
>> ચાલો ફાઈલો વાંચવા પર ખસેડો.

102
00:05:45,260 --> 00:05:48,220
અમારી ડિરેક્ટરીમાં પાછા અમે printer.c તરીકે ઓળખાતી ફાઈલ હોય છે.

103
00:05:48,220 --> 00:05:50,910
ચાલો તે ફાઈલ અમે ફક્ત બનાવનાર સાથે ચાલે -

104
00:05:50,910 --> 00:05:53,350
doc.txt.

105
00:05:53,350 --> 00:05:58,150
આ કાર્યક્રમ તરીકે નામ સૂચવે છે, માત્ર છાપે ફાઈલના સમાવિષ્ટો પસાર કરશે.

106
00:05:58,150 --> 00:06:00,230
અને ત્યાં અમે તેને હોય છે.

107
00:06:00,230 --> 00:06:03,780
કોડ ઓફ રેખાઓ આપણે પહેલાં લખ્યો હતો અને doc.txt માં સાચવી.

108
00:06:03,780 --> 00:06:06,980
હાય. મારું નામ જેસન છે.

109
00:06:06,980 --> 00:06:09,120
જો અમે printer.c માં ડાઇવ

110
00:06:09,120 --> 00:06:13,570
અમે જુઓ કે કોડ ઘણાં આપણે શું માત્ર typewriter.c માં મારફતે ચાલ્યો જેવું જ દેખાય છે.

111
00:06:13,570 --> 00:06:16,720
ખરેખર રેખા 22, જ્યાં અમે ફાઇલ ખોલી,

112
00:06:16,720 --> 00:06:19,220
અને 39 લાઇન છે, જ્યાં અમે ફાઈલ બંધ

113
00:06:19,220 --> 00:06:23,890
બંને છે લગભગ typewriter.c માટે સમાન, fopen બીજી દલીલ માટે સાચવો.

114
00:06:23,890 --> 00:06:26,510
આ સમય અમે ફાઈલ માંથી વાંચવા રહ્યાં છો,

115
00:06:26,510 --> 00:06:29,040
તેથી અમે r પસંદ કરેલ છે તેના બદલે વાઇડ છે.

116
00:06:29,040 --> 00:06:31,950
આમ, ચાલો પ્રક્રિયા બીજા ભાગ પર ભાર મૂકે છે.

117
00:06:31,950 --> 00:06:36,060
35 લીટી, અમારા 4 લૂપ બીજી શરત તરીકે,

118
00:06:36,060 --> 00:06:38,590
અમે fgets કૉલ કરવા માટે,

119
00:06:38,590 --> 00:06:42,190
સાથી પહેલાં fputs માટે કાર્ય કરે છે.

120
00:06:42,190 --> 00:06:44,660
આ સમય અમે ત્રણ દલીલો છે.

121
00:06:44,660 --> 00:06:48,810
પ્રથમ અક્ષરો જ્યાં શબ્દમાળા સંગ્રહિત કરવામાં આવશે એરે માટે નિર્દેશક છે.

122
00:06:48,810 --> 00:06:52,670
બીજા અક્ષરોની મહત્તમ સંખ્યા પર વાંચી શકાય છે.

123
00:06:52,670 --> 00:06:56,010
અને ત્રીજા ફાઇલ જેની સાથે અમે કામ કરી રહ્યા છીએ માટે નિર્દેશક છે.

124
00:06:56,010 --> 00:07:00,780
તમે નોટિસ કરીશું કે લૂપ માટે અંત થાય છે જ્યારે fgets નલ આપે છે.

125
00:07:00,780 --> 00:07:02,940
બે કારણ કે આ રીતે થઇ શકે છે.

126
00:07:02,940 --> 00:07:05,380
પ્રથમ, એક ભૂલ આવી શકે છે.

127
00:07:05,380 --> 00:07:10,740
બીજું, અને વધુ તો ફાઈલના અંતે પહોંચી હતી અને કોઇ વધુ અક્ષરો વાંચી હતી.

128
00:07:10,740 --> 00:07:14,040
કિસ્સામાં તમે આશ્ચર્ય પામી રહ્યા છીએ, બે કાર્યો અસ્તિત્વમાં નથી કે અમને જણાવો માટે પરવાનગી આપે છે

129
00:07:14,040 --> 00:07:17,160
કારણ કે જે આ ચોક્કસ નલ નિર્દેશક માટે કારણ છે.

130
00:07:17,160 --> 00:07:21,090
અને, આશ્ચર્યજનક નથી, કારણ કે તેઓ ફાઇલો સાથે કામ સાથે કરી છે,

131
00:07:21,090 --> 00:07:26,940
બંને ferror કાર્ય અને અક્ષર એફ સાથે feof કાર્ય શરુ થાય છે.

132
00:07:26,940 --> 00:07:32,130
>> છેલ્લે, પહેલાં આપણે એવા તારણ પર, એક ફાઈલ કાર્ય ઓવરને વિશે ઝડપી નોંધ,

133
00:07:32,130 --> 00:07:36,690
, જેમાં માત્ર ઉલ્લેખ કર્યો છે, feof તરીકે લખાયેલ છે.

134
00:07:36,690 --> 00:07:41,550
ઘણી વખત તમે તમારી જાતને શોધી જ્યારે અને આંટીઓ ઉપયોગ માટે ક્રમશઃ ફાઇલો દ્વારા તમારી રીતે વાંચી શકશો.

135
00:07:41,550 --> 00:07:45,790
આમ, તમે એક આ આંટીઓ અંત રસ્તો જરૂર પછી તમે આ ફાઇલો ઓવરને સુધી પહોંચી શકશો.

136
00:07:45,790 --> 00:07:50,510
તમારી ફાઈલ નિર્દેશક પર feof કૉલિંગ અને જોવા માટે જો તે સાચું છે ચકાસીને

137
00:07:50,510 --> 00:07:52,310
કે જે હમણાં જ આવું કરશે.

138
00:07:52,310 --> 00:07:59,820
આમ, શરત (feof! (Fp)) સાથે જ્યારે લૂપ સંપૂર્ણ યોગ્ય ઉકેલ જેવી લાગે.

139
00:07:59,820 --> 00:08:03,770
જોકે કહેવું, અમે અમારા લખાણ ફાઈલ બાકી રેખા હોય છે.

140
00:08:03,770 --> 00:08:07,130
અમે અમારા જ્યારે લૂપ દાખલ કરો અને બધું બહાર કામ આયોજન કરીશું નહીં.

141
00:08:07,130 --> 00:08:12,750
આગામી દ્વારા રાઉન્ડ પર, અમારા કાર્યક્રમ જોવા માટે જો fp ઓફ feof સાચું છે તે ચકાસવા કરશે,

142
00:08:12,750 --> 00:08:15,430
પરંતુ - અને આ નિર્ણાયક અહીં સમજવા બિંદુ છે -

143
00:08:15,430 --> 00:08:17,770
તે સાચું હજી સુધી રહેશે.

144
00:08:17,770 --> 00:08:21,110
કે કારણ કે feof હેતુ માટે તપાસ નથી

145
00:08:21,110 --> 00:08:24,400
જો વાંચી કામ કરવા માટે આગામી કોલ ફાઇલ ઓવરને ફટકો પડશે,

146
00:08:24,400 --> 00:08:28,190
પરંતુ તપાસો કે નહીં ફાઈલ ઓવરને પહેલાથી જ પહોંચી ગઈ છે.

147
00:08:28,190 --> 00:08:30,140
આ ઉદાહરણ કિસ્સામાં,

148
00:08:30,140 --> 00:08:32,780
અમારી ફાઈલ ના છેલ્લા વાક્ય વાંચવા સંપૂર્ણપણે સરળતાથી જાય છે,

149
00:08:32,780 --> 00:08:36,210
પરંતુ હજુ સુધી કાર્યક્રમ છે કે અમે અમારી ફાઈલ ઓવરને ફટકો કર્યું છે ખબર નથી.

150
00:08:36,210 --> 00:08:40,549
તે જ્યાં સુધી તે એક વધારાની વાંચી નથી કે તે ફાઈલ ઓવરને ગણકો.

151
00:08:40,549 --> 00:08:43,210
આમ, યોગ્ય સ્થિતિ નીચેના હશે:

152
00:08:43,210 --> 00:08:49,330
fgets અને તેના ત્રણ દલીલો - ઉત્પાદન, ઉત્પાદન કદ, અને fp -

153
00:08:49,330 --> 00:08:52,570
અને સમાન નથી કે તમામ null છે.

154
00:08:52,570 --> 00:08:55,260
આ અભિગમ અમે printer.c માં લીધો છે,

155
00:08:55,260 --> 00:08:57,890
અને આ કિસ્સામાં, લૂપ બહાર નીકળે છે પછી,

156
00:08:57,890 --> 00:09:04,290
તમે feof અથવા ferror આ લૂપ બહાર નીકળતા માટે ચોક્કસ તર્ક એ વપરાશકર્તા જાણ માટે કહી શકે છે.

157
00:09:04,290 --> 00:09:08,100
>> માટે લેખન અને ફાઈલ માંથી વાંચવા તેના મોટા ભાગના આધારભૂત છે,

158
00:09:08,100 --> 00:09:10,150
એક સરળ પ્રક્રિયા 3-ભાગ છે.

159
00:09:10,150 --> 00:09:12,530
પ્રથમ, અમે ફાઈલ ખોલો.

160
00:09:12,530 --> 00:09:16,740
બીજું, અમે અમારા ફાઇલમાં કેટલીક વસ્તુઓ મૂકી છે અથવા તેને બહાર કેટલીક વસ્તુઓ લે છે.

161
00:09:16,740 --> 00:09:19,200
ત્રીજું, અમે ફાઈલ બંધ કરો.

162
00:09:19,200 --> 00:09:21,170
પ્રથમ અને છેલ્લા ભાગો સરળ હોય છે.

163
00:09:21,170 --> 00:09:23,920
મધ્યમ ભાગ છે જ્યાં કાવતરાબાજ સામગ્રી આવેલું છે.

164
00:09:23,920 --> 00:09:27,760
અને છતાં હૂડ નીચે આપણે હંમેશા zeros અને શૈલીઓનો લાંબા ક્રમ સાથે કામ કરીએ છીએ,

165
00:09:27,760 --> 00:09:30,710
તે વખતે બેધ્યાનપણું એક સ્તર ઉમેરવા કોડિંગ મદદ કરતું નથી,

166
00:09:30,710 --> 00:09:35,350
કે કંઈક કે જે વધુ નજીકથી મળતી આવે છે કે અમે શું જોવાનું ઉપયોગ કરી રહ્યા છો માં ક્રમ કરે છે.

167
00:09:35,350 --> 00:09:39,570
ઉદાહરણ તરીકે, જો આપણે એક બીટમેપ 24-bit ફાઇલ સાથે કામ કરી રહ્યા છીએ,

168
00:09:39,570 --> 00:09:43,290
અમે સંભવિત અથવા વાંચી આવશે એક સમયે ત્રણ બાઇટ્સ લખ્યું.

169
00:09:43,290 --> 00:09:46,450
, કે જે કિસ્સામાં તે અર્થમાં બનાવવા માટે નક્કી કરે છે અને યોગ્ય નામ આપશે

170
00:09:46,450 --> 00:09:48,980
એક સ્ટ્રક્ટ કે 3 બાઇટ્સ મોટી છે.

171
00:09:48,980 --> 00:09:51,410
>> જોકે ફાઇલો સાથે કામ જટિલ લાગે,

172
00:09:51,410 --> 00:09:54,530
તેમને ઉપયોગ અમને સાચી નોંધપાત્ર કંઈક પરવાનગી આપે છે.

173
00:09:54,530 --> 00:09:58,880
અમે અમારા કાર્યક્રમ બહાર વિશ્વની સ્થિતિ બદલી શકો છો,

174
00:09:58,880 --> 00:10:01,730
અમે કંઈક કે જે અમારા કાર્યક્રમ જીવન બહાર રહે બનાવી શકો છો,

175
00:10:01,730 --> 00:10:07,190
અથવા આપણે પણ કંઈક કે જે પહેલાં અમારી કાર્યક્રમ ચાલી શરૂ બનાવવામાં આવી હતી બદલી શકો છો.

176
00:10:07,190 --> 00:10:11,210
ફાઈલો સાથે સંપર્ક સી માં પ્રોગ્રામીંગ ખરેખર શક્તિશાળી હિસ્સો છે

177
00:10:11,210 --> 00:10:15,300
અને હું એ જોવા માટે કે તમે શું કરવા માટે આવે કોડ માં તેની સાથે બનાવવા જઈ રહ્યાં છો ઉત્સાહિત છું.

178
00:10:15,300 --> 00:10:19,770
મારું નામ જેસન Hirschhorn છે. આ CS50 છે.

179
00:10:19,770 --> 00:10:21,770
[CS50.TV]

180
00:10:21,770 --> 00:10:25,940
>> [હાસ્ય]

181
00:10:25,940 --> 00:10:29,330
ઠીક છે. એક લો. અહીં અમે જાઓ.

182
00:10:49,000 --> 00:10:52,140
જ્યારે અમે ફાઈલ લાગે છે - ઓહ >> રાહ જુઓ,. માફ કરશો.

183
00:10:52,140 --> 00:10:56,800
[હાસ્ય] ઠીક.

184
00:11:06,620 --> 00:11:09,970
ત્યાં હે.

185
00:11:13,670 --> 00:11:16,310
જ્યારે અમે ફાઈલ લાગે છે -

186
00:11:17,610 --> 00:11:20,710
જ્યારે તમે ફાઈલ લાગે છે - ઠીક છે. મને કહો જ્યારે તમે તૈયાર છો.

187
00:11:20,710 --> 00:11:22,520
ઓહ, મહાન.

188
00:11:22,520 --> 00:11:26,180
એક teleprompter માંથી વાંચવા છતાં લાગે - નં. મારા ખરાબ.