关于行缓存？？？

蓝色键盘

1、斑竹，应该是>;txt 2>;&1吧！
2、一颗流星，贴上来你的代码

一颗流星

呵呵。首先，同意蓝色键盘，应该是2>;&1.
其次，蓝色键盘，我的那个程序其实跟我帖出来的程序差不多，反正是根据输入的选项进行若干操作。
fflush放的位置有要求吗？

蓝色键盘

只有某种操作向缓冲区写了数据，才有flush的必要。

一颗流星

我觉得很奇怪呀。就算它是行缓存的，一旦读入换行符，不是就执行实际的i/o操作吗？我用printf("choose\n";不是有个换行符吗？它就应该实际输出啦，怎么还会在缓存里再次被输出呢？纳闷！

uiibono

[quote]原帖由 "蓝色键盘"]只有某种操作向缓冲区写了数据，才有flush的必要。[/quote 发表：


蓝色键盘你能否贴个代码片段上来看看，
模仿对初学者来说是比较好的学习方法。

蓝色键盘

会楼上，要模仿的其实就是只要你做了io的些操作（例如printf，putc,fputs等）后需要做flush而已！这个要代码的话，也行，如下：
开始
/*调用了行缓存或者全缓存等缓存机制函数*/
fflush()
结束

I/O普及到的东西太多，而且版本之间存在不小差异，我看有必要贴个东西了！下面这个时从google中找到的，楼上两位兄弟，凑合着看一下吧！看完了估计你们都明白了。

1. 
   
2. tsinghua
   
3. 
   
4. 优秀的 Free OS (BM: suzhe ultrasparc)
   
5. 
   
6. 
   
7. 
   
8. 
   
9. 
   
10. [回到开始][上一层][下一篇]
    
11. 
    
12. 
    
13. --------------------------------------------------------------------------------
    
14. 
    
15. 发信人: kxn (哪些教研组在招人呢？faint), 信区: Linux
    
16. 标 题: [转载]-unix环境高级编程--第5章 标准I/O库
    
17. 发信站: BBS 水木清华站 (Wed Mar 15 14:11:07 2000)
    
18. 
    
19. 
    
20. 发信人: taosm (128+64-->;cool), 信区: unix
    
21. 
    
22. 标 题: unix环境高级编程--第5章 标准I/O库
    
23. 
    
24. 发信站: 西十八BBS (Fri Mar 10 11:48:39 2000), 转信
    
25. 
    
26. 
    
27. 
    
28. 第五章〓标准I/O库?
    
29. 
    
30. 5?1〓引言?
    
31. 
    
32. 本章说明标准I/O库。因为不仅在Unix而且在很多操作系统上都实现此库，所以它
    
33. 
    
34. 由ANSI C
    
35. 
    
36. 标准说明。标准I/O库处理很多细节，例如缓存分配，以优化长度执行I/O等。这样
    
37. 
    
38. 
    
39. 使用户就
    
40. 
    
41. 不必担心如何选择使用正确的块长度(如3?9节中所述)。标准I/O库是在系统调用
    
42. 
    
43. 函数基础
    
44. 
    
45. 上构造的，它便于用户使用，但是如果不较深入了解库的操作，也会带来一些问题
    
46. 
    
47. 。?
    
48. 
    
49. 标准I/O库是由Dennis Ritchie在1975年左右编写的。它是由Mike Lesk编写的可移
    
50. 
    
51. 植I/O库
    
52. 
    
53. 的主要修改版本。令人惊异的是，15年后制订的标准I/O库对它只作极小的修改。
    
54. 
    
55. ?
    
56. 
    
57. 5?2〓流和FILE对象?
    
58. 
    
59. 在第三章中，所有I/O函数都是针对文件描述符的。当打开一个文件时，即返回一
    
60. 
    
61. 
    
62. 个文件描
    
63. 
    
64. 述符，然后该文件描述符就用于后读的I/O操作。而对于标准I/O库，那么它们的操
    
65. 
    
66. 作则是围
    
67. 
    
68. 绕流(streams)进行的。(请勿将标准I/O术语流与系统V的STREAMS I/O系统相混淆
    
69. 
    
70. 。)当用标
    
71. 
    
72. 准I/O库打开或创建一个文件时，我们已使一个流与一个文件相结合。?
    
73. 
    
74. 当打开一个流时，标准I/O函数fopen返回一个指向FILE对象的指针。该对象通常是
    
75. 
    
76. 一个结构
    
77. 
    
78. ，它包含了I/O库为管理该流所需要的所有信息：用于实际I/O的文件插述符，指向
    
79. 
    
80. 流缓存的
    
81. 
    
82. 指针，缓存的长度，当前在缓存中的字符数，出错标志等等。?
    
83. 
    
84. 
    
85. 应用程序没有必要检验一个FILE对象。为了引用一个流需将FILE指针作为参数传递
    
86. 
    
87. 给每个标
    
88. 
    
89. 准I/O函数。在本书中，我们称指向FILE对象的指针类型为FILE*)为文件指针。?
    
90. 
    
91. 
    
92. 
    
93. 在本章中，我们以Unix系统为例，说明标准I/O库。正如前述，此标准库已移框到
    
94. 
    
95. 除Unix以
    
96. 
    
97. 外的很多系统中。但是为了说明该库如何实现的一些细节，我们选择Unix实现作为
    
98. 
    
99. 典型进行
    
100. 
     
101. 介绍。?
     
102. 
     
103. 5?3〓标准输入、标准输出和标准出错?
     
104. 
     
105. 对一个进程予定义了三个流，它们自动地可为进程使用：标准输入、标准输出和标
     
106. 
     
107. 
     
108. 准出错。
     
109. 
     
110. 在3?2节中我们曾用文件描述符STDIN 迹茫模＊常病紽ILENO,STDOUT 迹茫模＊常
     
111. 
     
112. 〗FILENO
     
113. 
     
114. 和STDERR 迹茫模＊常病紽ILENO分别表示它们。?
     
115. 
     
116. 这三个标准I/O流通过予定义文件指针stdin,stdout和stderr加以引用。这三个文
     
117. 
     
118. 件指针同
     
119. 
     
120. 样定义在头文件中。?
     
121. 
     
122. 5?4〓缓冲存储?
     
123. 
     
124. 标准I/O提供缓冲存储的目的是尽可能减少使用read和write调用的数量。(回忆图
     
125. 
     
126. 3?1，其
     
127. 
     
128. 中显示了在不同的缓存长度情况下，为执行I/O所需的CPU时间量。)它也对每个I/
     
129. 
     
130. 
     
131. O流自动地
     
132. 
     
133. 进行缓冲存储管理，避免了应用程序需要考虑这一点所带来的麻烦。不幸的是，标
     
134. 
     
135. 准I/O库
     
136. 
     
137. 令人最感迷惑的也是它的缓冲存储。?
     
138. 
     
139. 标准I/O提供了三种类型的缓冲存储：?
     
140. 
     
141. 1?全缓冲。在这种情况下，当填满标准I/O缓存后才进行实际I/O操作。对于驻在
     
142. 
     
143. 磁盘上的
     
144. 
     
145. 文件通常是由标准I/O库实施全缓冲的。在一个流上执行第一次I/O操作时，通常调
     
146. 
     
147. 用malloc
     
148. 
     
149. (第7?8节)标准I/O函数获得需使用的缓存。?
     
150. 
     
151. 术语刷新(flush)说明标准I/O缓存的写操作。缓存可由标准I/O例程自动地刷新(例
     
152. 
     
153. 
     
154. 如当填满
     
155. 
     
156. 一个缓存时)，或者可以调用函数fflush刷新一个流。值得引起注意的是在Unix环
     
157. 
     
158. 境中，刷
     
159. 
     
160. 新有两种意思。在标准I/O库方面，刷新意味着将缓存中的内容写到磁盘上(该缓存
     
161. 
     
162. 可以只是
     
163. 
     
164. 局部填写的)。在终端驱动程序方面(例如在第十一章中所述的teflush函数)，刷新
     
165. 
     
166. 表示丢弃
     
167. 
     
168. 已存在缓存中的数据。?
     
169. 
     
170. 2?行缓冲。在这种情况下，当在输入和输出中遇到新行符时，标准I/O库执行I/O
     
171. 
     
172. 操作。这
     
173. 
     
174. 允许我们一次输出一个字符(用标准I/O fputc函数)，但只有写了一行之后才进行
     
175. 
     
176. 
     
177. 实际I/O操
     
178. 
     
179. 作。当流涉及一个终端时(例如标准输入和标准输出)，典型地使用行缓冲。?
     
180. 
     
181. 对于行缓冲，有两个限制。第一个是：因为标准I/O库用来收集每一行的缓存的长
     
182. 
     
183. 度是固定
     
184. 
     
185. 的，所以只要填满了缓存，那么即使还没有写一个新行符，也进行I/O操作。第二
     
186. 
     
187. 个是：任
     
188. 
     
189. 何时候只要通过标准输入输出与要求从(a)一个不带缓冲的流，或者(b)一个行缓冲
     
190. 
     
191. 的流(它
     
192. 
     
193. 予先要求从系统核得到数据)得到输入数据，那么这就会造成刷新所有行缓冲输出
     
194. 
     
195. 流。?
     
196. 
     
197. 在(b)中带了一个在括号中的说明的理由是，所需的数据可能已在该缓存中，它并
     
198. 
     
199. 
     
200. 不要求系
     
201. 
     
202. 统核在需要该数据才进行该操作。很明显，从不带缓冲的一个流中进行输入((a)项
     
203. 
     
204. )要求当
     
205. 
     
206. 时从系统核得到数据。?
     
207. 
     
208. 3?不带缓冲。标准I/O库不对字符进行缓冲。如果用标准I/O函数写若干字符到不
     
209. 
     
210. 带缓冲的
     
211. 
     
212. 流中，则相当于用write系统的用函数将这些字符写全相比较的打开文件上。标准
     
