苏嵌实训——day13

标签：fp 文件苏嵌 return int 实训 day13 include buf

文章目录

零、概述
一、文件IO

1.1 学习IO的前提
1.2 IO是什么
1.3 如何使用IO
1.4 IO的分类
1.5 文件IO的接口
1.6 man手册的使用
1.7 errno
1.8 文件描述符
1.9 API接口的使用

1.9 1 open
1.9.2 perror
1.9.3 read
1.9.4 write
1.9.5 close
1.9.6 lseek
1.10 练习:自己去实现cp命令 mycp(保证可以去拷贝二进制文件)

二、标准IO

2.1 标准IO的定义

2.1.1 文件流指针

2.2 标准IO函数接口

2.2.1 fopen
2.2.2 fclose
2.2.3. fgetc
2.2.4 feof
2.2.5 ferror
2.2.7 fgets
2.2.8 fputs
练习：请编写一个代码，用来测试文件的行数
2.2.9 fread
2.2.10 fwrite

零、概述

文件IO 进程进程间通信，线程，线程同步，网络编程

一、文件IO

苏嵌实训——day13_#include

IO(input output)

1.1 学习IO的前提

为什么要学习IO
嵌入式：由软件控制硬件，嵌入式需要对内存进行操作，和对内核进行操作，来完成操作硬件。
IO的内容都有什么：主要学习已经提供好的API函数接口
linux下一切皆文件
linux是一个多用户多任务的操作系统 ----》进程
因为IO进程在应用层和内核层之交互，所以说学习时定义过于抽象
linux操作系统把文件分为两大类

（1）二进制文件 —》a.out —>按照计算机的逻辑去存储
（2）文本文件 —》.c或者.txt —>按照程序员的逻辑去存储

底层存储是一样，逻辑存储上不一样。

1.2 IO是什么

IO指的是Input output,指的是对内存的输入和输出

苏嵌实训——day13_#include_02

1.3 如何使用IO

需要借助概念：linux下一切皆文件
所以说对文件的操作:打开文件---------读写文件----------关闭文件

1.4 IO的分类

文件IO:是由操作系统提供的API接口，也被称为系统调用，每个操作系统的IO—API接口是不一样的，也就造成了linux下的可执行我呢见如果调用了文件IO的话，是不能移植到别的平台的，因为文件IO的接口是由操作系统提供，不同操作系统接口是不一样的。
标准IO：stdio.h ----->是由标准C库 ANSI C库提供的API接口，标准IO是在文件IO的基础上封装出来的。

1.5 文件IO的接口

1. open
2. read
3. write
4. close
5. lseek
    注意：windows函数接口：_open _read _write _close
          ios函数接口：  Open Read Write Close

1.6 man手册的使用

man：是一个在线函数查询接口

1   Executable programs or shell commands（ 可执行程序或者shell命令）
2   **System calls (functions provided by the kernel)（系统调用）（内核提供的函数）
3   **Library calls (functions within program libraries)（库调用）（程序库中的函数）
4   Special files (usually found in /dev) （特殊文件）（通常位于 /dev）  
5   File formats and conventions eg /etc/passwd （文件格式和规范）
6   Games （游戏）
7   Miscellaneous (including macro packages and conventions), e.g. man(7), groff(7) 杂项（包括宏包和规范）
8   System administration commands (usually only for root) （系统管理命令）（通常只用于管理用户）
9   Kernel routines [Non standard]（内核例程）【非标准】

1.7 errno

errno是一个全局变量，存在于#include <errno.h>中，用于标注错误信息，那么当函数报错返回时，会将这个全局变量重新根据错误信息表中的对用的号码设置一下

苏嵌实训——day13_linux_03

1.8 文件描述符

文件描述符是什么：一个文件的标志，是一个int类型的数据，非负数，值是小的。

苏嵌实训——day13_linux_04

注意：
./aout在刚运行时，内核会自动为他打开三个设备文件，返回三个文件描述：

标准输入 -----0
标准输出 -----1
标准错误输出 ----2

1.9 API接口的使用

附加：函数的三要素：功能，参数，返回值

1.9 1 open

1.头文件：
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


2.原型：
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
3.功能：打开一个文件
4.参数：
pathname:路径及名称
        例如："1.txt"    //以后参数是char*类型一般直接写字符串
flags:打开文件的方式
    必须包括：
        O_RDONLY：只读权限打开文件
        O_WRONLY：只写权限打开文件
        O_RDWR：读写方式打开文件
