linux c 文件的基本操作

最新推荐文章于 2024-07-11 22:18:20 发布
最新推荐文章于 2024-07-11 22:18:20 发布
阅读量3.6k 收藏 2
点赞数
分类专栏： linux 应用编程 文章标签： linux 文件操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bugouyonggan/article/details/17554605
版权

由于需要把一些程序中的数据存储到文件中（只所以不用sqlite数据库，是因为在嵌入式设备上空间太小了，我们的数据有很少）。要求第一行要是写入的内容行数，从第二行起才是要存的数据，每条数据放一行。

在用fputs（）函数存放第一条内容后，发现不会自动换行，并且我写入fputs（“\n”，fd），也不行，但是要继续用fputs写入内容在写换行符就可以了。为什么第一行不能换行呢？

在写完第一行后，用fseek函数指定文件的开头，并且需要一个非零的偏移量，然后再写换行符，就可以换行了。但是如果用fseek指定文件的开头，偏移量为零时，用换行符依然不能换行。真的挺奇怪的。还有在对文件操作时以追加方式打开则不能用fseek指定写入的位置，仅能在文件尾增加内容。以写方式打开时，总是清空文件以前的内容。

下边是我的程序截图：

 
#include <stdio.h>
#include <string.h>
#include <stddef.h>
#include <cstring>
#include "operatefile.h"


#define     DEVFILE    "/home/liu/test/testoperatefile/deviceInfo"
#define		DEVFILE_BAK     "/home/liu/test/testoperatefile/deviceInfoBak"
#define		DEVFILE_TEST     "/home/liu/test/testoperatefile/deviceInfotest"
#define 	MAX_DEVICE_NUM		100
#define NO_MORE			-1

StDevice_t g_device[10];


int getDeviceValue( char *buf, StDevice_t  myDeviceInfo)
{
	char tempDevType[3] = {0};
	int count;

	memcpy(buf, myDeviceInfo.nodeID,NODE_ID_LEN);		//nodeid
	buf[NODE_ID_LEN] = ';';
	sprintf(tempDevType, "%2d",myDeviceInfo.devType);
	printf("tempdevtype %x  %c%c\n",myDeviceInfo.devType,tempDevType[0],tempDevType[1]);
	memcpy(&buf[NODE_ID_LEN+1],tempDevType, 2);			// devtype
	buf[NODE_ID_LEN+1+2] = ';';
	memcpy(&buf[NODE_ID_LEN+1+2+1],myDeviceInfo.cmdVersion,__CMD_VERSION_LEN);   //cmd version
	buf[NODE_ID_LEN+1+2+1 + __CMD_VERSION_LEN] = ';';
	if( myDeviceInfo.devType == 0x01)
		count = 8;
	if ( myDeviceInfo.devType == 0x02 )
		count = 22;
	memcpy(&buf[NODE_ID_LEN+1+2+1 + __CMD_VERSION_LEN +1],myDeviceInfo.devID.generalDevID,count);    // device serial
	buf[NODE_ID_LEN+1+2+1 + __CMD_VERSION_LEN +1+count] = '#';
	buf[NODE_ID_LEN+1+2+1 + __CMD_VERSION_LEN +1+count +1] = '\0';
	return 0;
}



int renewDevInfo(char syncCode[4])
{
	StDevice_t  l_device;
	char buf[50]= {0};
	FILE *fd;
	int i=-1,count;
	char devNum[5] = {0};

	rename( DEVFILE, DEVFILE_BAK);  //BACK UP DEVFILE

//	sem_wait(&g_devlist.devList.st_sem);
//	if( NO_MORE == g_devlist.devList.head)
//	{
//		sem_post(&g_devlist.devList.st_sem);
//		printf("g_devlist  have no device\n");
//	}
//	else
//	{
		fd =fopen(DEVFILE,"w");
		if(fd == NULL)
		{
			printf(" open DEVFILE IS ERROR \n");
			return -1;
		}
		fseek( fd, 0, SEEK_SET);
		fputs("hello,",fd);
		memset(buf,0,50);
//		l_device = g_devlist.device[g_devlist.devList.head];
		l_device = g_device[0];//ttttttttttttttttttt
		getDeviceValue(buf, l_device);
		fseek( fd, 10, SEEK_SET);		//这里的偏移量很重要，否则下一次fputs时就不会换行
//		fputs("\n",fd);
		fputs("\n",fd);
		fputs(buf,fd);
		printf("&&&&&&&&&&&&&&&&&&&&&&&&&&&&\n");
				for(i=0;i<50;i++) {
					printf(" %c",buf[i]);
				}
				printf("\n");

		fputs("\n",fd);
		for (i=1; l_device.next !=NO_MORE; i++)
		{
//			l_device = g_devlist.device[l_device.next];
			l_device = g_device[l_device.next] ;//ttttttttttttttttt
			memset(buf,0,50);
			getDeviceValue(buf, l_device);
			fputs(buf,fd);
			fputs("\n",fd);
		}

		memset(buf,0,50);
		sprintf(devNum, "%04d", i);
		memcpy(buf,devNum,4);
		buf[4] = ';';
		memcpy(&buf[5],syncCode,4);
		buf[5+4] ='#';
		buf[5+4+1]= '\n';
		fseek( fd, 0, SEEK_SET);
		fputs(buf,fd);

		fclose(fd);
//		sem_post(&g_devlist.devList.st_sem);
//	}


	return i ;
}


