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

2
00:00:05,330 --> 00:00:07,870
>> SPEAKER: Sejauh ini, kemungkinan
bahwa sebagian besar program Anda

3
00:00:07,870 --> 00:00:10,170
telah sedikit singkat.

4
00:00:10,170 --> 00:00:13,310
Anda menjalankan program seperti Mario atau Greedy.

5
00:00:13,310 --> 00:00:17,350
Itu melakukan sesuatu, itu mungkin meminta
pengguna untuk beberapa informasi,

6
00:00:17,350 --> 00:00:20,400
mencetak beberapa output ke layar,
tapi kemudian ketika program berakhir,

7
00:00:20,400 --> 00:00:23,252
ada benar-benar ada bukti ada
itu pernah berjalan di tempat pertama.

8
00:00:23,252 --> 00:00:25,960
Maksudku, yakin, Anda mungkin telah meninggalkan
terbuka di jendela terminal,

9
00:00:25,960 --> 00:00:29,770
tetapi jika Anda menghapus layar Anda, ada
benar-benar tidak ada bukti bahwa itu ada.

10
00:00:29,770 --> 00:00:33,720
Kami tidak memiliki cara untuk menyimpan
Informasi gigih, informasi

11
00:00:33,720 --> 00:00:36,890
yang ada setelah kami
Program telah berhenti berjalan,

12
00:00:36,890 --> 00:00:39,241
atau kita belum sampai ke titik ini.

13
00:00:39,241 --> 00:00:41,490
Untungnya meskipun, c tidak
memberikan kami kemampuan

14
00:00:41,490 --> 00:00:44,220
untuk melakukan hal ini dengan menerapkan
sesuatu yang disebut

15
00:00:44,220 --> 00:00:48,330
file, struktur yang pada dasarnya
merupakan file yang akan Anda dua kali lipat

16
00:00:48,330 --> 00:00:53,826
klik di komputer Anda, jika Anda
digunakan untuk lingkungan pengguna grafis.

17
00:00:53,826 --> 00:00:55,700
Umumnya ketika bekerja
dengan c, kami benar-benar

18
00:00:55,700 --> 00:00:59,965
akan bekerja dengan
pointer ke files-- berkas stars--

19
00:00:59,965 --> 00:01:02,090
kecuali sedikit
ketika kita berbicara tentang beberapa

20
00:01:02,090 --> 00:01:04,560
fungsi yang
bekerja dengan berkas pointer.

21
00:01:04,560 --> 00:01:08,990
Anda tidak perlu benar-benar menggali
terlalu jauh ke dalam pemahaman pointer

22
00:01:08,990 --> 00:01:09,730
sendiri.

23
00:01:09,730 --> 00:01:12,870
Ada sedikit mungil sedikit
di mana kita akan berbicara tentang mereka,

24
00:01:12,870 --> 00:01:18,090
tetapi umumnya mengajukan pointer dan
pointer, sedangkan saling terkait,

25
00:01:18,090 --> 00:01:20,290
tidak persis hal yang sama.

26
00:01:20,290 --> 00:01:22,440
>> Sekarang apa yang saya maksud ketika
Saya mengatakan data persisten?

27
00:01:22,440 --> 00:01:23,650
Apa data persisten?

28
00:01:23,650 --> 00:01:25,232
Mengapa kita peduli tentang hal itu?

29
00:01:25,232 --> 00:01:27,190
Katakanlah, misalnya, bahwa
Anda menjalankan program

30
00:01:27,190 --> 00:01:29,850
atau Anda sudah menulis ulang sebuah
Program itu permainan,

31
00:01:29,850 --> 00:01:32,960
dan Anda ingin melacak
semua bergerak pengguna

32
00:01:32,960 --> 00:01:36,620
sehingga mungkin jika sesuatu yang tidak beres,
Anda dapat meninjau file setelah pertandingan.

33
00:01:36,620 --> 00:01:39,970
Itulah yang kita maksud ketika kita
berbicara tentang data persisten.

34
00:01:39,970 --> 00:01:43,930
>> Dalam perjalanan menjalankan
Program, sebuah file dibuat.

35
00:01:43,930 --> 00:01:45,680
Dan ketika program Anda
telah berhenti berjalan,

36
00:01:45,680 --> 00:01:48,689
file yang masih ada di sistem Anda.

37
00:01:48,689 --> 00:01:50,230
Dan kita dapat melihat itu dan memeriksanya.

38
00:01:50,230 --> 00:01:53,670
Dan program yang akan ditetapkan untuk
telah menciptakan beberapa data persisten,

39
00:01:53,670 --> 00:01:57,390
data yang ada setelah program
telah selesai berjalan.

40
00:01:57,390 --> 00:02:02,320
>> Sekarang semua fungsi ini yang bekerja
dengan membuat file dan memanipulasi

41
00:02:02,320 --> 00:02:04,940
mereka dalam berbagai cara
tinggal di io.h standar,

42
00:02:04,940 --> 00:02:08,210
yang merupakan file header yang
Anda mungkin sudah pernah pon

43
00:02:08,210 --> 00:02:10,910
termasuk di bagian atas cukup
banyak semua program Anda

44
00:02:10,910 --> 00:02:14,130
karena mengandung salah satu
kebanyakan fungsi yang berguna bagi kita,

45
00:02:14,130 --> 00:02:16,130
printf, yang juga memungkinkan
tinggal di io.h. standar

