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

whyglinux

原帖由 "FH" 发表：

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

FH 多次提到“缝隙”这个概念，认为文件中真的存在着这么一个空白区域，真的是这样吗？

缝隙这个概念是在使用 fseek 定位文件指针、并且文件指针位置越过了文件结尾时产生的一个概念，此刻它指的是目前文件指针位置和原来文件结束位置之间的这片区域。注意，此时磁盘文件中并没有这样的一片区域，因为你还没有进行写文件的操作。

如果此时进行一个写文件的操作，根据 fseek 函数的说明，这块所谓的“缝隙”区域会用 0 来填充，然后随同要写的数据一起送到文件缓冲（即真正出现在文件中的内容）。从写文件开始起，“缝隙”这个概念已经不存在了，在磁盘文件中更不会有上述“缝隙”区域的存在。

为了说明这个问题，写了下面两个程序。程序功能分别是写一个100字节的文件（除了最后一个字节为字符 'a' 外，文件的其它内容为 0），区别就是一个不用 fseek，一个用fseek。特别请 FH 检验一下两种方式产生的两个文件有什么不同，fseek 带来的“缝隙”到底对最终文件有无影响。至少，我看不出这两个文件（tst1、tst2）有什么不同。

1. 
   
2. #include <stdio.h>;
   
3. 
   
4. #if 1 // <= change the 1 here to 0 to compile program 2
   
5. 
   
6. // program 1: without using fseek()
   
7. int main()
   
8. {
   
9.   FILE *fp;
   
10.   char c[99];
    
11.   int i;
    
12.   for (i=0; i<99; i++) {
    
13.     c[i] = 0;
    
14.   }
    
15.   fp = fopen("tst1", "w");
    
16.   fwrite(c, 1, 99, fp);
    
17.   fwrite("a", 1, 1, fp);
    
18.   fclose(fp);
    
19. }
    
20. 
    
21. #else
    
22. 
    
23. // program 2: with using fseek()
    
24. int main()
    
25. {
    
26.   FILE *fp;
    
27.   fp = fopen("tst2", "w");
    
28.   fseek(fp, 100-1, 0);
    
29.   fwrite("a", 1, 1, fp);
    
30.   fclose(fp);
    
31. }
    
32. 
    
33. #endif
    

复制代码

fseek 函数的源代码

另外，上面windflowers1976贴出的 fseek 函数的源代码说明文件指针越过文件前面是非法的，但是指到文件结尾之后却没有问题。但是 fseek 的源代码还不能说明此时的 fwrite 或者 fread 函数是怎样处理这一情况的，关于这一点，要到 fwrite 和 fread 的代码中去查找吧。

windflowers1976

/* Don't actually seek.  The next reading or writing operation
     will force a call to the input or output room function,
     which will move to the target file position before reading or writing.  */

1. 
   
2. /* Copyright (C) 1991, 92, 93, 94, 96, 97, 98 Free Software Foundation, Inc.
   
3.    This file is part of the GNU C Library.
   
4. 
   
5.    The GNU C Library is free software; you can redistribute it and/or
   
6.    modify it under the terms of the GNU Library General Public License as
   
7.    published by the Free Software Foundation; either version 2 of the
   
8.    License, or (at your option) any later version.
   
9. 
   
10.    The GNU C Library is distributed in the hope that it will be useful,
    
11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
    
12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
13.    Library General Public License for more details.
    
14. 
    
15.    You should have received a copy of the GNU Library General Public
    
16.    License along with the GNU C Library; see the file COPYING.LIB.  If not,
    
17.    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    
18.    Boston, MA 02111-1307, USA.  */
    
19. 
    
20. #include <errno.h>;
    
21. #include <stdio.h>;
    
22. #include <string.h>;
    
23. 
    
24. 
    
25. /* Write NMEMB chunks of SIZE bytes each from PTR onto STREAM.  */
    
26. size_t
    
27. fwrite (ptr, size, nmemb, stream)
    
28.      const void *ptr;
    
29.      size_t size;
    
30.      size_t nmemb;
    
31.      register FILE *stream;
    