附加参数（以或的形式去附加）
        O_APPEND:以追加写的方式打开文件
        O_CREAT:如果文件存在则打开文件，如果文件不存在则创建文件，如果使用了O_CREAT这个参数，需要使用open的第三个参数，给与权限是一个8进制的整形，以0开头
        例如：0664
        O_EXCL:如果文件存在则报错返回
        O_NONBLOCK：以非阻塞方式打开一个文件
        O_TRUNC:以清空的方式打开文件
5.返回值：
    成功返回一个文件描述符
    失败返回-1；
注意：使用0666创建文件为什么出来的是0664呢？
    是由操作系统有一个叫做文件掩码的机制，将其它用户权限的可写权限抹掉
    使用umask查看文件掩码
    修改文件掩码 umask + 想要修改的权限值

苏嵌实训——day13_头文件_05

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
int main(int argc, char const *argv[])
{
    int fd = open("./1.txt",O_RDWR|O_CREAT,0666);   //打开一个文件
    if(-1 == fd)
    {
        perror("open");  //打印错误信息
        printf("errno = %d\n",errno);
        return -1;
    }
    perror("open1");
    return 0;
}

1.9.2 perror

头文件：
    #include <stdio.h>


原型：
    void perror(const char *s);
功能：以固定格式打印错误信息
参数：s:判断的函数名字
返回值：无

1.9.3 read

头文件：
#include <unistd.h>
原型：
    ssize_t read(int fd, void *buf, size_t count);
功能：对一个文件进行读取
参数：fd:目标文件描述符  ----》对哪个文件进行读取
      buf:存放读到的数据 ----》读到的数据存放的地址
      count:读多少
返回值：成功：返回读到的字节个数
        失败：返回-1
        读到文件末尾返回0
注意：但是最后依次read时如果文件剩余字节不够read的count，读到文件末尾时返回已经读到的字节个数，再一次读取时返回0

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>

int main(int argc, char const *argv[])
{
    //打开文件----》以读的方式打开
    int fd = open("./1.txt",O_RDONLY);
    if(-1 == fd)
    {
        perror("open");
        return -1;
    }
    //开始读取数据
    char buf[3] = {0};
    if(-1 == read(fd,buf,3))   //有多少空间读取多少个字节
    {
        perror("read");
        return -1;
    }
    printf("\n读取到的值为buf = %s\n",buf);
    //关闭文件描述符
    if(-1 == close(fd))
    {
        perror("close");
        return -1;
    }
    return 0;
}

1.9.4 write

头文件：
    #include <unistd.h>
原型：
    ssize_t write(int fd, const void *buf, size_t count);
功能：对一个文件进行写入操作
参数：fd:目标文件描述符 ----》对哪个文件进行操作
      buf:要写入的数据的地址----》要写入什么东西
      count:写入数据的大小  ---》写多少，以字节为单
返回值：
    成功：返回写入的字节个数
    失败： -1

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    int fd = open("./1.txt",O_WRONLY);
    if(-1 == fd)
    {
        perror("open");
        return -1;
    }
    //开始写入数据
    char buf[123] = "hello world";
    if(-1 == write(fd,buf,strlen(buf)))
    {
        perror("write");
        return -1;
    }
    return 0;
}

1.9.5 close

头文件：
    #include <unistd.h>

原型：
    int close(int fd);
功能：关闭一个文件
参数：fd要关闭的文件描述符
返回值：
    成功：返回 0
    失败： -1
注意：一个可执行程序最多打开1024个文件描述符，这个值可以通过内核去修改。

练习:先对一个文件进行写入helloworld，然后在从这个文件将helloworld读出来，打印到终端上。
结果：写入数据时正常，读取时未读到数据，这是因为读写指针的相互影响

1.9.6 lseek

头文件：
       #include <sys/types.h>
       #include <unistd.h>

原型：
     off_t lseek(int fd, off_t offset, int whence);
功能:操作读写指针，对读写指针进行偏移
参数：
    fd：目标文件描述符  ---》对哪个文件进行操作
    offset:如何偏移，偏移多少
        如果该数为负数，代表这向前进行偏移，如果偏移出了文件的开头，会报错返回
        如果该数为正数，代表这向后偏移，如果偏移除了文件的末尾，会扩大文件，用'\0'来填充，那么此类文件被称为---空洞文件---
    注意：如果偏移后没有对其进行任何写入操作内核认为该偏移无效，不会扩大文件大小。
    whence：基准位置  ----》根据哪一个位置进行偏移
       SEEK_SET :根据文件开头进行偏移
              The file offset is set to offset bytes.

       SEEK_CUR：根据用户当前位置进行偏移
              The file offset is set to its current location plus offset bytes.

       SEEK_END：根据文件末尾进行偏移
              The file offset is set to the size of the file plus offset bytes.