46
00:02:16,130 --> 00:02:20,400
Jadi Anda tidak perlu pon termasuk
file tambahan mungkin

47
00:02:20,400 --> 00:02:23,540
dalam rangka untuk bekerja dengan file yang pointer.

48
00:02:23,540 --> 00:02:29,980
>> Sekarang setiap fungsi pointer file tunggal,
atau setiap file I / O, input output

49
00:02:29,980 --> 00:02:33,310
fungsi, menerima sebagai salah satu
parameter atau masukan

50
00:02:33,310 --> 00:02:35,822
sebuah pointer-- berkas kecuali
untuk satu, fopen, yang

51
00:02:35,822 --> 00:02:38,280
adalah apa yang Anda gunakan untuk mendapatkan file
pointer di tempat pertama.

52
00:02:38,280 --> 00:02:41,010
Tapi setelah Anda membuka
file dan Anda mendapatkan file pointer,

53
00:02:41,010 --> 00:02:43,510
Anda kemudian dapat melewati mereka sebagai
argumen untuk berbagai fungsi

54
00:02:43,510 --> 00:02:46,720
kita akan berbicara tentang
hari ini, serta banyak lainnya

55
00:02:46,720 --> 00:02:48,520
sehingga Anda dapat bekerja dengan file.

56
00:02:48,520 --> 00:02:50,980
>> Jadi ada enam cukup
yang dasar umum

57
00:02:50,980 --> 00:02:52,870
bahwa kita akan bicarakan hari ini.

58
00:02:52,870 --> 00:02:57,160
fopen dan pendamping
Fungsi fclose, fgetc

59
00:02:57,160 --> 00:03:02,670
dan fungsi pendamping fputc,
dan fread dan fungsi pendamping nya,

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

61
00:03:03,820 --> 00:03:05,180
Jadi mari kita ke dalamnya.

62
00:03:05,180 --> 00:03:07,050
>> fopen-- apa fungsinya?

63
00:03:07,050 --> 00:03:10,050
Nah, ini akan membuka sebuah file dan
memberi Anda pointer berkas untuk itu,

64
00:03:10,050 --> 00:03:14,000
sehingga Anda kemudian dapat menggunakan
mengajukan pointer sebagai argumen

65
00:03:14,000 --> 00:03:16,730
ke salah satu file lain I / O fungsi.

66
00:03:16,730 --> 00:03:19,100
Hal yang paling penting
ingat dengan fopen

67
00:03:19,100 --> 00:03:24,222
adalah bahwa setelah Anda membuka
mengajukan atau membuat panggilan seperti di sini,

68
00:03:24,222 --> 00:03:26,930
Anda perlu memeriksa untuk memastikan
bahwa pointer yang kembali

69
00:03:26,930 --> 00:03:28,320
tidak sama dengan nol.

70
00:03:28,320 --> 00:03:31,320
Jika Anda belum menonton video di
pointer, ini mungkin tidak masuk akal.

71
00:03:31,320 --> 00:03:35,639
Tetapi jika Anda mencoba dan dereference
pointer recall null,

72
00:03:35,639 --> 00:03:38,180
program anda mungkin akan menderita
segmentasi sebuah [tidak terdengar].

73
00:03:38,180 --> 00:03:40,540
Kami ingin memastikan bahwa kami
mendapat pointer kembali yang sah.

74
00:03:40,540 --> 00:03:43,665
Sebagian besar waktu kita akan
mendapatkan pointer yang sah kembali

75
00:03:43,665 --> 00:03:45,280
dan itu tidak akan menjadi masalah.

76
00:03:45,280 --> 00:03:46,760
>> Jadi bagaimana kita membuat panggilan ke fopen?

77
00:03:46,760 --> 00:03:48,051
Ini terlihat cukup banyak seperti ini.

78
00:03:48,051 --> 00:03:52,690
Bintang berkas ptr-- ptr menjadi generik
nama file pointer-- fopen

79
00:03:52,690 --> 00:03:57,300
dan kami lulus dalam dua hal, nama file
dan operasi kami ingin melakukan.

80
00:03:57,300 --> 00:04:01,690
Jadi kita mungkin memiliki panggilan yang terlihat seperti
this-- ptr Bintang file 1 sama dengan fopen

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

82
00:04:04,040 --> 00:04:07,020
Dan operasi aku telah memilih adalah r.

83
00:04:07,020 --> 00:04:08,639
>> Jadi apa yang Anda pikirkan r di sini?

84
00:04:08,639 --> 00:04:11,180
Apa hal-hal yang kita
mungkin bisa lakukan untuk file?

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

86
00:04:13,760 --> 00:04:17,500
Jadi r adalah operasi yang kita
memilih ketika kita ingin membaca file.

87
00:04:17,500 --> 00:04:20,260
Jadi kita akan pada dasarnya ketika
kami membuat panggilan seperti ini

88
00:04:20,260 --> 00:04:25,440
mendapatkan diri pointer berkas
seperti yang kita kemudian bisa membaca informasi

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

90
00:04:27,770 --> 00:04:34,190
>> Demikian pula, kita bisa membuka file 2.txt
untuk menulis dan jadi kami bisa lulus ptr2,

91
00:04:34,190 --> 00:04:38,210
pointer file yang saya buat di sini,
sebagai argumen untuk fungsi apapun yang

