APUE C/C++

UNIX环境高级编程（APUE） 学习记录 第三章 文件I\O

By jiutingqiu

APUE环境部署

root@apue:~# apt update
root@apue:~# apt -y install build-essential gcc gdb
root@apue:~# wget http://www.apuebook.com/src.3e.tar.gz
root@apue:~# tar xzf src.3e.tar.gz
root@apue:~# cd apue.3e/lib/
root@apue:~/apue.3e# make
root@apue:/home/apue/apue.3e# cp lib/libapue.a /usr/lib
root@apue:/home/apue/apue.3e# cp include/apue.h /usr/include/
root@apue:/home/apue/apue.3e# cp lib/error.c /usr/include/

第三章 文件I/0

3.3、open和openat

调用open或openat函数可以打开或创造一个文件，不同在于open是绝对目录，openat是相对目录
int型如何理解呢
在本书3.10 文件共享一节中的进程表项有说明
int值为一个标志，用于返回对应的文件指针

open

#函数定义
int open(const char *path, int oflag,.. /* mode_t mode */);

oflag:
O_RDONLY    只读打开    0
O_WRONLY    只写打开    1
O_RDWR      读、写打开   2
O_EXEC      只执行打开
O_SEARCH(不支持)       只搜索打开
....

mode 参数用于设置文件的权限
读权限 (r): 4
写权限 (w): 2
执行权限 (x): 1
#练习
root@apue:~/note# cat open.c 
#include "apue.h"
#include "stdio.h"

int main()
{
    int fd = open("/root/note/test",0);
    printf("%d\n",fd);

    return 0;
}

root@apue:~/note# gcc open.c -o open -w

#无test文件
root@apue:~/note# ./open 
-1

#有test文件
root@apue:~/note# touch test
root@apue:~/note# ./open 
3

#命令行用法
root@apue:~/note# cat open.c
#include "apue.h"
#include "stdio.h"
#define MAX 100

int main(int argc, char ** argv)    //argc 是一个整数，表示传递给程序的命令行参数的数量。 argv 是一个指向字符串数组的指针，每个字符串表示一个命令行参数。
{
    char path[MAX]; 
    int i, fd;

    sscanf(argv[1], "%s", path);  //sscanf根据指定的格式从字符串中读取数据，并将结果存储到指定的变量中
    i = atoi(argv[2]);              //atoi将一个以 null 结尾的字符串（表示整数的 ASCII 表示）转换为相应的整数值
    fd = open(path, i);             //open会返回一个int型

    printf("%d\n", fd);

    return 0;

}
root@apue:~/note# gcc open.c -o open -w

#没有test文件时，只读打开报错
root@apue:~/note# ./open /root/test 0
-1

#创造test文件
apue@apue:~/note$ touch test
apue@apue:~/note$ ll test
-rw-rw-r-- 1 apue apue 0  5月  7 23:44 test

#修改为只写权限
apue@apue:~/note$ chmod 200 test 
apue@apue:~/note$ ./open /home/apue/note/test 0
-1

#修改读权限，返回正常
apue@apue:~/note$ chmod 400 test 
apue@apue:~/note$ ./open /home/apue/note/test 0
3

openat

openat是相对目录

#函数定义
int open(int fd, const char *path, int oflag,.. /* mode_t mode */);
root@apue:~/note# cat openat.c 
#include "apue.h"
#include "stdio.h"
#include "fcntl.h"

int main()
{
    int fd, rt;
    fd = open("/root/note", O_EXCL);
    rt = openat(fd, "test", 0);

    printf("%d\n", rt);

    return 0;
}

#首先是没有test文件
root@apue:~/note# ./openat 
-1

root@apue:~/note# touch test
root@apue:~/note# ./openat 
4

apue@apue:~/note$ chmod 000 test
apue@apue:~/note$ ./openat 
-1

#假设const char *path指定的是一个绝对路径，fd将被忽略
root@apue:~/note# cat openat.c 
#include "apue.h"
#include "stdio.h"
#include "fcntl.h"

int main()
{
    int fd, rt;
    fd = open("/home", O_EXCL);
    rt = openat(fd, "/root/note/test", 0);

    printf("%d\n", rt);

    return 0;
}
root@apue:~/note# gcc openat.c -o openat -w
root@apue:~/note# ./openat 
4