213. 
     
214. 出错况std
     
215. 
     
216. err通常是不带缓存后，这就使得出错信息可以尽快显示出来，而不管它们是否含
     
217. 
     
218. 有一个新
     
219. 
     
220. 行字符。?
     
221. 
     
222. 
     
223. ANSI C要求下列缓冲特征：?
     
224. 
     
225. 1?当且仅当标准输入和标准输出并不涉及交互作用设备时，它们才是全缓冲的。
     
226. 
     
227. ?
     
228. 
     
229. 2?标准出错决不会是全缓冲的。?
     
230. 
     
231. 但是，这并没有告诉我们如果标准输入和输出涉及交互作用设备时，它们是不带缓
     
232. 
     
233. 冲的还是
     
234. 
     
235. 行缓冲的，以及标准输出是不带缓冲的，还是行缓冲的。SVR4和4?3BSD的系统默
     
236. 
     
237. 认使用下
     
238. 
     
239. 列类型的缓冲：?
     
240. 
     
241. ·标准出错是不带缓存的。?
     
242. 
     
243. ·如若是涉及终端设备的其它流，则它们是行缓冲的；否则是全缓冲的。?
     
244. 
     
245. 
     
246. 对任何一个给定的流，如果我们并不喜欢这些系统默认，则可调用下列两个函数中
     
247. 
     
248. 的一个更
     
249. 
     
250. 改缓冲类型：?
     
251. 
     
252. #include?
     
253. 
     
254. void setbuf(FILE *?fp?,char　*?buf?);?
     
255. 
     
256. int setvbuf(FILE *?fp?,char *?buf?,int ?mode?,size 迹茫模＊常病絫
     
257. 
     
258. ?size)
     
259. 
     
260. ?;?
     
261. 
     
262. 返回：若成功为0，出错为非0?
     
263. 
     
264. 这些函数一定要在流已被打开后调用(这是十分明显的，因为每个函数都要求一个
     
265. 
     
266. 有效的文
     
267. 
     
268. 
     
269. 件指针作为它们的第一个参数)，而且也应在对该流执行任何一个其它操作之前调
     
270. 
     
271. 用。?
     
272. 
     
273. 使用setbuf函数，我们可以打开或关闭缓冲机制。为了带缓存进行I/O，参数buf必
     
274. 
     
275. 须指向一
     
276. 
     
277. 个长度为BUFSIZ的缓存(该常数定义在中)。通常在此之后该流就是全缓
     
278. 
     
279. 冲的，但
     
280. 
     
281. 是如果该流与一个终端设备相关，那么某些系统也可将其设置为行缓冲的。为了关
     
282. 
     
283. 闭缓冲，
     
284. 
     
285. 将buf设置为NULL。?
     
286. 
     
287. 使用setvbuf，我们可以精确地说明我们所需的缓冲类型。这是依靠mode参数实现
     
288. 
     
289. 的：?
     
290. 
     
291. 
     
292. 迹茫模＊常病絀OFBF〓全缓冲?
     
293. 
     
294. 迹茫模＊常病絀OLBF〓行缓冲?
     
295. 
     
296. 迹茫模＊常病絀ONBF〓不带缓冲?
     
297. 
     
298. 如果我们指定一个不带缓冲的流，则忽略buf和size参数。如果我们指定全缓冲或
     
299. 
     
300. 行缓冲，
     
301. 
     
302. 则buf和size可以选择地指定一个缓存及其长度。如果该流量带缓存的，而buf是N
     
303. 
     
304. ULL，则标
     
305. 
     
306. 准I/O库将自动地为该分配适当长度的缓存。对于适当长度，我们指的是由struct
     
307. 
     
308. 结构中的
     
309. 
     
310. 成员st 迹茫模＊常病絙lksige所指定的值(见4?2节)。如果系统不能为该流失定
     
311. 
     
312. 此值(例如
     
313. 
     
314. 
     
315. 若此流涉及一个设备或一个管道)，则分配长度为BUFSIZE的缓存。?
     
316. 
     
317. 贝克莱系统首先使用st 迹茫模＊常病絙lksize表示缓存长度。较早的系统V版本使
     
318. 
     
319. 用标准I/
     
320. 
     
321. O常数BUFSIZE
     
322. 
     
323. (其典型值是1024)。即使4?3+BSD使用st 迹茫模＊常病絙lksize决定最佳的I/O缓
     
324. 
     
325. 存长度，
     
326. 
     
327. 它仍将BUFSIZE为1024。?
     
328. 
     
329. 图5?1摘要列出了这两个函数的动作，以及它们的各个选择项。???
     
330. 
     
331. 图5?1〓setbuf和setvbuf函数摘要?
     
332. 
     
333. 要了解，如果在一个函数中分配一个自动变量类的标准I/O缓存，则从该函数返回
     
334. 
     
335. 之前，我
     
336. 
     
337. 
     
338. 们必须关闭该流。(我们将在7?8节对此作更多讨论。)另外，SVR4将缓的一部分用
     
339. 
     
340. 于它自己
     
341. 
     
342. 的管理操作，所以可以存放在缓存中的实际数据字节数少于size。一般而言，应由
     
343. 
     
344. 系统选择
     
345. 
     
346. 缓存的长度，并自动分配缓存。在这样处理时，标准I/O在我们关闭此流时将自动
     
347. 
     
348. 释放此缓
     
349. 
     
350. 存。?
     
351. 
     
352. 任何时候，我们都可强制刷新一个流。?
     
353. 
     
354. #include?
     
355. 
     
356. int fflush(FILE *?fp?);?
     
357. 
     
358. 返回：若成功为0，出错为EOF?
     
359. 
     
360. 
     
361. 此函数使该流所有末写的数据都被传递至系统核。作为一种特殊情形，如若fp是N
     
362. 
     
363. ULL，则此
     
364. 
     
365. 函数刷新所有输出流。?
     
366. 
     
367. 传送一个空指针以强迫刷新所有输出流，这是新由ANSI C引入的。非ANSI C库(例
     
368. 
     
369. 如较早的
     
370. 
     
371. 系统V版本和4?3BSD)并不支持此种特征。?
     
372. 
     
373. 5?5〓打开一个流?
     
374. 
     
375. 下列三个函数打开一个标准I/O流。?
     
376. 
     
377. #include?
     
378. 
     
379. FILE *fopen(const char *?pathname,?const char *?type);??
     
380. 
     
381. FILE *freopen(const char *?pathname,?const char *?type?,FILE *?fp?
     
382. 
     
383. 
     
384. );?
     
385. 
     
386. FILE *fdopen(int filedes,const char *?type);??
     
387. 
     
388. 三个函数的返回：若成功为文件指针，出错为NULL?
     
389. 
     
390. 这三个函数的区别是：?
     
391. 
     
392. 1? fopen打开路径名由pathname指示的一个文件。?
     
393. 
     
394. 2? freopen在一个特定的流上由fp指示打开一个指定的文件(其路径名由pathnam
     
395. 
     
396. e指示)，
     
397. 
     
398. 如若该流已经打开，则先关闭该流。此函数典型用于将一个指定的文件打开为一个
     
399. 
     
400. 预定义的
     
401. 
     
402. 流：标准输入、标准输出、或标准出错。?
     
403. 
     
404. 3? fdopen取一个现存的文件插述符(我们可能从open,dup,dup2,fcntl或pipe函数
     
405. 
     
406. 
     
407. 得到此文
     
408. 
     
409. 件插述符)，并使一个标准的I/O流与该插述符相结合。此函数常用于由创建管道和
     
410. 
     
411. 网络通信
     
412. 
     
413. 通道函数获得的插述符。因为这些特殊类型的文件不能用标准I/O fopen函数打开
     
414. 
     
415. ，我们必
     
416. 
     
417. 须先调用设备-专用函数以获得一个文件描述符，然后用fdopen使一个标准I/O流与
     
418. 
     
419. 该描述
     
420. 
     
421. 符相结合。?
     
422. 
     
423. fopen和freopen是ANSI C的所属部分。因为ANSI C并不涉及文件描述符，所以POS
     
424. 
     
425. IX?1具有
     
426. 
     
427. fdopen。?
     
428. 
     
429. 
     
430. type参数指定对该I/O流的读、写方式，ANSI C规定type参数可以有15种不同的值
     
431. 
     
432. ，它们示
     
433. 
     
434. 于图5?2中。???
     
435. 
     
436. 图5?2〓打开标准I/O流的type参数?
     
437. 
     
438. 使用字符b作为type的一部分，使得标准I/O系统可以区分文本文件和两进制文件。
     
439. 
     
440. 因为Unix
     
441. 
     
442. 系统核并不对这两种文件进行区分，所以在Unix系统环境下指定字符b作为type的
     
443. 
     
444. 一部分实
     
445. 
     
446. 际上并无作用。?
     
447. 
     
448. 对于fdopen,type参数的意义则稍有区别。因为该插述符已被打开，为写而打开并
     
449. 
     
450. 不截短该
     
451. 
     
452. 
     
453. 文件。例如，若该插述符原来是由open函数打开的，该文件那时已经存在，则其O
     
454. 
     
455. 迹茫模
     
456. 
     
457. ?２〗TRUNC标
     
458. 
     
459. 志将决定是否截短该文件。fdopen函数不能截短它为写而打开的任一文件。)另外
     
460. 
     
461. ，标准I/O
     
462. 
     
463. 添加方式也不能用于创建该文件(因为如若一个插述符引用一个文件，则该文件一
     
464. 
     
465. 定已经存
     
466. 
     
467. 在)。?
     
468. 
     
469. 当用添加类型打开一文件后，则每次写都将数据写到文件的当前尾端处。如若有多
     
470. 
     
471. 个进程用
     
472. 
     
473. 标准I/O添加方式打开了同一文件，那么来自每个进程的数据都将正确地写到文件
     
474. 
     
475. 
     