92
00:04:38,210 --> 00:04:40,080
menulis informasi ke file.

93
00:04:40,080 --> 00:04:43,767
Dan mirip dengan tulisan, ada
juga pilihan untuk menambahkan, a.

94
00:04:43,767 --> 00:04:45,600
Perbedaan antara
menulis dan menambahkan

95
00:04:45,600 --> 00:04:50,920
adalah bahwa ketika Anda menulis ke file,
jika Anda membuat panggilan ke fopen untuk menulis

96
00:04:50,920 --> 00:04:54,761
dan file yang sudah ada, itu
akan menimpa seluruh file.

97
00:04:54,761 --> 00:04:56,510
Ini akan memulai
di awal,

98
00:04:56,510 --> 00:04:58,820
menghapus semua informasi
yang sudah ada.

99
00:04:58,820 --> 00:05:02,210
>> Sedangkan jika Anda membukanya untuk menambahkan,
ia akan pergi ke akhir file

100
00:05:02,210 --> 00:05:04,340
jika sudah ada teks dalam
atau informasi di dalamnya,

101
00:05:04,340 --> 00:05:06,040
dan kemudian akan mulai
menulis dari sana.

102
00:05:06,040 --> 00:05:08,570
Jadi Anda tidak akan kehilangan salah satu
informasi yang telah Anda lakukan sebelumnya.

103
00:05:08,570 --> 00:05:12,110
Apakah Anda ingin menulis atau menambahkan
semacam tergantung pada situasi.

104
00:05:12,110 --> 00:05:16,840
Tapi Anda mungkin akan tahu apa yang
operasi yang tepat adalah ketika saatnya tiba.

105
00:05:16,840 --> 00:05:18,020
Jadi itu fopen.

106
00:05:18,020 --> 00:05:18,930
>> Bagaimana fclose?

107
00:05:18,930 --> 00:05:21,600
Nah, cukup sederhana, fclose
hanya menerima file pointer.

108
00:05:21,600 --> 00:05:24,000
Dan seperti yang Anda harapkan,
menutup file itu.

109
00:05:24,000 --> 00:05:29,270
Dan setelah kami menutup file, kita tidak bisa
melakukan setiap file yang lebih I / O fungsi,

110
00:05:29,270 --> 00:05:31,420
membaca atau menulis, pada file tersebut.

111
00:05:31,420 --> 00:05:36,444
Kita harus membuka ulang
mengajukan waktu lain dalam rangka

112
00:05:36,444 --> 00:05:38,610
untuk terus bekerja dengan
menggunakan fungsi I / O.

113
00:05:38,610 --> 00:05:41,520
Berarti sehingga fclose kita sudah selesai
bekerja dengan file ini.

114
00:05:41,520 --> 00:05:44,690
Dan semua yang kita butuhkan untuk lulus di adalah
nama pointer berkas.

115
00:05:44,690 --> 00:05:50,010
Jadi pada beberapa slide yang lalu, kami
fopened file 1 dot teks untuk membaca

116
00:05:50,010 --> 00:05:52,854
dan kami ditugaskan bahwa
mengajukan pointer ke ptr1.

117
00:05:52,854 --> 00:05:55,020
Sekarang kita sudah memutuskan kami
selesai membaca dari file itu.

118
00:05:55,020 --> 00:05:56,561
Kami tidak perlu melakukan lagi dengan itu.

119
00:05:56,561 --> 00:05:58,890
Kita bisa ptr1 hanya fclose.

120
00:05:58,890 --> 00:06:01,950
Dan sama, bisa kita
fclose yang lain.

121
00:06:01,950 --> 00:06:02,450
Baiklah.

122
00:06:02,450 --> 00:06:03,700
Jadi yang membuka dan menutup.

123
00:06:03,700 --> 00:06:05,780
Mereka adalah dua dasar
mulai operasi.

124
00:06:05,780 --> 00:06:08,050
>> Sekarang kita ingin benar-benar
melakukan beberapa hal menarik,

125
00:06:08,050 --> 00:06:11,940
dan fungsi pertama yang kita akan
melihat bahwa akan melakukannya adalah fgetc--

126
00:06:11,940 --> 00:06:14,110
mengajukan mendapatkan karakter.

127
00:06:14,110 --> 00:06:17,350
Itulah yang fgetc umumnya
akan menerjemahkan ke.

128
00:06:17,350 --> 00:06:20,190
Tujuannya dalam hidup adalah
membaca karakter berikutnya,

129
00:06:20,190 --> 00:06:22,079
atau jika ini sangat Anda
panggilan pertama untuk fgetc

130
00:06:22,079 --> 00:06:23,870
untuk file tertentu,
karakter pertama.

131
00:06:23,870 --> 00:06:26,210
Tapi kemudian setelah itu,
Anda mendapatkan yang berikutnya,

132
00:06:26,210 --> 00:06:31,500
karakter berikutnya dari file tersebut,
dan menyimpannya dalam variabel karakter.

133
00:06:31,500 --> 00:06:34,490
Seperti yang telah kita lakukan di sini,
Char ch sama fgetc,

134
00:06:34,490 --> 00:06:36,389
lulus dalam nama pointer berkas.

135
00:06:36,389 --> 00:06:38,180
Sekali lagi, itu sangat
penting di sini untuk diingat

136
00:06:38,180 --> 00:06:41,430
bahwa dalam rangka untuk memiliki
operasi ini berhasil,