root@apue:~/note# ls test /home/
test

/home/:
apue
#命令行用法
root@apue:~/note# cat openat.c 
#include "apue.h"
#include "stdio.h"
#include "fcntl.h"

#define MAX 100

int main(int argc,char** argv)
{
    char path[MAX], buf[MAX];
    int i, fd, rt;

    i = atoi(argv[2]);                  //atoi将一个以 null 结尾的字符串（表示整数的 ASCII 表示）转换为相应的整数值
    sscanf(argv[1], "%s", path);      //sscanf根据指定的格式从字符串中读取数据，并将结果存储到指定的变量中

    //类似pwd，后面章节会讲
    getcwd(buf, sizeof(buf));           //buf 是一个指向字符数组的指针，用于存储当前工作目录的路径名；

    fd = open(buf, O_EXCL);
    rt = openat(fd, path, i);

    printf("%d\n", rt);

    return 0;
}

root@apue:~/note# gcc openat.c -o openat -w

#当前目录测试
apue@apue:~/note$ ./openat test 0
-1
apue@apue:~/note$ chmod 400 test 
apue@apue:~/note$ ./openat test 0
4
apue@apue:~/note$ touch test1
apue@apue:~/note$ ./openat test1 0
4

#切换目录测试
apue@apue:~/note$ cd ..
apue@apue:~$ cp note/openat .
apue@apue:~$ ./openat test 0
-1
apue@apue:~$ touch test 
apue@apue:~$ ./openat test 0
4

3.4、creat

int creat(const char * path, mode_t mode);

mode_t 无符号int
实际上是8进制

creat 函数在创建文件时可以使用的权限位有：
S_IRUSR：用户拥有读权限。
S_IWUSR：用户拥有写权限。
S_IXUSR：用户拥有执行权限。
S_IRGRP：组拥有读权限。
S_IWGRP：组拥有写权限。
S_IXGRP：组拥有执行权限。
S_IROTH：其他人拥有读权限。
S_IWOTH：其他人拥有写权限。
S_IXOTH：其他人拥有执行权限。
通常，mode 参数可以通过按位或运算来组合这些权限位，例如 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH 表示用户和其他人有读写权限，组有读权限。
root@apue:~/note# cat creat.c 
#include "apue.h"
#include "fcntl.h"
#include "stdio.h"

int main()
{
    int rt;
    mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;    //rw-r--r--
    rt = creat("/root/note/fooooo", mode);

    printf("%d\n",rt);

    return 0;
}

root@apue:~/note# ll fooooo
ls: cannot access 'fooooo': No such file or directory

root@apue:~/note# gcc creat.c -o creat -w
root@apue:~/note# ./creat 
3
root@apue:~/note# ll fooooo 
-rw-r--r-- 1 root root 0  5月 20 22:51 fooooo
#写一个简易版的touch
root@apue:~/note# cat creat.c 
#include "apue.h"
#include "fcntl.h"
#include "stdio.h"

#define MAX 100

int main(int argc,char** argv)
{
    int rt;
    char path[MAX];
    mode_t mode[MAX];

    sscanf(argv[1], "%s", path);
    sscanf(argv[2], "%o", mode);
    rt = creat(path, *mode);

    printf("%d\n",rt);

    return 0;
}

root@apue:~/note# gcc creat.c -o creat -w

root@apue:~/note# ./creat foooo 600
3
root@apue:~/note# ll foooo 
-rw------- 1 root root 0  5月 20 23:04 foooo

3.5、close

关闭一个打开的文件
相关作用的实现，会在下面的blockhole展示

close (int fd);
root@VM-16-14-ubuntu:~/note# cat close.c 
#include "apue.h"
#include "stdio.h"

int
main()
{
    int fd, rt;
    fd = open("/root/note/test", 0);
    rt = close(fd);

    printf("%d\n", rt);

    return 0;
}

root@VM-16-14-ubuntu:~/note# gcc close.c -o close -w
root@VM-16-14-ubuntu:~/note# ./close 
-1
root@VM-16-14-ubuntu:~/note# touch test
root@VM-16-14-ubuntu:~/note# ./close 
0

3.6、lseek

