Linux文件IO与标准IO

int atoi(const char *nptr);
{
    nptr:为数组的字符串首地址
    返回值：将数字字符串转换为数字
}

man手册:

man 1：查看shell命令

man 2：查看系统调用

man 3：查看C标准库

标准IO

FILE* 是文件指针类型，该类型指向的是一个结构体,该结构体描述了文件相关信息,每一个应用程

序会默认定义三个文件流指针：stdin、stdout、stderr

stdin：标准输入流 文件io 0

stdout：标准输出流 文件io 1

stderr： 标准错误输出流 文件io 2

标准IO---> 属于C库函数 { 
    1、接口是由C标准(ANSI C标准)提供的，与语言以及程序有关
    2、又被称为高级IO(所谓的高级就是带缓存的IO)!!!
    3、一样可以用于所有普通文件的读写操作. 
}

1、打开----fopen()

FILE *fopen(const char *path, const char *mode);
path : 路径名
mode ：打开方式
		"r"   只读
		“r+”  读写不创建文件
		“w”	  只写
		“w+”  读写创建文件
		“a”   追加写
		“a+”  读写，追加写
    	“b”   二进制流，方便移植等，最好都加
    return  错误： NULL
    		成功：一个文件流
    

2、读取----fread()等…

int fgetc(FILE *stream): 从指定文件中读取一个字符, 并且将字符返回.
{ 
    stream: 流
    返回值: 
    		EOF：文件末尾 或 错误 
        	正确返回当前读取的字符... 
}

char *fgets(char *s, int size, FILE *stream); 常用代替scanf何gets
{
    s：数据首地址
    size：想要读取的字节数
        
    返回：NULL错误    
}
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
{
    ptr：数据首地址
    size：一个字节大小比如：sizeof(int)
    nmemb: 读取字节的个数
        //值得注意的是你读取的数据大小其实是 size*nmemb，比如char s[20],
        //fread(s,sizeof(s),sizeof(char),stdin)//别用stdin
        //fread(s,sizeof(char),sizeof(s),stdin)
    返回值：
        0 错误或者文件末尾
        成功返回读取数据大小
}

判断出错或者是文件末尾可以使用以下函数
    （只有fread函数需要，只有读取需要判断）：
{
    feof(): 判断是否到达文件末尾.
        用法: if(foef(fp) != 0) 
     ferror(): 判断文件操作是否出错. 
        用法: if(ferror(fp) != 0)
}

3、写入----fwrite()等…

int fputc(int ch, FILE *stream): 向文件写入一个字符.  
int fputs(const char *s, FILE *stream): 向文件写入一串数据. s表示数据的首地址.
{
    返回 ：EOF或非负数为错误
    
}
size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
{ 
    返回值: 错误: 0 或 比nmemb小的数字 
    正确返回成功写入的数据个数.
}

int fprintf(FILE *stream, const char *format, ...); 
{ 
    意义：将格式化字符串写入到指定文件当中 
    stream: 文件流指针 
    format: 格式控制字符串 
        ...: 可变参数 
            //fprintf(stdout, "hello   :%d\n",a);
        
}
int sprintf(char *str, const char *format, ...);
{ 
    意义：将格式化字符串存放到指定的字符串首地址中 
    str: 储存字符串 
    format: 格式控制字符串 
        ...: 可变参数 
		//sprintf(s, "hello  : %d\n", a);
}

4、关闭文件—fclose();

int fclose(FILE *stream);
{
	stream:文件流指针

}

5、偏移文件fseek

int fseek(FILE *stream, long offset, int whence){ 
 	whence参数: 
	SEEK_SET:文件开头
    SEEK_CUR:当前位置 
    SEEK_END:文件末尾 
    offset参数: 偏移量. 可以是负数向后偏移.
}
long ftell(FILE *stream)：返回当前文件流定位的位置，返回值是一个long类型. 常用于求文件大小
{
    ex：fseek(stream, 0, SEEK_END);
    	int m = ftell(stream);
    	printf("内存大小为%#x\n",m);
    
}
rewind(stream)：直接定位到文件开头 相当于：fseek(stream, 0, SEEK_SET)

标准IO的缓存

	全缓存：文件的读写一般都会采用全缓存方式
刷新条件：
	1. 使用fflush刷新
	2. 缓存区满
	3. 程序结束
	行缓存：标准输入 与 标准输出采用的方式