137
00:06:41,430 --> 00:06:45,690
file pointer itu sendiri pasti
telah dibuka untuk membaca.

138
00:06:45,690 --> 00:06:50,589
Kita tidak bisa membaca karakter dari file
pointer yang kita dibuka untuk menulis.

139
00:06:50,589 --> 00:06:52,630
Jadi itulah salah satu
keterbatasan fopen, kan?

140
00:06:52,630 --> 00:06:55,470
Kita harus membatasi
diri untuk hanya melakukan

141
00:06:55,470 --> 00:06:57,710
satu operasi dengan satu file pointer.

142
00:06:57,710 --> 00:07:00,220
Jika kita ingin membaca dan
menulis dari file yang sama,

143
00:07:00,220 --> 00:07:03,840
kita akan buka dua terpisah
pointer file ke file-- sama

144
00:07:03,840 --> 00:07:05,670
satu untuk membaca, satu untuk menulis.

145
00:07:05,670 --> 00:07:08,400
>> Jadi sekali lagi, satu-satunya alasan
Saya membawa bahwa sampai saat ini adalah

146
00:07:08,400 --> 00:07:11,920
karena jika kita akan membuat panggilan
untuk fgetc, file pointer pasti

147
00:07:11,920 --> 00:07:14,172
telah dibuka untuk membaca.

148
00:07:14,172 --> 00:07:15,880
Dan kemudian cukup sederhana,
semua yang perlu kita lakukan

149
00:07:15,880 --> 00:07:17,546
adalah lulus dalam nama file pointer.

150
00:07:17,546 --> 00:07:21,060
Jadi ch arang sama ptr1 fgetc.

151
00:07:21,060 --> 00:07:23,200
>> Itu akan membuat kita
yang character-- berikutnya

152
00:07:23,200 --> 00:07:25,575
atau lagi, jika ini adalah pertama
waktu kami telah membuat panggilan ini,

153
00:07:25,575 --> 00:07:29,750
yang character-- pertama apa pun
file ditunjukkan oleh ptr1.

154
00:07:29,750 --> 00:07:32,210
Ingat bahwa itu adalah file 1 dot teks.

155
00:07:32,210 --> 00:07:36,490
Ini akan mendapatkan karakter pertama yang
dan kami akan menyimpannya di ch variabel.

156
00:07:36,490 --> 00:07:37,941
Cukup sederhana.

157
00:07:37,941 --> 00:07:40,190
Jadi kita hanya melihat tiga
fungsi dan sudah kami

158
00:07:40,190 --> 00:07:43,070
dapat melakukan sesuatu yang cukup rapi.

159
00:07:43,070 --> 00:07:46,320
>> Jadi jika kita mengambil kemampuan ini
mendapatkan karakter

160
00:07:46,320 --> 00:07:48,943
dan kami lingkaran itu-- jadi kami
terus mendapatkan karakter

161
00:07:48,943 --> 00:07:51,390
dari file lebih dan
lebih dan over-- sekarang kami

162
00:07:51,390 --> 00:07:54,500
dapat membaca setiap satu
karakter dari sebuah file.

163
00:07:54,500 --> 00:07:58,670
Dan jika kita mencetak setiap karakter
segera setelah kita membaca itu,

164
00:07:58,670 --> 00:08:01,960
kita sekarang telah membaca dari sebuah file dan
dicetak isinya ke layar.

165
00:08:01,960 --> 00:08:05,610
Kami telah digabungkan secara efektif
file di layar.

166
00:08:05,610 --> 00:08:09,670
Dan itulah yang
Linux perintah cat tidak.

167
00:08:09,670 --> 00:08:13,250
>> Jika Anda mengetik kucing dalam nama file, itu
akan mencetak seluruh isi

168
00:08:13,250 --> 00:08:15,160
dari file dalam jendela terminal Anda.

169
00:08:15,160 --> 00:08:19,010
Dan lingkaran kecil di sini,
hanya tiga baris kode,

170
00:08:19,010 --> 00:08:23,270
tapi efektif duplikat
perintah cat Linux.

171
00:08:23,270 --> 00:08:25,210
Jadi sintaks ini mungkin
terlihat sedikit aneh,

172
00:08:25,210 --> 00:08:26,670
tapi inilah yang terjadi di sini.

173
00:08:26,670 --> 00:08:31,460
Sementara ch sama fgetc, ptr tidak
sama dengan EOF-- itu seluruh seteguk,

174
00:08:31,460 --> 00:08:34,669
tapi mari kita jatuhkan itu hanya
jadi jelas pada sintaks.

175
00:08:34,669 --> 00:08:37,169
Saya sudah dikonsolidasikan itu
demi ruang,

176
00:08:37,169 --> 00:08:39,049
meskipun itu sedikit
sintaksis rumit.

177
00:08:39,049 --> 00:08:41,194
>> Jadi bagian ini di kanan hijau
sekarang, apa itu lakukan?

178
00:08:41,194 --> 00:08:42,860
Nah, itu hanya panggilan fgetc kami, kan?

179
00:08:42,860 --> 00:08:44,530
Kami telah melihat itu sebelumnya.

180
00:08:44,530 --> 00:08:49,500
Ini memperoleh satu
karakter dari file.

181
00:08:49,500 --> 00:08:53,220
Kemudian kita bandingkan bahwa
karakter terhadap EOF.

