走进C标准库(3)——"stdio.h"中的getc和ungetc
接前文。
再来看看getc和ungetc的实现。在看这两个函数的实现之前，我们先来想一想这两个函数分别需要做的工作。
int getc(FILE *stream)
说明：函数getc从stream指向的输入流中读取下一个字符（如果有的话），并把它由unsigned char类型转换为int类型，并且流的相关的文件定位符（如果定义的话）向前移动一位。
返回值：函数getc返回stream指向的输入流的下一个字符，如果流处于文件结束处，则设置该流的文件结束指示符，函数getc返回EOF。如果发生了读错误，则设置流的错误指示符。函数getc返回EOF。
int ungetc( int c , FILE *stream );
说明：
函数ungetc把c指定的字符（转换为unsigned char类型）退回到stream指向的输入流中，退回字符是通过对流的后续读取并按照退回的反顺序来返回的。如果中间成功调用（对同一个流）了一个文件定位函数（fseek、fsetpos或者rewind），那么就会丢弃流的所有退回的字符。流的相应的外部存储保持不变。
退回的一个字符是受到保护的。如果同一个流调用ungetc函数太多次，中间又没有读或者文件定位操作，那么这种操作可能会失败。
如果c的值和宏EOF的值相等，则操作失败且输入流保持不变。
对ungetc的成功调用会清空流的文件结束符。读取或者丢弃所有回退的字符后，流的文件定位符的值和这些字符回退之前的值相同。对文本流来说，在对函数ungetc的一次成功调用之后，它的文件定位符的值是不明确的，直到所有回退字符被读取或者丢弃为止。对二进制流来说，每成功调用一次ungetc之后它的文件定位符都会减1。如果在一次调用之前它的值是零，那么调用之后它的值是不确定的。
返回值:
函数ungetc返回转换后的回退字符，如果操作失败，则返回EOF。
大致来说，getc就是从stream中读入一个字符，并将流的定位符前移；ungetc就是将流的定位符后移，然后将一个字符回退到stream流该定位符的位置上。
这时我们可能会考虑到一些问题：
1.在stdio.h阅读笔记1中，我们看到在fopen函数调用之后，并没有为我们的stream分配buffer，那么这个分配会在真正进行stream读取的时候建立吗？
2.如果在getc之前（即流定位符在_base）就进行ungetc操作，会产生什么样的效果呢？
3.如原文所说：“如果同一个流调用ungetc函数太多次，中间又没有读或者文件定位操作，那么这种操作可能会失败。”，是因为文件定位符到达_base的原因吗？
那我们就来看下getc和ungetc所做的工作：
首先来看ungetc
int __cdecl ungetc ( REG2 int ch, FILE *str ) { REG1 FILE *stream; _ASSERTE(str != NULL); /* Init stream pointer and file descriptor */ stream = str; /* Stream must be open for read and can NOT be currently in write mode. Also, ungetc() character cannot be EOF. */ if ( (ch == EOF) || !( (stream->_flag & _IOREAD) || ((stream->_flag & _IORW) && !(stream->_flag & _IOWRT)) ) ) return(EOF); /* If stream is unbuffered, get one. */ if (stream->_base == NULL) _getbuf(stream); /* now we know _base != NULL; since file must be buffered */ if (stream->_ptr == stream->_base) { if (stream->_cnt) /* my back is against the wall; i've already done * ungetc, and there's no room for this one */ return(EOF); stream->_ptr++; } if (stream->_flag & _IOSTRG) { /* If stream opened by sscanf do not modify buffer */ if (*--stream->_ptr != (char)ch) { ++stream->_ptr; return(EOF); } } else *--stream->_ptr = (char)ch; stream->_cnt++; stream->_flag &= ~_IOEOF; stream->_flag |= _IOREAD; /* may already be set */ return(0xff & ch); }
清楚的看到，对于没有分配buffer的I/O控制块，进行了缓冲区的分配。另外，当文件定位符指向文件开始时且数据存储区域剩余字符数目为0时，文件定位符无需后移，修改的是文件开始位置的字符；其他情况下，都是文件定位符先后移，再修改当前文件定位符指向的字符。完成这些之后，修改I/O控制块中的_cnt剩余字符计数和_flag标记。
看了下_getbuf函数的实现，从中可以看到FILE类中_charbuf变量的作用。删除了针对不同各个平台的#if代码之后，_getbuf函数核心代码如下：
1 void __cdecl _getbuf ( 2 FILE *str 3 ) 4 { 5 REG1 FILE *stream; 6 _ASSERTE(str != NULL); 7 stream = str; 8 if (stream->_base = _malloc_crt(_INTERNAL_BUFSIZ)) 9 { 10 stream->_flag |= _IOMYBUF; 11 stream->_bufsiz = _INTERNAL_BUFSIZ; 12 } 13 else { 14 stream->_flag |= _IONBF; 15 stream->_base = (char *)&(stream->_charbuf); 16 stream->_bufsiz = 2; 17 stream->_ptr = stream->_base; 18 stream->_cnt = 0; 19 return; 20 }
可以看到，当_getbuf分配不成功时，_base指针会指向_charbuf作为一个1 int长度的空间（可能是因为平台的原因，这里将1int理解为2个char），此时的_buffersize就为2。通过_charbuf的使用，也保证了当buffer分配失败时，也能正常从文件中读取数据。
接下来看下getc函数的实现：
#define getc(_stream) (--(_stream)->_cnt >= 0 \ ? 0xff & *(_stream)->_ptr++ : _filbuf(_stream))
表达式 (--(_stream)->_cnt >= 0 ? 0xff & *(_stream)->_ptr++ : _filbuf(_stream)) 的意义为：
当数据存储区域剩余字符的数目大于0的时候，减少一个剩余字符计数，返回0xff & *(_stream)->_ptr++；
否则，调用_filbuf(_stream)。
通过0xff & *(_stream)->_ptr++，getc函数获得了当前文件定位符指向的内容（只取8位？难道char还能不止8位吗？），然后文件定位符前移
剩下函数_filbuf(_stream)，显然其中含有C语言从文件中获取文本的方法（前面都是文本的管理机制）：
1 int __cdecl _filbuf ( 2 FILE *str 3 ) 4 { 5 REG1 FILE *stream; 6 _ASSERTE(str != NULL); 7 /* Init pointer to _iob2 entry. */ 8 stream = str; 9 if (!inuse(stream) || stream->_flag & _IOSTRG) 10 return(_TEOF); 11 if (stream->_flag & _IOWRT) { 12 stream->_flag |= _IOERR; 13 return(_TEOF); 14 } 15 stream->_flag |= _IOREAD; 16 /* Get a buffer, if necessary. */ 17 if (!anybuf(stream)) 18 _getbuf(stream); 19 else 20 stream->_ptr = stream->_base; 21 stream->_cnt = _read(_fileno(stream), stream->_base, stream->_bufsiz); 22 if ((stream->_cnt == 0) || (stream->_cnt == -1)) { 23 stream->_flag |= stream->_cnt ? _IOERR : _IOEOF; 24 stream->_cnt = 0; 25 return(_TEOF); 26 } 27 28 if ( !(stream->_flag & (_IOWRT|_IORW)) && 29 ((_osfile_safe(_fileno(stream)) & (FTEXT|FEOFLAG)) == 30 (FTEXT|FEOFLAG)) ) 31 stream->_flag |= _IOCTRLZ; 32 /* Check for small _bufsiz (_SMALL_BUFSIZ). If it is small and 33 if it is our buffer, then this must be the first _filbuf after 34 an fseek on a read-access-only stream. Restore _bufsiz to its 35 larger value (_INTERNAL_BUFSIZ) so that the next _filbuf call, 36 if one is made, will fill the whole buffer. */ 37 if ( (stream->_bufsiz == _SMALL_BUFSIZ) && (stream->_flag & 38 _IOMYBUF) && !(stream->_flag & _IOSETVBUF) ) 39 { 40 stream->_bufsiz = _INTERNAL_BUFSIZ; 41 } 42 stream->_cnt--; 43 return(0xff & *stream->_ptr++); 44 }
在语句stream->_cnt = _read(_fileno(stream), stream->_base, stream->_bufsiz);中通过调用_read函数来将原来在硬盘文件中的数据读取到程序数据段的栈空间中，具体的功能看下_read的代码：
1 /*** 2 *int _read(fh, buf, cnt) - read bytes from a file handle 3 * 4 *Purpose: 5 * Attempts to read cnt bytes from fh into a buffer. 6 * If the file is in text mode, CR-LF's are mapped to LF's, thus 7 * affecting the number of characters read. This does not 8 * affect the file pointer. 9 * 10 * NOTE: The stdio _IOCTRLZ flag is tied to the use of FEOFLAG. 11 * Cross-reference the two symbols before changing FEOFLAG's use. 12 * 13 *Entry: 14 * int fh - file handle to read from 15 * char *buf - buffer to read into 16 * int cnt - number of bytes to read 17 * 18 *Exit: 19 * Returns number of bytes read (may be less than the number requested 20 * if the EOF was reached or the file is in text mode). 21 * returns -1 (and sets errno) if fails. 22 * 23 *Exceptions: 24 * 25 *******************************************************************************/ 26 27 int __cdecl _read ( 28 int fh, 29 void *buf, 30 unsigned cnt 31 ) 32 { 33 int bytes_read; /* number of bytes read */ 34 char *buffer; /* buffer to read to */ 35 int os_read; /* bytes read on OS call */ 36 char *p, *q; /* pointers into buffer */ 37 char peekchr; /* peek-ahead character */ 38 ULONG filepos; /* file position after seek */ 39 ULONG dosretval; /* o.s. return value */ 40 41 /* validate fh */ 42 if ( ((unsigned)fh >= (unsigned)_nhandle) || 43 !(_osfile(fh) & FOPEN) ) 44 { 45 /* bad file handle */ 46 errno = EBADF; 47 _doserrno = 0; /* not o.s. error */ 48 return -1; 49 } 50 bytes_read = 0; /* nothing read yet */ 51 buffer = buf; 52 if (cnt == 0 || (_osfile(fh) & FEOFLAG)) { 53 /* nothing to read or at EOF, so return 0 read */ 54 return 0; 55 } 56 if ((_osfile(fh) & (FPIPE|FDEV)) && _pipech(fh) != LF) { 57 /* a pipe/device and pipe lookahead non-empty: read the lookahead 58 * char */ 59 *buffer++ = _pipech(fh); 60 ++bytes_read; 61 --cnt; 62 _pipech(fh) = LF; /* mark as empty */ 63 } 64 65 /* read the data */ 66 67 if ( !ReadFile( (HANDLE)_osfhnd(fh), buffer, cnt, (LPDWORD)&os_read, 68 NULL ) ) 69 { 70 /* ReadFile has reported an error. recognize two special cases. 71 * 72 * 1. map ERROR_ACCESS_DENIED to EBADF 73 * 74 * 2. just return 0 if ERROR_BROKEN_PIPE has occurred. it 75 * means the handle is a read-handle on a pipe for which 76 * all write-handles have been closed and all data has been 77 * read. */ 78 79 if ( (dosretval = GetLastError()) == ERROR_ACCESS_DENIED ) { 80 /* wrong read/write mode should return EBADF, not EACCES */ 81 errno = EBADF; 82 _doserrno = dosretval; 83 return -1; 84 } 85 else if ( dosretval == ERROR_BROKEN_PIPE ) { 86 return 0; 87 } 88 else { 89 _dosmaperr(dosretval); 90 return -1; 91 } 92 } 93 bytes_read += os_read; /* update bytes read */ 94 if (_osfile(fh) & FTEXT) { 95 /* now must translate CR-LFs to LFs in the buffer */ 96 97 /* set CRLF flag to indicate LF at beginning of buffer */ 98 if ( (os_read != 0) && (*(char *)buf == LF) ) 99 _osfile(fh) |= FCRLF; 100 else 101 _osfile(fh) &= ~FCRLF; 102 103 /* convert chars in the buffer: p is src, q is dest */ 104 p = q = buf; 105 while (p < (char *)buf + bytes_read) { 106 if (*p == CTRLZ) { 107 /* if fh is not a device, set ctrl-z flag */ 108 if ( !(_osfile(fh) & FDEV) ) 109 _osfile(fh) |= FEOFLAG; 110 break; /* stop translating */ 111 } 112 else if (*p != CR) 113 *q++ = *p++; 114 else { 115 /* *p is CR, so must check next char for LF */ 116 if (p < (char *)buf + bytes_read - 1) { 117 if (*(p+1) == LF) { 118 p += 2; 119 *q++ = LF; /* convert CR-LF to LF */ 120 } 121 else 122 *q++ = *p++; /* store char normally */ 123 } 124 else { 125 /* This is the hard part. We found a CR at end of 126 buffer. We must peek ahead to see if next char 127 is an LF. */ 128 ++p; 129 130 dosretval = 0; 131 if ( !ReadFile( (HANDLE)_osfhnd(fh), &peekchr, 1, 132 (LPDWORD)&os_read, NULL ) ) 133 dosretval = GetLastError(); 134 if (dosretval != 0 || os_read == 0) { 135 /* couldn't read ahead, store CR */ 136 *q++ = CR; 137 } 138 else { 139 /* peekchr now has the extra character -- we now 140 have several possibilities: 141 1. disk file and char is not LF; just seek back 142 and copy CR 143 2. disk file and char is LF; seek back and 144 discard CR 145 3. disk file, char is LF but this is a one-byte 146 read: store LF, don't seek back 147 4. pipe/device and char is LF; store LF. 148 5. pipe/device and char isn't LF, store CR and 149 put char in pipe lookahead buffer. */ 150 if (_osfile(fh) & (FDEV|FPIPE)) { 151 /* non-seekable device */ 152 if (peekchr == LF) 153 *q++ = LF; 154 else { 155 *q++ = CR; 156 _pipech(fh) = peekchr; 157 } 158 } 159 else { 160 /* disk file */ 161 if (q == buf && peekchr == LF) { 162 /* nothing read yet; must make some 163 progress */ 164 *q++ = LF; 165 } 166 else { 167 /* seek back */ 168 filepos = _lseek_lk(fh, -1, FILE_CURRENT); 169 if (peekchr != LF) 170 *q++ = CR; 171 } 172 } 173 } 174 } 175 } 176 } 177 178 /* we now change bytes_read to reflect the true number of chars 179 in the buffer */ 180 bytes_read = q - (char *)buf; 181 } 182 return bytes_read; /* and return */ 183 }
通过调用ReadFile的WINAPI函数，就可以完成从磁盘中把文件的内容读到数据段的栈内了。
BOOL WINAPI ReadFile(
_In_ HANDLE hFile,
_Out_ LPVOID lpBuffer,
_In_ DWORD nNumberOfBytesToRead,
_Out_opt_ LPDWORD lpNumberOfBytesRead,
_Inout_opt_ LPOVERLAPPED lpOverlapped
);
通过使用已经分配好的文件句柄，将数据读到lpBuffer指向的内存区域，读入的最大数据量通过nNumberOfBytesToRead变量进行设定，通过lpNumberOfBytesRead返回实际读取的字节数。
_read函数在读到数据之后，如果设定的模式为文本流，则需要解决文本流中的换行回车的问题，这里就不深究了。有兴趣可以看文章：
http://www.360doc.com/content/11/0113/20/3508740_86319358.shtml
这样，我们的getc就成功将FILE类的_cnt设定为了剩余字符的数目，将_base指向了通过栈上存储数据的地址。然后，只要将当前文件位置指针_ptr中的数据返回，_ptr指向下一个位置，_cnt减一就好了。
这时候，我们回过头来看FILE结构，就可以知道里面成员变量的意义了。
1 typedef struct _iobuf { 2 char *_ptr; 3 int _cnt; 4 char *_base; 5 int _flag; 6 int _file; 7 int _charbuf; 8 int _bufsiz; 9 char *_tmpfname; 10 }FILE;
_ptr为数据存储区域（可为缓冲区或_charbuf对应的存储区域）当前位置指针。
_cnt为数据存储区域剩余字符数目。
_base为数据存储区域首地址。
_flag为当前I/O控制块所控制的I/O操作类型，有读、写等。
_file为对应的文件描述符（详见博文《走进C标准库(2)》）
_charbuf为缓冲区申请失败时的一个2字节的数据存储区
_bufsiz为缓冲区大小
_tmpfname为所使用存储一些中间操作数据的临时文件。
到这里，我们就可以回答开始时的3个问题了。
1.在getc和ungetc中如果没有分配buffer，都会尝试给I/O控制块分配buffer，但是ungetc分配完buffer后不会尝试从文件中将数据读到buffer中。
2.可以在buffer的首地址处存储一个字符。如果_ptr指在_base，那么数据存储区域为空（为从文件中读取数据）时，ungetc才能在首地址处添加一个字符。
3.多次ungetc使_ptr到达_base之后，就无法再进行ungetc了。
完