/*
 * read device infor
 *
 * return  the total of read
 */

int readDeviceInfo(void)
{
	int num,count,sum;
	char buf[100];
	char ret;
	int  i;
	char nodeid[5]= {0};
	char devType[3] ={0};
	char cmdVersion[__CMD_VERSION_LEN] ={0};
	char deviceID[22] ={0};
	char chNum[5]={0};
	StDevice_t device;
	FILE *fd;
	FILE *fdtest;


	fd = fopen(DEVFILE, "r+" );
	fdtest = fopen(DEVFILE_TEST, "w+" );//tttttttttttttttttttttttt
	if (NULL == fd)
	{
		printf("open FILE_NAME is error\n");
		return -1;
	}
	if( fgets(buf,100, fd ) != NULL)     //get number of device
	{
		fputs(buf,fdtest); //tttttttttttttttttttttttttt
		for (i =0; buf[i] != ';' ; i++)
		{
			chNum[i]= buf[i];
		}
	}
	if( chNum[4] == '0')
	{
		printf(" text is empty\n");
		return -1;
	}
	sum =0;
	while( fgets(buf,100, fd ) != NULL)
	{
//		num = devAllocate();
		fputs(buf,fdtest); //tttttttttttttttttttttttttt
//		device = g_devlist.device[num];
//		i=0;
//		while(buf[i] !=';')     // nodeid
//		{
//			device.nodeID[i]=buf[i];
//			i++;
//		}
//		count = 0;
//		while(buf[i] != ';')
//		{
//			devType[count] = buf[i];
//			i++;
//			count++;
//		}
//		//sprintf(&devic.devType, "%x%x",devType)
//		devic.devType=((int)(devType[0] - '0')) + (int)(devType[1]- '0');
//		count = 0;
//		while(buf[i]!= ';')
//		{
//			device.cmdVersion[count] = buf[i];
//			i++;
//			count++;
//		}
//		count = 0;
//		while( buf[i]!='#')
//		{
//			device.devID[count] = buf[i];
//			i++;
//			count++;
//		}
//		insertDevice(num);
		sum++;
		printf(" READ SUM IS %d\n",sum);

	}
	fclose(fd);
	return  sum;
}

int main(int argc, char**agrv)
{
	StDevice_t *device;
	int i, count,ret;
	char syncCode[5] = {0};
	char num[5] = {0};
	char array1[4]={ '0','0','0','1'};
	char array2[2]={'0','1'};
	char array3[8]={'0','1','2','3','4','5','6','7'};
	char array4[22] = {'0','2','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1'};
	device=g_device;

	for (i =0,count =1; i< 9; i++,count++){

		memcpy(device[i].nodeID, array1, 4);
		//device[0].nodeID[3] = '1';
		sprintf((char *)&device[i].nodeID[3],"%d", count);
		device[i].devType = 0x02;				//general
		memcpy(device[i].cmdVersion, array2, 2);
		//device[0].cmdVersion[1] = '1';
		sprintf((char *)&device[i].cmdVersion[1],"%d", count);
		memcpy(device[i].devID.generalDevID, array4, 22);
		//device[i].devID.generalDevID[1] = '1';
		//sprintf((char *)&device[i].devID.generalDevID[1],"%d", count);
		sprintf(num,"%d", count);
		device[i].devID.generalDevID[1]=num[0];
		device[i].next = i+1;
		printf("dev nodeidis %c%c%c%c, devtype:%x \n",device[i].nodeID[0],device[i].nodeID[1],device[i].nodeID[2],device[i].nodeID[3],device[i].devType);
		printf(" devversion: %c%c, devID: %c %c %c %c %c\n",device[i].cmdVersion[0],device[i].cmdVersion[1],device[i].devID.generalDevID[0],device[i].devID.generalDevID[1],device[i].devID.generalDevID[2],device[i].devID.generalDevID[3],device[i].devID.generalDevID[4]);
	}
	device[i-1].next = NO_MORE;
//	for (i = 0,count=4320; i<10; i++) {
	count=4320;
		sprintf(syncCode,"%4d",count);
		printf("syncCode is %c%c%c%c\n",syncCode[0],syncCode[1],syncCode[2],syncCode[3]);
		ret =renewDevInfo(syncCode);
		count++;
//	}
	readDeviceInfo();

	return 0;
}