182
00:08:53,220 --> 00:08:57,470
EOF adalah nilai khusus yang
didefinisikan dalam io.h standar, yang

183
00:08:57,470 --> 00:08:59,390
adalah akhir file karakter.

184
00:08:59,390 --> 00:09:03,450
Jadi pada dasarnya apa yang akan terjadi
adalah lingkaran ini akan membaca karakter,

185
00:09:03,450 --> 00:09:07,445
bandingkan dengan EoF, yang
akhir file karakter.

186
00:09:07,445 --> 00:09:10,070
Jika mereka tidak cocok, jadi kami belum
mencapai akhir file,

187
00:09:10,070 --> 00:09:11,490
kami akan mencetak karakter yang keluar.

188
00:09:11,490 --> 00:09:13,740
Kemudian kita akan kembali ke
mulai dari loop lagi.

189
00:09:13,740 --> 00:09:18,310
Kita akan mendapatkan karakter, periksa
terhadap EOF, mencetaknya, dan sebagainya

190
00:09:18,310 --> 00:09:21,094
dan seterusnya dan seterusnya,
perulangan melalui cara yang

191
00:09:21,094 --> 00:09:22,760
sampai kita telah mencapai akhir dari file.

192
00:09:22,760 --> 00:09:24,593
Dan kemudian pada saat itu,
kita akan dicetak

193
00:09:24,593 --> 00:09:26,210
keluar seluruh isi file.

194
00:09:26,210 --> 00:09:29,450
Jadi sekali lagi, kita hanya melihat
fopen, fclose, dan fgetc

195
00:09:29,450 --> 00:09:34,950
dan sudah kita dapat menduplikasi
perintah terminal Linux.

196
00:09:34,950 --> 00:09:38,850
>> Seperti yang saya katakan di awal,
kami memiliki fgetc dan fputc,

197
00:09:38,850 --> 00:09:41,860
dan fputc adalah pendamping
fungsi fgetc.

198
00:09:41,860 --> 00:09:44,880
Dan, seperti yang Anda bayangkan,
itu adalah setara menulis.

199
00:09:44,880 --> 00:09:49,440
Hal ini memungkinkan kita untuk menulis
karakter ke file.

200
00:09:49,440 --> 00:09:53,290
>> Sekali lagi, peringatan sementara, hanya
seperti itu adalah dengan fgetc, file

201
00:09:53,290 --> 00:09:56,660
bahwa kita sedang menulis ke harus sudah
dibuka untuk menulis atau untuk menambahkan.

202
00:09:56,660 --> 00:10:00,820
Jika kita mencoba dan menggunakan fputc pada file
bahwa kita telah membuka untuk membaca,

203
00:10:00,820 --> 00:10:02,760
kita akan menderita
sedikit kesalahan.

204
00:10:02,760 --> 00:10:04,440
Tetapi panggilan ini cukup sederhana.

205
00:10:04,440 --> 00:10:08,000
modal fputc A ptr2, semua
yang akan dilakukan adalah itu

206
00:10:08,000 --> 00:10:12,040
akan menulis surat
menjadi A ke dalam file 2 dot

207
00:10:12,040 --> 00:10:14,760
teks, yang merupakan nama
mengajukan bahwa kami membuka dan ditugaskan

208
00:10:14,760 --> 00:10:17,280
pointer ke ptr2.

209
00:10:17,280 --> 00:10:20,430
Jadi kita akan menulis
Modal A untuk mengajukan 2 dot teks.

210
00:10:20,430 --> 00:10:24,592
Dan kami akan menulis seru
menunjuk ke file 3 dot

211
00:10:24,592 --> 00:10:27,330
teks, yang ditunjuk oleh ptr3.

212
00:10:27,330 --> 00:10:29,730
Jadi sekali lagi, cukup sederhana di sini.

213
00:10:29,730 --> 00:10:32,727
>> Tapi sekarang kita bisa melakukan hal lain.

214
00:10:32,727 --> 00:10:34,560
Kami memiliki contoh ini
kami hanya akan lebih

215
00:10:34,560 --> 00:10:38,950
tentang mampu mereplikasi kucing
Perintah Linux, salah satu yang mencetak

216
00:10:38,950 --> 00:10:40,500
ke layar.

217
00:10:40,500 --> 00:10:43,510
Nah, sekarang kita memiliki kemampuan
membaca karakter dari file

218
00:10:43,510 --> 00:10:46,590
dan menulis karakter ke file,
kenapa tidak kita hanya mengganti yang

219
00:10:46,590 --> 00:10:50,720
panggilan untuk printf dengan panggilan untuk fputc.

220
00:10:50,720 --> 00:10:54,090
>> Dan sekarang kita sudah diduplikasi cp,
perintah yang sangat dasar Linux

221
00:10:54,090 --> 00:10:59,100
yang kita bicarakan jauh
lalu di Linux perintah video.

222
00:10:59,100 --> 00:11:01,070
Kami sudah efektif
digandakan itu di sini.

223
00:11:01,070 --> 00:11:04,790
Kami membaca karakter dan kemudian kami
menulis bahwa karakter ke file lain.

224
00:11:04,790 --> 00:11:07,660
Membaca dari satu file, menulis
lain, berulang

225
00:11:07,660 --> 00:11:11,350
dan lagi sampai kita memukul EOF.

