1
00:00:00,000 --> 00:00:05,330

2
00:00:05,330 --> 00:00:07,870
>> વક્તા: અત્યાર સુધી, તે સંભવિત છે
તમારા કાર્યક્રમો મોટા ભાગના

3
00:00:07,870 --> 00:00:10,170
થોડી ક્ષણજીવી રહી છે.

4
00:00:10,170 --> 00:00:13,310
તમે મારિયો અથવા લોભી જેવા કાર્યક્રમ ચાલે છે.

5
00:00:13,310 --> 00:00:17,350
તે કદાચ પૂછે છે, કંઈક કરે છે
કેટલીક માહિતી માટે વપરાશકર્તા,

6
00:00:17,350 --> 00:00:20,400
સ્ક્રીન પર અમુક આઉટપુટ છાપો,
પરંતુ તે પછી તમારા કાર્યક્રમ પર જ્યારે

7
00:00:20,400 --> 00:00:23,252
ત્યાં કોઈ પુરાવા ખરેખર છે
તે ક્યારેય પ્રથમ સ્થાને ચલાવી હતી.

8
00:00:23,252 --> 00:00:25,960
મને ખાતરી છે કે, તમે છોડી ગયા છે શકે છે, અર્થ
તે ટર્મિનલ વિન્ડોમાં ખોલો

9
00:00:25,960 --> 00:00:29,770
તમે તમારી સ્ક્રીન સાફ પરંતુ જો ત્યાં છે
તે અસ્તિત્વમાં છે કે જે ખરેખર કોઈ પુરાવા.

10
00:00:29,770 --> 00:00:33,720
અમે સ્ટોર એક સાધન નથી
નિરંતર માહિતી, માહિતી

11
00:00:33,720 --> 00:00:36,890
કે અમારા પછી અસ્તિત્વમાં
કાર્યક્રમ ચાલી બંધ થઈ ગયું છે,

12
00:00:36,890 --> 00:00:39,241
અથવા આપણે આ બિંદુ સુધી નથી.

13
00:00:39,241 --> 00:00:41,490
સદનસીબે છતાં, સી કરે
ક્ષમતા સાથે અમને પૂરી પાડે છે

14
00:00:41,490 --> 00:00:44,220
અમલીકરણ દ્વારા આ કરવા માટે
કહેવાય કંઈક

15
00:00:44,220 --> 00:00:48,330
ફાઈલ એક માળખું છે કે જે મૂળભૂત
તમે ડબલ કરશે કે જે ફાઈલ રજૂ

16
00:00:48,330 --> 00:00:53,826
તમે છો, તો તમારા કમ્પ્યુટર પર ક્લિક કરો
ગ્રાફિકલ વપરાશકર્તા પર્યાવરણ માટે વપરાય છે.

17
00:00:53,826 --> 00:00:55,700
સામાન્ય રીતે કામ જ્યારે
C સાથે, અમે ખરેખર છો

18
00:00:55,700 --> 00:00:59,965
સાથે કામ કરી રહ્યું
પોઇન્ટર ફાઇલ ફાઈલો છે માટે stars--

19
00:00:59,965 --> 00:01:02,090
થોડો સિવાય
અમે થોડા વિશે વાત ત્યારે

20
00:01:02,090 --> 00:01:04,560
કાર્યો કે
ફાઇલ પોઇન્ટર સાથે કામ કરે છે.

21
00:01:04,560 --> 00:01:08,990
તમે ખરેખર ખોદવામાં આવ્યા છે કરવાની જરૂર નથી
સમજ પોઇન્ટર માં ખૂબ ઊંડા

22
00:01:08,990 --> 00:01:09,730
પોતાને.

23
00:01:09,730 --> 00:01:12,870
થોડી નાનકડું બીટ છે
અમે તેમને વિશે વાત કરશે, જ્યાં

24
00:01:12,870 --> 00:01:18,090
પરંતુ સામાન્ય રીતે પોઇંટરો ફાઇલ અને
પોઇન્ટર, જંગ, જ્યારે

25
00:01:18,090 --> 00:01:20,290
બરાબર આ જ વાત નથી.

26
00:01:20,290 --> 00:01:22,440
>> હવે હું ત્યારે શું અર્થ નથી
હું સતત માહિતી કહે છે?

27
00:01:22,440 --> 00:01:23,650
નિરંતર માહિતી શું છે?

28
00:01:23,650 --> 00:01:25,232
અમે તે વિશે શા માટે કાળજી નથી?

29
00:01:25,232 --> 00:01:27,190
કે, ઉદાહરણ તરીકે, કહે છે
તમે એક કાર્યક્રમ ચલાવી રહ્યા છો

30
00:01:27,190 --> 00:01:29,850
અથવા તમે ફરીથી લખાઈ કર્યું
એક રમત છે કે કાર્યક્રમ,

31
00:01:29,850 --> 00:01:32,960
અને તમે ટ્રેક રાખવા માંગો છો
વપરાશકર્તા ચાલ બધી

32
00:01:32,960 --> 00:01:36,620
જેથી કંઈક ખોટું છે કે કદાચ જો,
તમે આ રમત પછી ફાઈલ સમીક્ષા કરી શકો છો.

33
00:01:36,620 --> 00:01:39,970
કે જ્યારે અમે શું અર્થ છે
નિરંતર માહિતી વિશે વાત કરો.

34
00:01:39,970 --> 00:01:43,930
>> ચાલી દરમિયાન તમારા
કાર્યક્રમ, ફાઇલ બનાવવામાં આવેલ છે.

35
00:01:43,930 --> 00:01:45,680
અને જ્યારે તમારા કાર્યક્રમ
ચાલી બંધ થઈ ગયું છે,

36
00:01:45,680 --> 00:01:48,689
તે ફાઈલ હજુ પણ તમારી સિસ્ટમ પર અસ્તિત્વ ધરાવે છે.

37
00:01:48,689 --> 00:01:50,230
અને અમે તેને જોવા અને તે પરીક્ષણ કરી શકે છે.

38
00:01:50,230 --> 00:01:53,670
અને જેથી કાર્યક્રમ સુયોજિત કરવામાં આવશે
કેટલાક સતત માહિતી બનાવવામાં આવી છે,

39
00:01:53,670 --> 00:01:57,390
માહિતી કાર્યક્રમ પછી અસ્તિત્વમાં
ચાલી સમાપ્ત થઈ ગઈ છે.

40
00:01:57,390 --> 00:02:02,320
>> હવે કામ કરે છે આ તમામ કાર્યોને
ફાઈલો બનાવવા અને હેરફેર સાથે

41
00:02:02,320 --> 00:02:04,940
વિવિધ રીતે તેમને
ધોરણ io.h માં રહે છે,

42
00:02:04,940 --> 00:02:08,210
જે એક હેડર ફાઈલ છે કે
તમે કદાચ પાઉન્ડ કરવામાં આવી છે