476. 中。?
     
477. 
     
478. 4?3+BSD以前的贝克莱版本以及Kenighan和Ritchie〔1988〕177页上所示的简单版
     
479. 
     
480. 本并不能
     
481. 
     
482. 正确地处理添加方式。这些版本在打开流时，调用lsee，使文件位移量为文件结尾
     
483. 
     
484. 处。在涉
     
485. 
     
486. 及多个进程时，为了正确地支持添加方式，该文件必须用O 迹茫模＊常病紸PPEND
     
487. 
     
488. 标志打开
     
489. 
     
490. ，我们已在3?
     
491. 
     
492. 3节中对此进行了讨论。在每次写前，做一次lseek操作同样也不能正确工作(如同
     
493. 
     
494. 在3?11节
     
495. 
     
496. 中讨论的一样)。?
     
497. 
     
498. 
     
499. 当以读和写类型打开一文件时(type中+号)，具有下列限制：?
     
500. 
     
501. ·如果中间没有fflush?fseek、fsetpos或rewind，则在输出的后面不能直接跟随
     
502. 
     
503. 输入。?
     
504. 
     
505. ·如果中间没有fseek、fsetpos或rewind,或者一个输出操作没有到达文件尾端，
     
506. 
     
507. 则在输入
     
508. 
     
509. 操作之后不能直接跟随输出。?
     
510. 
     
511. 按照图5?2，我们在图5?3中摘要列出了打开一个流的六种不同的方式。???
     
512. 
     
513. 图5?3〓打开一个标准I/O流的六种不同的方式?
     
514. 
     
515. 注意，在指定w或a类型创建一个新文件时，我们无法说明该文件的存取数位。(在
     
516. 
     
517. 第三章中
     
518. 
     
519. 所述的open函数和creat函数则能做到这一点。)POSIX?1要求以这种方式创建的文
     
520. 
     
521. 
     
522. 件具有下
     
523. 
     
524. 列存取数：?
     
525. 
     
526. S 迹茫模＊常病絀RUSR｜S 迹茫模＊常病絀WUSR｜S 迹茫模＊常病絀RGRP｜S〖Ｃ
     
527. 
     
528. 模＊常
     
529. 
     
530. 〗IWGRP｜S 迹茫模＊常病絀ROTH｜S 迹茫模＊常病絀WOTH?
     
531. 
     
532. 除非一个流引用一个终端设备，否则按系统默认，它被打开时是全缓冲的。若一个
     
533. 
     
534. 流引用一
     
535. 
     
536. 终端设备时，该流是行缓冲的。一旦打开了流，那么在对该流执行任何操作之前，
     
537. 
     
538. 如果希望
     
539. 
     
540. ，则可使用前节所述的setbuf和setvbuf改变缓冲的类型。?
     
541. 
     
542. 调用fclose关闭一个打开的流。?
     
543. 
     
544. 
     
545. #include ?
     
546. 
     
547. int fclose(FILE *?fp?);?
     
548. 
     
549. 返回：若成功为0，出错为EOF?
     
550. 
     
551. 在该文件被关闭之前，刷新在缓存中的输出数据。在缓存中的输入数据则被丢弃。
     
552. 
     
553. 如果标准
     
554. 
     
555. I/O库已经为该流自动分配了一个缓存，则释放此缓存。?
     
556. 
     
557. 当一个进程正常终止时(直接调用exit，或从main函数返回)，则所有带来写的已在
     
558. 
     
559. 缓存中数
     
560. 
     
561. 据的标准I/O流都被刷新，所有打开的标准I/O流都被关闭。?
     
562. 
     
563. 5?6〓读、写一个流?
     
564. 
     
565. 一旦打开了一个流，则可在三种不同类型的非格式化I/O中进行选择，对其进行读
     
566. 
     
567. 
     
568. 、写操作
     
569. 
     
570. 。(在5?1)节中，我们说明了格式化I/O函数，例如printf和scanf。)?
     
571. 
     
572. 1?每次一个字符的I/O。一次读或写一个字符，如果流星带缓冲的，则标准I/O函
     
573. 
     
574. 数处理所
     
575. 
     
576. 有缓冲。?
     
577. 
     
578. 2?每次一行的I/O。使用fgets和fputs一次读或写一行。每行都以一个新行符终止
     
579. 
     
580. 。当调用
     
581. 
     
582. fgets时，我们应说明我们能处理的最大行长。我们将在5?7节中说明这两个函数
     
583. 
     
584. 。?
     
585. 
     
586. 3?直接I/O。fread和fwrite函数支持这种类型的I/O。每次I/O操作读或写某种数
     
587. 
     
588. 量的对象
     
589. 
     
590. 
     
591. ，而每个对象具有指定的长度。这两个函数常用于从二进制文件中读写一个结构。
     
592. 
     
593. 我们在5
     
594. 
     
595. ?9节中说明这两个函数。?
     
596. 
     
597. 直接I/O这个术语来自ANSI C标准，有时也被称为：二进制I/O、一次一个对象I/O
     
598. 
     
599. 、面向记
     
600. 
     
601. 录的I/O、或面向结构的I/O。?
     
602. 
     
603. 输入函数?
     
604. 
     
605. 有三个函数使我们可以一次读一个字符。?
     
606. 
     
607. #include?
     
608. 
     
609. int getc(FILE *?fp?);?
     
610. 
     
611. int fgetc(FILE *?fp?);?
     
612. 
     
613. 
     
614. int getchar(void);?
     
615. 
     
616. 三个函数的返回：若成功为下一个字符已处文件尾或出错为EOF?
     
617. 
     
618. 函数getchar等同于getc(stdin)。前二个函数的区别是getc可被实现为宏，而fge
     
619. 
     
620. tc则不能
     
621. 
     
622. 实现为宏。这意味着：?
     
623. 
     
624. 1? getc的参数不应当是具有副作用的表达式。?
     
625. 
     
626. 2?因为fgetc一定是个函数，所以我们可以得到其地址。这就允许我们将fgetc的
     
627. 
     
628. 地址作为一个参数传送给另一个函数。?
     
629. 
     
630. 3?调用fgetc所需时间很可能长于调用getc,因为调用函数通常所需的时间长于调
     
631. 
     
632. 用宏。确
     
633. 
     
634. 实，检验一下头文件的大多数实现，从中可见getc是一个宏，其编码具
     
635. 
     
636. 
     
637. 有较高的
     
638. 
     
639. 工作效率。?
     
640. 
     
641. 这三个函数以不带符号字符(unsigned char)类型转换为int的方式返回下一个字符
     
642. 
     
643. 。说明为
     
644. 
     
645. 不带符号的理由是，如果最高位为1也不会使返回值为负。要求整型返回值的理由
     
646. 
     
647. 是，这样
     
648. 
     
649. 就可以返回所有可能的字符值再加上一个已发生错误或已到达文件尾端的指示值。
     
650. 
     
651. 在
     
652. ?h>;中的常数EOF被要求是一个负值，其值经常是-1。这就意味着我们不能将这三
     
653. 
     
654. 个函数的
     
655. 
     
656. 返回值存放在一个字符变量中，我们在以后还要将这些函数的返回值与常数EOF相
     
657. 
     
658. 
     
659. 比较。?
     
660. 
     
661. 注意，不管是出错还是到达文件尾端，这三个函数都返回同样的值。为了区分这两
     
662. 
     
663. 种不同的
     
664. 
     
665. 情况，我们必须调用ferror或feof。?
     
666. 
     
667. #include?
     
668. 
     
669. int ferror(FILE *?fp?);?
     
670. 
     
671. int feof(FILE *?fp?);?
     
672. 
     
673. 二个函数返回：若条件为真为非0(真)，否则为0(假)?
     
674. 
     
675. void clearerr(FILE *?fp?);?
     
676. 
     
677. 在大多数实现的FILE对象中，为每个流保持了两个标志：?
     
678. 
     
679. ·出错标志，?
     
680. 
     
681. 
     
682. ·文件结束标志。?
     
683. 
     
684. 调用clearerr则清除这二个标志。?
     
685. 
     
686. 从一个流读之后，可以调用ungetc将字符再送回流中。?
     
687. 
     
688. #include?
     
689. 
     
690. int ungetc(int c,FILE *?fp?);?
     
691. 
     
692. 返回：若成功为C，出错为EOF?
     
693. 
     
694. 送回到流中的字符以后又可从流中读出，但读出字符的顺序与送回的顺序相反。应
     
695. 
     
696. 当了解，
     
697. 
     
698. 虽然ANSI C允许支持任何数量的字符回送的实现，但是它要求任何一种实现都要支
     
699. 
     
700. 持一个字
     
701. 
     
702. 符的回送功能。?
     
703. 
     
704. 
     
705. 回送的字符，不必一定是上一次读到的字符。不能回送EOF。但是当已经到达文件
     
706. 
     
707. 尾端时，
     
708. 
     
709. 我们仍可以回送一字符。下次读将返回该字符，再次读则返回EOF。所以能这样做
     
710. 
     
711. 的原因是
     
712. 
     
713. 一次成功的ungetc调用会清除该流的文件结束指示。?
     
714. 
     
715. 当正在读一个输入流，并进行某种形式的分字或分配号操作时，经常使用回送字符
     
716. 
     
717. 操作。有
     
718. 
     
719. 时我们需要先看一看下一个字符，以决定如何处理当前字符。然后就需要方便地将
     
720. 
     
721. 刚查看的
     
722. 
     
723. 字符送回，以便下一次调用getc时返回该字符。如果标准I/O库不提供回送能力，
     
724. 
     
725. 就需将该
     
726. 
     
727. 
     
728. 字符存放到一个我们自己的变量中，并设置一个标志以便差别在下一次需要一个字
     
729. 
     
730. 符时是调
     
731. 
     
732. 用getc，还是从我们自己的变量中取用。?
     
733. 
     
734. 输出函数?
     
735. 
     