设置文件偏移量

off_t lseek(int fd, off_t offset, int whence)

fd：文件描述符，表示需要操作的文件。
offset：偏移量，指定相对于 whence 参数的位置进行偏移。
whence：偏移的起始位置，可以是以下几种值之一：
    SEEK_SET：从文件的开头开始计算偏移。
    SEEK_CUR：从当前位置开始计算偏移。
    SEEK_END：从文件末尾开始计算偏移。
root@VM-16-14-ubuntu:~/note# cat lseek.c 
#include "stdio.h"
#include "apue.h"

int
main()
{
    int fd;
    fd = open("/home/note/test", 0);

    if (lseek(fd, 0, SEEK_CUR) == -1)
        printf("cannot seek\n");
    else
        printf("seek ok\n");

    return 0;
}

root@VM-16-14-ubuntu:~/note# gcc lseek.c -o lseek -w
root@VM-16-14-ubuntu:~/note# ./lseek 
cannot seek

3.7、read

ssize_t read(int fd, void *buf, size_t count);

fd：文件描述符，表示要读取的文件。
buf：指向存储读取数据的缓冲区的指针。
count：要读取的最大字节数。
root@VM-16-14-ubuntu:~/note# cat read.c 
#include "apue.h"
#include "stdio.h"

int
main()
{
    char buf[256];
    int fd;

    if ((fd = open("/root/note/test", 0)) == -1)
        printf("No such file or directory!");
    if ((read(fd, buf, 10)) == -1)
        printf("read error!");

    printf("%s\n", buf);

    return 0;

}

root@VM-16-14-ubuntu:~/note# gcc read.c -o read -w
root@VM-16-14-ubuntu:~/note# ./read 
abcdefghij
root@VM-16-14-ubuntu:~/note# cat test 
abcdefghijABCDEFGHIJ

3.8、write

向打开文件写数据

ssize_t write(int fd, const void *buf, size_t nbytes)

fd：文件描述符，表示要写入的文件。
buf：指向要写入数据的缓冲区的指针。
count：要写入的字节数。

root@VM-16-14-ubuntu:~/note# cat write.c 
#include "stdio.h"
#include "apue.h"

char buf[] = "ABCEDFGHIJ";

int
main()
{
    int fd, rt;

    fd = open("/root/note/test", 1);
    rt = write(fd, buf, 10);

    printf("%d\n", rt);

    return 0;
}

root@VM-16-14-ubuntu:~/note# gcc write.c -o write -w
root@VM-16-14-ubuntu:~/note# cat test 
maskdmkmkwq
root@VM-16-14-ubuntu:~/note# ./write 
10
root@VM-16-14-ubuntu:~/note# cat test 
ABCEDFGHIJq

blockhole

root@VM-16-14-ubuntu:~/note# cat blockhole.c 
#include "stdio.h"
#include "apue.h"

//读写 读 读
#define RWRR (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)

char buf1[] = "abcdefghij";
char buf2[] = "ABCDEFGHIJ\n";

int
main()
{
    int fd;

    //创造文件，文件权限为644
    if ((fd = creat("/root/note/test", RWRR)) < 0)
        printf("create file error!");
    //往文件写数据
    if (write(fd, buf1, sizeof(buf1)) != sizeof(buf1))
        printf("write buf1 file error!");
    //设置偏移量，防止buf2覆盖
    if (lseek(fd, sizeof(buf1), SEEK_SET) == -1)
        printf("lseek error!");

    //if(close(fd) == -1)
    //  printf("close file error!");

    if (write(fd, buf2, sizeof(buf2)) != sizeof(buf2))
        printf("wirte buf2 file error!");

    return 0;
}

root@VM-16-14-ubuntu:~/note# gcc blockhole.c -o blockhole -w
root@VM-16-14-ubuntu:~/note# rm -rf test 
root@VM-16-14-ubuntu:~/note# ./blockhole 
root@VM-16-14-ubuntu:~/note# cat test 
abcdefghijABCDEFGHIJ
#体现close功能，关闭了fd
root@VM-16-14-ubuntu:~/note# cat blockhole.c 
#include "stdio.h"
#include "apue.h"

//读写 读 读
#define RWRR (S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)