43
00:02:08,210 --> 00:02:10,910
ખૂબ ટોચ પર સમાવેશ થાય છે
તમારા કાર્યક્રમો ખૂબ બધા

44
00:02:10,910 --> 00:02:14,130
તે એક છે કારણ કે
અમારા માટે સૌથી વધુ ઉપયોગી કાર્યો,

45
00:02:14,130 --> 00:02:16,130
પણ દે છે કે printf,
ધોરણ io.h. રહે

46
00:02:16,130 --> 00:02:20,400
તેથી જો તમે સમાવેશ પાઉન્ડ કરવાની જરૂર નથી
કોઈપણ વધારાના ફાઈલો કદાચ

47
00:02:20,400 --> 00:02:23,540
ક્રમમાં ફાઇલ પોઇન્ટર સાથે કામ કરવા માટે.

48
00:02:23,540 --> 00:02:29,980
>> હવે દરેક એક ફાઈલ નિર્દેશક કાર્ય,
અથવા દરેક એક ફાઈલ I / O, ઇનપુટ આઉટપુટ

49
00:02:29,980 --> 00:02:33,310
કાર્ય, એક તરીકે સ્વીકારે છે
તેના પરિમાણો અથવા ઇનપુટ્સ

50
00:02:33,310 --> 00:02:35,822
સિવાય ફાઇલ નિર્દેશક
એક, fopen, જે

51
00:02:35,822 --> 00:02:38,280
તમે ફાઈલ વિચાર ઉપયોગ શું છે
પ્રથમ સ્થાને નિર્દેશક.

52
00:02:38,280 --> 00:02:41,010
પરંતુ તમે ખોલી છે પછી
ફાઇલ અને તમે ફાઈલ પોઇન્ટર વિચાર,

53
00:02:41,010 --> 00:02:43,510
પછી તમે તેમને પસાર કરી શકો છો
વિવિધ કાર્યો માટે દલીલો

54
00:02:43,510 --> 00:02:46,720
અમે વિશે વાત કરવા જઈ રહ્યાં છો
આજે, તેમજ અન્ય ઘણા લોકો

55
00:02:46,720 --> 00:02:48,520
કે જેથી તમે ફાઈલો સાથે કામ કરી શકે છે.

56
00:02:48,520 --> 00:02:50,980
>> તેથી છ ખૂબ હોય છે
સામાન્ય મૂળભૂત મુદ્દાઓ

57
00:02:50,980 --> 00:02:52,870
આજે આપણે વિશે વાત કરવા જઈ રહ્યાં છે.

58
00:02:52,870 --> 00:02:57,160
fopen અને તેના સાથી
કાર્ય fclose, fgetc

59
00:02:57,160 --> 00:03:02,670
અને તેના સાથી કાર્ય fputc,
અને fread અને તેના સાથી કાર્ય,

60
00:03:02,670 --> 00:03:03,820
fwrite.

61
00:03:03,820 --> 00:03:05,180
તેથી આપણે તેને અધિકાર વિચાર કરીએ.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- તે શું કરે છે?

63
00:03:07,050 --> 00:03:10,050
વેલ, તે ફાઇલ ખોલે છે અને તે
તે તમે ફાઈલ નિર્દેશક આપે છે,

64
00:03:10,050 --> 00:03:14,000
તેથી પછી તમે ઉપયોગ કરી શકો છો કે
એક દલીલ તરીકે નિર્દેશક ફાઇલ

65
00:03:14,000 --> 00:03:16,730
અન્ય ફાઈલ I / O કાર્યો કોઇ પણ.

66
00:03:16,730 --> 00:03:19,100
સૌથી મહત્વની બાબત
fopen સાથે યાદ

67
00:03:19,100 --> 00:03:24,222
તમે ખોલી છે છે કે પછી
ફાઇલ અથવા અહીં એક જેવી કોલ કર્યો હતો,

68
00:03:24,222 --> 00:03:26,930
તમે તેની ખાતરી કરવા માટે તપાસ કરવાની જરૂર છે
કે તમે પાછા મળી કે નિર્દેશક

69
00:03:26,930 --> 00:03:28,320
નલ માટે સમાન નથી.

70
00:03:28,320 --> 00:03:31,320
તમે વિડિઓ પર જોવાયેલા ન હોય તો
પોઇન્ટર, આ અર્થમાં બનાવવા શકે છે.

71
00:03:31,320 --> 00:03:35,639
પરંતુ તમે પ્રયાસ કરો અને ખોટો સંદર્ભ તો
એક નલ નિર્દેશક યાદ છે,

72
00:03:35,639 --> 00:03:38,180
તમારા કાર્યક્રમ કદાચ જોખમાશે
સેગ્મેન્ટેશન [અશ્રાવ્ય].

73
00:03:38,180 --> 00:03:40,540
અમે ખાતરી કરો કે કરવા માંગો છો અમે
કાયદેસર નિર્દેશક પાછા મળી.

74
00:03:40,540 --> 00:03:43,665
સમય મોટા ભાગના અમે
પાછા કાયદેસર નિર્દેશક મેળવેલ છે

75
00:03:43,665 --> 00:03:45,280
અને તે એક સમસ્યા રહેશે નહીં.

76
00:03:45,280 --> 00:03:46,760
>> તેથી અમે કેવી રીતે કોલ fopen માટે કરી શકું?

77
00:03:46,760 --> 00:03:48,051
તે આ જેમ ખૂબ ખૂબ લાગે છે.

78
00:03:48,051 --> 00:03:52,690
સામાન્ય હોવા ptr ptr-- ફાઇલ સ્ટાર
નિર્દેશક fopen ફાઇલ નામ

79
00:03:52,690 --> 00:03:57,300
અને અમે બે વસ્તુઓ ફાઈલ નામ પસાર
અને કામગીરી અમે હાથ કરવા માંગો છો.

80
00:03:57,300 --> 00:04:01,690
તેથી અમે જેવી લાગે છે કે કોલ હોય શકે
છે આ ફાઇલ સ્ટાર ptr 1 fopen બરાબર

81
00:04:01,690 --> 00:04:04,040
file1.txt.

82
00:04:04,040 --> 00:04:07,020
અને હું પસંદ કરેલા કામગીરી આર છે.

83
00:04:07,020 --> 00:04:08,639
>> તેથી શું તમે આર અહીં લાગે છે નથી?

84
00:04:08,639 --> 00:04:11,180
વસ્તુઓ આ પ્રકારના શું છે અમે
ફાઇલો માટે કરવા માટે સમર્થ હોઈ શકે છે?

85
00:04:11,180 --> 00:04:13,760

86
00:04:13,760 --> 00:04:17,500
તેથી આર કામગીરી છે કે અમે
અમે એક ફાઈલ વાંચી કરવા માંગો છો જ્યારે પસંદ કરો.

87
00:04:17,500 --> 00:04:20,260
તેથી અમે મૂળભૂત ત્યારે કરશે
અમે આ જેવી કૉલ કરો

