IO函数汇总

FILE结构体

245 struct _IO_FILE {
257 char* _IO_buf_base; /* 缓冲区开始地址 /
258 char _IO_buf_end; /* 缓冲区结束地址 */
267 268 int _fileno; //用于系统调用的文件描述符
286 };

fopen 打开文件

#include <stdio.h> FILE *fopen(const char *pathname, const char *mode);
功能：以指定的方式打开一个给定的文件，并返回该文件的文件地址
参数1：要打开的文件文件路径，可以是相对路径，也可以是绝对路径
参数2：文件打开的方式，需要以以下字符开头的字符串
r 以只读的形式打开文件，文件光标定位在开头.如果文件不存在，则报错
r+ 以读写的形式打开文件，文件光标定位在开头.如果文件不存在，则报错
w 以只写的形式打开文件，如果文件存在，则清空文件内容，如果文件不存在，则创建该文件，文件光标定位在开头.
w+ 以读写的形式打开文件，如果文件存在，则清空文件内容，如果文件不存在，则创建该文件，文件光标定位在开头.
a 以追加的形式打开文件，如果文件不存在则创建文件，文件光标定位在结尾
a+ 以读或者追加的形式打开文件，如果文件不存在，则创建文件，如果第一次是读数据，则光标定位在开头，否则定位在结尾
返回值：成功调用返回打开的文件地址，失败返回NULL，并置位错误码

fclose：关闭文件

#include <stdio.h>
int fclose(FILE *stream);
功能：关闭给定的文件指针
参数1：要关闭的文件指针
返回值：成功返回0，失败返回EOF，并置位错误码

fgetc\fputc:单字符的输入输出

#include <stdio.h>
int fputc(int c, FILE *stream);
功能：将给定的字符，写入到文件指针stream指向的文件中去
参数1：要写入的字符
参数2：打开的文件指针
返回值：成功返回写入字符的ａｓｃｉｉ值，失败返回EOF，并置位错误码
#include <stdio.h>
int fgetc(FILE *stream);
功能：从指定文件中，读取一个字符
参数：打开的文件指针
返回值：从文件中读取的第一个字符的ascii值，失败返回EOF并置位错误码

fputs\fgets:字符串输入输出

#include <stdio.h>
int fputs(const char *s, FILE *stream);
功能：将给定的字符串，写入到文件中
参数1：要写入的字符串起始地址
参数2：打开的文件指针
返回值：成功返回写入的字符个数（字符串长度），失败返回EOF
#include <stdio.h>
char *fgets(char *s, int size, FILE *stream);
功能：从stream所指向的文件中，最多读取size-1的字符到s中，在读取过程中，如果遇到回车或者文件结束，会结束本次读取，并且会把回车也放入容器中。在后面自动加上’\0’
参数1：存放数据的容器，一般是一个字符数组
参数2：读取的大小
参数3：文件指针
返回值：成功返回容器的起始地址，失败返回NULL

标准IO函数也可以使用stdin、stdout、stderr

#include<myhead.h>
int main(int argc, const char *argv[])
{
char buf[20] = “”;
printf(“请输入一个字符串：”);
fgets(buf, sizeof(buf), stdin); //从终端读取数据到buf中
buf[strlen(buf)-1] = ‘\0’; //将回车换成 ‘\0’
printf(“buf = %s”, buf);
fputs(“我是一个错误”, stderr); //向标准出错中写入数据
return 0;
}

有关系统时间的函数

#include <time.h>
time_t time(time_t *tloc);
功能：获取系统时间，从1970年1月1日0时0分0秒，到目前累计的秒数
参数：用于接收的秒数
返回值：秒数
使用方式：
1、time_t sys_time = time(NULL);
2、time_t sys_time = 0；
time(&sys_time);
struct tm *localtime(const time_t timep);
功能：将time_t 秒数，转换为时间类型的结构体
参数：time_t 类型的时间秒数
返回值：时间结构体
struct tm {
int tm_sec; / 秒数 /
int tm_min; / 分钟 (0-59) /
int tm_hour; / 小时 (0-23) /
int tm_mday; / 月中天数 (1-31) /
int tm_mon; / 月份+1 (0-11) /
int tm_year; / 年 + 1900 /
int tm_wday; / 周中天数 (0-6, Sunday = 0) /
int tm_yday; / 年中天数 (0-365, 1 Jan = 0) /
int tm_isdst; / Daylight saving time */
};
实例
sprintf( buf,“%4d-%2d-%2d %2d:%2d:%2d\n”,
time_ptr->tm_year+1900,
time_ptr->tm_mon+1,
time_ptr->tm_mday,
time_ptr->tm_hour,
time_ptr->tm_min,
time_ptr->tm_sec);

