IO操作所用到的基础函数操作

标准IO：

#include <stdio.h>
#include <errno.h>

FILE * fopen(const char *pathname, const char *mode);//打开一个对应字符串表示文件名字的文件

int fscanf(FILE *stream, const char *format, ...);//从文件输入 到程序（读文件）
int fprintf(FILE *stream, const char *format, ...);//从程序输出 到文件（写文件）
int fgetc(FILE *stream);//从文件中读取一个字符，输入到程序中
int fputc(int c, FILE *stream);//往文件中写入一个字符，从程序输出内容
char * fgets(char *s, int size, FILE *stream);//一次从文件中读取多个字符
int fputs(const char *s, FILE *stream);//往文件中写入多个字符，输出多个字符到文件中
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);//读取指定大小的文件内容，输入到程序中;
size_t fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream);//写入指定大小的程序内容到文件中，从程序输出数据到文件；

int fclose(FILE *stream);//关闭指定的文件
void perror(const char *s);//打印当前的错误码
int feof(FILE *stream); //测试是否到文件末尾
int ferror(FILE *stream); //测试是否出错

long ftell(FILE *stream);    //读取当前文件读写偏移量
int feof(FILE *stream);    /检测文件读写到末尾标志位end-of-file
void clearerr(FILE *stream);    //清除end-of-dile标志位和错误标志

int printf(const char *format, ...);
int fprintf(FILE *stream, const char *format, ...);
int dprintf(int fd, const char *format, ...);
int sprintf(char *buf, const char *format, ...);
int snprintf(char *buf, size_t size, const char *format, ...);

文件IO

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

int open(const char *pathname, int flags, mode_t mode);    //打开文件

ssize_t read(int fd, void *buf, size_t count);  //从文件中读取指定大小字节的数据
ssize_t write(int fd, const void *buf, size_t count);//把程序内存空间地址的数据写入到文件

int close(int fd);//关闭打开的文件

off_t lseek(int fd, off_t offset, int whence);//文件读写位置偏移（修改文件当前操作位置）

int dup(int oldfd);            //复制文件描述符，系统分配
int dup2(int oldfd, int newfd);//复制文件描述符，自己设定

char *strerror(int errnum);    //错误处理显示
void perror(const char *s);    //错误处理显示

void _exit(int status);    //退出
void exit(int status);
void _Exit(int status);

int fcntl(int fd, int cmd, ... /* arg */ )
int ioctl(int fd, unsigned long request, ...);

int truncate(const char *path, off_t length);    截断文件，需要地址
int ftruncate(int fd, off_t length);             截断文件，需要fd

文件流与文件描述符互换

int fileno(FILE *stream);
FILE *fdopen(int fd, const char *mode);

文件属性操作

#include <sys/types.h> 
#include <sys/stat.h> 
#include <unistd.h>

int stat(const char *pathname, struct stat *statbuf);//获取一个文件的属性内容

int fstat(int fd, struct stat *statbuf);//获取已经打开的文件的文件属性

int lstat(const char *pathname, struct stat *statbuf);//如果获取的文件为符号 链接文件，则获取符号链接文件的属性

struct passwd *getpwuid(uid_t uid);//根据用户id，得到用户信息，返回值就是用户信息结构体的地址，通过地址访问用户信息
struct group *getgrgid(gid_t gid);//根据用户组id，得到用户组信息，返回值就是用户组信息结构体的地址，通过地址可以访问到用户组信息

目录操作

#include <sys/types.h> 
#include <dirent.h>

DIR * opendir(const char *name);//打开目录
DIR *fdopendir(int fd);

struct dirent *readdir(DIR *dirp);//读取目录中的文件（普通、目录、...）,一次只读取一个文件，内容就是一个文件的基本信息

int closedir(DIR *dirp);//关闭目录

进程操作

#include <sys/types.h> 
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>

pid_t fork(void); //创建一个子进程

pid_t getpid(void);//返回当前执行进程的pid
pid_t getppid(void);//返回当前执行进程的父进程的pid