刷新条件：
	1. 遇到'\n' 
	2. 使用fflush刷新
	3. 程序结束
	4. 缓存区满
	无缓存：标准错误输出使用的方式
没有刷新条件，有数据则马上输出

setvbuf–缓存

 int setvbuf(FILE *stream, char *buf, int mode, size_t size);
{
    stream : 文件流指针
    buf	   ：重定义缓存区地址，可改为NULL，就只影响模式
    mode：   	_IONBF unbuffered  		无缓存

              	_IOLBF line buffered 	行缓存 默认个数

              	_IOFBF fully buffered	全缓存
    size : sizeof(buf)
        返回值：成功返回0
}

文件IO

文件IO---> 系统调用 
{ 
1、接口使用操作系统(POSIX标准)提供, 与操作系统有关 
2、又被称为低级IO(不带缓存的IO)!!! 
3、Linux系统下有的特殊类型文件只能用文件IO来操作，例如: 管道、设备文件等.. 
}

1、打开–open

int open(const char *pathname, int flags);
{
    不会创建新文件，单纯打开文件,因此该函数的使用 要求文件必须存在 
}
int open(const char *pathname, int flags, mode_t mode); 
{
    能够创建新文件，需要指定第三个参数mode.
    pathname: 文件路径名 
    flag: 文件相关标志位. 
        例如: 可以设置文件在程序中的读写权限. 
            O_RDONLY: 
    		O_WRONLY: 
    		O_RDWR: 
    		O_APPEDN: 以追加方式打开文件. 
            O_CREAT: 以创建方式打开 
            O_TRUNC: 清空文件 
            O_EXCL: 检测文件是否已经存在，通常与O_CREAT一起使用 
            O_NONBLOCK or O_NDELAY: 非阻塞方式 
            mode:只有flag引用O_CREAT时才用mode 
    		设置文件的属性权限，使用八进制表示. rw-rw-r--: 0664 
                返回值: -1: 表示错误 
                    	正确返回一个新的文件描述符，用于操作该文件. 
}

2、read()—读取

ssize_t read(int fd, void *buf, size_t count);
{
    fd: 文件描述符
    buf：文件读取储存地址
    count：读取数据大小
    返回值：-1错误 0到达末尾
        	正确返回读取数据大小
}

3、write()–写入

ssize_t write(int fd, const void *buf, size_t count);
{
    fd：文件描述符
    buf：输入数据地址
    count：输入数据大小
        返回值：-1错误
        正确返回写入数据大小
}

4、close()—关闭

int close(int fd);
{
	fd: 文件描述符
	返回值：0正确
			-1：错误
	值得一提的是fd等于0 1 2的时候时代表着关闭输入，输出，错误输出
    （主要用于守护进程时后台运行，减轻资源占用率）
}

5、lseek()—读写定位函数

off_t lseek(int fd, off_t offset, int whence);
{
    fd :文件描述符
    offset：偏移大小，正数向前移，负数向后移
    whence：偏移位置：SEEK_SET：文件开始位置
        			SEEK_CUR：文件当前读写到的位置
        			SEEK_END：文件结束位置
        返回值：-1错误
        		成功返回偏移后的位置
}

6、perror–错误输出函数

void perror(const char *s) 
{
    意义: 函数内部会自动检测错误类型并且输出 错误原因. 
}

7、stat()\fstat()\lstat()–文件属性函数

int stat(const char *path, struct stat *buf);
{
    该函数不能对链接文件进行处理. 
        struct stat 结构内部包含文件属性的描述 
        path: 文件路径 buf: 存放文件属性的首地址 
            返回值： -1 代表出错. 0 代表成功. 
}
int fstat(int fd, struct stat *buf); 
{ 
    第一个参数需要传递文件描述符 
}
int lstat(const char *path, struct stat *buf); 
{
    可以对链接文件进行处理.常常使用这个函数 
}