736. 对应于上面所述的每个输入函数都有一个输出函数。?
     
737. 
     
738. #include?
     
739. 
     
740. int putc(int ?c?,FILE *?fp?);?
     
741. 
     
742. int fputc(int ?c?,FILE *?fp?）;?
     
743. 
     
744. int putchar(int ?c?);?
     
745. 
     
746. 三个函数返回：若成功为C，出错为EOF?
     
747. 
     
748. 与输入函数一样，putchar(c)等同于putc(c,stdout),putc可被实现为宏，而fput
     
749. 
     
750. 
     
751. c则不能实
     
752. 
     
753. 现为宏。?
     
754. 
     
755. 5?7〓每次一行I/O?
     
756. 
     
757. 下面二个函数提供每次输入一行的功能。?
     
758. 
     
759. #include?
     
760. 
     
761. char *fgets(char *?buf?,int ?n?，FILE *?fp?）；?
     
762. 
     
763. char *gets(char *?buf?);?
     
764. 
     
765. 二个函数返回：若成功为buf,已处文件尾或出错为NULL?
     
766. 
     
767. 这两个函数都指定了缓存地址，读入的行将送入其中。gets从标准输入读，而fge
     
768. 
     
769. ts则从指
     
770. 
     
771. 定的流读。?
     
772. 
     
773. 
     
774. 对于fgets，我们必须指定缓存的长度，n。此函数一直读到并包括下一个新行符为
     
775. 
     
776. 止，但是
     
777. 
     
778. 不超过n-1字符，读入的字符都送入缓存。该缓存以null字符结尾。如若该行，包
     
779. 
     
780. 括最后一
     
781. 
     
782. 个新行符的字符数超过n-1,则只返回一个不完整的行，而且缓存总是以null字符结
     
783. 
     
784. 尾。对fg
     
785. 
     
786. ets的下一次调用则会继续读该行。?
     
787. 
     
788. gets是一个不推荐使用的函数。问题是调用者在使用gets时不能指定缓存的长度。
     
789. 
     
790. 这样就可
     
791. 
     
792. 能造成缓存越界(如若该行长于缓存长度)，写到缓存之后的存储空间中，从而产生
     
793. 
     
794. 不可予料
     
795. 
     
796. 
     
797. 的后果。这种缺陷曾被利用来构成1988的Internet蠕虫。关于这种情况的说明清见
     
798. 
     
799. ACM通信J
     
800. 
     
801. une 1989(Vol?32,No?6)。gets与fgets的另一个区别是，gets并不将新行符存入
     
802. 
     
803. 缓存中。
     
804. 
     
805. ?
     
806. 
     
807. 这两个函数对新行符进行处理方面的差别与Unix的进展有关。早在Version 7的手
     
808. 
     
809. 册中就说
     
810. 
     
811. 明："为了向后兼容，gets删除新行符，而fgets则保持新行符。"?
     
812. 
     
813. 虽然ANSI C要求提供gets,但请不要使用它。?
     
814. 
     
815. fputs和puts提供每次输出一行的功能。?
     
816. 
     
817. #include?
     
818. 
     
819. 
     
820. int fputs(const char *?str,?FILE *?fp?);?
     
821. 
     
822. int puts(const char *?str);??
     
823. 
     
824. 二个函数返回：若成功为非负值，出错为EOF?
     
825. 
     
826. 函数fputs将一个以null符终止的字符串写到指定的流，终止符null不写出。注意
     
827. 
     
828. ，这并不
     
829. 
     
830. 一定是每次输出一行，因为它并不要求在null符之前一定是新行符。通常，在nul
     
831. 
     
832. l符之前是
     
833. 
     
834. 一个新行符，但并不要求总是如此。?
     
835. 
     
836. puts将一个以null符终止的字符串写到标准输出，终止符不写出。但是，puts然后
     
837. 
     
838. 又将一个
     
839. 
     
840. 新行符写到标准输出。?
     
841. 
     
842. 
     
843. puts并不象它所对应的gets那样不安全。但是我们还是避免使用它，以免需要记住
     
844. 
     
845. 它在最后
     
846. 
     
847. 又加上了一个新行符。如果总是使用fgets和fputs,那么就会熟悉在每行终止处我
     
848. 
     
849. 们必须自
     
850. 
     
851. 己加一个新行符。?
     
852. 
     
853. 5?8〓标准I/O的效率?
     
854. 
     
855. 使用前面部分所述的函数，我们可以对标准I/O系统的效率有所了解。程序5?1类
     
856. 
     
857. 似于程序
     
858. 
     
859. 3?3，它使用getc和putc将标准输入复制到标准输出。这两个函数可以实现为宏。
     
860. 
     
861. ???
     
862. 
     
863. 程序5?1〓用getc和putc将标准输入复制到标准输出?
     
864. 
     
865. 
     
866. 我们可以用fgetc和fputc改写该程序，这两个一定是函数，而不是宏。(我们没有
     
867. 
     
868. 示出对源
     
869. 
     
870. 代码更改的细节。)?
     
871. 
     
872. 最后，我们还编写了一个读、写行的版本，程序5?2。???
     
873. 
     
874. 程序5?2〓用fgets和fputs将标准输入复制到标准输出?
     
875. 
     
876. 注意，在程序5?1和程序5?2中，我们没有显式地关闭标准I/O流。我们知道exit
     
877. 
     
878. 函数将会
     
879. 
     
880. 刷新任何未写的数据，然后关闭所有打开的流。(我们将在8?5节讨论这一点。)将
     
881. 
     
882. 这三个程
     
883. 
     
884. 序的时间与图3?1中的时间进行比较是很有趣的。我们在图5?4中显示了对同一文
     
885. 
     
886. 件(1?5M
     
887. 
     
888. 
     
889. bytes,30,000行)进行操作所得的数据。???
     
890. 
     
891. 图5?4〓使用标准I/O例程得到的时间结果?
     
892. 
     
893. 对于这三个标准I/O版本的每一个，其用户CPU时间都是大于图3?1中的最佳read版
     
894. 
     
895. 本，因为
     
896. 
     
897. 每次读一个字符版本中有一个要执行150万次的循环，而在每次读1行的版本中有一
     
898. 
     
899. 个要执行
     
900. 
     
901. 30，000次的循环。在read版本中，其循环只需执行180次(对于缓存长度为8192字
     
902. 
     
903. 节)。因为
     
904. 
     
905. 系统CPU时间都相同，所以用户CPU时间的差别造成了时钟时间的差别。?
     
906. 
     
907. 系统CPU时间相同的原因是因为所以这些程序对系统核提出的读、写请求数相同。
     
908. 
     
909. 注意，使
     
910. 
     
911. 
     
912. 用标准I/O例程的一个优点是我们无需考虑缓冲及最佳I/O长度的选择。我们在使用
     
913. 
     
914. fgets时
     
915. 
     
916. 需要考虑最大行长，但是最佳I/O长度的选择要方便得多。?
     
917. 
     
918. 图5?4中的最后一列是每个main函数的文本空间字节数(由C编译产生的机器指令)
     
919. 
     
920. 。从中可
     
921. 
     
922. 见，使用getc的版本在文本空间中作了getc和putc的宏代换，所以它所需使用的指
     
923. 
     
924. 令数超过
     
925. 
     
926. 了调用fgetc和fputc函数所需指令数。观察getc版本和fgetc版本在用户CPU时间方
     
927. 
     
928. 面的差别
     
929. 
     
930. ，可以看到在程序中作宏代换和调用两个函数在进行本测试的系统上并没有造成多
     
931. 
     
932. 大差别。
     
933. 
     
934. 
     
935. ?
     
936. 
     
937. 使用每次一行I/O版本其速度大约是每次一个字符版本的两倍(用户CPU时间和时钟
     
938. 
     
939. 时间两者)
     
940. 
     
941. 。如果fgets和fputs函数是用getc和putc实现的(例如，见Kesnighan和Ritchie〔
     
942. 
     
943. 1988〕的7
     
944. 
     
945. ?7节)，那么，可以予期fgets版本的时间会与getc版本相接近。实际上，我们可
     
946. 
     
947. 以予料每
     
948. 
     
949. 次一行的版本会更慢一些，因为除了现已存在的60，000次函数调用外还需增加了
     
950. 
     
951. 百万次宏
     
952. 
     
953. 调用。而在本测试中所用的每次一行函数是用memccopy(3)实现的。通常，为了提
     
954. 
     
955. 高效率，m
     
956. 
     
957. 
     
958. emccpy函数是用汇编语言而非C语言编写的。?
     
959. 
     
960. 这些时间数字的最后一个有趣三点是：fgetc版本较图3?1中BUFSIZE＝１的版本要
     
961. 
     
962. 快得多。
     
963. 
     
964. 两者都使用了约3百次的函数调用，而fgetc版本的速度在用户CPU时间方面，大约
     
965. 
     
966. 是后者的5
     
967. 
     
968. 倍，而在时钟时间方面则几乎是100倍。造成这种差别的原因是：使用read的版本
     
969. 
     
970. 执行了3百
     
971. 
     
972. 万次函数调用，这也就引起3百万次系统调用。而对于fgetc版本，它也执行3百万
     
973. 
     
974. 次函数调
     
975. 
     
976. 用，但是这只引起360次系统调用。系统调用与普通的函数调用相比是很花费时间
     
977. 
     
978. 的。?
     
979. 
     
980. 
     
981. 需要声明的是这些时间结果只在某些系统只才是有效的。这种时间结果依赖于很多
     
982. 
     
983. 实现的特
     
984. 
     
985. 征，而这种特征对于不同的Unix系统却可能是不同的。尽管如此，有这样一组数据
     
986. 
     
987. ，并对它
     
988. 
     
989. 们的差别作出解释，这有助于我们更好地了解系统。?
     
990. 
     
991. 在本节及3?9节中我们学到的基本事实是：标准I/O库与直接调用read和write函数
     
992. 
     
993. 相比并不
     
994. 
     
995. 慢很多。我们观察到的大致代价是使用getc和putc复制1Mbyte数据大约需3?0秒C
     
996. 
     
997. PU时间。
     
998. 
     
999. 对于大多数比较复杂的应用程序，最主要的用户CPU时间是由应用本身的各种处理
     
1000. 
      
1001. 花费的，
      
1002. 
      
1003. 
      
1004. 而不是由标准I/O例程消耗的。?
      
1005. 
      
1006. 5?9〓两进制I/O?
      
1007. 
      
1008. 5?6节中的函数是以一次一个字符或一次一行的方式进行操作的。如若做两进制Ｉ
      
1009. 
      
1010. ／Ｏ，那
      
1011. 
      
1012. 么我们一次愿忌读、写一整个结构。为了使用getc或putc做到这一点，我们必须循
      
1013. 
      
1014. 环通过整
      
1015. 
      
1016. 个结构，一次读、写一个字节。因为fputs在遇到null字节时就停止，而在结构中
      
1017. 
      
1018. 可能含有n
      
1019. 
      
1020. ull字节，所以我们不能使用每次一行函数实现这种要求。相类似，如果输入数据
      
1021. 
      
1022. 中包含有n
      
1023. 
      
1024. ull字节或新行符，则fgets也不能正确工作。因此，提供了下列两个函数以执行两
      
1025. 
      
1026. 
      
1027. 进制I/O
      
1028. 
      
1029. 操作。?
      
1030. 
      
1031. #include?
      
1032. 
      
1033. size 迹茫模＊常病絫 fread(void *?ptr?,size 迹茫模＊常病絫 ?size?，s
      
1034. 
      
1035. ize ＣＤ
      
1036. 
      
1037. ＊常病絫 ?nobj?,FILE *?fp?);?
      
1038. 
      
1039. size 迹茫模＊常病絫 fwrite(const void *?ptr?,size 迹茫模＊常病絫 ?si
      
1040. 
      
1041. ze?，siz
      
1042. 
      
1043. e 迹茫模＊常病絫 ?nobj?,FILE *?fp?);?
      
1044. 
      
1045. 二个函数的返回：读或写的对象数?
      
1046. 
      
1047. 这些函数有两个常见的用法。?
      
1048. 
      
1049. 
      
1050. 1?读或写一个两进制数组。例如，将一个浮点数组的第2至第5个元素写至一个文
      
1051. 
      
1052. 件上，我
      
1053. 
      
1054. 们可以写成：?
      
1055. 
      
1056. float data〔10〕;?
      
1057. 
      
1058. if(fwrite(& data〔２〕,sizeof(float),4,fp)!=4)?
      
1059. 
      
1060. err 迹茫模＊常病絪ys(″fwrite error″);?
      
1061. 
      
1062. 其中，指定size为每个数组元素的长度，nobj为欲写的元素数。?
      
1063. 
      
1064. 2?读或写一个结构，例如，我们可以写成：?
      
1065. 
      
1066. struct {?
      
1067. 
      
1068. short count;?
      
1069. 
      
1070. long total;?
      
1071. 
      
1072. 
      
1073. char name［NAMESIZE］；?
      
1074. 
      
1075. }item;?
      
1076. 
      
1077. if(fwrite(&item,sizeof(item),1,fp)!=1)?
      
1078. 
      
1079. err 迹茫模＊常病絪ys(″fwrite error″);?
      
1080. 
      
1081. 其中，我们指定size为结构的长度，nobj为1(要写的对象数)。将这两个例子结合
      
1082. 
      
1083. 起来就可
      
1084. 
      
1085. 读或写一个结构数组。为了做到这一点，size应当是该结构的sizeof,nobj应是该
      
1086. 
      
1087. 数组中的
      
1088. 
      
1089. 元素数。?
      
1090. 
      
1091. fiead和fwrite返回读或写的对象数。对于读，如果出错或读到了文件尾端，则此
      
1092. 
      
1093. 数字可以
      
1094. 
      
1095. 
      
1096. 少于nobj。在这种情况，应调用ferror或feof，以判断究竟是那一种情况。对于写
      
1097. 
      
1098. ，如果返
      
1099. 
      
1100. 回值少于所要求的nobj，则出错。?
      
1101. 
      
1102. 使用两进制I/O的基本问题是，它只能用于读在同一系统上原先写的数据。在很多
      
1103. 
      
1104. 年之前，
      
1105. 
      
1106. 这并无问题(那时，所有Unix系统都在ppp-11上运行)，而现在，很多异构系统通过
      
1107. 
      
1108. 网相互连
      
1109. 
      
1110. 接起来，而且，这种情况已经非常普遍。常常有这种情形，在一个系统上写的数据
      
1111. 
      
1112. ，在另一
      
1113. 
      
1114. 个系统上处理。在这种环境下，这两个函数可能就不能正常工作，其原因是：?
      
1115. 
      
1116. 1?在一个结构中，同一成员的位移量可能随编译程序和系统的不同而异。(由于不
      
1117. 
      
1118. 
      
1119. 同的对准
      
1120. 
      
1121. 要求。)确实，某些编译程序有一选择项，它允许紧密包装结构(节省存储空间，而
      
1122. 
      
1123. 运行性能
      
1124. 
      
1125. 则可能有所下降)或准确对齐，以便在运行时易于存取结构中各成员。这意味着即
      
1126. 
      
1127. 使在单一
      
1128. 
      
1129. 系统上，一个结构的两进制存放结构也可能因编译程序的选择项而不同。?
      
1130. 
      
1131. 2?用来存储多字节整数和浮点值的两进制格式在不同的系统结构间也可能是不同
      
1132. 
      
1133. 的。?
      
1134. 
      
1135. 在不同系统之间交换两进制数据的实际解决方法是使用较高层次的协议。关于网络
      
1136. 
      
1137. 协议作用
      
1138. 
      
1139. 的交换两进制数据的某些技术，请参阅Stevens〔１９９０〕的18?2节。?
      
1140. 
      
1141. 
      
1142. 在8?13节中，我们将再回到fread函数，那时将用它读一个两进制结构-Unix的进
      
1143. 
      
1144. 程记账记
      
1145. 
      
1146. 录。?
      
1147. 
      
1148. 5?10〓定位一个流?
      
1149. 
      
1150. 有两种方法定位一个标准I/O流。?
      
1151. 
      
1152. 1? ftell和fseek。这两个函数自Version 7以来就存在了，但是它们都假定文件
      
1153. 
      
1154. 的位置可
      
1155. 
      
1156. 以存放在一个长整型中。?
      
1157. 
      
1158. 2? fgetpos和fsetpos。这两个函数是新由ANSI C引入的。它们引进了一个新的抽
      
1159. 
      
1160. 象数据类
      
1161. 
      
1162. 型，fpos 迹茫模＊常病絫,它记录文件的位置。在非Unix系统中，这种数据类型可
      
1163. 
      
1164. 
      
1165. 以定义为
      
1166. 
      
1167. 记录一个文件的位置所需的长度。?
      
1168. 
      
1169. 需要移植到非Unix系统上运行的应用程序应当使用fgetpos和fsetpos。?
      
1170. 
      
1171. #include?
      
1172. 
      
1173. long ftell(FILE *?fp?);?
      
1174. 
      
1175. 返回：若成功为当前文件位置指示，出错为-1L?
      
1176. 
      
1177. int fseek(FILE *?fp?,long ?offset?,int ?whence);??
      
1178. 
      
1179. 返回：若成功为0，出错为非0?
      
1180. 
      
1181. void rewind(FILE *?fp);??
      
1182. 
      
1183. 对于一个两进制文件，其位置指示器是从文件起始位置开始度量，并以字节为计量
      
1184. 
      
1185. 单位的。
      
1186. 
      
1187. 
      
1188. ftell用于两进制文件时，其返回值就是这种字节位置。为了用fseek定位一个两进
      
1189. 
      
1190. 制文件，
      
1191. 
      
1192. 必须指定一个字节位移量，以及解释这种位移量的方式。whence的值与3?6节中l
      
1193. 
      
1194. seek函数
      
1195. 
      
1196. 的相同：SEEK 迹茫模＊常病絊ET表示从文件的起始位置开始计算位移量；SEEK〖
      
1197. 
      
1198. 茫模＊
      
1199. 
      
1200. ２〗CVR表示从当前文件位置；
      
1201. 
      
1202. SEEK 迹茫模＊常病紼ND表示从文件的尾端。ANSI C并不要求一个实现对两进制文
      
1203. 
      
1204. 件支持SEE
      
1205. 
      
1206. K 迹茫模＊常病紼ND规格说明
      
1207. 
      
1208. ，其原因是某些系统要求两进制文件的长度是某个幻数的整数倍，不是部分则充填
      
1209. 
      
1210. 
      
1211. 为0。但
      
1212. 
      
1213. 是在Unix中，对于两进制文件SEEK 迹茫模＊常病紼ND是得到支持的。?
      
1214. 
      
1215. 对于文本文件，它们的文件当前位置可能不以简单的字节位移量来度量。再一次，
      
1216. 
      
1217. 这主要也
      
1218. 
      
1219. 是在非Unix系统中，它们可能以不同的格式存放文本文件。为了定位一个文本文件
      
1220. 
      
1221. ，whence
      
1222. 
      
1223. 一定要是SEEK 迹茫模＊常病絊ET,而且offset只能有两种值：0(表示反绕文件关其
      
1224. 
      
1225. 起始位置
      
1226. 
      
1227. )，或
      
1228. 
      
1229. 是对该文件的ftell所返回的值。使用rewind函数也可将一个流设置到文件的起始
      
1230. 
      
1231. 位置。?
      
1232. 
      
1233. 
      
1234. 正如我们已提及的，下列两个函数是C标准新引进的。?
      
1235. 
      
1236. #include?
      
1237. 
      
1238. int fgetpos(FILE *?fp?,fpos 迹茫模＊常病絫 *?pos?);?
      
1239. 
      
1240. int fsetpos(FILE *?fp?,const fpos 迹茫模＊常病絫 *?pos?);?
      
1241. 
      
1242. 二个函数返回：若成功为0，出错为非0?
      
1243. 
      
1244. fgetpos将文件位置指示器的当前值存入由pos指向的对象中。在以后调用fsetpos
      
1245. 
      
1246. 时，可以
      
1247. 
      
1248. 使用此值将流重新定位至该位置。?
      
1249. 
      
1250. 5?11〓格式化I/O?
      
1251. 
      
1252. 格式化输出?
      
1253. 
      
1254. 执行格式化输出处理的是三个printf函数。?
      
1255. 
      
1256. 
      
1257. #include?
      
1258. 
      
1259. int printf(const char *?format,????);?
      
1260. 
      
1261. int fprintf(FILE *?fp?,const char *?format,????);?
      
1262. 
      
1263. 二个函数返回：若成功为输出字符数，若输出了错为负值?
      
1264. 
      
1265. int sprintf(char *?buf?,const char *?format,????);?
      
1266. 
      
1267. 返回：存入数组的字符数?
      
1268. 
      
1269. printf将格式化数据写到标准输出，fprintf写至指定的流，sprintf将格式化的字
      
1270. 
      
1271. 符送入数
      
1272. 
      
1273. 组buf中。sprintf在该数组的尾端自动加一个null字节，但该字节不包括在返回值
      
1274. 
      
1275. 中。?
      
1276. 
      
1277. 4?3BSD定义sprintf返回第一个参数(缓存指针，类型为char*)，而不是一个整型
      
1278. 
      
1279. 
      
1280. 。ANSI C
      
1281. 
      
1282. 要求sprintf返回一个整型。?
      
1283. 
      
1284. 注意，sprintf可能会造成由buf指向的缓存的越界(溢出)。保证该缓存有足够长度
      
1285. 
      
1286. 是调用者
      
1287. 
      
1288. 的责任。?
      
1289. 
      
1290. 对这三个函数可能使用的各种格式变换，请参阅Unix手册，或Kesmighan和Ritchi
      
1291. 
      
1292. e〔1988〕
      
1293. 
      
1294. 的附录B。?
      
1295. 
      
1296. 下列三种printf族的变体类似于上面的三种，但是可变参数表(???)代换成了a
      
1297. 
      
1298. rg。?
      
1299. 
      
1300. #include?
      
1301. 
      
1302. 
      
1303. 88〕的7?
      
1304. 
      
1305. 3节。应当了解的是，由ANSI C提供的可变长度参数表例程(头文件和
      
1306. 
      
1307. 相关的例
      
1308. 
      
1309. 程)与由SVR3(以及更早版本)和4?3BSD提供的例程是不同的。?
      
1310. 
      
1311. 格式化输入?
      
1312. 
      
1313. 执行格式化输入处理的是三个scanf函数。?
      
1314. 
      
1315. #include?
      
1316. 
      
1317. int scanf(const char *?format,????);?
      
1318. 
      
1319. int fscanf(FILE *?fp?,const char *?format,????);?
      
1320. 
      
1321. int sscanf(const char *?buf?,const char *?format,???);??
      
1322. 
      
1323. 三个函数返回：指定的输入项数，若输入出错，叵在任一变换前已至文件尾则为E
      
1324. 
      
1325. 
      
1326. OF?
      
1327. 
      
1328. 如同printf族一样，关于这三个函数的各个格式选择项的详细情况，请参阅Unix手
      
1329. 
      
1330. 册。?
      
1331. 
      
1332. 5?12〓实现细节?
      
1333. 
      
1334. 正如我们已提及的，在Unix中，标准I/O库最终都要调用第三章中说明的I/O例程。
      
1335. 
      
1336. 每个I/O
      
1337. 
      
1338. 流都有一个与其相关联的文件插述符，可以对一个流调用fileno以获得其插述符。
      
1339. 
      
1340. ?
      
1341. 
      
1342. #include?
      
1343. 
      
1344. int fileno(FILE *?fp?）；?
      
1345. 
      
1346. 返回：与该流相关联的文件描述符?
      
1347. 
      
1348. 
      
1349. 如果要调用dup或fcntl等函数，那么就需要此函数。?
      
1350. 
      
1351. 为了了解你所使用的系统中标准I/O库的实现，最好从头文件开始。从
      
1352. 
      
1353. 中可以看
      
1354. 
      
1355. 到
      
1356. 
      
1357. ；FILE对象是如何定义的；每个流的标志的定义；定义为宏的各个标准I/O例程(例
      
1358. 
      
1359. 如getc)
      
1360. 
      
1361. 。Keinighan和Ritche〔1988〕中的8?5节含有一个简单的实现，从中可以看到很
      
1362. 
      
1363. 多Unix实
      
1364. 
      
1365. 现的基本样式。Plallger〔1992〕的第十二章提供了标准I/O库一种实现的全部源
      
1366. 
      
1367. 代码。4?
      
1368. 
      
1369. 3＋BSD中标准I/O库的实现(由Chris Torek编写)也是公开可以使用的。?
      
1370. 
      
1371. 
      
1372. 实例?
      
1373. 
      
1374. 程序5?3为三个标准流以及一个与一个普通文件相关联的流打印有关缓冲状态信息
      
1375. 
      
1376. 。注意，
      
1377. 
      
1378. 在打印缓冲状态信息之前，先对每个流执行I/O操作，因为第一个I/O操作通常就造
      
1379. 
      
1380. 成为该流
      
1381. 
      
1382. 分配缓存。结构成员 迹茫模＊常病紽lag、 迹茫模＊常病絙ufsize以及常数〖Ｃ
      
1383. 
      
1384. 模＊常
      
1385. 
      
1386. 〗IONBF和 迹茫模＊常病絀OLBF是由作者所使用的系统定义的。?
      
1387. 
      
1388. 如果我们运行程序5?3两次，一次使三个标准与终端相连接，另一次使它们重定向
      
1389. 
      
1390. 到普通文
      
1391. 
      
1392. 件，则所得结果是：?
      
1393. 
      
1394. 
      
1395. $ a?out〓?stdin,stdout和stderr?都连至终端?
      
1396. 
      
1397. enter any character〓键入新行符?
      
1398. 
      
1399. one line to standard error?
      
1400. 
      
1401. stream=stdin,line buffered,buffer size=128?
      
1402. 
      
1403. stream=stdout,line buffered,buffer size=128?
      
1404. 
      
1405. stream=stderr,unbuffered,buffer size=8?
      
1406. 
      
1407. stream=/etc/motd,fully buffered,buffer size=8192?
      
1408. 
      
1409. $ a?outstd?out 2>;std?err〓三个流都重定向，再次运行该程
      
1410. 
      
1411. 序?
      
1412. 
      
1413. $ cat std?err?
      
1414. 
      
1415. one line to standard error?
      
1416. 
      
1417. 
      
1418. $ cat std?out?
      
1419. 
      
1420. enter any character?
      
1421. 
      
1422. stream=stdin,fully buffered,buffer size=8192?
      
1423. 
      
1424. stream=stdout,fully buffered,buffer size=8192?
      
1425. 
      
1426. stream=stderr,unbuffered,buffer size=8?
      
1427. 
      
1428. stream=/etc/motd,fully buffered,buffer size=8192???
      
1429. 
      
1430. 程序5?3〓对各个标准I/O流打印缓冲状态信息?
      
1431. 
      
1432. 从中可见，该系统的默认是：当标准输入、输出连至终端时，它们是行缓冲的。行
      
1433. 
      
1434. 缓存的长
      
1435. 
      
1436. 度是128bytes。注意，这并没有将输入、输出的行长限制为128bytes,这些是缓存
      
1437. 
      
1438. 的长度。
      
1439. 
      
1440. 
      
1441. 将512bytes的行写到标准输出会四次调用write系统调用。当将这两个流重新定向
      
1442. 
      
1443. 到普通文
      
1444. 
      
1445. 件时，它们扰变或是全缓冲的，其缓存长度是该文件系统优先选用的I/O长度(从s
      
1446. 
      
1447. tat结构中
      
1448. 
      
1449. 得到的st 迹茫模＊常病絙lksize)。从中也可看到，标准出错如它所应该的那样是
      
1450. 
      
1451. 非缓冲的
      
1452. 
      
1453. ，而普通文件按系统默认是全缓冲的。?
      
1454. 
      
1455. 5?13〓临时文件?
      
1456. 
      
1457. 标准I/O库提供了二个函数以帮助创建临时文件。?
      
1458. 
      
1459. #include?
      
1460. 
      
1461. char *tmpnam(char *?ptr?);?
      
1462. 
      
1463. 
      
1464. 返回：指向-唯一路径名的指针?
      
1465. 
      
1466. FILE *tmpfile(void);?
      
1467. 
      
1468. 返回：若成功为文件指针，出错为NULL?
      
1469. 
      
1470. temnam产生一个与现在文件名不同的一个有效路径名字符串。每次调用它时，它都
      
1471. 
      
1472. 产生一个
      
1473. 
      
1474. 不同的路径名，最多调用次数是TMP 迹茫模＊常病組AX。TMP 迹茫模＊常病組AX定
      
1475. 
      
1476. 义在
      
1477. io?h>;中。?
      
1478. 
      
1479. 虽然TMP 迹茫模＊常病組AX是由ANSI C定义的。但该C标准只要求其值至少应为25
      
1480. 
      
1481. 。但是，X
      
1482. 
      
1483. PG都要求其值
      
1484. 
      
1485. 
      
1486. 至少为10，000。在此最小值允许一个实现使用4位数字作为临时文件名的同时(00
      
1487. 
      
1488. 00～９９
      
1489. 
      
1490. ９９），大多数Unix实现用的却是大、小写字符。?
      
1491. 
      
1492. 若ptr是NULL，则所产生的路径名存放在一个静态区中，指向该静态区的指针作为
      
1493. 
      
1494. 函数值返
      
1495. 
      
1496. 回。下一次再调用tmpnam时，会重写该静态区。(这忌味着，如果我们调用此函数
      
1497. 
      
1498. 多次，而
      
1499. 
      
1500. 且想保存路径名，则我们应当保存该路径名的副本，而不是指针的副本。)如若pt
      
1501. 
      
1502. r不是NULL
      
1503. 
      
1504. ，则认为它指向长度至少是L 迹茫模＊常病絫mpnam个字符的数组。(常数L ＣＤ
      
1505. 
      
1506. ＊常病絫
      
1507. 
      
1508. 
      
1509. mpanam
      
1510. 
      
1511. 定义在头文件中。)所产生的路径名存放在该数组中，ptr也作为函数值
      
1512. 
      
1513. 返回。?
      
1514. 
      
1515. tmpfile创建一个临时二进制文件(类型wb+),在关闭该文件时，或程序结束时将自
      
1516. 
      
1517. 动删除这
      
1518. 
      
1519. 种文件。注意，UNIX对二进制文件都不作特殊区分。?
      
1520. 
      
1521. 实例?
      
1522. 
      
1523. 程序5?4说明了这两个函数的应用。若执行程序5?4，则得：?
      
1524. 
      
1525. $ a?out?
      
1526. 
      
1527. /usr/tmp/aaaa 00470?
      
1528. 
      
1529. /usr/tmp/baaa 00470?
      
1530. 
      
1531. 
      
1532. one line of output?
      
1533. 
      
1534. 加到临时文件名中的5位数字后缀是进程ID。这就保证了对各个进程产生的路径名
      
1535. 
      
1536. 都会不同
      
1537. 
      
1538. 。?
      
1539. 
      
1540. tmpfile函数经常使用的标准Unix技术是先调用tempnam产生一个唯一的路径名，然
      
1541. 
      
1542. 后立即un
      
1543. 
      
1544. link它。???
      
1545. 
      
1546. 程序5?4〓tmpnam和tmpfile函数应用实例?
      
1547. 
      
1548. 请回忆4?15节，对一个文件解除连接，并不删除其内容，关闭该文件时才删除其
      
1549. 
      
1550. 内容。?
      
1551. 
      
1552. tempnam是tmpnam的一个变体，它允许调用者为所产生的路径名指定目录和前缀。
      
1553. 
      
1554. 
      
1555. ?
      
1556. 
      
1557. 对于目录有四种不同的选择，并且使用第一个为真的作为目录：?
      
1558. 
      
1559. 1?如果定义了环境变量TMPDIR，则用其作为目录。(在7?9节中将说明环境变量。
      
1560. 
      
1561. )?
      
1562. 
      
1563. 2?如果参数directory非NULL，则用其作为目录。?
      
1564. 
      
1565. 3?在中的字符串P 迹茫模＊常病絫mpdir用作为目录。?
      
1566. 
      
1567. 4?本地目录，通常是/tmp,用作为目录。?
      
1568. 
      
1569. 如果prefix非NULL，则它应该是最多包含5个字符的字符串，用其作为文件名的头
      
1570. 
      
1571. 几个字符
      
1572. 
      
1573. 。?
      
1574. 
      
1575. 该函数调用malloc函数分配动态存储区，用其存放所构造的路径名。当我们不再使
      
1576. 
      
1577. 
      
1578. 用此路径
      
1579. 
      
1580. 名时就可释放此存储区。(在7?8节中说明malloc和fiee函数。)?
      
1581. 
      
1582. tempnam不是POSIX?1和ANSI C的所属部分，它是XPG3的所属部分。?
      
1583. 
      
1584. 我们所说明的实现对应于SVR4和4?3＋ＢＳＤ。除了XPG3版本，不支持环境变量T
      
1585. 
      
1586. MPDIR之外
      
1587. 
      
1588. ，其它则与此相同。?
      
1589. 
      
1590. 实例?
      
1591. 
      
1592. 程序5?5显示了tempnam的应用???
      
1593. 
      
1594. 程序5?5〓tempnam函数的应用?
      
1595. 
      
1596. 注意，如果命令行参数(目录或前缀)中的任一个以空白开始，则我们将其作为nul
      
1597. 
      
1598. l指针传送
      
1599. 
      
1600. 
      
1601. 给该函数。下面显示使用该程序的各种方式。?
      
1602. 
      
1603. 上面说明过的选择目录名的四个步骤按序执行，该函数也检查相应的目录名是否有
      
1604. 
      
1605. 意义。如
      
1606. 
      
1607. 果该目录并不存在(例如/no/such/dir)，蔌者对该目录并无写存取数(例如/etc/u
      
1608. 
      
1609. ucp),则跳
      
1610. 
      
1611. 过这些，试探对目录名的下一次选择。从本例中可以看到在路径名中如何使用进程
      
1612. 
      
1613. ?
      
1614. 
      
1615. $ a?out /home/stevens TEMP〓指定目录和前缀?
      
1616. 
      
1617. /home/stevens/TEMPAAAa00571?
      
1618. 
      
1619. $ a?out″″PFX〓使用默认目录：p 迹茫模＊常病絫mpdir?
      
1620. 
      
1621. /usr/tmp/PFXAAAa00572?
      
1622. 
      
1623. 
      
1624. $ TMPDIR=/tmp a?out/usr/tmp″″〓使用环境变量；无前缀?
      
1625. 
      
1626. /tmp/AAAa00573〓环境变量复量目录?
      
1627. 
      
1628. $ TMPDIR=/no/such/dir a?out/tmp QQQQ?
      
1629. 
      
1630. /tmp/QQQQAAAa00574〓忽略无效环境目录?
      
1631. 
      
1632. $ TMPDIR=/no/such/file a?out /etc/uucp MMMMM?
      
1633. 
      
1634. /usr/tmp/MMMMMAAAa00575〓无效环境和无效目录两者皆忽略ID，也可看出在本实
      
1635. 
      
1636. 现中，P 迹茫模＊常病
      
1637. 
      
1638. mpdir是/usr/tmp。设置环境变量的技术(在程序前的TMPDIR=???)适用于Bour
      
1639. 
      
1640. ne shell和
      
1641. 
      
1642. Kornshell。?
      
1643. 
      
1644. 5?14〓标准I/O的代替软件?
      
1645. 
      
1646. 
      
1647. 标准I/O库并不是非常完善的。Korn和VO〔1991〕列出它的很多不是之处-某些属于
      
1648. 
      
1649. 其基本
      
1650. 
      
1651. 设计，但是大多数则与各种不同的实现有关。?
      
1652. 
      
1653. 在标准I/O库中，一个效率不高的不足处是需要复制的数据量。当使用每次一行函
      
1654. 
      
1655. 数fgets和
      
1656. 
      
1657. fputs时，通常需要复制二次数据：一次是在系统核和标准I/O缓存之间(当调用re
      
1658. 
      
1659. ad和write
      
1660. 
      
1661. 时)，第二次是在标准I/O缓存和用户程序中的行缓存之间。快速I/O库〔AT&T 199
      
1662. 
      
1663. 0a中的fio
      
1664. 
      
1665. (3)〕避免了这一点，其方法是使读1行的函数返回指向该行的指针，而不是将该行
      
1666. 
      
1667. 复制到另
      
1668. 
      
1669. 
      
1670. 一个缓存中。H〔1988〕报告了由于作了这种更改，grep(1)公用程序的速度增加了
      
1671. 
      
1672. 2倍。?
      
1673. 
      
1674. Korn和Vo〔1991〕说明了标准I/O库的另一种代替版：sfio。这一软件包在速度上
      
1675. 
      
1676. 与fio相近
      
1677. 
      
1678. ，通常快于标准I/O库。sfio也提供了一些新的特征：推广了I/O流，使其不仅可以
      
1679. 
      
1680. 代表文件
      
1681. 
      
1682. ，也可代表存储区；可以编写处理模块，并以找方式将其压入I/O流，这样就可以
      
1683. 
      
1684. 改变一个
      
1685. 
      
1686. 流的操作；较好的异常处理等。?
      
1687. 
      
1688. Krieger,Stumm和Unrau〔1992〕说明了另一个代换软件包，它使用了映照文件-mm
      
1689. 
      
1690. ap函数，
      
1691. 
      
1692. 
      
1693. 我们将在12?9说明此函数。该新软件包称为ASI(Alloc Stream Interface)。此程
      
1694. 
      
1695. 序界面类
      
1696. 
      
1697. 
      
1698. 
      
1699. 似于Unix存储分配函数(malloc,realloc和fiee，这些在7?8节中说明)。与sfio软
      
1700. 
      
1701. 件包相同
      
1702. 
      
1703. ，ASI使用指针力图减少数据复制量。?
      
1704. 
      
1705. 5?15〓摘要?
      
1706. 
      
1707. 大多数Unix应用程序都使用标准I/O库。我们在本章中说明了该库提供的所有函数
      
1708. 
      
1709. ，某些实
      
1710. 
      
1711. 现细节和效率方面的考虑。应该看到标准I/O库使用了缓存机制，而这种机制是产
      
1712. 
      
1713. 生很多问
      
1714. 
      
1715. 题，引起很多混淆的一个领域。?
      
1716. 
      
1717. 返回：若成功为0，出错为－１?
      
1718. 
      
1719. 
      
1720. 
      
1721. --
      
1722. 
      
1723. 
      
1724. --
      
1725. ※ 来源:·BBS 水木清华站 smth.org·[FROM: 166.111.136.178]
      
1726. 
      
1727. 
      
1728. 
      
1729. --------------------------------------------------------------------------------
      
1730. 
      
1731. [回到开始][上一层][下一篇]
      
1732. 
      
1733. 欢迎访问Cterm主页
      
1734. 
      

复制代码

一颗流星

这是《高级编程》上的内容，我看过了，可是还是不很明白。或许错多了，被纠正多了，会慢慢地深入理解吧。
谢谢了！

蓝色键盘

那么，我只能去自杀了！。。。。。。
如果上面的不满足于你的理解，下面是linux实现的一部分

1. 
   
2. 1 /*
   
3. 2  * iobuf.c
   
4. 3  *
   
5. 4  * Keep track of the general-purpose IO-buffer structures used to track
   
6. 5  * abstract kernel-space io buffers.
   
7. 6  *
   
8. 7  */
   
9. 8
   
10. 9 #include <linux/iobuf.h>;
    
11. 10 #include <linux/slab.h>;
    
12. 11 #include <linux/vmalloc.h>;
    
13. 12
    
14. 13
    
15. 14 static kmem_cache_t *kiobuf_cachep;
    
16. 15
    
17. 16 void end_kio_request(struct kiobuf *kiobuf, int uptodate)
    
18. 17 {
    
19. 18         if ((!uptodate) && !kiobuf->;errno)
    
20. 19                 kiobuf->;errno = -EIO;
    
21. 20
    
22. 21         if (atomic_dec_and_test(&kiobuf->;io_count)) {
    
23. 22                 if (kiobuf->;end_io)
    
24. 23                         kiobuf->;end_io(kiobuf);
    
25. 24                 wake_up(&kiobuf->;wait_queue);
    
26. 25         }
    
27. 26 }
    
28. 27
    
29. 28 static int kiobuf_init(struct kiobuf *iobuf)
    
30. 29 {
    
31. 30         init_waitqueue_head(&iobuf->;wait_queue);
    
32. 31         iobuf->;array_len = 0;
    
33. 32         iobuf->;nr_pages = 0;
    
34. 33         iobuf->;locked = 0;
    
35. 34         iobuf->;bh = NULL;
    
36. 35         iobuf->;blocks = NULL;
    
37. 36         atomic_set(&iobuf->;io_count, 0);
    
38. 37         iobuf->;end_io = NULL;
    
39. 38         return expand_kiobuf(iobuf, KIO_STATIC_PAGES);
    
40. 39 }
    
41. 40
    
42. 41 int alloc_kiobuf_bhs(struct kiobuf * kiobuf)
    
43. 42 {
    
44. 43         int i;
    
45. 44
    
46. 45         kiobuf->;blocks =
    
47. 46                 kmalloc(sizeof(*kiobuf->;blocks) * KIO_MAX_SECTORS, GFP_KERNEL);
    
48. 47         if (unlikely(!kiobuf->;blocks))
    
49. 48                 goto nomem;
    
50. 49         kiobuf->;bh =
    
51. 50                 kmalloc(sizeof(*kiobuf->;bh) * KIO_MAX_SECTORS, GFP_KERNEL);
    
52. 51         if (unlikely(!kiobuf->;bh))
    
53. 52                 goto nomem;
    
54. 53
    
55. 54         for (i = 0; i < KIO_MAX_SECTORS; i++) {
    
56. 55                 kiobuf->;bh[i] = kmem_cache_alloc(bh_cachep, GFP_KERNEL);
    
57. 56                 if (unlikely(!kiobuf->;bh[i]))
    
58. 57                         goto nomem2;
    
59. 58         }
    
60. 59
    
61. 60         return 0;
    
62. 61
    
63. 62 nomem2:
    
64. 63         while (i--) {
    
65. 64                 kmem_cache_free(bh_cachep, kiobuf->;bh[i]);
    
66. 65                 kiobuf->;bh[i] = NULL;
    
67. 66         }
    
68. 67         memset(kiobuf->;bh, 0, sizeof(*kiobuf->;bh) * KIO_MAX_SECTORS);
    
69. 68
    
70. 69 nomem:
    
71. 70         free_kiobuf_bhs(kiobuf);
    
72. 71         return -ENOMEM;
    
73. 72 }
    
74. 73
    
75. 74 void free_kiobuf_bhs(struct kiobuf * kiobuf)
    
76. 75 {
    
77. 76         int i;
    
78. 77
    
79. 78         if (kiobuf->;bh) {
    
80. 79                 for (i = 0; i < KIO_MAX_SECTORS; i++)
    
81. 80                         if (kiobuf->;bh[i])
    
82. 81                                 kmem_cache_free(bh_cachep, kiobuf->;bh[i]);
    
83. 82                 kfree(kiobuf->;bh);
    
84. 83                 kiobuf->;bh = NULL;
    
85. 84         }
    
86. 85
    
87. 86         if (kiobuf->;blocks) {
    
88. 87                 kfree(kiobuf->;blocks);
    
89. 88                 kiobuf->;blocks = NULL;
    
90. 89         }
    
91. 90 }
    
92. 91
    
93. 92 int alloc_kiovec(int nr, struct kiobuf **bufp)
    
94. 93 {
    
95. 94         int i;
    
96. 95         struct kiobuf *iobuf;
    
97. 96         
    
98. 97         for (i = 0; i < nr; i++) {
    
99. 98                 iobuf = kmem_cache_alloc(kiobuf_cachep, GFP_KERNEL);
    
100. 99                 if (unlikely(!iobuf))
     
101. 100                         goto nomem;
     
102. 101                 if (unlikely(kiobuf_init(iobuf)))
     
103. 102                         goto nomem2;
     
104. 103                 if (unlikely(alloc_kiobuf_bhs(iobuf)))
     
105. 104                         goto nomem2;
     
106. 105                 bufp[i] = iobuf;
     
107. 106         }
     
108. 107         
     
109. 108         return 0;
     
110. 109
     
111. 110 nomem2:
     
112. 111         kmem_cache_free(kiobuf_cachep, iobuf);
     
113. 112 nomem:
     
114. 113         free_kiovec(i, bufp);
     
115. 114         return -ENOMEM;
     
116. 115 }
     
117. 116
     
118. 117 void free_kiovec(int nr, struct kiobuf **bufp)
     
119. 118 {
     
120. 119         int i;
     
121. 120         struct kiobuf *iobuf;
     
122. 121         
     
123. 122         for (i = 0; i < nr; i++) {
     
124. 123                 iobuf = bufp[i];
     
125. 124                 if (iobuf->;locked)
     
126. 125                         unlock_kiovec(1, &iobuf);
     
127. 126                 kfree(iobuf->;maplist);
     
128. 127                 free_kiobuf_bhs(iobuf);
     
129. 128                 kmem_cache_free(kiobuf_cachep, bufp[i]);
     
130. 129         }
     
131. 130 }
     
132. 131
     
133. 132 int expand_kiobuf(struct kiobuf *iobuf, int wanted)
     
134. 133 {
     
135. 134         struct page ** maplist;
     
136. 135         
     
137. 136         if (iobuf->;array_len >;= wanted)
     
138. 137                 return 0;
     
139. 138         
     
140. 139         maplist = kmalloc(wanted * sizeof(struct page **), GFP_KERNEL);
     
141. 140         if (unlikely(!maplist))
     
142. 141                 return -ENOMEM;
     
143. 142
     
144. 143         /* Did it grow while we waited? */
     
145. 144         if (unlikely(iobuf->;array_len >;= wanted)) {
     
146. 145                 kfree(maplist);
     
147. 146                 return 0;
     
148. 147         }
     
149. 148
     
150. 149         if (iobuf->;array_len) {
     
151. 150                 memcpy(maplist, iobuf->;maplist, iobuf->;array_len * sizeof(*maplist));
     
152. 151                 kfree(iobuf->;maplist);
     
153. 152         }
     
154. 153         
     
155. 154         iobuf->;maplist   = maplist;
     
156. 155         iobuf->;array_len = wanted;
     
157. 156         return 0;
     
158. 157 }
     
159. 158
     
160. 159 void kiobuf_wait_for_io(struct kiobuf *kiobuf)
     
161. 160 {
     
162. 161         struct task_struct *tsk = current;
     
163. 162         DECLARE_WAITQUEUE(wait, tsk);
     
164. 163
     
165. 164         if (atomic_read(&kiobuf->;io_count) == 0)
     
166. 165                 return;
     
167. 166
     
168. 167         add_wait_queue(&kiobuf->;wait_queue, &wait);
     
169. 168 repeat:
     
170. 169         set_task_state(tsk, TASK_UNINTERRUPTIBLE);
     
171. 170         if (atomic_read(&kiobuf->;io_count) != 0) {
     
172. 171                 run_task_queue(&tq_disk);
     
173. 172                 schedule();
     
174. 173                 if (atomic_read(&kiobuf->;io_count) != 0)
     
175. 174                         goto repeat;
     
176. 175         }
     
177. 176         tsk->;state = TASK_RUNNING;
     
178. 177         remove_wait_queue(&kiobuf->;wait_queue, &wait);
     
179. 178 }
     
180. 179
     
181. 180 void __init iobuf_cache_init(void)
     
182. 181 {
     
183. 182         kiobuf_cachep = kmem_cache_create("kiobuf", sizeof(struct kiobuf),
     
184. 183                                           0, SLAB_HWCACHE_ALIGN, NULL, NULL);
     
185. 184         if (!kiobuf_cachep)
     
186. 185                 panic("Cannot create kiobuf SLAB cache");
     
187. 186 }
     
188. 187
     

复制代码

[/code]

一颗流星

蓝色键盘，你可千万不要去自杀呀——我今后还有若干问题，你自杀了，我找谁去？哈哈，我的理解能力太差了，你要给我时间：）
其实我的理解力＋领悟力很强的，我也不知道为什么在这个问题上这么迟钝。唉！上帝造人是公平的。
这个帖子，我已经收了。慢慢研究研究：）如果还搞不明白，我就去自杀！

chdonald

是每输入一个字符就判断了吗?如果是干脆就用无缓冲机制得了嘛