我的程序里边，为什么fwrite没有把数据写到文件里边啊？

whyglinux

把这个帖子中出现的一些问题归纳了一下。如有不同看法，欢迎继续讨论。

1. 楼主给出的程序是正确的，执行程序能得到预期的结果。这个程序其实出自一本介绍在 Unix 下 C 编程的书（具体叫什么记不得了），以前看到过。

2. 楼主刚开始说产生的文件是“空文件”（真正的结果不是空文件），那只是因为他对文件的检查方式不对。到底文件内容是否为空，不是“看”（指用显示文件内容的命令或者用编辑软件）它能不能显示出东西来，而是要通过查看文件的大小来获知。所谓的“看”，只能使用于文本文件，对非文本文件不适用。

3. fwrite 函数使用二进制方式写文件。例如，一个整数如果用 4 个字节表示，则在文件中一个整数始终占有 4 个字节，不论整数的大小；与此不同，如果是用字符方式写文件，则一个整数在文件中占有的字节数与整数的大小（整型数字的个数）有关（当然还跟规定的格式有关，如果有的话）。

4. 对于二进制文件，它是用来被使用的（如读取、执行等），而不是用来看的（显示它的内容没有实际意义）。比如这个程序产生的二进制文件 datafile，它的作用就是用同样的结构体变量来读取，如上面的 jiutiao2004  给出的程序所示例的那样；这也是检查楼主的程序写 datafile 是否成功的可靠方法。

5. 很多人也已经注意到了，写到 datafile 中的东西并不都是我们所需要的数据，其中还夹杂着一些“垃圾”。产生的原因是由于结构体的“位对齐”造成的（可参见以前的一些这方面的讨论，如这个帖子：http://bbs.chinaunix.net/forum/viewtopic.php?t=68019&highlight=%BD%E1%B9%B9%CC%E5）。本来结构体 record 的大小是 4+9 = 13 个字节，但是由于位对齐的原因，其实际大小是 16。另外，login 字符数组中的字符也并不是全部都是有效字符，这也是产生垃圾的一个原因。垃圾字符的存在不影响 datafile 的使用，不是错误。

6. 关于 fseek 函数。其功能是用来定位文件读写指针。如果文件指的是设备文件，则 fseek 的行为是不确定的；如果文件是一个磁盘文件，则 fseek 函数可以把文件指针指向文件结束符的后面。这时可以从这个位置起写数据，而这之前和原来文件结尾之间的“空隙”部分将用 0 来填充。因此，FH 的担心是多余的。他在上面是这样写的：
>;>; 【逻辑错误】看这里：
>;>; for(i=4;i>;=0;i--)
>;>; 先用i=4调用putrec，对于空文件，fseek会怎样？
>;>; fseek和fwrite的返回码都不判！
>;>; 对于空文件来说，最后写出的文件中应该包含几个记录，谁能说清楚？应该是3条记录而不是5条记录吧？
>;>; 是不是产生空洞好像和系统相关吧？

所以对于空文件，象楼主那样使用fseek也不会有错误。另外，对于这个程序，即使对 fseek 和 fwrite 的返回值不作判断也是可以的，没有什么强有力的理由（比如算法上的要求，这一点要与 fread 函数区别）要求一定这么做，更谈不上是逻辑（算法）上的错误。

FH

to whyglinux:
1.我没见过哪个文档里面说到fseek可以定位于文件逻辑结束之后的，如果有，麻烦向我推荐一下；如果没有，我不赞成这样使用，即使它被许多环境证明了。因为任何公司都不会保障未公开文档的功能的延续性。
2.关于fseek与fwrite的返回码问题，我仍坚持我的观点，至少可以从fseek的返回码判断是否成功定位于文件逻辑结束之后吧？此外，我觉得fwrite也应该判，至少我的程序里面都判，除非是写log的时候。
3.如果fseek并不能提供所特需的定位功能，那么这个程序是不是有逻辑上的错误呢？我是就此前提论事。

windflowers1976

原帖由 "FH" 发表：
to whyglinux:
1.我没见过哪个文档里面说到fseek可以定位于文件逻辑结束之后的，如果有，麻烦向我推荐一下；如果没有，我不赞成这样使用，即使它被许多环境证明了。因为任何公司都不会保障未公开文档的功能的延续性..........

我查了下 APUE 中文版39页说过 lseek 这样做是可以的,fseek 没有说可以;可以的原因我估计fseek  是对lseek 的上层封装.
其他同意你的观点.
有义务保证自己被调用的代码非常健壮,没有权力要求别人或调用的代码非常健壮.
基于上述的论调,不管是捕捉异常的办法或判断返回码,为了健壮性,程序的运行过程中检查错误是被要求的.