以下是常用文件操作函数：

clearerr（清除文件流的错误旗标） 
相关函数 feof
表头文件 #include<stdio.h> 
定义函数 void clearerr(FILE * stream); 
函数说明 clearerr（）清除参数stream指定的文件流所使用的错误旗标。 
返回值 

　 
fclose（关闭文件） 
相关函数 close，fflush，fopen，setbuf 
表头文件 #include<stdio.h> 
定义函数 int fclose(FILE * stream); 
函数说明 fclose()用来关闭先前fopen()打开的文件。此动作会让缓冲区内的数据写入文件中，并释放系统所提供的文件资源。 
返回值 若关文件动作成功则返回0，有错误发生时则返回EOF并把错误代码存到errno。 
错误代码 EBADF表示参数stream非已打开的文件。 
范例 请参考fopen（）。

　 
fdopen（将文件描述词转为文件指针） 
相关函数 fopen，open，fclose 
表头文件 #include<stdio.h> 
定义函数 FILE * fdopen(int fildes,const char * mode); 
函数说明 fdopen()会将参数fildes 的文件描述词，转换为对应的文件指针后返回。参数mode 字符串则代表着文件指针的流形态，此形态必须和原先文件描述词读写模式相同。关于mode 字符串格式请参考fopen()。 
返回值 转换成功时返回指向该流的文件指针。失败则返回NULL，并把错误代码存在errno中。

范例 #include<stdio.h>
main()
{
FILE * fp =fdopen(0,”w+”);
fprintf(fp,”%s\n”,”hello!”);
fclose(fp);
}

执行 hello!


feof（检查文件流是否读到了文件尾） 
相关函数 fopen，fgetc，fgets，fread 
表头文件 #include<stdio.h> 
定义函数 int feof(FILE * stream); 
函数说明 feof()用来侦测是否读取到了文件尾，尾数stream为fopen（）所返回之文件指针。如果已到文件尾则返回非零值，其他情况返回0。 
返回值 返回非零值代表已到达文件尾。

　 
fflush（更新缓冲区） 
相关函数 write，fopen，fclose，setbuf 
表头文件 #include<stdio.h> 
定义函数 int fflush(FILE* stream); 
函数说明 fflush()会强迫将缓冲区内的数据写回参数stream指定的文件中。如果参数stream为NULL，fflush()会将所有打开的文件数据更新。 
返回值 成功返回0，失败返回EOF，错误代码存于errno中。 
错误代码 EBADF 参数stream 指定的文件未被打开，或打开状态为只读。其它错误代码参考write（）。

　 
fgetc（由文件中读取一个字符） 
相关函数 open，fread，fscanf，getc 
表头文件 include<stdio.h> 
定义函数 nt fgetc(FILE * stream); 
函数说明 fgetc()从参数stream所指的文件中读取一个字符。若读到文件尾而无数据时便返回EOF。 
返回值 getc()会返回读取到的字符，若返回EOF则表示到了文件尾。 
范例 #include<stdio.h>
main()
{
FILE *fp;
int c;
fp=fopen(“exist”,”r”);

while((c=fgetc(fp))!=EOF)
   printf(“%c”,c);

fclose(fp);
}

fgets（由文件中读取一字符串） 
相关函数 open，fread，fscanf，getc 
表头文件 include<stdio.h> 
定义函数 har * fgets(char * s,int size,FILE * stream); 
函数说明 fgets()用来从参数stream所指的文件内读入字符并存到参数s所指的内存空间，直到出现换行字符、读到文件尾或是已读了size-1个字符为止，最后会加上NULL作为字符串结束。 
返回值 gets()若成功则返回s指针，返回NULL则表示有错误发生。 
范例 #include<stdio.h>
main()
{
char s[80];
fputs(fgets(s,80,stdin),stdout);
}

执行 this is a test /*输入*/
this is a test /*输出*/

　 
fileno（返回文件流所使用的文件描述词） 
相关函数 open，fopen 
表头文件 #include<stdio.h> 
定义函数 int fileno(FILE * stream); 
函数说明 fileno()用来取得参数stream指定的文件流所使用的文件描述词。 
返回值 返回文件描述词。

范例 #include<stdio.h>
main()
{
FILE * fp;
int fd;

fp=fopen(“/etc/passwd”,”r”);

fd=fileno(fp);
printf(“fd=%d\n”,fd);

fclose(fp);
}