返回值：
    成功：返回偏移的字节个数（根据文件开头来定）
    失败： -1

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>

int main(int argc, char const *argv[])
{
    int fd = open(argv[1],O_RDWR|O_CREAT,0666);
    if(-1 == fd)
    {
        perror("open");
        return -1;
    }
    //开始进行写入数据
    if(-1 == write(fd,"hello world",11))
    {
        perror("write");
        return -1;
    }
    if(-1 == lseek(fd,-11,SEEK_END))
    {
        perror("lseek");
        return -1;
    }
    char buf[123] = {0};
    if(-1 == read(fd,buf,sizeof(buf)))
    {
        perror("read");
        return -1;
    }
    printf("buf = %s\n",buf);
    close(fd);
    return 0;
}

1.10 练习:自己去实现cp命令 mycp(保证可以去拷贝二进制文件)

//读取时循环读取，写入时循环写入，使用argv参数
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#define SIZE 123
int main(int argc, char const *argv[])
{
    if(3 != argc)
    {
        printf("输入参数错误，例如：./a.out + 源文件 + 目标文件\n");
        return -1;
    }
    //打开要复制的文件以只读方式打开，打开要粘贴的文件，以写入并创建并且清空
    int fd = open(argv[1],O_RDONLY);
    if(-1 == fd)
    {
        perror("open");
        return -1;
    }
    int fd1 = open(argv[2],O_WRONLY|O_CREAT|O_TRUNC,0664);
    if(-1 == fd1)
    {
        perror("open1");
        return -1;
    }
    //开始读取  ---》边读边写
    while(1)
    {
        //先读
        char buf[SIZE] = {0};//作为数据的中转站
        ssize_t ret = read(fd,buf,sizeof(buf));
        if(-1 == ret)
        {
            perror("read");
            return -1;
        }
        if(0 == ret)
        {
            printf("读取到文件的末尾，退出while循环\n");
            break;
        }
        //写入
        if(-1 == write(fd1,buf,ret))
        {
            perror("write");
            return -1;
        }
    }
    close(fd);
    close(fd1);
    return 0;
}

二、标准IO

2.1 标准IO的定义

标准IO是由标准C库提供的API接口，是在文件IO的基础上封装出来的函数接口，第一个原因是为了增加可移植性。并且，标准IO在文件IO的基础上封装了一个叫缓冲区的东西，用来存放一些不是很着急的数据，等到缓冲区满，调用一次文件IO完成写入工作或者读取工作。有些数据是特别着急的，

比如：下发的命令，实时监控数据，必须要使用文件IO。
伪代码：
    fopen(参数)
    ｛
        if(is win)
        {
            _open(参数)；            
        }
        else if(is linux)
        {
            open(参数)；
        }
    ｝

2.1.1 文件流指针

FILE pointer
文件流指针:是一个文件的标志，是在文件描述符上封装出来的一个结构体指针，缓冲区就在这个流指针中。
流：流指针 -----文件流指针 —这个流
追代码：
安装一个索引搜索文件tags(搜索引擎)

第一步：创建目录的引擎文件—tags (想要搜索哪个目录就在哪个目录下创建)
ctags -R //生成一个引擎文件叫tags
第二步：搜索
vi -t 目标字符串例如: vi -t FILE
第三步：选择准确的目录下的文件
第四步：翻阅文档----》代码跳转
追代码：光标点击想要跳转的字符串，ctrl + ]进行跳转搜索
返回上一层：ctrl + t

苏嵌实训——day13_头文件_06

2.2 标准IO函数接口

2.2.1 fopen

头文件: #include <stdio.h>
原型：FILE *fopen(const char *pathname, const char *mode);
功能:打开一个文件
参数：pathname:要打开文件的路径及名称
mode:打开文件的方式
r:以只读的方式打开一个文件，文件必须存在
r+:以读写的方式打开一个文件，文件必须存在
w：如果文件存在则清空写入，如果文件不存在则创建写入
w+:如果文件存在则清空读写，如果文件不存在则创建读写
a:如果文件存在则追加写入，如果文件不存在则创建再写入
a+:如果文件不存在则创建文件并追加写入和读取，读取时从文件开头开始读取，写入时从文件的末尾开始写入，lseek偏移后不能进行写入操作
如果进行写入操作，则追加在末尾写入（不管之前如何偏移）
注意：有可能以后会遇到 rb+,b代表执行二进制操作，linux下无区分
返回值：
成功会返回一个文件流指针
失败返回NULL。

苏嵌实训——day13_文件IO_07