226
00:11:11,350 --> 00:11:14,250
Kita harus akhir
mengajukan kita mencoba untuk menyalin dari.

227
00:11:14,250 --> 00:11:18,500
Dan dengan itu kita akan menulis semua
karakter kita perlu file

228
00:11:18,500 --> 00:11:19,500
bahwa kita sedang menulis ke.

229
00:11:19,500 --> 00:11:24,270
Jadi ini adalah cp, perintah copy Linux.

230
00:11:24,270 --> 00:11:26,550
>> Pada awal
video ini, saya memiliki peringatan yang

231
00:11:26,550 --> 00:11:29,840
bahwa kita akan berbicara
sedikit tentang pointer.

232
00:11:29,840 --> 00:11:32,480
Berikut adalah khusus di mana kami
akan berbicara tentang pointer

233
00:11:32,480 --> 00:11:34,800
selain file pointer.

234
00:11:34,800 --> 00:11:37,870
Jadi fungsi ini terlihat agak menakutkan.

235
00:11:37,870 --> 00:11:39,120
Itu punya beberapa parameter.

236
00:11:39,120 --> 00:11:40,430
Ada banyak hal yang terjadi di sini.

237
00:11:40,430 --> 00:11:42,760
Ada banyak yang berbeda
warna dan teks.

238
00:11:42,760 --> 00:11:47,100
Tapi sungguh, itu hanya
versi generik dari fgetc

239
00:11:47,100 --> 00:11:50,110
yang memungkinkan kita untuk mendapatkan
jumlah informasi.

240
00:11:50,110 --> 00:11:53,560
Hal ini dapat sedikit tidak efisien jika kita
mendapatkan karakter satu per satu,

241
00:11:53,560 --> 00:11:55,770
iterasi melalui file
satu karakter pada satu waktu.

242
00:11:55,770 --> 00:12:00,230
Bukankah lebih baik untuk mendapatkan
100 pada waktu atau 500 pada suatu waktu?

243
00:12:00,230 --> 00:12:03,250
>> Nah, fread dan fungsi pendamping
fwrite, yang akan kita bicarakan

244
00:12:03,250 --> 00:12:05,490
dalam kedua, memungkinkan kita untuk melakukan hal itu.

245
00:12:05,490 --> 00:12:08,480
Kita dapat membaca jumlah yang sewenang-wenang
informasi dari sebuah file

246
00:12:08,480 --> 00:12:10,290
dan kami menyimpannya di suatu tempat sementara.

247
00:12:10,290 --> 00:12:12,980
Alih-alih mampu hanya
muat di satu variabel,

248
00:12:12,980 --> 00:12:15,790
kita mungkin perlu menyimpannya dalam array.

249
00:12:15,790 --> 00:12:19,980
Dan, kita lulus dalam empat
argumen untuk fread-- pointer

250
00:12:19,980 --> 00:12:23,940
ke lokasi di mana kami
akan menyimpan informasi,

251
00:12:23,940 --> 00:12:29,180
seberapa besar setiap unit informasi
akan, berapa banyak unit informasi

252
00:12:29,180 --> 00:12:35,192
kami ingin memperoleh, dan dari
File yang kita ingin mendapatkan mereka.

253
00:12:35,192 --> 00:12:37,150
Mungkin terbaik diilustrasikan
dengan contoh di sini.

254
00:12:37,150 --> 00:12:41,640
Jadi mari kita mengatakan bahwa kita mendeklarasikan
array 10 bilangan bulat.

255
00:12:41,640 --> 00:12:45,080
Kami baru saja dideklarasikan pada
tumpukan sewenang-wenang int arr 10.

256
00:12:45,080 --> 00:12:46,970
Jadi itu cukup sederhana.

257
00:12:46,970 --> 00:12:51,970
Sekarang apa yang kita lakukan meskipun adalah
frecall ini kita membaca ukuran int

258
00:12:51,970 --> 00:12:54,180
kali 10 byte informasi.

259
00:12:54,180 --> 00:12:59,040
Ukuran int makhluk four-- itu
ukuran integer di c.

260
00:12:59,040 --> 00:13:02,790
>> Jadi apa yang kita lakukan adalah kita membaca
40 byte senilai informasi

261
00:13:02,790 --> 00:13:05,850
dari file yang ditunjukkan oleh ptr.

262
00:13:05,850 --> 00:13:08,600
Dan kita menyimpan mereka
40 byte di suatu tempat

263
00:13:08,600 --> 00:13:12,080
di mana kami telah menyisihkan
40 byte senilai memori.

264
00:13:12,080 --> 00:13:15,970
Untungnya, kami sudah melakukan itu dengan
menyatakan arr, array itu di sana.

265
00:13:15,970 --> 00:13:19,770
Yang mampu memegang
10 unit empat-byte.

266
00:13:19,770 --> 00:13:22,860
Jadi secara total, dapat menahan 40
byte senilai informasi.

267
00:13:22,860 --> 00:13:26,540
Dan kita sekarang membaca 40 byte
informasi dari file,

268
00:13:26,540 --> 00:13:30,330
dan kita menyimpannya di arr.

269
00:13:30,330 --> 00:13:35,470
>> Ingat dari video pada pointer yang
nama array, seperti arr,

270
00:13:35,470 --> 00:13:38,370
benar-benar hanya sebuah pointer
untuk elemen pertama.