执行 fd=3

　 
fopen（打开文件） 
相关函数 open，fclose 
表头文件 #include<stdio.h> 
定义函数 FILE * fopen(const char * path,const char * mode); 
函数说明 参数path字符串包含欲打开的文件路径及文件名，参数mode字符串则代表着流形态。
mode有下列几种形态字符串:
r 打开只读文件，该文件必须存在。
r+ 打开可读写的文件，该文件必须存在。
w 打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
w+ 打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
a 以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。
a+ 以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。
上述的形态字符串都可以再加一个b字符，如rb、w+b或ab＋等组合，加入b 字符用来告诉函数库打开的文件为二进制文件，而非纯文字文件。不过在POSIX系统，包含Linux都会忽略该字符。由fopen()所建立的新文件会具 有S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH(0666)权限，此文件权限也会参考umask 值。 
返回值 文件顺利打开后，指向该流的文件指针就会被返回。若果文件打开失败则返回NULL，并把错误代码存在errno 中。 
附加说明 一般而言，开文件后会作一些文件读取或写入的动作，若开文件失败，接下来的读写动作也无法顺利进行，所以在fopen()后请作错误判断及处理。 
范例 #include<stdio.h>
main()
{
FILE * fp;

fp=fopen(“noexist”,”a+”);
if(fp= =NULL) return;

fclose(fp);
}

fputc（将一指定字符写入文件流中） 
相关函数 fopen，fwrite，fscanf，putc 
表头文件 #include<stdio.h> 
定义函数 int fputc(int c,FILE * stream); 
函数说明 fputc 会将参数c 转为unsigned char 后写入参数stream 指定的文件中。 
返回值 fputc()会返回写入成功的字符，即参数c。若返回EOF则代表写入失败。 
范例 #include<stdio.h>
main()
{
FILE * fp;
char a[26]=”abcdefghijklmnopqrstuvwxyz”;
int i;

fp= fopen(“noexist”,”w”);

for(i=0;i<26;i++)
   fputc(a[i],fp);

fclose(fp);
}


fputs（将一指定的字符串写入文件内） 
相关函数 fopen，fwrite，fscanf，fputc，putc 
表头文件 #include<stdio.h> 
定义函数 int fputs(const char * s,FILE * stream); 
函数说明 fputs()用来将参数s所指的字符串写入到参数stream所指的文件内。 
返回值 若成功则返回写出的字符个数，返回EOF则表示有错误发生。 
范例 请参考fgets（）。 

fread（从文件流读取数据） 
相关函数 fopen，fwrite，fseek，fscanf 
表头文件 #include<stdio.h> 
定义函数 size_t fread(void * ptr,size_t size,size_t nmemb,FILE * stream); 
函数说明 fread()用来从文件流中读取数据。参数stream为已打开的文件指针，参数ptr 指向欲存放读取进来的数据空间，读取的字符数以参数size*nmemb来决定。Fread()会返回实际读取到的nmemb数目，如果此值比参数 nmemb 来得小，则代表可能读到了文件尾或有错误发生，这时必须用feof()或ferror()来决定发生什么情况。
返回值 返回实际读取到的nmemb数目。

附加说明   
范例 #include<stdio.h>
#define nmemb 3
struct test
{
char name[20];
int size;
}s[nmemb];

main()
{
FILE * stream;
int i;

stream = fopen(“/tmp/fwrite”,”r”);
fread(s,sizeof(struct test),nmemb,stream);
fclose(stream);

for(i=0;i<nmemb;i++)
   printf(“name[%d]=%-20s:size[%d]=%d\n”,i,s[i].name,i,s[i].size);
}

执行 name[0]=Linux! size[0]=6
name[1]=FreeBSD! size[1]=8
name[2]=Windows2000 size[2]=11

　
freopen（打开文件） 
相关函数 fopen，fclose 
表头文件 #include<stdio.h> 
定义函数 FILE * freopen(const char * path,const char * mode,FILE * stream); 
函数说明 参数path字符串包含欲打开的文件路径及文件名，参数mode请参考fopen()说明。参数stream为已打开的文件指针。Freopen()会将原stream所打开的文件流关闭，然后打开参数path的文件。 
返回值 文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则返回NULL，并把错误代码存在errno 中。

范例 #include<stdio.h>
main()
{
FILE * fp;

fp=fopen(“/etc/passwd”,”r”); 
fp=freopen(“/etc/group”,”r”,fp);

fclose(fp);
}

fseek（移动文件流的读写位置） 
相关函数 rewind，ftell，fgetpos，fsetpos，lseek 
表头文件 #include<stdio.h> 
定义函数 int fseek(FILE * stream,long offset,int whence); 
函数说明 fseek()用来移动文件流的读写位置。参数stream为已打开的文件指针，参数offset为根据参数whence来移动读写位置的位移数。 
参数 whence为下列其中一种:
SEEK_SET从距文件开头offset位移量为新的读写位置。SEEK_CUR 以目前的读写位置往后增加offset个位移量。
SEEK_END将读写位置指向文件尾后再增加offset个位移量。
当whence值为SEEK_CUR 或SEEK_END时，参数offset允许负值的出现。
下列是较特别的使用方式:
1) 欲将读写位置移动到文件开头时:fseek(FILE *stream,0,SEEK_SET);
2) 欲将读写位置移动到文件尾时:fseek(FILE *stream,0,0SEEK_END); 
返回值 当调用成功时则返回0，若有错误则返回-1，errno会存放错误代码。 
附加说明 fseek()不像lseek()会返回读写位置，因此必须使用ftell()来取得目前读写的位置。

