C/C++文件操作

基于C的文件操作 在ANSI C中，对文件的操作分为两种方式，即流式文件操作和I/O文件操作
一、流式文件操作

1.fopen()
FILE *fopen(const char *filename,const char *mode) //4996
文件通过fopen_s和 _wfopen_s打开后是不共享的，"r"的话，其他程序可只读打开，其他模式都打开不了
errno_t fopen_s( FILE** pFile, const char *filename, const char *mode );
errno_t _wfopen_s( FILE** pFile, const wchar_t *filename, const wchar_t *mode );

_tfopen_s

fopen_s(&fp,"newfile.txt","rw,ccs=encoding");
允许的值的编码是UNICODE，UTF-8和UTF-16LE。 如果存在为不指定任何值编码，fopen_s使用ANSI编码。

FILE *pfile;
errno_t err = fopen_s(&pfile, "1.txt", "r");
if (err == 0)//返回0为成功
{
cout << "The file '1.txt' was opened\n" << endl;
}

"r" 只读,文件不存在则失败 rw ra wa 都是不允许的
"w" 只写,文件不存就创建,如果该文件存在，其内容将被销毁。
"a" 追加,文件不存就创建
"r+" 读/写,如无文件出错，打开位于文件头
"w+" 读/写,文件不存就创建
"a+" 读取和追加,文件不存就创建


一个文件可以以文本模式或二进制模式打开，
这两种的区别是：在二进制模式中换行被当成一个字符''\n''，
而文本模式认为它是两个字符0x0D,0x0A； \r\n
如果在文件中读到0x1B，文本模式会认为这是文件结束符，也就是二进制模型不会对文件进行处理，
而文本方式会按一定的方式对数据作相应的转换。

系统默认的是以文本模式打开 t b

D 指定临时文件。最后的文件指针被关闭时，它将被删除。

共享模式
_fsopen、_wfsopen _tfsopen

FILE *_fsopen(
const char *filename,
const char *mode,
int shflag
);

变量shflag是常量表达式包含 Share.h 中定义的以下清单常量之一。
_SH_COMPAT 为 16 位应用程序设置兼容性模式。
_SH_DENYNO 允许读取和写入访问。
_SH_DENYRD 拒绝对文件的读取访问。
_SH_DENYRW 拒绝对文件的读取和写入访问。
_SH_DENYWR 拒绝对文件的写入访问。

允许其他读的话，你关闭文件之后，他才会读到你写的内容

13.fread()
char x[4230];
fread(x,200,12 ,fp);//共读取200*12=2400个字节

size_t fread(void *ptr, size_t size, size_t n, FILE *stream);
size是每块的字节数；n是读取的块数，
如果成功，返回实际读取的块数(不是字节数)，
本函数一般用于二进制模式打开的文件中。
14.fwrite()
char x[]="I Love You";
　　 fwire(x, 6,12,fp);//写入6*12=72字节
　　 将把"I Love"写到流fp中12次，共72字节

size_t fwrite(const void *ptr, size_t size, size_t n, FILE *stream);
如果成功，返回实际写入的块数(不是字节数)，本函数一般用于二进制模式打开的文件中。

2.fclose()
int fclose(FILE *fp);如果成功，返回0,失败返回EOF

3.fputc() fputwc _fputtc 返回EOF WEOF指示错误
fputc('X',fp);
4.fgetc() fgetwc _fgettc 返回EOF WEOF指示错误
char ch1=fgetc(fp);
5.fseek()
此函数一般用于二进制模式打开的文件中，功能是定位到流中指定的位置
int fseek(FILE *stream, long offset, int whence);
如果成功返回0，参数offset是移动的字符数，whence是移动的基准，取值是
SEEK_SET 0 文件开头
SEEK_CUR 1 当前读写的位置
SEEK_END 2 文件尾部

fseek(fp,1234L,SEEK_CUR);//把读写位置从当前位置向后移动1234字节
fseek(fp,0L,2);//把读写位置移动到文件尾
6.fputs()
fputs("I Love You",fp);
7.fgets()
从流中读一行或指定个字符
char *fgets(char *s, int n, FILE *stream);
从流中读取n-1个字符，除非读完一行,不包括行尾的''\n''参数s是来接收字符串，
如果成功则返回s的指针，否则返回NULL。
8.fprintf()
fprintf(fp,"%2d%s",4,"Hahaha");
9.fscanf()
fscanf(fp,"%d%d" ,&x,&y);
10.feof()
if(feof(fp)) printf("已到文件尾");
11.ferror()
int ferror(FILE *stream);
返回流最近的错误代码，可用clearerr()来清除它，void clearerr(FILE *stream);
printf("%d",ferror(fp));
12.rewind()
把当前的读写位置回到文件开始,相当于fseek(fp,0L,SEEK_SET);
rewind(fp);
13.remove()
删除文件 remove("c:\\io.sys");