void exit(int status);结束当前进程，把所有文件的缓冲区刷新
void _exit(int status);//结束当前进程，_exit结束就是直接结束

pid_t wait(int *wstatus);//等待任意的子进程结束，哪个子进程结束就回收谁
pid_t waitpid(pid_t pid, int *wstatus, int options);

创建守护进程函数
pid_t setsid(void);//设置当前进程为会话组组长

int chdir(const char *path);//修改子进程工作路径

mode_t umask(mode_t mask);//在子进程中修改文件权限

int getdtablesize(void);//关闭父进程打开的文件描述符(如：标准输入、标准输出、标准错误)

exec函数族

#include <unistd.h>把当前进程执行的代码，替换成其他程序代码

int execl(const char *pathname, const char *arg, ... /* (char *) NULL */);

int execlp(const char *file, const char *arg, ... /* (char *) NULL */);

int execle(const char *pathname, const char *arg, ... /*, (char *) NULL, char *const envp[] */);

int execv(const char *pathname, char *const argv[]);

int execvp(const char *file, char *const argv[]);

int execvpe(const char *file, char *const argv[], char *const envp[]);

进程间通信

共享内存
#include <sys/ipc.h> 
#include <sys/shm.h>
#include <sys/types.h>

int shmget(key_t key, size_t size, int shmflg);//创建 、 打开一个共享内存
void * shmat(int shmid, const void *shmaddr, int shmflg);//映射共享内存到进程中
int shmdt(const void *shmaddr);//撤销共享内存的映射
int shmctl(int shmid, int cmd, struct shmid_ds *buf);//共享内存控制
key_t ftok(const char *pathname, int proj_id);//计算key值

消息队列
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/msg.h>

int msgget(key_t key, int msgflg);//创建打开消息队列
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);//往消息队列中发送消息
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,int msgflg);//从哪个消息队列获取消息
int msgctl(int msqid, int cmd, struct msqid_ds *buf);//控制消息队列

信号灯
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/sem.h>

int semget(key_t key, int nsems, int semflg);//创建 打开信号灯集
int semop(int semid, struct sembuf *sops, size_t nsops);//操作信号量，+、-
int semctl(int semid, int semnum, int cmd, ...);//控制信号灯集

管道
1、无名管道
#include <unistd.h>

int pipe(int pipefd[2]);//无名管道打开时，完成两次打开，一次以读打开，一次以写打开，得到两个文件描述符

2、有名管道
#include <sys/types.h> 
#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);//创建有名管道文件

信号
#include <sys/types.h> 
#include <signal.h>

int kill(pid_t pid, int sig);发送信号
int raise(int sig);======》kill(getpid(), sig);//往当前进程发送信号

unsigned int alarm(unsigned int seconds);//等待一段时间后，往当前进程发送SIGALRM信号
int pause(void);//阻塞休眠等待当前进程接收信号，函数才结束

线程

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void * (*start_routine) (void *), void *arg);//在进程中创建线程，在当前进程中，启动一个新线程，新执行的任务

int pthread_join(pthread_t thread, void **retval);//等待线程的结束，回收线程资源

void pthread_exit(void *retval);//结束当前线程

线程的同步与互斥

同步
#include <semaphore.h>

int sem_init(sem_t * sem, int pshared , unsigned int value);：//要初始化的信号量，要设置哪个信号量值

int sem_wait(sem_t * sem);//p操作，申请资源 - ，阻塞等待 - 1，如果大于0 能够-1成功，结束函数，如果 == 0 不能够 - 1 成功就阻塞等待能够-1为止

int sem_post(sem_t * sem);//v操作，释放资源， + ，当前线程完成了某个操作，进行+1 ，让其他线程可以继续执行

互斥
#include <pthread.h>

int pthread_mutex_init(pthread_mutex_t * mutex,const pthread_mutexattr_t * attr);//互斥锁的初始化
int pthread_mutex_lock(pthread_mutex_t *mutex); //加锁 
int pthread_mutex_unlock(pthread_mutex_t *mutex); //解锁