88
00:04:20,260 --> 00:04:25,440
જાતને એક ફાઈલ નિર્દેશક મેળવવામાં આવશે
અમે પછી માહિતી વાંચી શકે છે, જેમ કે

89
00:04:25,440 --> 00:04:27,770
file1.txt છે.

90
00:04:27,770 --> 00:04:34,190
>> એ જ રીતે, અમે ફાઈલ 2.txt ખોલી શકે
ptr2 લખવા માટે અને તેથી અમે પસાર કરી શકો છો,

91
00:04:34,190 --> 00:04:38,210
હું અહીં બનાવેલ ફાઇલ નિર્દેશક,
કોઈપણ કાર્ય કરવા માટે એક દલીલ તરીકે

92
00:04:38,210 --> 00:04:40,080
ફાઈલ માહિતી લખે છે.

93
00:04:40,080 --> 00:04:43,767
અને લેખન માટે સમાન, ત્યાં
પણ વિકલ્પ છે, કંઈક ઉમેરવા માટે.

94
00:04:43,767 --> 00:04:45,600
વચ્ચે તફાવત
લેખન અને ઉમેરવાની

95
00:04:45,600 --> 00:04:50,920
હોવા તમે ફાઈલ લખી ત્યારે,
તમે લખવા માટે fopen કૉલ કરવા માટે કરો છો, તો

96
00:04:50,920 --> 00:04:54,761
અને તે ફાઇલ પહેલેથી તે અસ્તિત્વમાં
સમગ્ર ફાઈલ પર ફરીથી લખી જઈ રહી છે.

97
00:04:54,761 --> 00:04:56,510
તે શરૂ કરવા જઈ રહ્યું છે
ખૂબ શરૂઆતમાં,

98
00:04:56,510 --> 00:04:58,820
બધી માહિતી કાઢી નાંખવા
કે ત્યાં પહેલેથી જ છે.

99
00:04:58,820 --> 00:05:02,210
>> તમે ઉમેરવાની માટે તેને ખોલવા માટે જ્યારે જો,
તે ફાઈલ ઓવરને પર જશે

100
00:05:02,210 --> 00:05:04,340
પહેલેથી જ લખાણ હોય તો
તે અથવા તે માહિતી

101
00:05:04,340 --> 00:05:06,040
અને તે પછી શરૂ થશે
ત્યાંથી લખી.

102
00:05:06,040 --> 00:05:08,570
તેથી તમે કોઇ ગુમાવી નહીં
જો તમે પહેલાં કર્યું છે માહિતી.

103
00:05:08,570 --> 00:05:12,110
તમે લખી અથવા ઉમેરવા માંગો છો કે કેમ
સૉર્ટ ની પરિસ્થિતિ પર આધાર રાખે છે.

104
00:05:12,110 --> 00:05:16,840
પરંતુ તમે કદાચ શું ખબર પડશે
સમય આવે ત્યારે યોગ્ય કામગીરી છે.

105
00:05:16,840 --> 00:05:18,020
જેથી fopen છે.

106
00:05:18,020 --> 00:05:18,930
>> શું fclose વિશે શું?

107
00:05:18,930 --> 00:05:21,600
વેલ, તે સારુ સરળ, fclose
ફક્ત ફાઇલ નિર્દેશક સ્વીકારે છે.

108
00:05:21,600 --> 00:05:24,000
અને તમે અપેક્ષા શકે છે,
તે ફાઇલ બંધ.

109
00:05:24,000 --> 00:05:29,270
અમે ફાઈલ બંધ કરી અને એકવાર, અમે નથી કરી શકો છો
કોઈ વધુ ફાઇલ I / O કાર્યો કરે છે

110
00:05:29,270 --> 00:05:31,420
વાંચન અથવા ફાઇલ પર લખી.

111
00:05:31,420 --> 00:05:36,444
અમે ફરીથી ખોલવા માટે છે
ક્રમમાં બીજા સમય ફાઈલ

112
00:05:36,444 --> 00:05:38,610
સાથે કામ ચાલુ રાખવા માટે
તે I / O કાર્યો ઉપયોગ કરે છે.

113
00:05:38,610 --> 00:05:41,520
અમે પૂર્ણ કરી લીધું તેથી fclose અર્થ
આ ફાઇલ સાથે કામ કરે છે.

114
00:05:41,520 --> 00:05:44,690
અને અમે પસાર કરવા માટે જરૂર છે
ફાઇલ નિર્દેશક ના નામ પર.

115
00:05:44,690 --> 00:05:50,010
એક દંપતિ પહેલા સ્લાઇડ્સ પર તેથી, અમે
વાંચન માટે fopened ફાઇલ 1 ટપકું લખાણ

116
00:05:50,010 --> 00:05:52,854
અને અમે તે સોંપાયેલ
ptr1 માટે નિર્દેશક ફાઇલ.

117
00:05:52,854 --> 00:05:55,020
હવે અમે છો નક્કી કર્યું છે
તે ફાઈલ માંથી વાંચવા થાય છે.

118
00:05:55,020 --> 00:05:56,561
અમે તેની સાથે કોઈ વધુ કરવાની જરૂર નથી.

119
00:05:56,561 --> 00:05:58,890
અમે માત્ર fclose ptr1 કરી શકો છો.

120
00:05:58,890 --> 00:06:01,950
અને એ જ રીતે, અમે કરી શકે
અન્ય મુદ્દાઓ fclose.

121
00:06:01,950 --> 00:06:02,450
બધા અધિકાર.

122
00:06:02,450 --> 00:06:03,700
તેથી તે ખોલવાનું અને બંધ છે.

123
00:06:03,700 --> 00:06:05,780
તે બે મૂળભૂત છે
કામગીરી શરૂ થાય છે.

124
00:06:05,780 --> 00:06:08,050
>> હવે અમે ખરેખર કરવા માંગો છો
કેટલીક રસપ્રદ સામગ્રી નથી,

125
00:06:08,050 --> 00:06:11,940
અને પ્રથમ કાર્ય છે કે અમે પડશે
કે fgetc-- છે કે શું કરશે જોવા

126
00:06:11,940 --> 00:06:14,110
એક અક્ષર વિચાર ફાઇલ.

127
00:06:14,110 --> 00:06:17,350
તે સામાન્ય fgetc શું છે
અનુવાદ થશે.

128
00:06:17,350 --> 00:06:20,190
જીવન તેના ધ્યેય છે
આગલા અક્ષર વાંચી,

129
00:06:20,190 --> 00:06:22,079
અથવા આ તમારા ખૂબ જ છે, તો
fgetc પ્રથમ કોલ

130
00:06:22,079 --> 00:06:23,870
ચોક્કસ ફાઈલ માટે,
પ્રથમ અક્ષર.

131
00:06:23,870 --> 00:06:26,210
પરંતુ તે પછી,
તમે આગામી એક વિચાર

132
00:06:26,210 --> 00:06:31,500
તે ફાઈલ ખૂબ જ આગામી પાત્ર,
એક અક્ષર ચલ અને સ્ટોર્સ તે.