char buf1[] = "abcdefghij";
char buf2[] = "ABCDEFGHIJ\n";

int
main()
{
    int fd;

    //创造文件，文件权限为644
    if ((fd = creat("/root/note/test", RWRR)) < 0)
        printf("create file error!");
    //往文件写数据
    if (write(fd, buf1, sizeof(buf1)) != sizeof(buf1))
        printf("write buf1 file error!");
    //设置偏移量，防止buf2覆盖
    if (lseek(fd, sizeof(buf1), SEEK_SET) == -1)
        printf("lseek error!");

    if(close(fd) == -1)
        printf("close file error!");

    if (write(fd, buf2, sizeof(buf2)) != sizeof(buf2))
        printf("wirte buf2 file error!");

    return 0;
}

root@VM-16-14-ubuntu:~/note# ./blackhole 
wirte buf2 file error!

3.9、I\O的效率

#include <iostream>
#include <apue.h>
#include <fcntl.h>
#define BUFFSIZE 4096
using namespace std;

int main()
{
    int n,fd1,fd2,ts;

    char buf[BUFFSIZE];

    fd1 = open("/home/apue/note/test",2);
    fd2 = open("/home/apue/note/wtest",2);

    while ((n = read(fd1, buf, BUFFSIZE)) > 0)
        if (write(fd2, buf, n) != n)
            cout << "write error!" << endl;

    if (n < 0)
        cout << "read error!" << endl;    

    return 0;

}

apue@ThinkPad-X13:~/note$ cat test
ABCDEFGHIJK
apue@ThinkPad-X13:~/note$ > wtest 
apue@ThinkPad-X13:~/note$ ./io 
apue@ThinkPad-X13:~/note$ cat test
ABCDEFGHIJK

root@VM-16-14-ubuntu:~/note# cat io.c 
#include "apue.h"
#include "stdio.h"

int
main(int argc, char** argv)
{
    int fd1, fd2, rt;
    char buf[256];

    if ((fd1 = open(argv[1], 2)) == -1)
        printf("%s No such file or directory!\n", argv[1]);
    if ((fd2 = open(argv[2], 2)) == -1)
        printf("%s No such file or directory!\n", argv[2]);

    while ((rt = read(fd1, buf, sizeof(buf))) > 0)
        if (write(fd2, buf, rt) != rt)
            printf("write error!\n");
    if (rt < 0)
        printf("read error!\n");

    return 0;
}

root@VM-16-14-ubuntu:~/note# gcc io.c -o io -w
root@VM-16-14-ubuntu:~/note# ./io test wtest
wtest No such file or directory!
write error!
root@VM-16-14-ubuntu:~/note# touch wtest
root@VM-16-14-ubuntu:~/note# ./io test wtest
root@VM-16-14-ubuntu:~/note# cat wtest 
abcdefghijABCDEFGHIJ

3.10、文件共享

1、进程表项

首先说一下进程表项，这里拿 open 和 read 函数进行举例，
定义 open 和 read
int fd = open(“/root/test”, 0);
ssize_t rt = read(fd, buf, size);

open 打开一个文件并写入到进程表项中，一般情况下 fd 为 3，
0 是标准读入
1 是标准输出
2 是标准错误

read 通过 fd 获取文件表项中的文件指针
通过文件指针对其文件进行后续的操作

2、文件表项

图中的文件表项是一小部分，这里不展开说
1. 文件状态标志：这些标志位用于描述文件的状态，如文件的类型（普通文件、目录、符号链接等）、文件的访问权限（读、写、执行）等。
2. 当前文件偏移量：它通常是一个非负整数，用以度量从文件开始处计算的字节数。进行相关操作

3、v 节点指针

1. v 节点指针：包含文件类型和对此文件进行各种操作的函数的指针信息，同时还包含 i 节点
2. i 节点：包含文件的所有者、文件长度、文件所在的设备、实际数据块的指针。

3.11、pread/pwrite

ssize_t pread(int fd, void *buf, size_t count, off_t offset);
ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset);

fd：文件描述符，从这个文件描述符读取数据。/文件描述符，向这个文件描述符写入数据。
buf：指向读取数据的缓冲区。/指向要写入数据的缓冲区。
count：要读取的字节数。/要写入的字节数。
offset：从文件开头开始的偏移量。