15.tmpfile()
生成一个临时文件，以"w+b"的模式打开，并返回这个临时流的指针，
如果失败返回NULL。在程序结束时，这个文件会被自动删除。
FILE *fp=tmpfile();
16.tmpnam(); //4996
char *tmpnam(char *s);
生成一个唯一的文件名，
其实tmpfile()就调用了此函数，参数s用来保存得到的文件名，并返回这个指针，
如果失败，返回NULL。

char name[100] = {0};
if (0 == tmpnam_s(name, 100))
//tmpnam(name);
printf("Temporary name: %s\n", name);

二、直接I/O文件操作
这是C提供的另一种文件操作，它是通过直接存/取文件来完成对文件的处理，
而上篇所说流式文件操作是通过缓冲区来进行；流式文件操作是围绕一个FILE指针来进行，
而此类文件操作是围绕一个文件的“句柄”来进行，什么是句柄呢？它是一个整数，
是系统用来标识一个文件(在WINDOWS中，句柄的概念扩展到所有设备资源的标识)的唯一的记号。
此类文件操作常用的函数如下表，
这些函数及其所用的一些符号在io.h和fcntl.h中定义，在使用时要加入相应的头文件。

1.open()
打开一个文件并返回它的句柄，如果失败，将返回一个小于0的值
int open(const char *path, int access [, unsigned mode]);
path是要打开的文件名，access是打开的模式，
mode是可选项。表示文件的属性，主要用于UNIX系统中，在DOS/WINDOWS这个参数没有意义

打开模式如下
O_RDONLY 只读方式 O_WRONLY 只写方式 O_RDWR 读/写方式
O_NDELAY 用于UNIX系统 O_APPEND 追加方式 O_CREAT 如果文件不存在就创建
O_TRUNC 把文件长度截为0 O_EXCL 和O_CREAT连用，
如果文件存在返回错误 O_BINARY 二进制方式
O_TEXT 文本方式

int handle=open("c:\\msdos.sys",O_BINARY|O_CREAT|O_WRITE);

指定共享模式
_topen
int _open、_wopen (filename, oflag, pmode)//<io.h> <fcntl.h>//4996
返回值-1 指示错误

_sopen_s、_wsopen_s 非零返回值指示错误

errno_t _sopen_s(
int* pfh,
const char *filename,
int oflag,
int shflag,
int pmode
);

pfh
文件句柄或 -1（如果出现错误）。

oflag 允许的操作类型
_O_APPEND 在执行每个写入操作之前，将文件指针移动到文件末尾
_O_BINARY 二进制模式
_O_TEXT 文本模式
_O_CREAT 创建文件并打开它以供写入,filename存在则不起作用
_O_RDONLY 打开文件以供只读。 不能与指定 _O_RDWR或 _O_WRONLY
_O_WRONLY 打开文件以供只写。 不能与指定 _O_RDONLY或 _O_RDWR
_O_RDWR 打开文件以供读取和写入。不能与指定 _O_RDONLY或 _O_WRONLY
_O_TRUNC 打开文件并将其长度截断为零；该文件必须具有写入权限。
不能与指定 _O_RDONLY。 _O_TRUNC用于 _O_CREAT打开一个现有文件或创建一个文件。
_O_U16TEXT
_O_U8TEXT
_O_WTEXT

shflag 允许的共享类型。
_SH_DENYRW 拒绝对文件的读取和写入访问。
_SH_DENYWR 拒绝对文件的写入访问。
_SH_DENYRD 拒绝对文件的读取访问。
_SH_DENYNO 允许读取和写入访问。

pmode=0 权限设置
_S_IREAD 只允许读取。
_S_IWRITE 允许写入。（实际上，允许读取和写入）
_S_IREAD | _S_IWRITE 允许读取和写入。
不可能提供只写权限。 因此，模式 _S_IWRITE和 _S_IREAD | _S_IWRITE是等效的。

int fh;
errno_t err = _sopen_s(&fh, "1.txt", _O_RDWR, _SH_DENYNO, _S_IREAD | _S_IWRITE);
printf("%d %d\n", err, fh);
if (err != 0)
exit(1);
write(fh, "i love u", 8);