32. {
    
33.   register const unsigned char *p = (const unsigned char *) ptr;
    
34.   register size_t to_write = size * nmemb;
    
35.   register size_t written = 0;
    
36.   int newlinep;
    
37.   size_t buffer_space;
    
38.   int default_func;
    
39. 
    
40.   if (!__validfp (stream) || !stream->;__mode.__write)
    
41.     {
    
42.       __set_errno (EINVAL);
    
43.       return 0;
    
44.     }
    
45. 
    
46.   if (ferror (stream))
    
47.     return 0;
    
48.   if (p == NULL || to_write == 0)
    
49.     return 0;
    
50. 
    
51.   if (!stream->;__seen || stream->;__put_limit == stream->;__buffer)
    
52.     {
    
53.       /* This stream has never been seen before.
    
54.          Calling __flshfp will give it a buffer
    
55.          and I/O functions if it needs them.  */
    
56.       if (__flshfp (stream, *p++) == EOF)
    
57.         return 0;
    
58.       if (--to_write == 0)
    
59.         return 1;
    
60.       else
    
61.         ++written;
    
62.     }
    
63. 
    
64.   default_func
    
65.     = stream->;__room_funcs.__output == __default_room_functions.__output;
    
66. 
    
67.   {
    
68.     int save = errno;
    
69. 
    
70.     if (__stdio_check_offset (stream) == EOF && errno != ESPIPE)
    
71.       {
    
72.         stream->;__error = 1;
    
73.         goto done;
    
74.       }
    
75. 
    
76.     __set_errno (save);
    
77.   }
    
78. 
    
79.   if (stream->;__buffer == NULL && default_func &&
    
80.       stream->;__offset == stream->;__target)
    
81.   write_through:
    
82.     /* This is an unbuffered stream using the standard output
    
83.        buffer-flushing function, so we just do a straight write.  */
    
84.     {
    
85.       int count = (stream->;__io_funcs.__write == NULL ? to_write :
    
86.                    (*stream->;__io_funcs.__write) (stream->;__cookie,
    
87.                                                   (const char *) p,
    
88.                                                   to_write));
    
89.       if (count >; 0)
    
90.         {
    
91.           written += count;
    
92.           if (stream->;__offset != -1)
    
93.             {
    
94.               stream->;__offset += count;
    
95.               stream->;__target = stream->;__offset;
    
96.             }
    
97.           to_write -= count;
    
98.           p += count;
    
99.         }
    
100.       else
     
101.         stream->;__error = 1;
     
102.       goto done;
     
103.     }
     
104. 
     
105.   /* We ignore the end pointer here since we want to find out how much space
     
106.      is really in the buffer, even for a line-buffered stream.  */
     
107.   buffer_space = stream->;__bufsize - (stream->;__bufp - stream->;__buffer);
     
108. 
     
109.   newlinep = (stream->;__linebuf &&
     
110.               memchr ((const void *) p, '\n', to_write) != NULL);
     
111. 
     
112.   if (newlinep && stream->;__bufp == stream->;__buffer &&
     
113.       stream->;__offset == stream->;__target)
     
114.     /* The buffer's empty, and we want to write our data
     
115.        out soon anyway, so just write it straight out.  */
     
116.     goto write_through;
     
117. 
     
118.   if (stream->;__bufsize == 0 && !default_func)
     
119.     {
     
120.       /* No buffer, and a special function.
     
121.          We can't do much better than putc.  */
     
122.       while (to_write-- >; 0)
     
123.         {
     
124.           if (__flshfp (stream, *p++) == EOF)
     
125.             break;
     
126.           else
     
127.             ++written;
     
128.         }
     
129.     }
     
130.   else if (!default_func || buffer_space >;= to_write)
     
131.     {
     
132.       /* There is enough room in the buffer for everything we want to write
     
133.          or the user has specified his own output buffer-flushing/expanding
     
134.          function.  */
     
135.     fill_buffer:
     
136.       while (to_write >; 0)
     
137.         {
     
138.           register size_t n = to_write;
     
139. 
     
140.           if (n >; buffer_space)
     
141.             n = buffer_space;
     
142. 
     
143.           buffer_space -= n;
     
144. 
     
145.           written += n;
     
146.           to_write -= n;
     
147. 
     
148.           if (n < 20)
     
149.             while (n-- >; 0)
     
150.               *stream->;__bufp++ = *p++;
     
151.           else
     
152.             {
     
153.               memcpy ((void *) stream->;__bufp, (void *) p, n);
     
154.               stream->;__bufp += n;
     
155.               p += n;
     
156.             }
     
157. 
     
158.           if (to_write == 0)
     
159.             /* Done writing.  */
     
160.             break;
     
161.           else if (buffer_space == 0)
     
162.             {
     
163.               /* We have filled the buffer, so flush it.  */
     
164.               if (fflush (stream) == EOF)
     
165.                 break;
     
166. 
     
167.               /* Reset our record of the space available in the buffer,
     
168.                  since we have just flushed it.  */
     
169.             check_space:
     
170.               buffer_space = (stream->;__bufsize -
     
171.                               (stream->;__bufp - stream->;__buffer));
     
172.               if (buffer_space == 0)
     
173.                 {
     
174.                   /* With a custom output-room function, flushing might
     
175.                      not create any buffer space.  Try writing a single
     
176.                      character to create the space.  */
     
177.                   if (__flshfp (stream, *p++) == EOF)
     
178.                     goto done;
     
179.                   ++written;
     
180.                   --to_write;
     
181.                   goto check_space;
     
182.                 }
     
183.             }
     
184.         }
     
185. 
     
186.       /* We have written all the data into the buffer.  If we are
     
187.          line-buffered and just put a newline in the buffer, flush now to
     
188.          make sure it gets out.  */
     
189.       if (newlinep)
     
190.         fflush (stream);
     
191.     }
     
192.   else
     
193.     {
     
194.       /* It won't all fit in the buffer.  */
     
195. 
     
196.       if (stream->;__bufp != stream->;__buffer)
     
197.         {
     
198.           /* There are characters in the buffer.  Flush them.  */
     
199.           if (__flshfp (stream, EOF) == EOF)
     
200.             goto done;
     
201.         }
     
202. 
     
203.       /* The buffer has been flushed.
     
204.          Now either fill it or write directly.  */
     
205. 
     
206.       buffer_space = stream->;__bufsize - (stream->;__bufp - stream->;__buffer);
     
207. 
     
208.       if (stream->;__offset == stream->;__target &&
     
209.           (buffer_space < to_write || newlinep))
     
210.         /* What we have to write is bigger than the buffer,
     
211.            or it contains a newline and we're line-buffered,
     
212.            so write it out.  */
     
213.         goto write_through;
     
214.       else
     
215.         /* It will fit in the buffer.  */
     
216.         goto fill_buffer;
     
217.     }
     
218. 
     
219. done:;
     
220.   return (size_t) written / size;
     
221. }
     