sprintf\snprintf:将格式串转换为字符串

int sprintf(char *str, const char *format, …);
功能：将格式串转换为字符串放入字符数组中
参数1：存放格式串的字符数组
参数2：格式串，可以包含格式控制符
参数3：可变参数，根据参数2中的格式控制符个数确定
返回值：成功返回转换的字符个数，失败返回-1
int snprintf(char *str, size_t size, const char *format, …);
该函数比sprintf更加安全，因为多了一个size的限制

fread\fwrite:模块化读写

#include <stdio.h>
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);
功能：对文件进行模块化读写操作
参数1：要写入（存放数据）数据的起始地址
参数2：每一项的大小
参数3：总的项数
参数4：文件指针
返回值：成返回读取的项数值，失败返回小于项数的值
注意：fread并不能区分是文件结束了，还是因为出现错误了，需要使用feof或ferror来区分

关于文件光标的函数

#include <stdio.h>
int fseek(FILE *stream, long offset, int whence);
功能：对文件光标进行偏移
参数1：文件指针
参数2：偏移量
0:表示向后偏移
=0:表示不偏移
<0:表示向前偏移
参数3：偏移位置
SEEK_SET:文件开头
SEEK_END:文件结束
SEEK_CUR:当前位置
返回值：成功返回0，失败返回-1并置位错误码
long ftell(FILE *stream);
功能：返回文件当前位置（就是当前位置相对于文件起始位置的偏移字节数）
参数：文件指针
返回值：偏移字节数
常用：fseek(fp, 0, SEEK_END);
ftell(fp); //文件大小
void rewind(FILE *stream);
功能：将光标定位到开头 类似于 fseek(fp, 0, SEEK_SET)
参数：文件指针
返回值：无

open打开文件

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
功能：以指定的方式打开指定的文件
参数1：要打开的文件路径
参数2：文件打开标识
必须包含以下三者之一：
O_RDONLY:以只读的形式打开文件
O_WRONLY:以只写的形式打开文件
O_RDWR:以读写的形式打开文件
以下的可以选择性加入，使用位或完成：
O_CREAT：如果文件存在，就直接打开，如果文件不存在，则创建文件，此时，参数3必须要加，表示创建的文件权限
O_TRUNC：表示清空文件内容
O_APPEND:以追加的形式打开文件
O_EXCL:确保打开的是不存在的文件，通常跟O_CREAT一起使用，表示本次操作必须创建新文件，如果文件存在，则open函数报错，错误码为：EEXIST
——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
“r”: O_RDONLY
“r+”: O_RDWR
“w”: O_WRONLY|O_CREAT|O_TRUNC
“w+”: O_RDWR|O_CREAT|O_TRUNC
“a”: O_WRONLY|O_APPEND|O_CREAT
“a+”: O_RDWR|O_APPEND|O_CREAT
——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
参数3：当参数2中有O_CREAT属性时，参数3必须加上，表示本次创建文件的文件权限，但是，最终的权限不是用户给定的权限
文件最终的权限是 给定的权限mode&~umask的值
umask可以通过指令umask进行查看当前终端的默认掩码
可以通过 umask -n 来将掩码更改成 n，但是，这种方式更改的umask只在当前终端有效，其他终端无效
也可以通过umask（n）来更改umask的值
#include <sys/stat.h>
mode_t umask(mode_t cmask);
功能：更改当前的umask的值
参数：要更改的umask的值
普通文件权限一般为：0664
目录文件权限一般为：0775
——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
返回值：成功返回一个新的文件描述符，失败返回-1并置位错误码

close关闭文件

#include <unistd.h>
int close(int fd);
功能：关闭文件描述符
参数：要关闭的文件描述符
返回值：成功返回0，失败返回-1并置位错误码

read\write 数据读写

#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);
功能：向指定的文件中，写入指定的信息
参数1：已打开的文件描述符
参数2：要写入的数据的起始地址
参数3：要写入的数据大小
返回值：成功返回写入字符的个数，失败返回-1并置位错误码
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);
功能：从指定的文件中读取count个字节的数据到buf中
参数1：打开的文件描述符
参数2：要存放数据的容器起始地址
参数3：要读取的字节个数
返回值：成功返回读取字节的个数，失败返回-1并置位错误码