2.close()
close(handle)
3.lseek()
此函数返回执行后文件新的存取位置。
lseek(handle,-1234L,SEEK_CUR);//把存取位置从当前位置向前移动1234个字节。
　　 x=lseek(hnd1,0L,SEEK_END);//把存取位置移动到文件尾，x=文件尾的位置即文件长度
4.read()
char x[200];
read(hnd1,x,200);
5.write()
char x[]="I Love You";
write(handle,x,strlen(x));
7.eof()
while(!eof(handle1)){……};
8.filelength()
相当于lseek(handle,0L,SEEK_END);
long x=filelength(handle);
9.rename()
rename("c:\\config.sys","c:\\config.w40");
10.chsize();
改变文件长度
int chsize(int handle, long size);
参数size表示文件新的长度，成功返回0，否则返回-1，
如果指定的长度小于文件长度，则文件被截短；
如果指定的长度大于文件长度，则在文件后面补"\0"。
chsize(handle,0x12345);

C++:

在fstream类中
一、打开文件
void open(const char* filename,int mode,int access);
mode:要打开文件的方式:
ios::app：　　　以追加的方式打开文件 ，文件不存在，则创建，它与任何一个使用，都是文件不存在则创建,有app,即使没写out也会有out
ios::ate：　　　打开文件后立即定位到文件末尾， 不可单独使用,文件不存在，则失败，ios:app就包含有此属性
ios::binary： 　以二进制方式打开文件，缺省的方式是文本方式。两种方式的区别见前文
ios::in：　　　 读，文件不存在，则失败(ifstream的默认模式)
ios::out：　　　写，文件不存在，则创建(ofstream的默认模式)
ios::nocreate： 不建立文件，所以文件不存在时打开失败　
ios::noreplace：不覆盖文件，所以打开文件时如果文件存在失败
ios::trunc：　　打开文件时，删除文件现有的内容， 不可单独使用，必须有ios::out配合使用,文件不存在则创建

access:打开文件的属性
0：普通文件，打开访问
1：只读文件
2：隐含文件
4：系统文件

Windows系统的文本文件，每一行结束以2个字符(CR和LF)为记号
未设置binary进行读或写，换行字符会被替换为上述2个字符
如果文件内容是二进制数据而非字符序列，就应该使用binary，例如复制文件
如果将文件当做文本处理，则不应该设置binary

fstream file1;
　　 file1.open("c:\\config.sys",ios::binary|ios::in,0);

fstream有两个子类：ifstream和ofstream
ifstream file2("c:\\pdos.def");//以输入方式打开文件
　　 ofstream file3("c:\\x.123");//以输出方式打开文件
对比C
in 读取 "r" binary 相当于加了一个b
out 清空而后涂写 "w"
out|trunc 清空而后涂写 "w"
out|app 追加 "a"
app 追加 "a"
in|out 文件不存在则失败,没有trunc,也会删除文件内容，为保留需加app "r+"
in|out|trunc 先清空，再读/写 "w+"
in|app 在尾段更新 "a+"
in|out|app 在尾段更新 "a+"

trunc|app 是不允许的

ifstream file;
file.open("1.txt");

if (file){
char c;
while (file.get(c))
{
cout.put(c);
}

file.clear();//清除设于文件尾端的state flag
file.close();
}

不采用字符逐一处理，改用单独一个语句打印整个内容
cout << file.rdbuf();

二、关闭文件
file1.close();
三、读写文件
1、文本文件的读写
file1<<"I Love You";//向文件写入字符串"I Love You"
int I;
file1>>I;//从文件输入一个整数值。

操纵符 功能 输入/输出
dec 格式化为十进制数值数据 输入和输出
endl 输出一个换行符并刷新此流 输出
ends 输出一个空字符 输出
hex 格式化为十六进制数值数据 输入和输出
oct 格式化为八进制数值数据 输入和输出
setpxecision(int p) 设置浮点数的精度位数 输出

要把123当作十六进制输出：
file1<<hex<<123;
要把3.1415926以5位精度输出：
file1<<setpxecision(5)<<3.1415926。
2、二进制文件的读写
①put()
向流写入一个字符
file1.put(''c'');
②get()
char x;
file2.get(x);
x=file2.get();//这种形式是从流中返回一个字符，如果到达文件尾，返回EOF

file2.get(str1,127,"A");//ifstream &get(char *buf,int num,char delim="\n");
//从文件中读取字符到字符串str1，当遇到字符''A''或读取了127个字符时终止。
③读写数据块
read(unsigned char *buf,int num);
　　write(const unsigned char *buf,int num);