133
00:06:31,500 --> 00:06:34,490
અમે અહીં કર્યું છે,
ઘરનાં પરચૂરણ કામો સીએચ, fgetc બરાબર

134
00:06:34,490 --> 00:06:36,389
ફાઇલ નિર્દેશક નામે પસાર કરે છે.

135
00:06:36,389 --> 00:06:38,180
ફરીથી, તે ખૂબ જ છે
યાદ રાખો અહીં મહત્વનું

136
00:06:38,180 --> 00:06:41,430
ક્રમમાં હોય કે
આ ઓપરેશન સફળ,

137
00:06:41,430 --> 00:06:45,690
ફાઇલ નિર્દેશક પોતે must've
વાંચન માટે ખોલવામાં આવી છે.

138
00:06:45,690 --> 00:06:50,589
અમે ફાઈલ માંથી એક અક્ષર વાંચી શકતા નથી
અમે લખવા માટે ખોલી કે નિર્દેશક.

139
00:06:50,589 --> 00:06:52,630
જેથી એક છે
fopen મર્યાદાઓ, અધિકાર?

140
00:06:52,630 --> 00:06:55,470
અમે પ્રતિબંધિત છે
જાતને માત્ર અભિનય

141
00:06:55,470 --> 00:06:57,710
એક ફાઈલ નિર્દેશક સાથે એક કામગીરી.

142
00:06:57,710 --> 00:07:00,220
અમે વાંચી કરવા ઈચ્છતો હોય તો અને
એ જ ફાઈલ લખી,

143
00:07:00,220 --> 00:07:03,840
અમે ઓપન બે અલગ હશે
એ જ ફાઈલ કરવા માટે ફાઇલ પોઇન્ટર

144
00:07:03,840 --> 00:07:05,670
વાંચન માટે એક, લેખન માટે.

145
00:07:05,670 --> 00:07:08,400
>> તેથી ફરીથી, આ માત્ર કારણ
હું હવે લાવવા

146
00:07:08,400 --> 00:07:11,920
અમે કૉલ કરવા માટે જઈ રહ્યાં છો કારણ કે જો
fgetc માટે, તે ફાઇલ નિર્દેશક must've

147
00:07:11,920 --> 00:07:14,172
વાંચન માટે ખોલવામાં આવી છે.

148
00:07:14,172 --> 00:07:15,880
અને પછી ખૂબ સરળ,
બધા અમે શું કરવાની જરૂર છે

149
00:07:15,880 --> 00:07:17,546
ફાઇલ નિર્દેશક નામે પાસ છે.

150
00:07:17,546 --> 00:07:21,060
તેથી ઘરનાં પરચૂરણ કામો સીએચ fgetc ptr1 સમકક્ષ હોય છે.

151
00:07:21,060 --> 00:07:23,200
>> તે અમને બનશે
આગામી character--

152
00:07:23,200 --> 00:07:25,575
અથવા ફરી આ પ્રથમ છે, તો
અમે આ ફોન કર્યા સમય,

153
00:07:25,575 --> 00:07:29,750
પ્રથમ character-- ગમે
ફાઇલ ptr1 દ્વારા નિર્દેશ કરવામાં આવે છે.

154
00:07:29,750 --> 00:07:32,210
તે ફાઈલ 1 ટપકું લખાણ હતું કે યાદ અપાવે છે.

155
00:07:32,210 --> 00:07:36,490
તે છે કે પ્રથમ અક્ષર મળશે
અને અમે ચલ સીએચ માં સંગ્રહે પડશે.

156
00:07:36,490 --> 00:07:37,941
ખૂબ સરળ.

157
00:07:37,941 --> 00:07:40,190
તેથી અમે માત્ર ત્રણ પર જોવામાં કર્યું છે
કાર્યો અને અમે પહેલાથી જ

158
00:07:40,190 --> 00:07:43,070
ખૂબ સુઘડ કંઈક કરી શકો છો.

159
00:07:43,070 --> 00:07:46,320
>> અમે આ ક્ષમતા લેવા તેથી જો
એક અક્ષર મેળવવાની

160
00:07:46,320 --> 00:07:48,943
અને અમે લૂપ જેથી તેને અમે
અક્ષરો વિચાર ચાલુ

161
00:07:48,943 --> 00:07:51,390
ફાઇલ પર અને
ઉપર અને over-- હવે અમે

162
00:07:51,390 --> 00:07:54,500
દરેક એક વાંચી શકે છે
ફાઇલ પાત્ર.

163
00:07:54,500 --> 00:07:58,670
અને અમે દરેક અક્ષર છાપો તો
અમે તેને વાંચી પછી તરત જ,

164
00:07:58,670 --> 00:08:01,960
અમે હવે એક ફાઈલ વાંચી છે અને
સ્ક્રીન પર તેના સમાવિષ્ટો મુદ્રિત.

165
00:08:01,960 --> 00:08:05,610
અમે અસરકારક રીતે શ્રેણીબદ્ધ કર્યું
સ્ક્રીન પર તે ફાઇલ.

166
00:08:05,610 --> 00:08:09,670
અને તે છે શું
Linux આદેશ બિલાડી કરે છે.

167
00:08:09,670 --> 00:08:13,250
>> તમે ફાઇલ નામ બિલાડી લખો, તો તે
સમગ્ર સમાવિષ્ટો છાપશે

168
00:08:13,250 --> 00:08:15,160
તમારા ટર્મિનલ વિન્ડોમાં ફાઈલની.

169
00:08:15,160 --> 00:08:19,010
અને તેથી અહીં આ થોડું લૂપ,
કોડ માત્ર ત્રણ રેખાઓ,

170
00:08:19,010 --> 00:08:23,270
પરંતુ તે અસરકારક રીતે ડુપ્લિકેટ્સ
Linux આદેશ કેટ.

171
00:08:23,270 --> 00:08:25,210
તેથી આ વાક્યરચના શકે
, થોડો વિચિત્ર લાગે

172
00:08:25,210 --> 00:08:26,670
પરંતુ અહીં શું થઈ રહ્યું છે.

173
00:08:26,670 --> 00:08:31,460
સીએચ fgetc બરાબર, જ્યારે ptr નથી
તે સમગ્ર કોળિયો છે EOF-- સમાન,

174
00:08:31,460 --> 00:08:34,669
પરંતુ તે માત્ર તોડી દો
તેથી તે બંધારણ પર સ્પષ્ટ છે.

175
00:08:34,669 --> 00:08:37,169
હું તેને મજબૂત કર્યું
જગ્યા ખાતર,

176
00:08:37,169 --> 00:08:39,049
તે થોડી છે, તેમ છતાં
વાક્યરચના અનુસાર મુશ્કેલ.

177
00:08:39,049 --> 00:08:41,194
>> જેથી લીલા અધિકાર આ ભાગ
હવે, તે શું કરી રહ્યો છે?