范例 #include<stdio.h>
main()
{
FILE * stream;
long offset;
fpos_t pos;

stream=fopen(“/etc/passwd”,”r”);
fseek(stream,5,SEEK_SET);
printf(“offset=%d\n”,ftell(stream));

rewind(stream);
fgetpos(stream,&pos);
printf(“offset=%d\n”,pos);

pos=10;

fsetpos(stream,&pos);
printf(“offset = %d\n”,ftell(stream));

fclose(stream);
}

执行 offset = 5
offset =0
offset=10

　 
ftell（取得文件流的读取位置） 
相关函数 fseek，rewind，fgetpos，fsetpos 
表头文件 #include<stdio.h> 
定义函数 long ftell(FILE * stream); 
函数说明 ftell()用来取得文件流目前的读写位置。参数stream为已打开的文件指针。 
返回值 当调用成功时则返回目前的读写位置，若有错误则返回-1，errno会存放错误代码。 
错误代码 EBADF 参数stream无效或可移动读写位置的文件流。

范例 参考fseek()。

　 

fwrite（将数据写至文件流） 
相关函数 fopen，fread，fseek，fscanf 
表头文件 #include<stdio.h> 
定义函数 size_t fwrite(const void * ptr,size_t size,size_t nmemb,FILE * stream); 
函数说明 fwrite()用来将数据写入文件流中。参数stream为已打开的文件指针，参数ptr 指向欲写入的数据地址，总共写入的字符数以参数size*nmemb来决定。Fwrite()会返回实际写入的nmemb数目。 
返回值 返回实际写入的nmemb数目。

范例 #include<stdio.h>
#define set_s (x,y) {strcoy(s[x].name,y);s[x].size=strlen(y);}
#define nmemb 3
struct test
{
char name[20];
int size;
}s[nmemb];
main()
{
FILE * stream;

set_s(0,”Linux!”);
set_s(1,”FreeBSD!”);
set_s(2,”Windows2000.”);
stream=fopen(“/tmp/fwrite”,”w”);
fwrite(s,sizeof(struct test),nmemb,stream);

fclose(stream);
}

执行 参考fread（）。

　 

getc（由文件中读取一个字符） 
相关函数 read，fopen，fread，fgetc 
表头文件 #include<stdio.h> 
定义函数 int getc(FILE * stream); 
函数说明 getc()用来从参数stream所指的文件中读取一个字符。若读到文件尾而无数据时便返回EOF。虽然getc()与fgetc()作用相同，但getc()为宏定义，非真正的函数调用。 
返回值 getc()会返回读取到的字符，若返回EOF则表示到了文件尾。 
范例 参考fgetc()。

　 
getchar（由标准输入设备内读进一字符） 
相关函数 fopen，fread，fscanf，getc 
表头文件 #include<stdio.h> 
定义函数 int getchar(void); 
函数说明 getchar()用来从标准输入设备中读取一个字符。然后将该字符从unsigned char转换成int后返回。 
返回值 getchar()会返回读取到的字符，若返回EOF则表示有错误发生。 
附加说明 getchar()非真正函数，而是getc(stdin)宏定义。

范例 #include<stdio.h>
main()
{
FILE * fp;
int c,i;

for(i=0li<5;i++)
{
   c=getchar();
   putchar(c);
}
}

执行 1234 /*输入*/
1234 /*输出*/


gets（由标准输入设备内读进一字符串） 
相关函数 fopen，fread，fscanf，fgets 
表头文件 #include<stdio.h> 
定义函数 char * gets(char *s); 
函数说明 gets()用来从标准设备读入字符并存到参数s所指的内存空间，直到出现换行字符或读到文件尾为止，最后加上NULL作为字符串结束。 
返回值 gets()若成功则返回s指针，返回NULL则表示有错误发生。 
附加说明 由于gets()无法知道字符串s的大小，必须遇到换行字符或文件尾才会结束输入，因此容易造成缓冲溢出的安全性问题。建议使用fgets()取代。 
范例 参考fgets()

　 
mktemp（产生唯一的临时文件名） 
相关函数 tmpfile 
表头文件 #include<stdlib.h> 
定义函数 char * mktemp(char * template); 
函数说明 mktemp()用来产生唯一的临时文件名。参数template所指的文件名称字符串中最后六个字符必须是XXXXXX。产生后的文件名会借字符串指针返回。 
返回值 文件顺利打开后，指向该流的文件指针就会被返回。如果文件打开失败则返回NULL，并把错误代码存在errno中。