read()从文件中读取 num 个字符到 buf 指向的缓存中，
如果在还未读入 num 个字符时就到了文件尾，可以用成员函数 int gcount();来取得实际读取的字符数；
而 write() 从buf 指向的缓存写 num 个字符到文件中，值得注意的是缓存的类型是 unsigned char *，有时可能需要类型转换。

unsigned char str1[]="I Love You";
　　　　int n[5];
　　　　ifstream in("xxx.xxx");
　　　　ofstream out("yyy.yyy");
　　　　out.write(str1,strlen(str1));//把字符串str1全部写到yyy.yyy中
　　　　in.read((unsigned char*)n,sizeof(n));//从xxx.xxx中读取指定个整数，注意类型转换
　　　　in.close();out.close();

四、检测EOF
eof();如果到达文件尾返回非0值，否则返回0。
五、文件定位
和C的文件操作方式不同的是,C++ I/O系统管理两个与一个文件相联系的指针
一个是读指针，它说明输入操作在文件中的位置；另一个是写指针，它下次写操作的位置。
seekg()是设置读位置，seekp是设置写位置

istream &seekg(streamoff offset,seek_dir origin);
　　　　ostream &seekp(streamoff offset,seek_dir origin);

streamoff定义于 iostream.h 中，定义有偏移量 offset 所能取得的最大值
seek_dir 表示移动的基准位置，是一个有以下值的枚举
ios::beg：　　文件开头
ios::cur：　　文件当前位置
ios::end：　　文件结尾

这两个函数一般用于二进制文件，
因为文本文件会因为系统对字符的解释而可能与预想的值不同

file1.seekg(1234,ios::cur);//把文件的读指针从当前位置向后移1234个字节
　　file2.seekp(1234,ios::beg);//把文件的写指针从文件开头向后移1234个字节

//头文件 sstream
stringstream strm;
string s = "hello";
stringstream strm1(s); //拷贝一个字符串

strm1.str(); //返回strm1所保存的string的拷贝
strm1.str(s); //将s拷贝到strm中，返回void

例：
//从cin读取姓名电话,以空格隔开,保存到结构体
string line, word;
vector<PersonInfo> people;
while (getline(cin,line))
{
PersonInfo info;
istringstream record(line);
record >> info.name; // >> 操作符会以空格停止
while (record >> word)
info.phones.push_back(word);
people.push_back(info);
}

//再写到文件
fstream fstrm4("4.txt", ios::in | ios::out | ios::app);
for (size_t i = 0; i < people.size(); ++i)
{
fstrm4 << endl;
fstrm4 << people[i].name << ' ';
auto beg = people[i].phones.begin();
auto end = people[i].phones.end();
while (beg != end)
{
fstrm4 << *beg++ << ' ';
}
}
fstrm4.close();

for (const auto &entry : people)
{
ostringstream formatted, badNums;
for (const auto &nums : entry.phones)
{
// if (!valid(nums)) //假设有valid函数验证电话号码的正确性
// badNums << "" << nums;
// else
formatted << " " << /*format(*/nums/*)*/; //假设有format函数 格式化电话号码
}
if (badNums.str().empty())
cout << entry.name << " " << formatted.str() << endl;
else
cerr << "input error:" << entry.name
<< " invalid number(s) " << badNums.str() << endl;
}

Win32 overlapped I/O

CreateFile()、ReadFile()、WriteFile()
CloseHandle()

打开文件(硬盘、软盘、光盘等)、串行口、并行口、Named pipes、Console
HANDLE WINAPI CreateFile( //失败返回INVALID_HANDLE_VALUE
_In_ LPCTSTR lpFileName, //文件名
_In_ DWORD dwDesiredAccess, //存取模式(读或写)
_In_ DWORD dwShareMode, //共享模式
_In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, //安全属性
_In_ DWORD dwCreationDisposition, //如何产生
_In_ DWORD dwFlagsAndAttributes, //文件属性
_In_opt_ HANDLE hTemplateFile //一个临时文件,将拥有全部的属性拷贝
);

dwDesiredAccess ：GENERIC_READ、GENERIC_WRITE
dwShareMode ：0 不共享
FILE_SHARE_DELETE
FILE_SHARE_READ
FILE_SHARE_WRITE

lpSecurityAttributes ：可以为NULL