178
00:08:41,194 --> 00:08:42,860
ઠીક છે, કે અમારા fgetc કૉલ, બરાબર ને?

179
00:08:42,860 --> 00:08:44,530
અમે તે પહેલાં જોઇ છે.

180
00:08:44,530 --> 00:08:49,500
તે એક મેળવવા છે
ફાઇલ પાત્ર.

181
00:08:49,500 --> 00:08:53,220
પછી અમે તે તુલના
EOF સામે પાત્ર.

182
00:08:53,220 --> 00:08:57,470
EOF છે કે ખાસ કિંમત છે
ધોરણ io.h, માં વ્યાખ્યાયિત થયેલ છે

183
00:08:57,470 --> 00:08:59,390
ફાઇલ પાત્ર અંત છે.

184
00:08:59,390 --> 00:09:03,450
જેથી મૂળભૂત શું ચાલી રહ્યું છે તે
આ લૂપ એક અક્ષર વાંચી હશે છે,

185
00:09:03,450 --> 00:09:07,445
, આ EOF સાથે સરખામણી
ફાઇલ પાત્ર અંત થાય છે.

186
00:09:07,445 --> 00:09:10,070
તેઓ સરખા નહિં હોય, તેથી અમે છે
, ફાઈલ ઓવરને પહોંચી

187
00:09:10,070 --> 00:09:11,490
અમે તે અક્ષર છાપો પડશે.

188
00:09:11,490 --> 00:09:13,740
પછી અમે પાછા જવા પડશે
ફરીથી લૂપ પ્રારંભ.

189
00:09:13,740 --> 00:09:18,310
અમે એક અક્ષર મળશે, ચેક
EOF સામે, તેથી તેને છાપી બહાર, અને

190
00:09:18,310 --> 00:09:21,094
અને તેથી પર અને તેથી પર,
જે રીતે દ્વારા રહ્યાં

191
00:09:21,094 --> 00:09:22,760
અમે ફાઈલ ઓવરને પહોંચી ગયા છો ત્યાં સુધી.

192
00:09:22,760 --> 00:09:24,593
અને પછી તે બિંદુએ,
અમે મુદ્રિત હશે

193
00:09:24,593 --> 00:09:26,210
ફાઈલ સમગ્ર સમાવિષ્ટો બહાર.

194
00:09:26,210 --> 00:09:29,450
તેથી ફરી, અમે માત્ર જોઇ
fopen, fclose અને fgetc

195
00:09:29,450 --> 00:09:34,950
અને પહેલેથી જ અમે ડુપ્લિકેટ કરી શકો છો
એ Linux ટર્મિનલ આદેશ.

196
00:09:34,950 --> 00:09:38,850
>> હું શરૂઆતમાં જણાવ્યું હતું કે,
અમે fgetc અને fputc હતી,

197
00:09:38,850 --> 00:09:41,860
અને fputc સાથી હતી
fgetc કાર્ય.

198
00:09:41,860 --> 00:09:44,880
અને તેથી, જેમ કે તમે કલ્પના કરી શકે છે
તે લેખન સમકક્ષ છે.

199
00:09:44,880 --> 00:09:49,440
તે અમને લખવા માટે પરવાનગી આપે છે
ફાઈલ એક પાત્ર.

200
00:09:49,440 --> 00:09:53,290
>> ફરીથી, આ ચેતવણી છે, માત્ર
તે fgetc સાથે હતી, જેમ કે ફાઈલ

201
00:09:53,290 --> 00:09:56,660
અમે must've માટે લખી રહ્યાં છે કે આવી
લેખન માટે અથવા ઉમેરવાની માટે ખૂલ્લું હતું.

202
00:09:56,660 --> 00:10:00,820
અમે પ્રયાસ અને એક ફાઇલ પર fputc વાપરો તો
અમે વાંચન માટે ખોલી છે કે,

203
00:10:00,820 --> 00:10:02,760
અમે સહન કરવા જઈ રહ્યાં છો
એક ભૂલ એક બીટ છે.

204
00:10:02,760 --> 00:10:04,440
પરંતુ કોલ ખૂબ સરળ છે.

205
00:10:04,440 --> 00:10:08,000
fputc મૂડી ptr2, બધા
કે શું થઈ રહ્યું છે તે છે

206
00:10:08,000 --> 00:10:12,040
પત્ર લખવા જઈ
ફાઇલમાં 2 ટપકું માં

207
00:10:12,040 --> 00:10:14,760
આ નામ પણ હતું, જે લખાણ,
અમે ખોલી અને સોંપેલ તે ફાઇલ

208
00:10:14,760 --> 00:10:17,280
નિર્દેશક ptr2 છે.

209
00:10:17,280 --> 00:10:20,430
તેથી અમે એક લખી રહ્યા છીએ
કેપિટલ 2 ટપકું લખાણ ફાઈલ.

210
00:10:20,430 --> 00:10:24,592
અને અમે એક આશ્ચર્યચિહ્ન લખીશ
3 ટપકું ફાઈલમાં નિર્દેશ

211
00:10:24,592 --> 00:10:27,330
ptr3 દ્વારા નિર્દેશ કરવામાં આવ્યો હતો જે લખાણ.

212
00:10:27,330 --> 00:10:29,730
તેથી ફરી, અહીં ખૂબ સરળ.

213
00:10:29,730 --> 00:10:32,727
>> પરંતુ હવે અમે અન્ય વસ્તુ કરી શકો છો.

214
00:10:32,727 --> 00:10:34,560
અમે આ ઉદાહરણ છે
અમે માત્ર જતા હતા

215
00:10:34,560 --> 00:10:38,950
બિલાડી નકલ કરવા માટે સમર્થ હોવા અંગે
Linux આદેશ, છાપે છે કે એક

216
00:10:38,950 --> 00:10:40,500
સ્ક્રીન પર.

217
00:10:40,500 --> 00:10:43,510
ઠીક છે, હવે અમે ક્ષમતા હોય છે કે
ફાઇલો માંથી અક્ષરો વાંચવા માટે

218
00:10:43,510 --> 00:10:46,590
અને, ફાઇલો અક્ષરો લખવા
શા માટે આપણે માત્ર કે અલગ નથી

219
00:10:46,590 --> 00:10:50,720
fputc માટે કૉલ સાથે printf માટે ફોન કરો.

220
00:10:50,720 --> 00:10:54,090
>> અને હવે અમે સીપી ડુપ્લિકેટ કર્યું છે,
એક ખૂબ જ મૂળભૂત Linux આદેશ

221
00:10:54,090 --> 00:10:59,100
અમે માર્ગ લાંબા વિશે વાત કરી
પહેલા Linux માં વિડિઓ આદેશો.

222
00:10:59,100 --> 00:11:01,070
અમે અસરકારક રીતે કર્યું
અહીં કે ડુપ્લિકેટ.

223
00:11:01,070 --> 00:11:04,790
અમે એક અક્ષર વાંચી રહ્યા છો અને પછી અમે છો
બીજી ફાઇલ કે પાત્ર લખવાનું.