#include <stdio.h>
int main(int argc, char const *argv[])
{
    //打开一个文件需要定义一个文件流指针来指向fopen返回的已经封装好的文件流指针
    //FILE *fp = fopen("./1.txt","r");
    FILE *fp = fopen("./1.txt","w");
    if(NULL == fp)
    {
        perror("open");
        return -1;
    }
    printf("打开文件成功！\n");
    return 0;
}

2.2.2 fclose

头文件：
#include <stdio.h>
原型：
int fclose(FILE *stream);
功能：关闭一个文件流指针 //文件流指针里也绑定了一个文件的描述符
参数：目标文件流指针
返回值：
成功：返回 0
失败： -1

2.2.3. fgetc

头文件：
#include <stdio.h>
原型：
int fgetc(FILE *stream);
功能：从指定文件流指针中获取一个字符
参数：目标文件流指针
返回值：
成功：返回获取到的字符转化成int类型的数据
失败：返回EOF
到达文件末尾： EOF

2.2.4 feof

头文件：
#include <stdio.h>
原型：
int feof(FILE *stream);
功能：判断是否到达了文件末尾
参数：目标文件流指针
返回值：如果到达了文件的末尾返回一个非0值
其它情况返回0

2.2.5 ferror

头文件：
#include <stdio.h>
原型：
int ferror(FILE *stream);
功能：判断文件操作是否出错
参数：目标文件流指针
返回值：如果文件操作失败了，返回一个非0值
其它情况返回0

#include <stdio.h>
int main(int argc, char const *argv[])
{
    FILE *fp = fopen("./1.txt","r");
    if(NULL == fp)
    {
        perror("fopen");
        return -1;
    }
    //开始做循环读取
    while(1)
    {
        int ret = fgetc(fp);
        if(EOF == ret)
        {
            if(feof(fp))
            {
                printf("到达了文件末尾！\n");
                break;
            }
            else
            {
                printf("获取失败！\n");
                return -1;
            }
        }
        printf("获取到的数据为%d---所对应的字符为%c\n",ret,ret);
    }
    if(fclose(fp) == EOF)
    {
        printf("关闭失败\n");
        return -1;
    }
    return 0;
}

2.2.6 fputc

头文件：
#include <stdio.h>
原型：
int fputc(int c, FILE *stream);
功能：向指定的一个文件输出一个字符
参数：c:想要写入的字符，将int转换成 unsigned char类型的数据写入
stream:目标文件流指针
返回值：
成功返回：写入的字符转换成int类型的数据
失败返回：EOF

#include <stdio.h>
#include <string.h>
int main(int argc, char const *argv[])
{
    FILE *fp = fopen("./1.txt","w");
    if(NULL == fp)
    {
        perror("fopen");
        return -1;
    }
    //开始向文件中写入数据
    char buf[123] = "hello world";
    int i = 0;
    while(1)
    {
        fputc(buf[i],fp);
        if((strlen(buf) - 1) == i)
        {
            break;
        }
        i++;  //遍历数组使用
    }
    fclose(fp);
    return 0;
}

2.2.7 fgets

头文件：
#include <stdio.h>
原型：
char *fgets(char *s, int size, FILE *stream);
功能:行读取
参数：s:读取到的数据存放的地址
size:读取的字节个数
1.当\n之前的字节个数小于size,遇到\n结束读取
但是换行符也会被当做一个字符被读到内存之中，并且会在最后一个字符后添加’\0’.
2.当\n之前的字节个数大于size,会读到size个大小的字节时停止读取，
会在末尾加上一个’\0’，会将最后一个字节的字符给覆盖掉。
机制会在读取完之后读写指针向前偏移一个字节
stream:目标文件流指针
返回值：
成功返回：读到的字符串的首地址
失败返回：NULL
读到文件末尾：返回NULL

#include <stdio.h>
int main(int argc, char const *argv[])
{
    FILE *fp = fopen("./1.txt","r");
    if(NULL == fp)
    {
        perror("fopen");
        return -1;
    }
    //行读取
    while(1)
    {
        char buf[123] = {0};
        if(fgets(buf,11,fp) == NULL)
        {
            //失败或者读到文件末尾
            if(feof(fp))
            {
                printf("读到了文件的末尾\n");
                break;
            }
            else
            {
                perror("fgets");
                return -1;
            }
           
        }
        printf("buf = %s\n",buf);
    }
    fclose(fp);
    return 0;
}

2.2.8 fputs

头文件：
#include <stdio.h>
原型：
int fputs(const char *s, FILE *stream);
功能：向一个文件进行字符串输入
参数：s:想要写入的数据的地址
stream:目标文件流指针
返回值：
成功返回：一个非负数
失败返回：EOF(-1)