lseek 光标偏移

#include <sys/types.h>
#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence);
功能：移动文件的光标
参数1：文件描述符
参数2：偏移量
0:向后偏移
=0:不偏移
<0:向前偏移
参数3：偏移起始位置
SEEK_SET:文件开头
SEEK_END:文件结尾
SEEK_CUR:文件当前位置
返回值：成功返回文件光标当前的位置，失败返回-1并置位错误码

opendir:打开文件夹

#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *name);
功能：打开指定的文件夹
参数：要打开的文件夹路径
返回值：成功返回文件夹指针，失败返回NULL，并置位错误码

closedir：关闭文件夹

#include <sys/types.h>
#include <dirent.h>
int closedir(DIR *dirp);
功能：关闭指定的文件夹
参数：之前打开的文件夹指针
返回值：成功返回0，失败返回-1并置位错误码

readdir：读取文件信息

#include <dirent.h>
struct dirent readdir(DIR dirp);
功能：读取打开的文件夹中的记录信息
参数：文件夹指针
返回值：成功返回当前文件夹指针对应的目录信息，失败返回NULL并置位错误码
struct dirent {
ino_t d_ino; / Inode 号 /
off_t d_off; / 文件夹指针的偏移量/
unsigned short d_reclen; /* 当前结构体的长度 /
unsigned char d_type; / 文件的类型，不支持所有的文件类型 /
char d_name[256]; / 文件名称 */
};
关于文件类型：
DT_BLK This is a block device.
DT_CHR This is a character device.
DT_DIR This is a directory.
DT_FIFO This is a named pipe (FIFO).
DT_LNK This is a symbolic link.
DT_REG This is a regular file.
DT_SOCK This is a UNIX domain socket.
DT_UNKNOWN The file type could not be determined.

fork进程的创建函数

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);
功能：拷贝父进程得到子进程
参数：无
返回值：成功时，父进程中返回子进程的pid号，子进程中返回0，失败返回-1并置位错误码

进程号的获取

#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);
功能：获取当前进程的进程号
参数：无
返回值：当前进程的pid
pid_t getppid(void);
功能：获取当前进程的父进程的pid号
参数：无
返回值：当前进程父进程的pid

进程的退出（exit、_exit）

#include <stdlib.h>
void exit(int status);
功能：退出当前进程，并刷新当前进程打开的标准IO文件指针的缓冲区
参数：退出时的状态
EXIT_SUCCESS：成功退出
EXIT_FAILURE：失败退出
返回值：无
#include <unistd.h>
void _exit(int status);
功能：退出当前进程，但是不刷新标准IO的缓冲区
参数：退出时的状态
EXIT_SUCCESS：成功退出
EXIT_FAILURE：失败退出
返回值：无

进程资源回收（wait、waitpid）

#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *wstatus);
功能：阻塞回收子进程的资源，如果没有进程退出，那么就阻塞等待
参数：子进程退出时的状态，一般不接收，直接填NULL即可
返回值：成功返回回收的子进程的pid，失败返回-1并置位错误码
pid_t waitpid(pid_t pid, int *wstatus, int options);
功能：既可以阻塞也可以非阻塞形式回收僵尸进程
参数1：要回收的进程号
0:表示回收具体的某个进程
=0：能够回收当前进程所在的进程组中的任意一个子进程
=-1：回收任意一个子进程
<-1: 回收别的进程组（进程组id为给定的pid的绝对值）中的任意一个子进程
参数2：子进程退出时的状态，一般不接收，直接填NULL即可
参数3：表示是否阻塞回收僵尸进程
0：表示阻塞
WNOHANG：表示非阻塞
返回值：
0: 如果成功回收了子进程资源，那么会返回该子进程的pid
=0: 表示以非阻塞的形式回收资源，但是没有回收到子进程
=-1：失败返回-1并置位错误码

pthread_create:创建线程

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void ), void arg);
功能：在当前进程中，创建一个分支线程
参数1：用于接收创建好的线程ID
参数2：线程的属性，一般填NULL表示使用系统默认的属性创建线程
参数3：线程体函数，需要传递一个函数，参数为void，返回值为void
参数4：参数3的参数
返回值：成功创建返回0，失败返回一个错误码，注意，不是内核提供的错误码

pthread_self:线程号的获取