224
00:11:04,790 --> 00:11:07,660
એક ફાઈલ વાંચન, લેખન
ઉપર અને ઉપર અન્ય માટે

225
00:11:07,660 --> 00:11:11,350
અને ઉપર ફરીથી અમે EOF હિટ સુધી.

226
00:11:11,350 --> 00:11:14,250
અમે ઓવરને મળી છે
ફાઇલ અમે માંથી નકલ કરવાનો પ્રયાસ કરી રહ્યાં છો.

227
00:11:14,250 --> 00:11:18,500
અને તે દ્વારા આપણે બધા તેવા પરચૂરણ ખર્ચ પડશે
અક્ષરો અમે ફાઇલ કરવાની જરૂર

228
00:11:18,500 --> 00:11:19,500
અમે લખી રહ્યાં છે.

229
00:11:19,500 --> 00:11:24,270
તેથી આ સી.પી., Linux નકલ આદેશ છે.

230
00:11:24,270 --> 00:11:26,550
>> ખૂબ જ પ્રારંભમાં
આ વિડિઓ, હું ચેતવણી હતી

231
00:11:26,550 --> 00:11:29,840
અમે એક ચર્ચા છે કે જે
પોઇન્ટર વિશે થોડુંક.

232
00:11:29,840 --> 00:11:32,480
અમે છો જ્યાં અહીં ખાસ છે
પોઇન્ટર વિશે વાત કરવા જઈ

233
00:11:32,480 --> 00:11:34,800
વધુમાં પોઇન્ટર ફાઈલ કરવા માટે.

234
00:11:34,800 --> 00:11:37,870
તેથી આ કાર્ય પ્રકારની ડરામણી લાગે છે.

235
00:11:37,870 --> 00:11:39,120
તે ઘણા પરિમાણો મળ્યું છે.

236
00:11:39,120 --> 00:11:40,430
અહીં પર જવા ઘણો છે.

237
00:11:40,430 --> 00:11:42,760
વિવિધ ઘણો છે
રંગો અને લખાણો.

238
00:11:42,760 --> 00:11:47,100
પરંતુ ખરેખર, તે માત્ર છે
fgetc ના જિનેરિક વર્ઝન

239
00:11:47,100 --> 00:11:50,110
કે અમને કોઇ વિચાર પરવાનગી આપે છે
માહિતી જથ્થો.

240
00:11:50,110 --> 00:11:53,560
તે અમે હો તો થોડી બિનકાર્યક્ષમ હોઈ શકે છે
એક સમયે અક્ષરો એક મેળવવામાં,

241
00:11:53,560 --> 00:11:55,770
ફાઇલ વારો
એક સમયે એક પાત્ર.

242
00:11:55,770 --> 00:12:00,230
તે વિચાર NICER હોઈ નથી
એક સમયે એક સમય અથવા 500 100?

243
00:12:00,230 --> 00:12:03,250
>> વેલ, fread અને તેના સાથી કાર્ય
fwrite, અમે વિશે વાત કરીશું

244
00:12:03,250 --> 00:12:05,490
બીજા, અમને માત્ર તે કરવા માટે પરવાનગી આપે છે.

245
00:12:05,490 --> 00:12:08,480
અમે એક મનસ્વી રકમ વાંચી શકે છે
એક ફાઇલ માંથી માહિતી

246
00:12:08,480 --> 00:12:10,290
અને અમે ક્યાંક કામચલાઉ સ્ટોર કરે છે.

247
00:12:10,290 --> 00:12:12,980
તેના બદલે માત્ર માટે સક્ષમ છે
એક ચલ તે ફિટ

248
00:12:12,980 --> 00:12:15,790
અમે એક એરે માં સંગ્રહે કરવાની જરૂર પડી શકે.

249
00:12:15,790 --> 00:12:19,980
અને તેથી, અમે ચાર પસાર
દલીલો નિર્દેશક fread-- માટે

250
00:12:19,980 --> 00:12:23,940
અમે છો જ્યાં પાંચ આંકડાના US સ્થાન
માહિતી અત્યારે સંગ્રહ કરવા જઈ,

251
00:12:23,940 --> 00:12:29,180
કેવી રીતે જાણકારી દરેક એકમ મોટા
હશે, માહિતી કેટલા એકમો

252
00:12:29,180 --> 00:12:35,192
અમે હસ્તગત કરવા માંગો છો, અને
જે ફાઈલ અમે તેમને વિચાર કરવા માંગો છો.

253
00:12:35,192 --> 00:12:37,150
કદાચ શ્રેષ્ઠ સચિત્ર
અહીં એક ઉદાહરણ છે.

254
00:12:37,150 --> 00:12:41,640
તેથી ચાલો આપણે જાહેર કહે છે કે દો
10 પૂર્ણાંકો ઝાકઝમાળ.

255
00:12:41,640 --> 00:12:45,080
અમે હમણાં જ જાહેર કર્યું છે
આપખુદ સ્ટેક આગમન 10 INT.

256
00:12:45,080 --> 00:12:46,970
તેથી તે ખૂબ સરળ છે.

257
00:12:46,970 --> 00:12:51,970
હવે અમે શું છતાં કરી રહ્યા છીએ છે
frecall અમે પૂર્ણાંક કદ વાંચી રહ્યા છો છે

258
00:12:51,970 --> 00:12:54,180
વખત માહિતી 10 બાઇટ્સ.

259
00:12:54,180 --> 00:12:59,040
પૂર્ણાંક અસ્તિત્વ માપ કે four--
સી પૂર્ણાંક માપ.

260
00:12:59,040 --> 00:13:02,790
>> તેથી શું અમે કરી રહ્યા છીએ અમે વાંચી રહ્યા છો છે
માહિતી વર્થ 40 બાઇટ્સ

261
00:13:02,790 --> 00:13:05,850
ફાઇલ ptr દ્વારા પર ધ્યાન.

262
00:13:05,850 --> 00:13:08,600
અને અમે તે સ્ટોર કરી રહ્યાં
40 બાઇટ્સ ક્યાંક

263
00:13:08,600 --> 00:13:12,080
અમે કોરે સુયોજિત છે જ્યાં
મેમરી વર્થ 40 બાઇટ્સ.

264
00:13:12,080 --> 00:13:15,970
સદનસીબે, અમે પહેલેથી જ દ્વારા તે કર્યું છે
કે એરે જમણી ત્યાં, આગમન જાહેર.

265
00:13:15,970 --> 00:13:19,770
હોલ્ડિંગ કે સક્ષમ છે
10 ચાર બાઇટ એકમો.

266
00:13:19,770 --> 00:13:22,860
કુલ તેથી, તે 40 પકડી શકે છે
બાઇટ્સ માહિતી વર્થ.

267
00:13:22,860 --> 00:13:26,540
અને અમે હવે 40 બાઇટ્સ વાંચી રહ્યા
ફાઇલ માહિતી,