附加说明 参数template所指的文件名称字符串必须声明为数组，如:
char template[ ]=”template-XXXXXX”；
不可用char * template=”template-XXXXXX”；

范例 #include<stdlib.h>
main()
{
char template[ ]=”template-XXXXXX”;
mktemp(template);
printf(“template=%s\n”,template);
}

　

putc（将一指定字符写入文件中） 
相关函数 fopen，fwrite，fscanf，fputc 
表头文件 #include<stdio.h> 
定义函数 int putc(int c,FILE * stream); 
函数说明 putc()会将参数c转为unsigned char后写入参数stream指定的文件中。虽然putc()与fputc()作用相同，但putc()为宏定义，非真正的函数调用。 
返回值 putc()会返回写入成功的字符，即参数c。若返回EOF则代表写入失败。 
范例 参考fputc（）。

　 
putchar（将指定的字符写到标准输出设备） 
相关函数 fopen，fwrite，fscanf，fputc 
表头文件 #include<stdio.h> 
定义函数 int putchar (int c); 
函数说明 putchar()用来将参数c字符写到标准输出设备。 
返回值 putchar()会返回输出成功的字符，即参数c。若返回EOF则代表输出失败。 
附加说明 putchar()非真正函数，而是putc(c，stdout)宏定义。 
范例 参考getchar()。

　

rewind（重设文件流的读写位置为文件开头） 
相关函数 fseek，ftell，fgetpos，fsetpos 
表头文件 #include<stdio.h> 
定义函数 void rewind(FILE * stream); 
函数说明 rewind()用来把文件流的读写位置移至文件开头。参数stream为已打开的文件指针。此函数相当于调用fseek(stream,0,SEEK_SET)。
返回值   
范例 参考fseek()


setbuf（设置文件流的缓冲区） 
相关函数 setbuffer，setlinebuf，setvbuf 
表头文件 #include<stdio.h> 
定义函数 void setbuf(FILE * stream,char * buf); 
函数说明 在打开文件流后，读取内容之前，调用setbuf()可以用来设置文件流的缓冲区。参数stream为指定的文件流，参数buf指向自定的缓冲区起始地 址。如果参数buf为NULL指针，则为无缓冲IO。Setbuf()相当于调 用:setvbuf(stream,buf,buf?_IOFBF:_IONBF,BUFSIZ) 
返回值 

　 
setbuffer（设置文件流的缓冲区） 
相关函数 setlinebuf，setbuf，setvbuf 
表头文件 #include<stdio.h> 
定义函数 void setbuffer(FILE * stream,char * buf,size_t size); 
函数说明 在打开文件流后，读取内容之前，调用setbuffer()可用来设置文件流的缓冲区。参数stream为指定的文件流，参数buf指向自定的缓冲区起始地址，参数size为缓冲区大小。 
返回值 

setlinebuf（设置文件流为线性缓冲区） 
相关函数 setbuffer，setbuf，setvbuf 
表头文件 #include<stdio.h> 
定义函数 void setlinebuf(FILE * stream); 
函数说明 setlinebuf()用来设置文件流以换行为依据的无缓冲IO。相当于调用:setvbuf(stream,(char * )NULL,_IOLBF,0);请参考setvbuf()。 
返回值 


setvbuf（设置文件流的缓冲区） 
相关函数 setbuffer，setlinebuf，setbuf 
表头文件 #include<stdio.h> 
定义函数 int setvbuf(FILE * stream,char * buf,int mode,size_t size); 
函数说明 在打开文件流后，读取内容之前，调用setvbuf()可以用来设置文件流的缓冲区。参数stream为指定的文件流，参数buf指向自定的缓冲区起始地址，参数size为缓冲区大小，参数mode有下列几种
_IONBF 无缓冲IO
_IOLBF 以换行为依据的无缓冲IO
_IOFBF 完全无缓冲IO。如果参数buf为NULL指针，则为无缓冲IO。 
返回值 


ungetc（将指定字符写回文件流中） 
相关函数 fputc，getchar，getc 
表头文件 #include<stdio.h> 
定义函数 int ungetc(int c,FILE * stream); 
函数说明 ungetc()将参数c字符写回参数stream所指定的文件流。这个写回的字符会由下一个读取文件流的函数取得。 
返回值 成功则返回c 字符，若有错误则返回EOF。 

http://hi.baidu.com/exzz/blog/item/9881426e874344dc81cb4a86.html

另外 :

te< te<

 

fgets（由文件中读取一字符串）

　　相关函数

　　open，fread，fscanf，getc

　　表头文件

　　include<stdio.h>

　　定义函数

　　har * fgets(char * s,int size,FILE * stream);

　　函数说明

　　fgets()用来从参数stream所指的文件内读入字符并存到参数s所指的内存空间，直到出现换行字符、读到文件尾或是已读了size-1个字符为止，最后会加上NULL作为字符串结束。