271
00:13:38,370 --> 00:13:43,680
Jadi ketika kita lulus dalam arr sana, kami
, pada kenyataannya, lewat di pointer.

272
00:13:43,680 --> 00:13:46,120
>> Demikian pula kita dapat melakukan this--
kita tidak perlu

273
00:13:46,120 --> 00:13:51,200
perlu menyimpan penyangga kami di stack.

274
00:13:51,200 --> 00:13:54,990
Kami juga bisa dinamis mengalokasikan
sebuah penyangga seperti ini, menggunakan malloc.

275
00:13:54,990 --> 00:13:57,340
Ingat, ketika kita
dinamis mengalokasikan memori,

276
00:13:57,340 --> 00:14:00,550
kita menyimpannya di
tumpukan, tidak stack.

277
00:14:00,550 --> 00:14:02,110
Tapi itu masih penyangga.

278
00:14:02,110 --> 00:14:06,810
>> Masih, dalam hal ini, adalah
memegang 640 byte informasi

279
00:14:06,810 --> 00:14:09,230
karena ganda memakan delapan byte.

280
00:14:09,230 --> 00:14:11,570
Dan kami meminta 80 dari mereka.

281
00:14:11,570 --> 00:14:13,770
Kami ingin memiliki ruang
untuk mengadakan 80 ganda.

282
00:14:13,770 --> 00:14:17,210
Jadi 80 kali 8 adalah informasi 640 byte.

283
00:14:17,210 --> 00:14:21,880
Dan bahwa panggilan untuk fread adalah
mengumpulkan 640 byte informasi

284
00:14:21,880 --> 00:14:27,770
dari file yang ditunjukkan oleh
ptr dan menyimpannya sekarang di arr2.

285
00:14:27,770 --> 00:14:32,770
>> Sekarang kita juga dapat mengobati fread
seperti panggilan untuk fgetc.

286
00:14:32,770 --> 00:14:37,140
Dalam hal ini, kami hanya mencoba untuk
mendapatkan satu karakter dari file.

287
00:14:37,140 --> 00:14:40,070
Dan kita tidak perlu
array untuk memegang karakter.

288
00:14:40,070 --> 00:14:43,170
Kami hanya dapat menyimpannya dalam
variabel karakter.

289
00:14:43,170 --> 00:14:46,390
>> Menangkap, meskipun, adalah bahwa
ketika kita hanya memiliki variabel,

290
00:14:46,390 --> 00:14:50,290
kita harus lulus dalam
alamat variabel yang

291
00:14:50,290 --> 00:14:52,550
karena ingat bahwa
Argumen pertama yang fread

292
00:14:52,550 --> 00:14:59,210
adalah pointer ke lokasi dan memori
di mana kita ingin menyimpan informasi tersebut.

293
00:14:59,210 --> 00:15:01,550
Sekali lagi, nama sebuah
array pointer.

294
00:15:01,550 --> 00:15:04,200
Jadi kita tidak perlu melakukan berbagai ampersand.

295
00:15:04,200 --> 00:15:07,270
Tapi c, karakter c
sini, tidak array.

296
00:15:07,270 --> 00:15:08,390
Ini hanya variabel.

297
00:15:08,390 --> 00:15:11,840
Dan jadi kita perlu untuk lulus
ampersand c untuk menunjukkan

298
00:15:11,840 --> 00:15:15,350
bahwa itulah alamat mana kita ingin
untuk menyimpan ini satu byte informasi,

299
00:15:15,350 --> 00:15:20,479
satu karakter ini yang
kami mengumpulkan dari ptr.

300
00:15:20,479 --> 00:15:22,270
Fwrite-- Aku akan pergi melalui
ini sedikit lebih

301
00:15:22,270 --> 00:15:25,440
quickly-- cukup banyak
setara tepat dari fread

302
00:15:25,440 --> 00:15:27,720
kecuali itu untuk menulis
bukannya membaca, hanya

303
00:15:27,720 --> 00:15:31,610
seperti other-- kami sudah terbuka
dan dekat, dapatkan karakter,

304
00:15:31,610 --> 00:15:32,530
menulis karakter.

305
00:15:32,530 --> 00:15:35,040
Sekarang mendapatkan sewenang-wenang
jumlah informasi,

306
00:15:35,040 --> 00:15:37,170
tepat jumlah sewenang-wenang informasi.

307
00:15:37,170 --> 00:15:39,790
Jadi sama seperti sebelumnya, kita dapat
memiliki sebuah array dari 10 bilangan bulat

308
00:15:39,790 --> 00:15:43,210
di mana kita sudah memiliki
informasi yang tersimpan, mungkin.

309
00:15:43,210 --> 00:15:46,580
>> Itu mungkin beberapa baris kode
yang harus pergi antara kedua

310
00:15:46,580 --> 00:15:49,990
di mana saya mengisi arr dengan
sesuatu yang berarti.

311
00:15:49,990 --> 00:15:51,880
Aku mengisinya dengan 10 bilangan bulat yang berbeda.

312
00:15:51,880 --> 00:15:54,920
Dan sebaliknya, apa yang saya
lakukan adalah menulis dari arr

313
00:15:54,920 --> 00:15:58,600
dan mengumpulkan informasi dari arr.

314
00:15:58,600 --> 00:16:02,390
Dan aku mengambil informasi yang
dan memasukkannya ke dalam file.