268
00:13:26,540 --> 00:13:30,330
અને અમે આગમન માં સ્ટોર કરી રહ્યાં છો.

269
00:13:30,330 --> 00:13:35,470
>> પોઇન્ટર પર વિડિઓ થી યાદ છે કે
આવા આગમન તરીકે એરે ના નામ,

270
00:13:35,470 --> 00:13:38,370
ખરેખર માત્ર એક નિર્દેશક છે
તેના પ્રથમ તત્વ છે.

271
00:13:38,370 --> 00:13:43,680
તેથી અમે ત્યાં આગમન પસાર, ત્યારે અમે
એક નિર્દેશક પસાર, હકીકતમાં, છે.

272
00:13:43,680 --> 00:13:46,120
>> એ જ રીતે અમે આ કરવા કરી શકો છો
અમે જરૂરી નથી

273
00:13:46,120 --> 00:13:51,200
સ્ટેક પર અમારી બફર સેવ જરૂર છે.

274
00:13:51,200 --> 00:13:54,990
અમે પણ ગતિશીલ ફાળવણી કરી શકે છે
એક malloc ઉપયોગ કરીને, આ જેવા બફર.

275
00:13:54,990 --> 00:13:57,340
ત્યારે અમે યાદ રાખો
ગતિશીલ મેમરી ફાળવણી,

276
00:13:57,340 --> 00:14:00,550
અમે પર બચત કરી રહ્યાં છો
ઢગલો નથી, સ્ટેક.

277
00:14:00,550 --> 00:14:02,110
પરંતુ તે હજુ પણ બફર છે.

278
00:14:02,110 --> 00:14:06,810
>> તે હજુ પણ, આ કિસ્સામાં છે,
માહિતી 640 બાઇટ્સ હોલ્ડિંગ

279
00:14:06,810 --> 00:14:09,230
ડબલ આઠ બાઇટ્સ લે છે.

280
00:14:09,230 --> 00:14:11,570
અને અમે તેમને 80 માટે પૂછી રહ્યાં છો.

281
00:14:11,570 --> 00:14:13,770
અમે જગ્યા છે કરવા માંગો છો
80 ડબલ્સ ધરાવે છે.

282
00:14:13,770 --> 00:14:17,210
તેથી 80 ગુણ્યા 8 640 બાઇટ્સ માહિતી છે.

283
00:14:17,210 --> 00:14:21,880
અને fread કે કોલ છે
માહિતી 640 બાઇટ્સ એકત્ર

284
00:14:21,880 --> 00:14:27,770
ફાઇલ દ્વારા નિર્દેશ થી
ptr અને arr2 હવે સ્ટોર.

285
00:14:27,770 --> 00:14:32,770
>> હવે અમે પણ fread સારવાર કરી શકે છે
માત્ર fgetc કૉલ ગમે છે.

286
00:14:32,770 --> 00:14:37,140
આ કિસ્સામાં, અમે માત્ર પ્રયાસ કરી રહ્યા છો
ફાઇલ એક અક્ષર મળે છે.

287
00:14:37,140 --> 00:14:40,070
અને અમે એક જરૂર નથી
એરે એક અક્ષર ધરાવે છે.

288
00:14:40,070 --> 00:14:43,170
અમે હમણાં જ તે સ્ટોર કરી શકો છો
એક અક્ષર ચલ.

289
00:14:43,170 --> 00:14:46,390
>> કેચ છતાં છે, કે જે
અમે માત્ર એક ચલ હોય ત્યારે,

290
00:14:46,390 --> 00:14:50,290
અમે માં પસાર કરવાની જરૂર છે
કે ચલ સરનામું

291
00:14:50,290 --> 00:14:52,550
યાદ છે કે કારણ
fread પ્રથમ દલીલ

292
00:14:52,550 --> 00:14:59,210
સ્થાન અને મેમરી માટે નિર્દેશક છે
અમે આ માહિતી અત્યારે સંગ્રહ કરવા માંગો છો જ્યાં.

293
00:14:59,210 --> 00:15:01,550
ફરીથી, એક નામ
એરે એક નિર્દેશક છે.

294
00:15:01,550 --> 00:15:04,200
તેથી અમે 'ચિન્હ એરે શું કરવાની જરૂર નથી.

295
00:15:04,200 --> 00:15:07,270
પરંતુ સી, અક્ષર સી
અહીં, એક એરે નથી.

296
00:15:07,270 --> 00:15:08,390
તે માત્ર એક ચલ છે.

297
00:15:08,390 --> 00:15:11,840
અને તેથી અમે એક પસાર કરવાની જરૂર છે
નું ચિહ્ન સી દર્શાવવા માટે

298
00:15:11,840 --> 00:15:15,350
કે અમે માંગો છો જ્યાં સરનામું છે કે
માહિતી આ એક બાઈટ સંગ્રહવા માટે,

299
00:15:15,350 --> 00:15:20,479
આ એક પાત્ર કે
અમે ptr માંથી એકત્ર કરી રહ્યાં છો.

300
00:15:20,479 --> 00:15:22,270
હું મારફતે જાઓ પડશે Fwrite--
આ થોડો વધુ

301
00:15:22,270 --> 00:15:25,440
quickly-- ખૂબ ખૂબ છે
fread ચોક્કસ સમકક્ષ

302
00:15:25,440 --> 00:15:27,720
તે લખવા માટે સિવાય
તેના બદલે વાંચન, માત્ર

303
00:15:27,720 --> 00:15:31,610
આ other-- જેમ આપણે ખુલ્લા પડ્યું
અને બંધ, એક અક્ષર મેળવવા માટે,

304
00:15:31,610 --> 00:15:32,530
એક અક્ષર લખો.

305
00:15:32,530 --> 00:15:35,040
હવે તે મનસ્વી વિચાર છે
માહિતી જથ્થો,

306
00:15:35,040 --> 00:15:37,170
માહિતી અધિકાર મનસ્વી રકમ.

307
00:15:37,170 --> 00:15:39,790
તેથી પહેલા જેવી, અમે કરી શકો છો
10 પૂર્ણાંકો ઝાકઝમાળ છે

308
00:15:39,790 --> 00:15:43,210
જ્યાં અમે પહેલેથી જ હોય ​​છે
માહિતી કદાચ, સંગ્રહિત.

309
00:15:43,210 --> 00:15:46,580
>> તે કદાચ કોડ કેટલાક લાઇન્સ હતી
કે આ બે વચ્ચે જવું જોઈએ

310
00:15:46,580 --> 00:15:49,990
હું સાથે આગમન ભરો જ્યાં
અર્થપૂર્ણ કંઈક.

311
00:15:49,990 --> 00:15:51,880
હું 10 અલગ અલગ પૂર્ણાંકો સાથે ભરો.

312
00:15:51,880 --> 00:15:54,920
અને તેની જગ્યાએ, હું શું છું
કરી આગમન લખવાનું છે

313
00:15:54,920 --> 00:15:58,600
અને આગમન ના જાણકારી એકઠા કરે છે.