FH

to windflowers1976:
我也觉得lseek可以的话fseek也应该可以。谢谢。
不过我在几个环境的man中都没有见到对此的说明。

whyglinux

原帖由 "FH" 发表：
to whyglinux:
1.我没见过哪个文档里面说到fseek可以定位于文件逻辑结束之后的，如果有，麻烦向我推荐一下；如果没有，我不赞成这样使用，即使它被许多环境证明了。因为任何公司都不会保障未公开文档的功能的延续性..........

这里有一篇SunOS的man明确提到了这一点：http://www.cs.biu.ac.il/cgi-bin/man?fseek+3C，还有这里：http://www.opengroup.org/onlinepubs/007908799/xsh/fseek.html。在一般的linux文档中好像是都没有此项说明，但是却能在这种情况下使用，说明还是支持fseek的越过文件尾部写数据的。

FH

[quote]原帖由 "whyglinux"][/quote 发表：

谢谢。

忽然想到VM好像就是这样写的，结果在Windows文件系统里留下很多碎片，都不能清理。

whyglinux

碎片产生的原因应该是多次写文件造成的，与 fseek 是否越界（指文件尾部）使用无关。但是可能与 fseek 的频繁使用有关，因为 fseek 会刷新文件缓冲。其实不只是 fseek，还有很多途径可以造成频繁写文件的操作，这应该属于程序员的问题了。我是这么理解的。

FH

[quote]原帖由 "whyglinux"]碎片产生的原因应该是多次写文件造成的，与 fseek 是否越界（指文件尾部）使用无关。[/quote 发表：

呵呵，不敢苟同。
我觉得这与其产生的缝隙有绝对的关系，Windows认为这就是碎片，不能移动。
顺便说一下，我用的是预分配空间方式。

蓝色键盘

这个贴子讨论的人真多。

一个是fseek，一个是fwrite
| 设为精彩回复，大家继续，呵呵

windflowers1976

1. /* Copyright (C) 1991, 92, 93, 95, 96, 97 Free Software Foundation, Inc.
   
2.    This file is part of the GNU C Library.
   
3. 
   
4.    The GNU C Library is free software; you can redistribute it and/or
   
5.    modify it under the terms of the GNU Library General Public License as
   
6.    published by the Free Software Foundation; either version 2 of the
   
7.    License, or (at your option) any later version.
   
8. 
   
9.    The GNU C Library is distributed in the hope that it will be useful,
   
10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
    
11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
12.    Library General Public License for more details.
    
13. 
    
14.    You should have received a copy of the GNU Library General Public
    
15.    License along with the GNU C Library; see the file COPYING.LIB.  If not,
    
16.    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    
17.    Boston, MA 02111-1307, USA.  */
    
18. 
    
19. #include <errno.h>;
    
20. #include <stdio.h>;
    
21. 
    
22. 
    
23. /* Move the file position of STREAM to OFFSET
    
24.    bytes from the beginning of the file if WHENCE
    
25.    is SEEK_SET, the end of the file is it is SEEK_END,
    
26.    or the current position if it is SEEK_CUR.  */
    
27. int
    
28. fseek (stream, offset, whence)
    
29.      register FILE *stream;
    
30.      long int offset;
    
31.      int whence;
    
32. {
    
33.   long int o;
    
34. 
    
35.   if (!__validfp (stream))
    
36.     {
    
37.       __set_errno (EINVAL);
    
38.       return EOF;
    
39.     }
    
40. 
    
41.   /* Write out any pending data.  */
    
42.   if (stream->;__mode.__write && __flshfp (stream, EOF) == EOF)
    
43.     return EOF;
    
44. 
    
45.   /* Make sure we know the current offset info.  */
    
46.   stream->;__offset = -1;
    
47.   if (__stdio_check_offset (stream) == EOF)
    
48.     return EOF;
    
49. 
    
50.   /* We are moving the file position, so we are no longer at EOF.  */
    
51.   stream->;__eof = 0;
    
52. 
    
53.   if (stream->;__pushed_back)
    
54.     {
    
55.       /* Discard the character pushed back by ungetc.  */
    
56.       stream->;__bufp = stream->;__pushback_bufp;
    
57.       stream->;__pushed_back = 0;
    
58.     }
    
59. 
    
60.   /* Check the WHENCE argument for validity, and process OFFSET
    
61.      into an absolute position in O.  By the end of this switch,
    
62.      either we have returned, or O contains an absolute position.  */
    
63.   o = offset;
    
64.   switch (whence)
    
65.     {
    
66.     default:
    
67.       __set_errno (EINVAL);
    
68.       return EOF;
    
69. 
    
70.     case SEEK_END:
    
71.       /* We don't know where the end of the file is,
    
72.          so seek to the position in the file the user asked
    
73.          for, and then look where that is.  */
    
74.       if (stream->;__io_funcs.__seek == NULL)
    
75.         {
    
76.           __set_errno (ESPIPE);
    
77.           return EOF;
    
78.         }
    
79.       else
    
80.         {
    
81.           fpos_t pos = (fpos_t) o;
    
82.           if ((*stream->;__io_funcs.__seek)
    
83.               (stream->;__cookie, &pos, SEEK_END) < 0)
    
84.             {
    
85.               if (errno == ESPIPE)
    
86.                 stream->;__io_funcs.__seek = NULL;
    
87.               return EOF;
    
88.             }
    
89.           stream->;__offset = pos;
    
90.           /* Make O be absolute, rather than
    
91.              relative to the end of the file.  */
    
92.           o = pos;
    
93.         }
    
94. 
    
95.       /* Fall through to try an absolute seek.  */
    
96. 
    
97.     case SEEK_SET:
    
98.       /* Make O be relative to the buffer.  */
    
99.       o -= stream->;__target;
    
100.       /* Make O be relative to the current position in the buffer.  */
     
101.       o -= stream->;__bufp - stream->;__buffer;
     
102. 
     
103.       /* Fall through to see if we can do it by
     
104.          moving the pointer around in the buffer.  */
     
105. 
     
106.     case SEEK_CUR:
     
107.       /* If the offset is small enough, we can just
     
108.          move the pointer around in the buffer.  */
     
109. 
     
110. #if 0        /* Why did I think this would ever work???  */
     
111.       if (stream->;__put_limit >; stream->;__buffer)
     
112.         {
     
113.           /* We are writing.  */
     
114.           if (stream->;__bufp + o >;= stream->;__buffer &&
     
115.               stream->;__put_limit >; stream->;__bufp + o &&
     
116.               stream->;__get_limit >; stream->;__bufp + o)
     
117.             {
     
118.               /* We have read all the data we will change soon.
     
119.                  We can just move the pointer around.  */
     
120.               stream->;__bufp += o;
     
121.               return 0;
     
122.             }
     
123.           else
     
124.             {
     
125.               /* Flush the buffer.  */
     
126.               if (__flshfp(stream, EOF) == EOF)
     
127.                 return EOF;
     
128.             }
     
129.         } else
     
130. #endif
     
131.       if (o < 0 ?
     
132.           (-o <= stream->;__bufp - stream->;__buffer) :
     
133.           (o <= stream->;__get_limit - stream->;__bufp))
     
134.         {
     
135.           stream->;__bufp += o;
     
136.           return 0;
     
137.         }
     
138. 
     
139.       /* Turn it into an absolute seek.  */
     
140.       o += stream->;__bufp - stream->;__buffer;
     
141.       o += stream->;__target;
     
142.       break;
     
143.     }
     
144. 
     
145.   if (o < 0)
     
146.     {
     
147.       /* Negative file position is meaningless.  */
     
148.       __set_errno (EINVAL);
     
149.       return -1;
     
150.     }
     
151. 
     
152.   /* O is now an absolute position, the new target.  */
     
153.   stream->;__target = o;
     
154. 
     
155.   /* Set bufp and both end pointers to the beginning of the buffer.
     
156.      The next i/o will force a call to the input/output room function.  */
     
157.   stream->;__bufp
     
158.     = stream->;__get_limit = stream->;__put_limit = stream->;__buffer;
     
159. 
     
160.   /* Make sure __flshfp doesn't think the put_limit is at the beginning
     
161.      of the buffer because of line-buffering magic.  */
     
162.   stream->;__linebuf_active = 0;
     
163. 
     
164.   /* If there is no seek function, seeks always fail.  */
     
165.   if (stream->;__io_funcs.__seek == NULL)
     
166.     {
     
167.       /* This is preemptive, since we don't actually do the seeking.
     
168.          But it makes more sense for fseek to to fail with ESPIPE
     
169.          than for the next reading or writing operation to fail
     
170.          that way.  */
     
171.       __set_errno (ESPIPE);
     
172.       return EOF;
     
173.     }
     
174. 
     
175.   /* Don't actually seek.  The next reading or writing operation
     
176.      will force a call to the input or output room function,
     
177.      which will move to the target file position before reading or writing.  */
     
178.   return 0;
     
179. }

复制代码