#include <pthread.h>
pthread_t pthread_self(void);
功能：获取当前线程的线程号
参数：无
返回值：当前线程的线程号

pthread_exit:线程退出函数

#include <pthread.h>
void pthread_exit(void *retval);
功能：退出当前的线程
参数：线程退出时的状态，一般填NULL
返回值：无

pthread_jion : 线程资源的回收

#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);
功能：阻塞等待给定线程的退出，并回收该线程的资源
参数1：要回收的线程号
参数2：接收线程退出时的状态
返回值：成功返回0，失败返回错误码

pthread_detach:线程分离态

#include <pthread.h>
int pthread_detach(pthread_t thread);
功能：将线程设置成分离态，设置了分离态的线程，退出后，由系统回收其资源
参数：要被分离的线程id号
返回值：成功返回0，失败返回错误码

pthread_setcancelstate:设置取消属性

#include <pthread.h>
int pthread_setcancelstate(int state, int *oldstate);
功能：设置是否接收取消指令
参数1：新的状态
PTHREAD_CANCEL_ENABLE：可接受状态
PTHREAD_CANCEL_DISABLE：不可接收状态
参数2：线程的旧的状态容器，如果不愿意要之前的状态，填NULL即可
返回值：成功返回0，失败返回错误码

互斥锁的相关API

创建互斥锁

pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER; //静态初始化一个互斥锁

初始化互斥锁

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
功能：初始化一个互斥锁
参数1：互斥锁变量的地址
参数2：互斥锁的属性，一般填NULL，使用系统默认提供的属性
返回值：总是成功，不会失败

获取锁资源

int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：某个线程调用该函数表示获取锁资源
参数：互斥锁的地址
返回值：成功返回0，失败返回一个错误码

释放锁资源

int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：将线程中的锁资源释放
参数：互斥锁的地址
返回值：成功返回0，失败返回一个错误码

销毁锁资源

int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：销毁程序中的锁资源
参数：互斥锁地址
返回值：成功返回0，失败返回一个错误码

线程同步之无名信号量

创建无名信号量

创建无名信号量：只需要定义一个 sem_t 类型的变量，就创建了一个无名信号量
sem_t sem;

初始化无名信号量

int sem_init(sem_t *sem, int pshared, unsigned int value);
功能：完成对无名信号量的初始化工作
参数1：要被初始化的无名信号量地址
参数2：无名信号量适用情况
0：表示多线程之间
非0：表示多进程间同步
参数3：无名信号量的资源初始值
返回值：成功返回0，失败返回-1并置位错误码

申请资源：P操作，将资源减1操作

int sem_wait(sem_t *sem);
功能：申请无名信号量中的资源，使得该信号量中的value-1
参数：无名信号量地址
返回值：成功返回0，失败返回-1并置位错误码

释放资源：V操作，将资源加1操作

int sem_post(sem_t *sem);
功能：将无名信号量中的资源加1操作
参数：无名信号量地址
返回值：成功返回0，失败返回-1并置位错误码

销毁无名信号量

int sem_destroy(sem_t *sem);
功能：销毁一个无名信号量
参数：无名信号量地址
返回值：成功返回0，失败返回-1并置位错误码

线程同步之条件变量

创建条件变量

只需要定义一个pthread_cond_t类型的变量，就创建了一个条件变量
pthread_cond_t cond;

初始化条件变量

int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
功能：初始化一个条件变量
参数1：条件变量的地址
参数2：条件变量的属性，一般填NULL
返回值： 成功返回0，失败返回非0错误码

唤醒消费者线程

int pthread_cond_signal(pthread_cond_t *cond);
功能：唤醒等待队列中的第一个消费者线程
参数：条件变量的地址
返回值： 成功返回0，失败返回非0错误码
----------------------------------------------------------------------
int pthread_cond_broadcast(pthread_cond_t *cond);
功能：唤醒所有等待队列中的消费者线程
参数：条件变量的地址
返回值： 成功返回0，失败返回非0错误码

将消费者线程放入到等待队列中

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
功能：消费者线程进入等待队列中
参数1：条件变量的地址
参数2：互斥锁的地址：因为多个消费者线程在进入等待队列上是竞态的
返回值： 成功返回0，失败返回非0错误码

销毁条件变量

int pthread_cond_destroy(pthread_cond_t *cond);
功能：销毁一个条件变量
参数：条件变量的地址
返回值： 成功返回0，失败返回非0错误码