　　返回值

　　gets()若成功则返回s指针，返回NULL则表示有错误发生。

　　范例

　　#include<stdio.h>

　　main()

　　{

　　           char s[80];

　　           fputs(fgets(s,80,stdin),stdout);

　　}

　　执行

　　this is a test /*输入*/

this is a test /*输出*/

 

函数名: fputs

　　功 能: 送一个字符串到一个流中

　　用 法: int fputs(char *string, FILE *stream);

　　程序例:

　　#include <stdio.h>

　　int main(void)

　　{

　　           /* write a string to standard output */

　　           fputs("Hello world\n", stdout);

　　           return 0;

}

PS: while(gets(name)!=NULL)可检查文件是否结尾,while((ch=getchar())!=EOF)

gets()读取换行符并将其丢弃，fgets()把换行符存字符串里，但每次显示字符串会显示换行符（不足之处）。fgets() 是为文件I/O而设计得，在处理键盘输入时就不如gets()那么方便。它需要第二个参数来说明最大读入字符数，如果这个参数值为n ，fgets()就会读取最多n-1个字符或者读完一个换行符为止，由这二者中最先满足得那个来结束输入。

fgets()还需要第三个参数来说明哪一个文件。从键盘上读数据时，可以使用stdin 作为该参数，这个标识符在stdio.h中定义。

char name[MAX]

char *ptr;

ptr=fgets(name,MAX,stdio);

--------------------------------------------------------------------------------------

puts()用法很简单，只需给出字符串参数的地址。puts()专门打印字符串，遇到‘\0’才结束，故非字符串或无'\0'的最好不要打印，否则无法结束。

fputs() 是puts()的面向文件版本， 区别是fputs()需要第二个参数说明要写的文件。可以使用stdout 作为参数来进行输出显示，在stdio.h中定义。

与puts（）不同，fputs()并不为输出自动添加换行符。

注意 ：gets()丢掉输入里的换行符，但puts()为输出添加换行符。fgets()存储输入中的换行符，而fputs()也不为输出添加换行符。如把fgets()输入和puts()输出结合使用，每个字符串后会显示两个换行符。

假定写一个循环，读取一行并把它回显在下一行，可以这样：

char line[81];

while(gets(line))

            puts(line);

或者也可以这样：

char line[81];

while(fgets(line,81,stdin))

fputs(line,stdout);

在第一个循环中，line数组中的字符串被显示在单独的一行上，这是由于puts()为它添加了一个换行符。第二个循环，line 数组中的字符串同样显示在单独的一行上，这是由于fgets()存储了一个换行符。puts()是为和gets()一起使用而设计的，而fputs()是为和fgets()一起使用而设计的。