222. 
     
223. weak_alias (fwrite, fwrite_unlocked)

复制代码

呵呵,内核代码有人看啊.

fwizard

fseek允许设置文件位置超过文件的当前文件尾，如果之后在此新文件位置写入了数据，则后续从原文件尾新新写入的数据之间的空隙中读出的字节将用0填充直至次空隙写入实际的数据为止，下面给出的程序说明用fseek定位文件文件位置超过文件尾的两种情形。第一种是以非添加方式写数据超过文件尾，此时在当前文件尾和新写入的数据之间将行成所谓的“空洞”。第二种是以添加方式写数据，此时尽管可以用fseek定位文件当前位置超过文件尾，但是写该文件时，文件的当前位置被忽略，所有的数据都添加在文件尾并且文件当前位置被重新定位到新的文件尾

#include <stdio.h>;
#include <stdlib.h>;
#include "err_exit.h"

char buf[132];

int main(int argc,char *argv[])
{
  FILE *fd;
  fpos_t pos;
  if(argc != 2){
     fprintf(stderr,"Usage: %s mode \n",argv[0]);
     exit(EXIT_FAILURE);
   }
   
   if(argv[1][0]!='a'){
   if  ((fd = fopen("test_file","w+")==NULL)
   err_exit("fopen failed";
   }
   else{
     if((fd = fopen("test_file","a+")==NULL)
     err_exit("fopen failed";
     }
     
     
   fputs("0123456789",fd);
   fputs("ABCDEFGHIJ",fd);
   
   fseek(fd,0,SEEK_END);
   fgetpos(fd,&pos);
   printf("current file en position is %ld\n",pos);
   
   fseek(fd,30,SEEK_END);
   
   fgetpos(fd,&pos);
   printf("Now we call fseek(fd,30,SEEK_END)\n";
   printf("Current file position is %ld \n",pos);
   
   fputs("abcdefg",fd);
   printf("Now we write %c %s %c\n",'\"',"abcdefg",'\"');
   
   fgetpos(fd,&pos);
   printf("current position of file end is %ld\n",pos);
   fclose(fd);
}

运行示例：

# t13 a+
current file en position is 20
Now we call fseek(fd,30,SEEK_END)
Current file position is 50
Now we write " abcefg "
current position of file end is 57
current position of file end is 27
# od -c test_file
0000000   0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
0000020   G   H   I   J   a   b   c   d   e   f   g
0000033


# t13 w+
current file en position is 20
Now we call fseek(fd,30,SEEK_END)
Current file position is 50
Now we write " abcefg "
current position of file end is 57
# od -c test_file
0000000   0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
0000020   G   H   I   J  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0
0000040  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0  \0
0000060  \0  \0   a   b   c   d   e   f   g
0000071

几点说明：
   1。我这上面的程序基本上都是来源于unix程序设计教程这本书，自认为对于有一定c和c++编程基础又刚接触unix编程时的一本好书。当然如果在瘟下比较牛的话，可能也不需要，我是刚参加工作，理论有实践还比较差
   2。对于前面程序涉及的东西我想几位的解释已经让我明白的差不多了，先谢谢大家的热心帮助。
   3。关于大家后面的讨论我这里照样摘录了一个程序，大家运行测试一下，就知道里边包含的意思了
   4。对这个程序我运行的结果和书上给出的结果稍有出入，欢迎大家测试和讨论。
其中第一个红色行是对应行的书上给的结果
第二个红行是我运行出来的，书上没有。

welkin

1

FH

to whyglinux:
缝隙(gap)引自你提供的man文档。缝隙这一概念显然是逻辑上的而不是物理上的，这一点不用讨论。
我说的是缝隙给Windows FAT32文件系统造成的假象，即文件碎片问题。
我的VMDK文件存在很多碎片，怎么copy都不能消除，也不能被碎片整理工具消除。

whyglinux

那你看看文件的属性是否是系统属性，这样的文件不允许移动。比如Windows下那个大大的临时文件好像就是这样的。试试把文件的系统属性去掉，再用碎片整理。