314
00:15:58,600 --> 00:16:02,390
અને હું કે માહિતી લઈ રહ્યો છું
અને ફાઈલ માં મૂકી.

315
00:16:02,390 --> 00:16:05,410
>> તેથી તેના બદલે તે હોવાની
બફર કરવાનો ફાઇલ,

316
00:16:05,410 --> 00:16:08,790
અમે હવે જઈ રહ્યાં છો
ફાઇલ બફર.

317
00:16:08,790 --> 00:16:10,580
તેથી તે માત્ર વિપરીત છે.

318
00:16:10,580 --> 00:16:16,680
માત્ર પહેલાં જેવી તેથી ફરી, અમે કરી શકો છો
પણ મેમરી નો ઢગલો Chunk છે

319
00:16:16,680 --> 00:16:19,600
અમે ગતિશીલ કર્યું કે
ફાળવવામાં અને તે વાંચવામાં

320
00:16:19,600 --> 00:16:21,570
અને ફાઈલ કે લખી.

321
00:16:21,570 --> 00:16:24,900
>> અને અમે પણ એક ચલ છે
એક બાઈટ હોલ્ડિંગ સક્ષમ

322
00:16:24,900 --> 00:16:27,200
જેમ કે એક પાત્ર તરીકે જાણકારી.

323
00:16:27,200 --> 00:16:29,830
પરંતુ ફરીથી, અમે પસાર કરવાની જરૂર છે
કે ચલ સરનામું

324
00:16:29,830 --> 00:16:31,840
અમે તેને વાંચવામાં કરવા માંગો છો.

325
00:16:31,840 --> 00:16:35,280
તેથી અમે આ માહિતી લખી શકો છો
અમે તે સરનામા પર શોધી

326
00:16:35,280 --> 00:16:39,050
ફાઇલ નિર્દેશક, ptr.

327
00:16:39,050 --> 00:16:41,630
>> અન્ય ઘણાં બધાં છે
મહાન ફાઈલ I / O કાર્યો

328
00:16:41,630 --> 00:16:44,650
આ ઉપરાંત વિવિધ બાબતો
રાશિઓ આજે આપણે વિશે વાત કરી છે.

329
00:16:44,650 --> 00:16:46,450
આ મુદ્દાઓ એક દંપતી
તમને ઉપયોગી લાગે તેવા

330
00:16:46,450 --> 00:16:50,840
fgets અને fputs છે,
જે સમકક્ષ છે

331
00:16:50,840 --> 00:16:56,190
fgetc અને fputc પરંતુ વાંચવા માટે
એક ફાઈલ એક શબ્દમાળા.

332
00:16:56,190 --> 00:16:59,020
તેના બદલે એક પાત્ર,
તે સમગ્ર શબ્દમાળા વાંચી હશે.

333
00:16:59,020 --> 00:17:02,940
મૂળભૂત પરવાનગી આપે છે fprintf,
તમે ફાઈલ લખવા માટે printf ઉપયોગ કરે છે.

334
00:17:02,940 --> 00:17:05,619
તમે શું કરી શકો છો તેથી જેમ
ઉપયોગ ચલ બદલી વાક્યો

335
00:17:05,619 --> 00:17:09,900
આ જગ્યામાં ટકા અને હું
printf સાથે ટકા ડી, અને તેથી પર,

336
00:17:09,900 --> 00:17:14,690
તમે એ જ રીતે લઇ શકે છે
printf શબ્દમાળા અને કંઈક છાપવા

337
00:17:14,690 --> 00:17:16,800
એક ફાઈલ કે ગમે છે.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- તમે ડીવીડી પ્લેયર હોય તો
હું સામાન્ય રીતે અહીં ઉપયોગ અનુરૂપતા છે

339
00:17:20,720 --> 00:17:23,109
પ્રકારની મદદથી જેમ તમારા
રીવાઇન્ડ અને ફાસ્ટ ફોરવર્ડ

340
00:17:23,109 --> 00:17:25,819
બટનો ફિલ્મ આસપાસ ખસેડવા.

341
00:17:25,819 --> 00:17:28,369
એ જ રીતે, તમે ફાઈલ આસપાસ ખસેડી શકો છો.

342
00:17:28,369 --> 00:17:30,250
અંદર વસ્તુઓ એક
કે ફાઈલ બંધારણ

343
00:17:30,250 --> 00:17:34,270
તમે એક સૂચક છે કે સી બનાવે છે
જ્યાં તમે ફાઈલ છે.

344
00:17:34,270 --> 00:17:36,420
તમે ખૂબ જ હોય ​​છે
બાઇટ શૂન્ય પર, શરૂઆત?

345
00:17:36,420 --> 00:17:39,290
તમે બાઇટ 100 હોય છે,
બાઇટ 1000, અને તેથી પર?

346
00:17:39,290 --> 00:17:44,340
તમે આપખુદ ખસેડવા fseek ઉપયોગ કરી શકો છો
આગળ ધપાવવા અને પાછળ કે સૂચક.

347
00:17:44,340 --> 00:17:46,744
>> અને ફરી, ftell
એક ડીવીડી પ્લેયર માટે સમાન છે,

348
00:17:46,744 --> 00:17:49,660
કહે છે કે થોડી ઘડિયાળ જેવી છે
તમે કેટલા મિનિટ અને સેકન્ડ તમે

349
00:17:49,660 --> 00:17:52,480
ચોક્કસ ફિલ્મ માં છે.

350
00:17:52,480 --> 00:17:56,990
એ જ રીતે, ftell તમે કેવી રીતે કહે છે
ઘણા બાઇટ્સ તમે ફાઈલ માં છે.

351
00:17:56,990 --> 00:18:00,210
feof એક અલગ આવૃત્તિ છે
તમે કરેલા કે શું શોધવા

352
00:18:00,210 --> 00:18:01,700
આ ફાઈલ ઓવરને સુધી પહોંચી હતી.

353
00:18:01,700 --> 00:18:03,600
અને ferror એક કાર્ય છે
તમે ઉપયોગ કરી શકો છો

354
00:18:03,600 --> 00:18:06,959
કંઈક છે કે શું શોધવા માટે
ફાઇલ સાથે ખોટું કામ ગયો.

355
00:18:06,959 --> 00:18:08,750
ફરીથી, આ માત્ર છે
સપાટી ખંજવાળ.

356
00:18:08,750 --> 00:18:12,730
પુષ્કળ વધુ ફાઇલ I / O હજુ પણ છે
પ્રમાણભૂત io.h. કાર્યો

357
00:18:12,730 --> 00:18:16,620
પરંતુ આ કદાચ તમે મળશે
ફાઇલ પોઇન્ટર સાથે કામ કરવાનું શરૂ કર્યું.

358
00:18:16,620 --> 00:18:17,640
હું ડો લોયડ છું.

359
00:18:17,640 --> 00:18:19,750
આ CS50 છે.

360
00:18:19,750 --> 00:18:21,669