struct stat {
    
dev_t st_dev;/*包含文件的设备ID*/

ino_t st_ino;/*索引节点编号*/

mode_t st_mode;/*文件类型和模式*/

nlink_t st_nlink;/*硬链接数量*/
	printf(" %d",buf.st_nlink);
uid_t st_uid;/*用户ID */
    struct passwd * pw = getpwuid(buf.st_uid);
	printf(" %s",pw->pw_name)

gid_t st_gid;/*用户组ID */	 
	struct group * gr = getgrgid(buf.st_gid);
	printf(" %s",gr->gr_name);
dev_t st_rdev;/*设备ID(如果是特殊文件)*/

off_t st_size;/*总大小，以字节为单位*/
	printf(" %ld",buf.st_size);
blksize_t st_blksize;/*文件系统I/O的块大小*/

blkcnt_t st_blocks;/*分配512B的块数*/
    
struct timespec st_atim;/*上次访问时间*/
		struct tm *t;
		t = localtime(&buf.st_atime);
		printf(" %d-%d-%d %d:%d",t->tm_year+1900,
				t->tm_mon+1,
				t->tm_mday,
				t->tm_hour,
				t->tm_min);
		printf(" %s ",filename);
struct timespec st_mtim;/*上次修改时间*/
	同上
struct timespec st_ctim;/*上次状态改变时间*/
	同上
#define st_atime st_atim tv_sec /*向后兼容性*/

#define st_mtime st_mtim tv_sec

#define st_ctime st_ctim tv_sec

}；
    

st_mode–结构体

mode_t st_mode = {
##    
S_IFMT 0170000位掩码用于文件类型位字段
S_IFSOCK 0140000套接字
S_IFLNK 0120000符号链接
S_IFREG 0100000常规文件
S_IFBLK 0060000块设备
S_IFDIR 0040000目录
S_IFCHR 0020000字符设备
S_IFIFO 0010000管道文件
##		用法：
    switch(buf.st_mode & S_IFMT)
		{
		case S_IFREG:	
			printf("-");
			break;
		case S_IFDIR:	
			printf("d");
			break;
		case S_IFCHR:	
			printf("c");
			break;
		case S_IFBLK:	
			printf("b");
			break;
		case S_IFIFO:	
			printf("p");
			break;
		case S_IFLNK:	
			printf("l");
			break;
		case S_IFSOCK:	
			printf("s");
			break;
		}
##权限
	S_IRWXU 00700的所有者具有读、写和执行权限
S_IRUSR 00400所有者具有读权限
S_IWUSR 00200所有者具有写权限
S_IXUSR 00100所有者具有执行权限
	S_IRWXG 00070组具有读、写和执行权限组
S_IRGRP 00040具有读权限
S_IWGRP 00020组具有写权限
S_IXGRP 00010组具有执行权限
	S_IRWXO 00007其他人(不在组中)已经读、写和执行权限
S_IROTH 00004其他人具有读权限
S_IWOTH 00002其他用户有写权限
S_IXOTH 00001其他人有执行权限
## 用法
		/*判断文件权限*/
		int n;
		for(n=8;n>=0;n--)
		{
			if(buf.st_mode&(1<<n))
			{
				switch(n%3)
				{
				case 2:
					printf("r");
					break;
				case 1:
					printf("w");
					break;
				case 0:
					printf("x");
					break;
				default:
					break;

				}
			}
			else
			{
				printf("-");
			}
		}
    /*如果文件是符号链接文件，打印其源文件*/
		ssize_t readlink(const char *pathname, char *buf, size_t bufsiz);

    pathname：链接文件名路径
    buf：链接原文件内容存入首地址
    bufsize：存入数据大小
        返回值：失败 -1
        		成功返回存入内容数据大小
     
    ex：		if(S_ISLNK(buf.st_mode)) //判断是否为链接文件
		{
			printf(" -> ");
			if(readlink(filename,out,100)==-1)
			{

			}
			printf("%s",out);

		}
		printf("\n");
}

8、目录操作函数 --dir

DIR *opendir(const char *name); 
{
    意义: 打开指定的目录. 
    name: 目录名
    返回值: 正确返回目录流指针. 
    错误返回NULL 
}
struct dirent *readdir(DIR *dirp);
{ 
    意义: 依次读取目录中的文件信息.
        dirp：指针流
        返回值: NULL: 读取到目录流末尾 或 产生错误. 
            正确返回一个 概述当前目录文件的结构体.(struct dirent) 
            值得注意的是每读一次返回值就会往后移动一次直到读到null
}

struct dirent 结构体

struct dirent {

ino_t d_ino;/*索引节点编号*/

off_t d_off;/*非offset;见下文* /

unsigned short d_reclen;/*记录的长度*/

unsigned char d_type;/*文件类型;不支持所有文件系统类型*/

char d_name [256];/* 目录中文件的名字*/

}；