315
00:16:02,390 --> 00:16:05,410
>> Jadi, bukannya itu menjadi dari
file ke buffer,

316
00:16:05,410 --> 00:16:08,790
kita sekarang pergi dari
buffer ke file.

317
00:16:08,790 --> 00:16:10,580
Jadi itu hanya sebaliknya.

318
00:16:10,580 --> 00:16:16,680
Jadi sekali lagi, seperti sebelumnya, kita dapat
juga memiliki sepotong tumpukan memori

319
00:16:16,680 --> 00:16:19,600
bahwa kita sudah dinamis
dialokasikan dan membaca dari itu

320
00:16:19,600 --> 00:16:21,570
dan menulis yang ke file.

321
00:16:21,570 --> 00:16:24,900
>> Dan kami juga memiliki satu variabel
mampu menahan satu byte

322
00:16:24,900 --> 00:16:27,200
informasi, seperti karakter.

323
00:16:27,200 --> 00:16:29,830
Tapi sekali lagi, kita harus lulus dalam
alamat variabel yang

324
00:16:29,830 --> 00:16:31,840
ketika kita ingin membaca dari itu.

325
00:16:31,840 --> 00:16:35,280
Jadi kita dapat menulis informasi
kita menemukan di alamat itu

326
00:16:35,280 --> 00:16:39,050
ke file pointer, ptr.

327
00:16:39,050 --> 00:16:41,630
>> Ada banyak lainnya
File besar I / O fungsi

328
00:16:41,630 --> 00:16:44,650
yang melakukan berbagai hal selain
yang kita bicarakan hari ini.

329
00:16:44,650 --> 00:16:46,450
Beberapa yang
Anda mungkin menemukan berguna

330
00:16:46,450 --> 00:16:50,840
adalah fgets dan fputs,
yang setara dengan

331
00:16:50,840 --> 00:16:56,190
dari fgetc dan fputc tapi untuk membaca
satu string dari sebuah file.

332
00:16:56,190 --> 00:16:59,020
Alih-alih satu karakter,
itu akan membaca seluruh string.

333
00:16:59,020 --> 00:17:02,940
fprintf, yang pada dasarnya memungkinkan
Anda menggunakan printf untuk menulis ke file.

334
00:17:02,940 --> 00:17:05,619
Jadi seperti yang Anda dapat melakukan
substitusi variabel menggunakan

335
00:17:05,619 --> 00:17:09,900
i penampung persen dan
persen d, dan seterusnya, dengan printf

336
00:17:09,900 --> 00:17:14,690
Anda sama dapat mengambil
printf tali dan cetak sesuatu

337
00:17:14,690 --> 00:17:16,800
seperti itu ke sebuah file.

338
00:17:16,800 --> 00:17:20,720
>> fseek-- jika Anda memiliki DVD player
adalah analogi saya biasanya menggunakan di sini-

339
00:17:20,720 --> 00:17:23,109
adalah semacam seperti menggunakan Anda
mundur dan maju cepat

340
00:17:23,109 --> 00:17:25,819
tombol untuk bergerak di sekitar film.

341
00:17:25,819 --> 00:17:28,369
Demikian pula, Anda dapat bergerak di sekitar file.

342
00:17:28,369 --> 00:17:30,250
Salah satu hal dalam
bahwa struktur file

343
00:17:30,250 --> 00:17:34,270
yang c menciptakan untuk Anda adalah indikator
dari mana Anda berada dalam file.

344
00:17:34,270 --> 00:17:36,420
Apakah Anda di bagian paling
mulai, di byte nol?

345
00:17:36,420 --> 00:17:39,290
Apakah Anda di byte 100,
byte 1000, dan seterusnya?

346
00:17:39,290 --> 00:17:44,340
Anda dapat menggunakan fseek untuk sewenang-wenang memindahkan
bahwa indikator maju atau mundur.

347
00:17:44,340 --> 00:17:46,744
>> Dan ftell, lagi
mirip dengan DVD player,

348
00:17:46,744 --> 00:17:49,660
adalah seperti sebuah jam kecil yang memberitahu
Anda berapa menit dan detik Anda

349
00:17:49,660 --> 00:17:52,480
adalah menjadi film tertentu.

350
00:17:52,480 --> 00:17:56,990
Demikian pula, ftell memberitahu Anda bagaimana
banyak byte Anda ke file.

351
00:17:56,990 --> 00:18:00,210
feof adalah versi yang berbeda
mendeteksi apakah Anda sudah

352
00:18:00,210 --> 00:18:01,700
mencapai akhir file.

353
00:18:01,700 --> 00:18:03,600
Dan ferror adalah fungsi
Anda dapat menggunakan

354
00:18:03,600 --> 00:18:06,959
untuk mendeteksi apakah sesuatu memiliki
pergi kerja yang salah dengan file.

355
00:18:06,959 --> 00:18:08,750
Sekali lagi, ini hanya
menggaruk permukaan.

356
00:18:08,750 --> 00:18:12,730
Masih banyak lagi file I / O
fungsi dalam io.h. standar

357
00:18:12,730 --> 00:18:16,620
Tapi ini mungkin akan membuat Anda
mulai bekerja dengan berkas pointer.

358
00:18:16,620 --> 00:18:17,640
Aku Doug Lloyd.

359
00:18:17,640 --> 00:18:19,750
Ini adalah CS50.

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