bugouyonggan
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux-C 文件操作
m0_52604787的博客
12-04 2073
基于Linux环境下C语言编程的文件操作
Linux_C之文件操作
09-29 4643
wite系统调用： 系统调用write的作用是，把缓冲区buf的前nbytes个字节写入与文件描述fildes关联的文件中。它的返回实际写入的字节数，如果文件描述符有错或者底层的设置驱动程序对数据快长度比较敏感，该返回值可能会小于nbytes。如果这个函数的返回值为0,就表示未
Linux文件编程（标准C库）
最新发布
sakabu的博客
07-11 855
前面讲到的open函数都是基于linux内核的，也就是说在Windows系统上无法运行，移植性比较差，但标准C库同样有一套对文件进行操作的函数。
Promise使用
weixin_47450807的博客
10-09 354
Promise的使用 Es6中的Promise使得异步变得比同步变成简单，大大减少了代码量。 标题1. Promise的基本使用 新建一个Promise对象 var p=new Promise() 添加异步操作 在这里使用了jQuery，应该在文件中引入jQuery文件 var p=new Promise(function(resolve,reject) { $.ajax({ url:'arr.txt', dataType:'json', success(data){ re
linux c文件操作,linux c 下的文件操作
weixin_29522501的博客
04-28 188
在linuxc下是否能够使用fopen和fclose两个函数打开文件？为什么我使用fopen是程序出现“coredump”的错误，而使用open却可以成功。因为我接下来的工作用fopen比较方便，所以请高手指教。还有是不是所有vc下的c函数都能够在linuxc下使用？|C语言在Linux下面是完全可以用这两个函数的，可能是没有连接好函数库！|肯定可以，标准C的。关键是你代码其他地方有错...
Linux C语言的配置文件操作库
07-10
在Linux系统中，C语言作为底层编程的主要工具，其对配置文件的操作往往涉及到繁琐的文件I/O操作。然而，为了简化这一过程，开发者通常会利用特定的库来处理配置文件，比如读取、写入、解析键值对等。本文将深入探讨...
【Linux】->Linux目录结构及文件基本操作
01-09
Linux目录结构及文件基本操作Ⅰ Linux目录与Windows目录の差异Ⅱ Linux目录——FHS标准Ⅲ 目录路径A. 切换路径B. 绝对路径C. 相对路径Ⅳ 文件基本操作A. 新建a. 新建空白文件b. 新建目录B. 复制a. 复制文件b. 复制...
Linux下C语言_文件操作
03-04
Linux下C语言的文件操作与标准C库中的fopen()、fclose()、fread()、fwrite()等函数不同，open()、close()、read()、write()属于系统级调用，它们提供对文件的操作能力，而标准C库函数则是基于这些系统调用之上的封装...
使用C语言操作文件的基本函数整理
12-31
C语言creat()函数：创建文件函数 头文件： #include <sys> #include <sys> #include 定义函数： int creat(const char * pathname, mode_tmode); 函数说明： 1、参数 pathname 指向欲建立的文件路径字符串。 2...
linuxc 高级编程之文件操作（带截图）
03-03
//1.创建文件file1，写入字符串“abcdefghijklmn”； //2.创建文件file2，写入字符串“ABCDEFGHIJKLMN”; //3.读取file1中的内容，写入file2，使file2中的字符串内容为“abcdefghijklmn ABCDEFGHIJKLMN” 创建新文件，该文件具有用户读写权限。 //2.采用dup/dup2/fcntl复制一个新的文件描述符，通过新文件描述符向文件写入“class_name”字符串； //3.通过原有的文件描述符读取文件中的内容，并且打印显示； 1.输入文件名称，能够判断文件类型，判断实际用户对该文件具有哪些存取权限； ?2.要求打印出文件类型信息，inode节点编号，链接数目，用户id，组id，文件大小信息； ?3.修改文件的权限为当前用户读写，组内用户读写，组外用户无权限 新建文件，设置文件权限屏蔽字为0； 2.建立该文件的硬链接文件，打印硬链接文件的inode节点号和文件大小； ? 3.建立该文件的软链接文件，打印软链接文件的inode节点号和文件大小；打印软链接文件中的内容； 4.打印源文件的inode节点号，文件大小和链接数目； ? 5.调用unlink对源文件进行操作，打印源文件链接数目； .新建/home/user目录； 2.把当前工作路径移至/home/user目录； 3.打印当前工作路径； ?编写程序完成以下功能： ?1.递归遍历/home目录，打印出所有文件和子目录名称及节点号。 ?2.判断文件类型，如果是子目录，继续进行递归遍历，直到遍历完所有子目录为止
linux c 文件操作汇总
Fantasy1220的博客
05-27 614
本文包括31个常用文件操作的介绍及若干示例；fopen的详细介绍及示例；fopen和open 的区别。
Linux下C语言的文件操作
Old_Monster_的博客
01-24 1376
Linux下C语言的文件操作 文件的读写 代码 #include <stdio.h> #include <unistd.h> #include <string.h> #include <fcntl.h> #include <errno.h> #include <sys/types.h> #include <sys/stat.h> #define BUFFSIZE 512 #define MSG "hhhh9999" in
【Linux】C文件系统详解（一）——C文件操作
patrick的博客
11-17 389
1.文件描述符,重定向,缓冲区,语言和系统关于文件的不同的视角的理解 – 都是要让我们深刻理解文件2.文件系统3.动静态库 – a.制作者的角度 b.站在使用者的角度 c.如何理解动态库加载(进程地址空间的内容)
Linux c文件操作总结
Hello 刘付杰
07-23 1751
这一周以来一直与Linux的文件操作相关系统调用打交道,其与C语言中的文件操作函数有些许相似但又千差万别.尤其是open()函数的参数,相当复杂,因此作以记录便于查阅. 对于用Linux系统调用进行文件的常用操作作以总结 主要是关于open()系统调用的各个参数做记录.简述：open是UNIX系统（包括LINUX、Mac等）的系统调用函数，区别于C语言库函数fopen。#include<fcnt
Linux C文件操作
@@老胡的博客
10-12 514
使用fgetc或者fputc的时候，它底层的调用还是调用了read和write，但是在读取的时候做了一个系统的优化，也就是一次性读取了多个字节的内容，表面上看起来只读取一个字符，实际上底层中读取的是多个字节的字符。文件的属性信息与文件的实体不是存在在一个位置上的，把文件的属性信息存放在一个位置，这一类的文件叫做目录文件，也就是windows上的文件夹。表示从指定的文件中读下一个字符，返回一个没有符号的字符，或者EOF（end of file），需要读的文件必须是读或者读写的方式打开的，并且文件存在。
Linux C 文件操作
Wolf_Tong的博客
06-28 1655
打开文件 头文件 #include &lt;stdio.h&gt; 函数原型 FILE *fopen(const char *path, const char *mode); FILE *fdopen(int fd, const char *mode); FILE *freopen(const char *path, const char *mode, FILE *stream)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值