dwCreationDisposition ：CREATE_ALWAYS
指定文件存在且是可写的则重写该文件，函数成功，
last-error：ERROR_ALREADY_EXISTS
指定文件不存在，且路径存在，创建新文件，函数成功
last-error：0
CREATE_NEW
文件不存在且路径可写时创建新文件，
存在则函数失败，last-error：ERROR_FILE_EXISTS
OPEN_ALWAYS
文件存在，函数成功last-error：ERROR_ALREADY_EXISTS
文件不存在且路径可写时创建新文件last-error：0
OPEN_EXISTING
不存在，函数失败last-error：ERROR_FILE_NOT_FOUND
TRUNCATE_EXISTING
打开并清空，必须使用GENERIC_WRITE
不存在，函数失败last-error：ERROR_FILE_NOT_FOUND

dwFlagsAndAttributes, //文件属性(关键)

FILE_FLAG_OVERLAPPED 异步

hTemplateFile
可选择的，可为NULL

BOOL WINAPI ReadFile(
_In_ HANDLE hFile,
_Out_ LPVOID lpBuffer,
_In_ DWORD nNumberOfBytesToRead,
_Out_opt_ LPDWORD lpNumberOfBytesRead,
_Inout_opt_ LPOVERLAPPED lpOverlapped
);

BOOL WINAPI WriteFile(
_In_ HANDLE hFile,
_In_ LPCVOID lpBuffer,
_In_ DWORD nNumberOfBytesToWrite,
_Out_opt_ LPDWORD lpNumberOfBytesWritten,
_Inout_opt_ LPOVERLAPPED lpOverlapped
);

如果CreateFile的第6个参数指定为FILE_FLAG_OVERLAPPED，就必须在上述的lpOverlapped参数中提供一个指针，指向OVERLAPPED结构

typedef struct _OVERLAPPED {
ULONG_PTR Internal;
ULONG_PTR InternalHigh;
union {
struct {
DWORD Offset;
DWORD OffsetHigh;
};
PVOID Pointer;
};
HANDLE hEvent;
} OVERLAPPED, *LPOVERLAPPED;

Internal：通常保留
InternalHigh：通常保留
Offset：文件之中开始被读或被写的偏移位置(以字节为单位)，以文件头开始算起，如果目标设备(例如 pipes)没有支持文件位置，则此栏被忽略
hEvent:一个手动重置的event对象，当overlapped I/O完成时即被激发，ReadFileEx()和WriteFileEx() 会忽略这个栏位，彼时它可能用来被传递一个用户自定义的指针

 

BOOL WINAPI GetOverlappedResult(
_In_ HANDLE hFile,
_In_ LPOVERLAPPED lpOverlapped,
_Out_ LPDWORD lpNumberOfBytesTransferred,
_In_ BOOL bWait
);

lpNumberOfBytesTransferred:真正被传输的字节个数
bWait：是否要等待操作完成

成功返回TRUE，失败返回FALSE，如果bWait为FALSE而overlapped还是没有完成，GetLastError()传回ERROR_IO_INCOMPLETE

1.
BOOL rc;
HANDLE hFile;
DWORD numread;
OVERLAPPED overlap;
memset(&overlap, 0, sizeof(overlap));
char buf[512];
memset(buf, 0, sizeof(buf));

hFile = CreateFile(_T("1.txt"),
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{}

2.
overlap.Offset = 1500;

3.
rc = ReadFile(hFile, buf, 300, &numread, &overlap);

4.
if (rc)
{
//successfully
}
else
{
if (GetLastError() == ERROR_IO_PENDING) //等待执行
{
WaitForSingleObject(hFile, INFINITE);//等待执行完毕
rc = GetOverlappedResult(hFile, &overlap, &numread, FALSE);

}
else //其他错误
{}
5.
CloseHandle(hFile);

 

区别：

1、缓冲文件系统与非缓冲系统的区别

缓冲文件系统(fopen)：在内存为每个文件开辟一个缓存区，当执行读操作，从磁盘文件将数据读入内存缓冲区，装满后从内存缓冲区依次读取数据。写操作同理。
内存缓冲区的大小影响着实际操作外存的次数，缓冲区越大，操作外存的次数越少，执行速度快，效率高。缓冲区大小由机器而定。
借助文件结构体指针对文件管理，可读写字符串、格式化数据、二进制数据。
非缓冲文件系统(open)：依赖操作系统功能对文件读写，不设文件结构体指针，只能读写二进制文件。

2、open属于低级IO，fopen属于高级IO

3、open返回文件描述符，属于用户态，读写需进行用户态与内核态切换。
fopen返回文件指针

4、open是系统函数，不可移植
fopen是标准C函数，可移植

5、一般用fopen打开普通文件，open打开设备文件

6、如果顺序访问文件，fopen比open快
如果随机访问文件，open比fopen快