1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [File 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
Когато мислим за даден файл, което идва на ум е Microsoft Word документ,

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
Например, в Word документ добавите текст

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
от една дълга поредица от нули и единици.

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
или осем нули и единици, както и показване на ASCII герой на екрана.

15
00:00:45,000 --> 00:00:48,000
От друга страна, растерно изображение може да изглежда в три байта,

16
00:00:48,000 --> 00:00:50,000
или 24 нули и единици,

17
00:00:50,000 --> 00:00:53,000
и да ги интерпретира като три шестнадесетични числа

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
файлове не са нищо повече от поредица от нули и единици.

22
00:01:05,000 --> 00:01:08,000
Така че нека да се потопите в и погледнете как ние всъщност манипулират тези нули и единици

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
В C правим това чрез обявяване на показалеца на предварително определена структура

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
и почти всички от тях започват с буквата F, която стои за файла.

35
00:01:48,790 --> 00:01:53,560
На последно място, близко до малките червени Х в горния ъгъл на файловете отвори на вашия компютър,

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
>> В тази директория, имаме две C файлове и съответните им изпълними файлове.

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
И разбира се, това също е нищо повече от една дълга поредица от нули и единици.

50
00:02:41,100 --> 00:02:43,260
Ако отворим този нов файл,

51
00:02:43,260 --> 00:02:45,870
ние виждаме три реда код, за да влезе в нашата програма -

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
Ние винаги се занимават с една дълга поредица от нули и единици.

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
Има три варианта за този аргумент - W, R, и А.

64
00:03:30,630 --> 00:03:34,900
Избрали сме w в този случай, защото искаме да пишете на файла.

65
00:03:34,900 --> 00:03:38,820
R, както вероятно можете да се досетите, е за четене на файл.

66
00:03:38,820 --> 00:03:41,760
И за добавяне на файл.

67
00:03:41,760 --> 00:03:44,960
Докато w, така и може да се използва за писане за файлове,

68
00:03:44,960 --> 00:03:47,460
w ще започне писмена форма от началото на файла

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
Други включват неуспешно, 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
и РП е указател, който ни насочва към пишем.

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
Тук ние наричаме неуспешно и да го предадат нашия оригинален файлов указател.

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 вместо w.

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 началото с буквата F.

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
В следващия кръг чрез нашата програма ще провери за да видите ако 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 и три аргумента - изход, размер на продукцията, както и РП -

153
00:08:49,330 --> 00:08:52,570
и всички, че не е равна на нула.

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
И макар, че под предния капак сме винаги справяне с дълга поредица от нули и единици,

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-битов растерна графика файл,

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
Взаимодействаме с файлове е наистина мощен част от програмирането на C.

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 може да изглежда - не. Моя грешка.