pread 和 pwrite 是 POSIX 提供的系统调用，用于在指定的文件偏移位置进行读写操作，而不改变文件描述符的文件偏移量。这使得它们在多线程编程中非常有用，因为不同线程可以使用同一个文件描述符进行并发读写，而不需要担心相互干扰。

root@VM-16-14-ubuntu:~/note# cat pread_pwrite.c 
#include "apue.h"
#include "stdio.h"

int
main()
{
    int fd;
    char buf1[20], buf2[20];

    if ((fd = open("/root/note/test", 0)) == -1)
        printf("no file test error!");

    if (lseek(fd, 5, SEEK_CUR) == -1)
        printf("cannot seek\n");

    if ((read(fd, buf1, sizeof(buf1))) == -1)
        printf("read error!");

    printf("lseek buf1: %s\n", buf1);

    if (pread(fd, buf2, sizeof(buf2), 0) < 0)
                printf("pread file error!");

    printf("pread: %s\n", buf2);

    return 0;
}

root@VM-16-14-ubuntu:~/note# ./pread_pwrite 
lseek buf1: fghij
pread: abcdefghij

3.12、dup/dup2

int dup(int oldfd);
int dup2(int oldfd, int newfd);

oldfd：要复制的文件描述符。
newfd：指定的目标文件描述符。

dup 函数用于复制现有的文件描述符，并返回一个新的文件描述符
dup2 函数用于复制现有的文件描述符到指定的文件描述符。与 dup 不同，dup2 允许用户指定新文件描述符的值。如果新的文件描述符已经被打开，则会先将其关闭。
#主要是修改文件描述符的值
root@VM-16-14-ubuntu:~/note# cat duo_dup2.c 
#include "stdio.h"
#include "apue.h"

int
main()
{
    int fd, d1, d2;

    if ((fd = open("/root/note/test", 0)) == -1)
        printf("open test error!");

    if ((d1 = dup(fd)) < 0)
        printf("dup test error!");

    if ((d2 = dup2(fd, 20)) < 0)
        printf("dup2 test error!");

    printf("fd: %d, oldfd: %d, newfd: %d\n", fd, d1, d2);

    return 0;
}

root@VM-16-14-ubuntu:~/note# gcc duo_dup2.c -o duo_dup2 -w
root@VM-16-14-ubuntu:~/note# ./duo_dup2 
fd: 3, oldfd: 4, newfd: 20

3.13、sync、fsync和fdatasync

void sync(void);
int fsync(int fd);
int fdatasync(int fd);

区别
sync 是一个命令，而 fsync 和 fdatasync 是函数。
sync 同步所有挂载的文件系统的缓存数据，而 fsync 和 fdatasync 只同步特定文件的数据到磁盘。
fsync 同步文件的数据和属性，而 fdatasync 只同步文件的数据。

使用场景
sync 常用于需要确保所有数据都已写入磁盘，且文件系统缓存已清空的情况，例如系统关机前。
fsync 适用于需要确保特定文件的所有修改都已写入磁盘的情况，如关键性文件的更新。
fdatasync 更适合对文件数据更新要求高，但对文件属性不那么敏感的情况，例如数据库日志文件的写入。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

