嵌入式Linux开发学习记录（3）

一，标准IO学习

文件类型：

1. 常规文件 r
2. 目录文件 d
3. 字符设备文件 c
4. 块设备文件 b
5. 管道文件 p
6. 套接字文件 s
7. 符号链接文件 l

 FILE：一个结构体类型来存放打开的文件的相关信息，又被称为流（stream）

流的缓冲类型；全缓冲，行缓冲，无缓冲

打开流：

FILE *fopen(const char *path, const char *mode);//文件路径，打开方式

文件权限规则：（0666&~umask）权限掩码按位取反进行与操作，默认022，设置成0对文件权限无影响。

关闭流：

int fclose(FILE *stream);//流

按行输入：遇到‘\n’或已输入size-1个字符时返回，总是包含‘\0’

#include <stdio.h>
char *gets(char *s);//存放输入内容的缓冲区首地址
char *fgets(char *s,int size,FILE *stream);// 缓冲区大小，流指针

按行输出：puts会追加‘\n’

#include <stdio.h>
int puts(const char *s);
int fputs(const char *s,FILE *stream);

统计一个文本文件包含多少行

#include <stdio.h>  
#include <stdlib.h>  
  
int main() {  
    FILE *file = fopen("file.txt", "r"); // 打开文件以读取  
    if (file == NULL) {  
        perror("打开文件失败");  
        return 1;  
    }  
  
    int line_count = 0;  
    char line[1024]; // 假设每行不超过1024个字符  
  
    // 使用fgets循环读取文件，直到遇到文件结束或错误  
    while (fgets(line, sizeof(line), file) != NULL) {  
        line_count++;  
    }  
  
    fclose(file); // 关闭文件  
  
    printf("文件有 %d 行\n", line_count);  
    return 0;  
}

按对象读写：

#include <stdio.h>
size_t fread(void *ptr,size_t size,size_t n,FILE *fp);//缓冲区首地址，读取对象大小，读取对象数量，流指针
size_t fwrite(const void *ptr,size_t size,size_t n,FILE *fp);

实现文件的复制：

#include <stdio.h>

#define N 64

int main(int argc, char *argv[])
{
    FILE *fps, *fpd;
    char buf[N];
    int n;

    if(argc<3)
    {
        printf("Usage : %s <src_file> <dst_file>\n",argv[0]);
        return -1;
    }

    if((fps = fopen(argv[1],"r")) == NULL)
    {
        perror("fopen src file");
        return -1;
    }
    if((fpd = fopen(argv[2],"w")) == NULL)
    {
        perror("fopen dst file");
        return -1;
    }
    while((n=fread(buf,1,N,fps))>0)
    {
        fwrite(buf,1,n,fpd);
    }
    fclose(fps);
    fclose(fpd);

    return 0;
}

刷新流：

int fflush(FILE *fp);

定位流：

#include <stdio.h>
long ftell(FILE *stream);//当前流的读写位置
long fseek(FILE *stream, long offset, int whence);//流指针，偏移量，基准点。设定一个流的读写位置
void rewind(FILE *stream);//定位到起始位置

格式化输出：

#include <stdio.h>
int printf(const char *fmt,...);//输出格式化后字符串
int fprintf(FILE *stream,const char *fmt,...);//流指针
int sprintf(char *s,const char *fmt,...);//缓冲区首地址

二，文件IO学习

 标准io遵循C标准，文件IO遵循posix标准，可移植操作系统接口规范。无缓冲，文件描述符表示打开文件，可以访问各种类型文件。

打开文件：

#include <fcntl.h>
int open(const char *path,int oflag,...);//文件路径，打开方式，新文件权限

关闭文件：

#include <unistd.h>
int close(int fd);//文件描述符

读取数据：

#include <unistd.h>
size_t read(int fd,void *buf,size_t count);//文件描述符，缓冲区首地址，读取字节数

写入数据：

#include <unistd.h>
size_t write(int fd,void *buf,size_t count);//文件描述符，缓冲区首地址，写入字节数

 定位文件：

#include <unistd.h>
off_t lseek(int fd, off_t offset,int whence);//文件描述符，偏移量，基准点

fseek成功返回0，失败返回-1。lseek成功返回当前文件读写位置，错误返回-1

利用文件IO实现文件复制

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>


#define N 64

int main(int argc,char *argv[])
{
    int fds,fdt,n;
    char buf[N];

    if(argc<3)
    {
        printf("Usage:%s<src_file><dst_file>\n",argv[0]);
        return -1;
    }

    if((fds=open(argv[1],O_RDONLY))==-1)
    {
        fprintf(stderr,"open %s:%s\n",argv[1],strerror(errno));
        return -1;
    }
    if((fdt=open(argv[2],O_WRONLY|O_CREAT|O_TRUNC,0666))==-1)
    {
        fprintf(stderr,"open %s:%s\n",argv[2],strerror(errno));
        return -1;
    }


    while((n=read(fds,buf,N))>0)
    {
        write(fdt,buf,n);
    }
    close(fds);
    close(fdt);

    return 0;


}

三，进程

 执行一个程序所分配的资源的总称，程序的一次执行过程。

进程控制块（pcb）：进程标识PID，进程用户，进程状态，优先级，文件描述符表

 创建进程：

#include <unistd.h>
pid_t fork(void);//父进程返回子进程进程号，子进程返回0

子进程从fork下条语句开始执行

结束进程：

#include <stdlib.h>
#include <unistd.h>

void exit(int status);//刷新缓冲区
void _exit(int status);//不刷新缓冲区

exec函数族

#include <unistd.h>

int execl(const char *path,const char *arg,...);//程序名称，可变参数
int execlp(const char *file,const char *arg,...);在path中找程序名称。最后以NULL结尾

int execv(const char *path, char* const argv[]);//指针数组
int execvp(const char *file,char* const argv[]);

#include <stdlib.h>

int system(const char *command);//命令

进程回收：

#include <unistd.h>

pid_t wait(int *status);//指定保存子进程返回值和结束方式的地址，为NULL表示直接释放子进程，不接收返回值

pid_t waitpid(pid_t pid,int *status,int option);//回收对象，回收方式

创建守护进程

1. 创建子进程，父进程退出
2. 子进程创建新会话，脱离原先终端 setsid
3. 更改当前工作目录chdir
4. 重设文件权限掩码
5. 关闭所有从父进程继承的打开的文件描述符getdtablesize

四，线程 

 共享相同地址空间的多个任务

创建线程：

#include <pthread.h>

int pthread_create(pthread_t *thread,const pthread_attr_t *attr,void*(*routine)(void*),void *arg);//线程对象，线程属性结构体指针，线程执行的函数指针，传递给routine的参数

线程回收：

#include <pthread.h>

int pthread_join(pthread_t thread,void **retval);//线程对象，接受线程返回值的地址

线程结束：

#include <pthread.h>

void pthread_exit(void *retval);

信号量

初始化int sem_init(sem_t *sem,int pshared,unsigned int value);信号量对象，0-线程间，1-进程间，信号量初值

P操作（申请）int sem_wait(sem_t *sem);

V操作（释放）int sem_post(sem_t *sem);

互斥锁mutex

锁初始化，申请锁，访问完临界资源后释放锁

五，进程间通信

1. 无名管道pipe
2. 有名管道fifo
3. 信号signal
4. 共享内存
5. 消息队列
6. 信号灯集
7. 套接字socke

 无名管道

只能用于有亲缘关系的进程之间的通信

单工的通信模式，具有固定的读端和写端