#include <stdio.h>

int main(int argc, char const *argv[])
{
    FILE *fp = fopen("./1.txt","w");
    if(NULL == fp)
    {
        perror("fopen");
        return -1;
    }
    //想要写入的数据的地址
    char buf[123] = "hello world";
    if(EOF == fputs(buf,fp))
    {
        perror("fputs");
        return -1;
    }
    fclose(fp);
    return 0;
}

练习：请编写一个代码，用来测试文件的行数

#include <stdio.h>
#include <string.h>


int main(int argc, char const *argv[])
{
    FILE *fp = fopen(argv[1],"r");
    if(NULL == fp)
    {
        perror("fopen");
        return -1;
    }
    int count = 0;
    //开始计算
    while(1)
    {
        char buf[123] = {0};
        if(NULL == fgets(buf,sizeof(buf),fp))
        {
            //出错或者到了文件末尾
            if(feof(fp))
            {
                printf("到达了文件的末尾\n");
                break;
            }
            else
            {
                perror("fgets");
                return -1;
            }
        }
        if(buf[strlen(buf) - 1] == '\n')
        {
            printf("buf = %s\n",buf);
            count++;
        }
        
    }
    count++;
    printf("该文件的行数为:%d\n",count);
    fclose(fp);
    return 0;
}

2.2.9 fread

头文件：
#include <stdio.h>
原型：
size_t fread(void *ptr, size_t size, size_t nmemb, FILE stream);
功能：二进制读取文件
参数：ptr:存放读到的数据的地址
size:对象的大小
nmemb：对象的个数
注意：总的读取的字节个数为对象的大小对象的个数
stream:目标文件流指针
返回值：
成功返回：成功返回读到的对象的个数
失败返回：0

2.2.10 fwrite

头文件：
#include <stdio.h>
原型：
size_t fwrite(const void *ptr, size_t size, size_t nmemb,
FILE *stream);
功能：二进制写入文件
参数：ptr:想要写入的数据的首地址
size:对象的大小
nmemb：对象的个数
stream:目标文件流指针
返回值：
成功返回：成功返回读到的对象的大小
失败返回：返回一个小的对象的个数

#include <stdio.h>
#include <string.h>
struct person
{
    char name[32];
    char sex;
    int age;
    char phone[12];
};
struct person p1;  //定义一个录入使用的结构体
struct person p2;  //定义一个读取时使用的结构体

int main(int argc, char const *argv[])
{
STAT:
    //界面：
    printf("****************************\n");
    printf("1.录入信息 2 读取信息  3.退出\n");
    printf("****************************\n");
    printf("input>> ");
    int input = 0;
    scanf("%d",&input);
    if (input > 3 || input < 0)
    {
        goto STAT;
    }
    if(1 == input)
    {
        printf("请输入姓名\n");
        scanf("%s",p1.name);
        getchar();
        printf("请输入性别\n");
        scanf("%c",&p1.sex);
        getchar();
        printf("请输入年龄\n");
        scanf("%d",&p1.age);
        printf("请输入手机号\n");
        scanf("%s",p1.phone);
        getchar();
        FILE *fp = fopen("./1.txt","a");
        if(NULL == fp)
        {
            perror("fopen");
            return -1;
        }
        if(1 != fwrite(&p1,sizeof(p1),1,fp))
        {
            perror("fwrite");
            return -1;
        }
        fclose(fp);
        printf("写入信息结束，正在跳转菜单");
        goto STAT;
    }
    else if(2 == input)
    {
        char usrname[32] = {0};
        //读取信息
        printf("请输入要查询人的姓名\n");
        scanf("%s",usrname);
        getchar();
        //开始对文件进行读取并匹配
        FILE *fp = fopen("./1.txt","r");
        if(NULL == fp)
        {
            perror("fopen");
            return -1;
        }
        //循环读取
        while(1)
        {
            if(0 == fread(&p2,sizeof(p2),1,fp))
            {
                if(feof(fp))
                {
                    printf("读到文件末尾\n");
                    break;
                }
                else
                {
                    perror("fread");
                    return -1;
                }
            }
            if(strcmp(usrname,p2.name) == 0)
            {
                printf("姓名：%s\n",p2.name);
                printf("性别：%c\n",p2.sex);
                printf("年龄：%d\n",p2.age);
                printf("手机号：%s\n",p2.phone);
            }
        }


    }
    
    return 0;
}

标签：fp,文件,苏嵌,return,int,实训,day13,include,buf
From： https://blog.51cto.com/u_15909950/5930324