int main() {
    // 创建一个新文件
    int fd = open("testfile.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    // 写入数据到文件
    const char *data = "Hello, world!\n";
    ssize_t bytes_written = write(fd, data, strlen(data));
    if (bytes_written == -1) {
        perror("write");
        close(fd);
        return 1;
    }

    // 调用 sync
    if (sync() == -1) {
        perror("sync");
        close(fd);
        return 1;
    }

    // 调用 fsync
    //if (fsync(fd) == -1) {
    //    perror("fsync");
    //    close(fd);
    //    return 1;
    //}

    // 调用 fdatasync
    //if (fdatasync(fd) == -1) {
    //    perror("fdatasync");
    //    close(fd);
    //    return 1;
    //}

    // 关闭文件
    if (close(fd) == -1) {
        perror("close");
        return 1;
    }

    printf("Sync, fsync, and fdatasync completed successfully.\n");

    return 0;
}

3.14、fcntl

int fcntl(int fd, int cmd, ... /* arg */ );

常见命令
    F_GETFD：获取文件描述符标志。
    F_SETFD：设置文件描述符标志。
    F_GETFL：获取文件状态标志。
    F_SETFL：设置文件状态标志。
    F_GETLK：获取文件锁的状态。
    F_SETLK：设置文件锁（非阻塞）。
    F_SETLKW：设置文件锁（阻塞）。

文件描述符标志
    FD_CLOEXEC: 在执行 exec 系列函数时自动关闭文件描述符。这个标志有助于防止文件描述符泄漏到新执行的程序中。

文件状态标志
    O_RDONLY: 以只读模式打开文件。
    O_WRONLY: 以只写模式打开文件。
    O_RDWR: 以读写模式打开文件。
    O_APPEND: 以追加模式打开文件，写操作会附加到文件的末尾。
    O_CREAT: 如果文件不存在，则创建文件。
    O_EXCL: 与 O_CREAT 一起使用，如果文件已存在，则返回错误。
    O_TRUNC: 如果文件存在，并且以写入模式打开，则将文件长度截断为 0。
    O_NONBLOCK: 以非阻塞模式打开文件。
    O_SYNC: 以同步模式打开文件，每次写入都等待物理 I/O 完成。
    O_DSYNC: 数据同步，类似于 O_SYNC，但只同步数据，不包括元数据。
    O_RSYNC: 读取时同步。
    O_NOFOLLOW: 如果参数是一个符号链接，则返回错误。
    O_DIRECTORY: 如果参数不是一个目录，则返回错误。
    O_NOATIME: 不更新文件的最后访问时间。
    O_CLOEXEC: 在执行 exec 系列函数时自动关闭文件描述符，这是文件状态标志中等效于 FD_CLOEXEC 的标志。

root@VM-16-14-ubuntu:~/note# cat fcntl.c 
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

int main() {
    int fd = open("/root/note/test", O_WRONLY | O_CREAT, 0644);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    struct flock lock;

    // 设置写锁
    lock.l_type = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0; // 锁定整个文件

    if (fcntl(fd, F_SETLK, &lock) == -1) {
        if (errno == EACCES || errno == EAGAIN) {
            printf("File is already locked by another process.\n");
        } else {
            perror("fcntl");
        }
        close(fd);
        return 1;
    }

    printf("File locked successfully.\n");

    // 在这里进行文件操作...

    sleep(30);

    // 解锁文件
    lock.l_type = F_UNLCK;
    if (fcntl(fd, F_SETLK, &lock) == -1) {
        perror("fcntl");
        close(fd);
        return 1;
    }

    printf("File unlocked successfully.\n");

    close(fd);
    return 0;
}

root@VM-16-14-ubuntu:~/note# ./fcntl & ./fcntl 
[1] 256236
File locked successfully.
File is already locked by another process.
File unlocked successfully.
[1]+  Exit 1                  ./fcntl

3.15、ioctl

ioctl 是一个输入/输出控制系统调用，通常用于对设备进行低级别操作。这些操作通常包括配置设备、获取设备状态等，无法通过标准系统调用（如 read 和 write）来完成。
这里的调用较为复杂，后续章节再做

int ioctl(int fd, unsigned long request, ...);

fd: 文件描述符，通常是打开设备文件后返回的描述符。
request: 控制命令，决定了要执行的操作。
...: 可选参数，根据具体的控制命令而变化。

By jiutingqiu

Related Post

APUE C/C++

UNIX环境高级编程（APUE） 学习记录 第五章 标准I/O库

jiutingqiu
APUE C/C++

UNIX环境高级编程（APUE） 学习记录 第四章 文件和目录

jiutingqiu
APUE C/C++

warning: implicit declaration of function ‘open’; did you mean ‘popen’? [-Wimplicit-function-declaration]

jiutingqiu

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注

You Missed

APUE C/C++

UNIX环境高级编程（APUE） 学习记录 第五章 标准I/O库

APUE C/C++

UNIX环境高级编程（APUE） 学习记录 第四章 文件和目录

APUE C/C++

warning: implicit declaration of function ‘open’; did you mean ‘popen’? [-Wimplicit-function-declaration]

APUE C/C++

UNIX环境高级编程（APUE） 学习记录 第三章 文件I\O