Linux 系统编程入门
静态库与动态库
静态库命名规则
- linux: libxxx.a 保持 lib 前缀 和 .a 后缀
- Windows: libxxx.lib
静态库的制作
gcc 获得 .o 文件 将 .o 文件用 ar 工具打包
ar rcs libxxx.a xxx.o xxx.o
# -r 将文件插入备份文件中
# -c 建立备份文件
# -s 索引
静态库使用
g++ main.cpp -I ./include -l calc -L./lib -o test && ./test
# -I 包含路径
# -l 库名字
# -L 库路径
动态库制作
- 命名规则
- Linux： libxxx.so 保持 lib 前缀和 .so 后缀, 在linux 下是一个可执行文件
- Windows: libxxx.dll
gcc -c -fpic *.c # 得到和位置无关的代码
gcc -shared *.o -o libxxx.so # 生成动态库
g++ main.cpp -I ./include -L lib/ -l calc -o main && ./main
# ./main: error while loading shared libraries: libcalc.so: cannot open shared object file: No such file or directory
动态库使用
程序启动之后，动态库会被动态加载到内存，通过 ldd (list dynamic dependencies) 命令检查动态库依赖关系
ldd main
# linux-vdso.so.1 (0x00007ffd771f6000)
# libcalc.so => not found
# libstdc++.so.6 => /lib/x86_64-linux-gnu/libstdc++.so.6 (0x00007f47d0be9000)
# libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f47d09f7000)
# libm.so.6 => /lib/x86_64-linux-gnu/libm.so.6 (0x00007f47d08a8000)
# /lib64/ld-linux-x86-64.so.2 (0x00007f47d0e28000)
# libgcc_s.so.1 => /lib/x86_64-linux-gnu/libgcc_s.so.1 (0x00007f47d088d000)
-
如何定位共享库文件呢？
当系统加载可执行代码时，能够知道其所依赖的库的名字，但还是需要知道绝对路径。
- 搜索路径
- elf 文件的 DT_RPATH 段
- LD_LIBRARY_PATH
- /etc/ld.so.cache 文件列表
- /lib, /usr/lib
- 搜索路径
加载动态库
# 方法一， 临时用
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:`pwd`/bin
./main
ldd main
# 方法二, 用户级别
# 写到 .shrc 中
# 方法三， 系统级别
# 写到 /etc/profile
- 添加到文件列表
sudo nano /etc/ld.so.conf
sudo ldconfig
静态库的优缺点
-
优点：
- 静态库被打包到应用程序中加载速度快
- 发布程序无需提供静态库，移植方便
-
缺点
- 消耗系统资源，浪费内存
- 更新、部署、发布麻烦
动态库的优缺点
-
优点：
- 可以实现进程间资源共享（共享库）
- 更新、部署、发布简单
- 可以控制何时加载动态库
-
缺点
- 加载速度相对静态库慢
- 发布程序时需要提供依赖的动态库
Makefile
- Makefile 文件定义了一系列规则来编译指定文件。
- make 一个命令行工具： 解释 Makefile 文件中指令的命令工具。
文件命名
-
makefile 或者 Makefile
-
一个 Makefile 文件中可以有一个或多个规则
- 目标 …: 依赖 …
- 命令 （shell 命令）
- …
- 目标 …: 依赖 …
-
目标： 最终要生成的文件（伪目标除外）
-
依赖： 生成目标所需要的文件或是目标
-
命令： 通过执行命令对依赖操作生成目标（命令前必须 Tab 缩进）
-
Makefile 中的其他规则一般都是为第一条规则服务的
工作原理
-
命令在执行之前， 需要先检查规则中的依赖是否存在
- 如果存在， 执行命令
- 如果不存在，向下检查其他规则，检查有没有一个规则是用来生成这个依赖的，如果找到了，则执行该规则中的命令。
-
检测更新，在执行规则中的命令是，会比较目标文件和依赖文件的时间
- 如果依赖的时间比目标的时间晚，需要重新生成目标
- 如果依赖的时间比目标时间早， 目标不需要更新，对应规则中的命令不需要被执行
变量
-
自定义变量： 变量名=变量值 var=hello
-
预定义变量：
- AR: 归档维护程序的名称，默认值 ar
- CC: C 编译器的名称， 默认值 cc
- CXX: C++ 编译器的名称, 默认值 g++
- $@: 目标的完整名称
-
获取变量的值: $(变量名)
模式匹配
- %.o:%.c
- %: 通配符， 匹配一个字符串
- 两个%匹配的是同一个字符串
函数
-
$(wildcard PATTERN)
- 功能： 获取指定目录下指定类型的文件列表
- 参数： PATTERN 指的是某个或多个目录下对应的某种类型的文件，如果有多个目录，一般使用空格间隔
- 返回： 得到的若干个文件列表，文件名之间使用空格间隔
- 示例： $(wildcard .cpp ./sub/.cpp)
- 返回值： a.cpp b.cpp c.cpp
-
$(patsubst ,,
) - 功能： 查找 text, 符合 patten, 用 replacement 替换
- pattern 可以包含通配符 %, 表示任意长度的字串。如果 replacement 中也包含 %， 那么replacement 中的 % 与 patten 代表字串相同，可以用 \ 来转义。
- 返回： 函数返回被替换过后的字符串
- 示例： $(patsubst %.c, %.o, x.c bar.c)
- 返回值格式: x.o bar.o
GDB 调试
GDB 是什么？
- GDB 是由 GUN 软件系统社区提供的调试工具， 同 GCC 配套组成了一套完整的开发环境， GDB 是 Linux 和许多类 Unix 系统中的标准开发环境。
开始调试
- 关掉编译器优化选项 （-O）
- 打开调试选项 (-g) 在可执行文件中加入源代码的信息，比如可执行文件中的第几条机器指令对应源代码中的第几行，但不是嵌入源文件，调试时需要保证 gdb 能找到源文件。
- (-Wall) 在不影响程序行为的情况下，打开所有 warning
g++ main.cpp -g -Wall -o test
gdb test
gdb 指令
-
查看当前文件代码
- list : 列出10行代码
- list\l 行号 : 从指定行显示, 指定行在显示的中心位置
- list\l 函数名 : 从指定函数显示
-
查看非当前文件代码
- list filename:line_number
- list filename:function_name
-
设置显示的行数
- show list/listsize
- set list/listsize
-
回车 : 上一次命令
-
设置断点
- b/break 行号/函数名/文件名：行号/文件名：函数
-
查看断点
- i/info b/break
-
删除断点
- d/del/delete 断点编号
-
设置断点无效
- dis/disable 断点编号
-
设置断点生效
- ena/enable 断点编号
-
设置断点条件
- b/break 10 if i == 5
-
运行gdb 程序
- start 程序停在第一行
- run 遇到断点才停
-
继续运行, 到下一个断点才停
- c/continue
-
向下执行一行代码,不会进入函数体
- n/next
-
变量操作
- p/print 变量名: 打印变量值
- ptype 变量名： 打印变量类型
-
向下单步调试，遇到函数进入函数体
- s/step
- finish 跳出函数体
-
自动变量操作
- display num， 自动打印指定变量的值
- i/info display
- undisplay 编号
-
其他操作
- set var 变量名=变量值
- until， 跳出循环
Linux系统IO函数
标准C库IO函数
-
fopen, fclose, fread, fwrite, fgets, fputs, fscanf, fprintf, fseek, fgetc, fputc, ftell, feof, fflush…
-
结构体： 文件描述符(整型值), 文件读写指针位置，IO缓冲区（内存地址）
用户程序 <–> C标准I/O库 <–> 内核(Read/Write) <–> 磁盘
虚拟地址空间(真实不存在)
Linux 下的可执行文件格式： ELF
| 用户区 | 内核区 |
|---|---|
| 0-3G | 3G-4G |
从左到右：
-
用户区
- 受保护的地址
- .text （代码段，二进制机器指令）
- .data (已初始化全局变量)
- .bss (未初始化全局变量)
- 堆空间 (大)
- 共享库
- 栈空间 (小)
- 命令行参数
- 环境变量
-
内核区 内核空间是受保护的，用户不能对该空间进行读写操作，否则会出现段错误。
- 内存管理
- 进程管理
- 设备驱动管理
- VFS虚拟文件系统
文件描述符
-
PCB 进程控制块
-
文件描述符
- 0 -> stdin_fileno， 标准输入，默认打开
- 1 -> stdout_fileno，标准输出，默认打开
- 2 -> stderr_fileno, 标准错误， 默认打开
- 3-1023 每打开一个新文件，占用一个文件描述符，而且是空闲的最小的一个文件描述符。
open 打开文件
#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc, char **argv) {
// 打开一个已经存在的文件
// int open(const char* pathname, int flags);
// int open(const char* pathname, int flags， mode_t mode );
// 参数： pathname: 要创建的文件路径
// flags: 对文件的操作权限和其他设置
// mode: 八进制数，表示用户对新创建的文件的操作权限， 最终权限是 (mode & ~umask)
// 返回一个新的文件描述符， 如果失败，返回 -1。
// errno: 属于Linux 系统函数库, 库里面的一个全局变量，记录的是最近的错误号。
/**
#include<stdio.h>
void perror(const char *s);
作用： 打印 errno 对应的错误描述
s 参数： 用户描述，比如 hello， 最终输出的内容的是 hello: xxx
(实际的错误输出)
*/
int fd = open("./a.txt", O_RDONLY);
if (-1 == fd) {
perror("open");
}
close(fd);
return 0;
}
create 文件
#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
// 创建一个新的文件
int fd = open("create.txt", O_RDWR |O_CREAT, 0775);
if(-1 == fd) {
perror("open create err");
}
close(fd);
return 0;
}
read 和 write
#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
/**
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);
参数: fd: 文件描述符， open得到，通过这个文件描述符操作某个文件
buf: 需要读取数据存放的地方，数组的地址
count: 指定数组的大小
返回值: 成功， 大于0， 返回实际读取到的字节数， 0 文件读取完，
失败-1 文件读取失败
#include <unistd.h>
ssize_t write(int fd, const void *buf, size_t count);
*/
// 1. open 打开文件
int fd = open("read_write.c", O_RDONLY);
if(-1 == fd){
perror("open err");
return -1;
}
// 2. 创建一个新的文件（copy 文件）
int dest_fd = open("cpy.txt", O_WRONLY| O_CREAT, 0777);
if(-1 == dest_fd){
perror("create err");
return -1;
}
// 3. 频繁的读写操作
char buffer[1024] = {0};
int len = 0;
while((len = read(fd, buffer, sizeof(buffer))) > 0){
write(dest_fd, buffer, len);
}
// 4. 关闭文件
close(dest_fd);
close(fd);
return 0;
}
lseek 函数
- 文件扩展功能
/**
// 标准C库函数
#include <stdio.h>
int fseek(FILE *stream, long offset, int whence);
// Linux 系统函数库
#include <sys/types.h>
#include <unistd.h>
off_t lseek(int fd, off_t offset, int whence);
参数: fd: 通过 open 得到，文件描述符
offset: 偏移量
whence: SEEK_SET 设置文件指针的偏移量
SEEK_CUR 设置偏移量，当前位置 + 第二个参数的 offset 的值
SEEK_END 设置偏移量，文件大小 + 第二个参数的 offset 的值
返回值： 返回文件指针的位置
作用： 1. 移动文件指针到文件头
lseek(fd, 0, SEEK_SET);
2. 获取当前文件指针的位置
lseek(fd, 0，SEEK_SET);
3. 获取文件长度
lseek(fd, 0, SEEK_END);
4. 扩展文件的长度， 当前文件 10b, 110b, 增加了100个字节
lseek(fd, 100, SEEK_END)
*/
#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
int fd = open("cpy.txt", O_RDWR);
if (-1 == fd) {
perror("read err");
return -1;
}
// 扩展文件的长度
int ret = lseek(fd, 100, SEEK_END);
if (-1 == ret) {
perror("lseek");
return -1;
}
write(fd , " ", 1);
close(fd);
return 0;
}
注： 需要写一次数据才能改变大小
stat 和 lstat 函数
- st_mode 变量： 一个16位的变量， 包含（文件类型， 特殊权限位，User, Group, Others）
- (st_mode & S_IFMT) == S_IFREG
/**
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int stat(const char *pathname, struct stat *statbuf);
作用：获取一个文件相关的一些信息
参数：
- pathname： 操作文件的路径
- statbuf: 结构体变量，传出参数，用于保存获取到的文件信息。
返回值：
- 成功： 返回0，
- 失败： 返回-1， 设置 errno
int lstat(const char *pathname, struct stat *statbuf);
作用： 获取软连接文件的信息
*/
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
struct stat statbuf;
// int ret = stat("cpy_s.txt", &statbuf);
int ret = lstat("cpy_s.txt", &statbuf);
if (-1 == ret) {
perror("stat err");
return -1;
}
printf("size: %1d\n", (int)statbuf.st_size);
return 0;
}
模拟实现 ls -l
#include <pwd.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
/**
*/
int main(int argc, char *argv[]) {
// 判断输入的参数是否正确
if (argc < 2) {
printf("%s filename\n", argv[0]);
return -1;
}
// 通过 stat 过去文件的信息
struct stat buffstat;
int ret = stat(argv[1], &buffstat);
if (-1 == ret) {
perror("stat err");
return -1;
}
// 获取文件类型和文件权限
char permit[11] = {0};
switch (buffstat.st_mode & S_IFMT) {
case S_IFLNK:
permit[0] = '1';
break;
case S_IFDIR:
permit[0] = 'd';
break;
case S_IFREG:
permit[0] = '-';
break;
case S_IFBLK:
permit[0] = 'b';
break;
case S_IFSOCK:
permit[0] = 's';
break;
case S_IFCHR:
permit[0] = 'c';
break;
case S_IFIFO:
permit[0] = 'p';
break;
default:
permit[0] = '?';
break;
}
// 判断文件的访问权限
permit[1] = (buffstat.st_mode & S_IRUSR) ? 'r' : '-';
permit[2] = (buffstat.st_mode & S_IWUSR) ? 'w' : '-';
permit[3] = (buffstat.st_mode & S_IXUSR) ? 'x' : '-';
permit[4] = (buffstat.st_mode & S_IRGRP) ? 'r' : '-';
permit[5] = (buffstat.st_mode & S_IWGRP) ? 'w' : '-';
permit[6] = (buffstat.st_mode & S_IXGRP) ? 'x' : '-';
permit[7] = (buffstat.st_mode & S_IROTH) ? 'r' : '-';
permit[8] = (buffstat.st_mode & S_IWOTH) ? 'w' : '-';
permit[9] = (buffstat.st_mode & S_IXOTH) ? 'x' : '-';
// 硬连接数
int linkNum = buffstat.st_nlink;
char *fileUser = getpwuid(buffstat.st_uid)->pw_name;
char *fileGroup = getpwuid(buffstat.st_gid)->pw_name;
// 文件大小
long int fileSize = buffstat.st_size;
// 获取修改时间
char *changeTime = ctime(&buffstat.st_mtime);
char mtime[512] = {0};
strncpy(mtime, changeTime, strlen(changeTime) - 1);
char buf[1024];
sprintf(buf, "%s %d %s %s %ld %s %s", permit, linkNum, fileUser, fileGroup,
fileSize, mtime, argv[1]);
printf("%s\n", buf);
return 0;
}
文件属性操作函数
- access
- 判断文件存在
/**
#include <unistd.h>
int access(const char *pathname, int mode);
作用： 判断某个文件是否有某个权限， 或者判断文件是否存在
参数： pathname: 判断文件路径
mode: R_OK, W_OK, X_OK： 判断是否有相应权限
返回值： 0 成功，-1 失败
*/
#include <stdio.h>
#include <unistd.h>
int main() {
int ret = access("cpy.txt", R_OK);
if (-1 == ret) {
perror("access err");
return -1;
}
printf("file exist!!! \n");
return 0;
}
- chmod
/**
#include <sys/stat.h>
int chmod(const char *pathname, mode_t mode);
作用： 修改文件的权限
参数： pathname: 要修改文件的路径
mode: 需要修改的权限值，八进制的数
返回值：成功 0， 失败 -1
*/
#include <stdio.h>
#include <sys/stat.h>
int main() {
int ret = chmod("cpy.txt", 0775);
if (-1 == ret) {
perror("chmod err");
return -1;
}
return 0;
}
- chown
/**
#include <unistd.h>
int chown(const char *pathname, uid_t owner, gid_t group);
*/
- truncate
/**
#include <sys/types.h>
#include <unistd.h>
int truncate(const char *path, off_t length);
作用： 缩减或者扩展文件的尺寸到指定大小
参数： path: 需要修改的文件的路径
length: 需要最终文件变成的大小
返回值： 成功 0， 失败 -1.
*/
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
int ret = truncate("cpy.txt", 20);
if (-1 == ret) {
perror("truncate err");
return -1;
}
return 0;
}
目录操作函数
- mkdir
- rmdir
- rename
- chdir
- getcwd
/**
// mkdir
#include<sys/stat.h>
#include <sys/types.h>
int mkdir(const char *pathname, mode_t mode);
参数： mode: 八进制的数
// rmdir
#include <unistd.h>
int rmdir(const char *pathname);
作用： 删除空目录
// rename
#include <stdio.h>
int rename(const char *oldpath, const char *newpath);
// chdir
#include <unistd.h>
int chdir(const char *path);
作用：修改进程的工作目录
// getcwd
#include <unistd.h>
char *getcwd(char *buf, size_t size);
作用： 获取当前的工作目录
参数： buf:存储的路径，指向的是一个数组（传出参数）
size: 数组大小
返回值： 返回的指向的一块内存， 这个数据就是第一个参数
*/
#include <sys/unistd.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(){
// 获取当前的工作目录
char buff[128];
getcwd(buff, sizeof(buff));
printf("current work path:%s \n", buff);
// 修改工作目录
int ret = chdir("../");
int fd = open("chdir.txt", O_CREAT | O_RDWR, 0664);
if(-1 == fd){
perror("open err");
return -1;
}
close(fd);
// 获取当前的工作目录
char buffCur[128];
getcwd(buffCur, sizeof(buffCur));
printf("now current work path: %s\n", buffCur);
return 0;
}
目录遍历函数
- opendir
- readdir
- closedir
/**
#include <dirent.h>
#include <sys/types.h>
DIR *opendir(const char *name);
参数：name : 需要打开的目录的名称
返回值： DIR* 类型，理解为名录流，错误返回 NULL;
#include <dirent.h>
struct dirent *readdir(DIR *dirp);
作用： 读取目录中的数据
参数： dirp 通过 opendir 返回的结果
返回值：struct dirent :
代表读取到的文件信息，读取到末尾或失败，返回NULL；
#include <dirent.h>
#include <sys/types.h>
int closedir(DIR *dirp);
作用： 关闭目录
*/
#include "string.h"
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
// 获取目录下所有普通文件的个数
int getFIleNumber(const char *path) {
DIR *dir = opendir(path);
if (dir == NULL) {
perror("opendir");
exit(0);
}
struct dirent *prt;
int total_number = 0;
while ((prt = readdir(dir))) {
// 获取名称
char *dname = prt->d_name;
// 忽略 ./ 和 ../ 两个目录
if (strcmp(dname, ".") == 0 || strcmp(dname, "..") == 0) {
continue;
}
// 判断是否是普通文件还是目录
if (prt->d_type == DT_DIR) {
// 目录， 需要继续读取这个目录
char newPath[256];
sprintf(newPath, "%s/%s", path, dname);
total_number += getFIleNumber(newPath);
}
if (prt->d_type == DT_REG) {
/// 普通文件
++total_number;
}
}
// 关闭目录
closedir(dir);
return total_number;
}
// 读取某个目录下文件的个数
int main(int argc, char *argv[]) {
if (argc < 2) {
printf("%s path\n", argv[0]);
return -1;
}
int file_numbers = getFIleNumber(argv[1]);
printf("file numbers: %d\n", file_numbers);
return 0;
}
dup 和 dup2 函数
- dup 复制文件描述符
/**
#include <unistd.h>
int dup(int oldfd);
作用： 复制一个新的文件描述符，和原来的文件描述符指向同一个文件，
从空闲文件描述符表中找一个最小的，作为新的拷贝的文件描述符
int dup2(int oldfd, int newfd);
*/
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
int fd1 = open("a.txt", O_RDWR | O_CREAT, 0664);
int fd2 = dup(fd1);
if (fd2 == -1) {
perror("dup");
return -1;
}
printf("fd1: %d, fd2: %d\n", fd1, fd2);
close(fd1);
char *str = "helloworld";
int ret = write(fd2, str, strlen(str));
if (-1 == ret) {
perror("write");
return -1;
}
close(fd2);
return 0;
}
- dup2 重定向文件描述符
/**
#include <unistd.h>
int dup(int oldfd);
作用： 复制一个新的文件描述符，和原来的文件描述符指向同一个文件，
从空闲文件描述符表中找一个最小的，作为新的拷贝的文件描述符
int dup2(int oldfd, int newfd);
作用： 重定向文件描述符，
oldfd 指向 a.txt, newfd 指向 b.txt, 调用函数成功后， newfd 和 b.txt
close, newfd 指向了a.txt。 oldfd 必须是一个有效的文件描述符, oldfd 和 newfd
相同，相当于什么都没做
*/
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
//
int fd = open("1.txt", O_RDWR | O_CREAT, 0664);
if (fd == -1) {
perror("open");
return -1;
}
int fd1 = open("2.txt", O_RDWR | O_CREAT, 0664);
if (-1 == fd1) {
perror("open");
return -1;
}
printf("fd: %d, fd1 %d \n", fd, fd1);
int fd2 = dup2(fd, fd1);
if (fd2 == -1) {
perror("dup2");
return -1;
}
// 通过 fd1 去写数据， 实际操作的是 1.txt, 而不是 2.txt
char str[] = "hello dup2";
int len = write(fd1, str, strlen(str));
if (len == -1) {
perror("write");
return -1;
}
printf("fd: %d, fd1: %d, fd2: %d\n", fd, fd1, fd2);
close(fd1);
// close(fd2);
close(fd);
return 0;
}
fcntl 函数
- fcntl 复制文件描述符，设置、获取文件的状态标志
/**
#include <fcntl.h>
#include <unistd.h>
int fcntl(int fd, int cmd, ... args);
参数： fd 需要操作的文件描述符
cmd : 表示对文件描述符进行如何操作
1. 复制文件描述符， F_DUPFD
2. F_GETFL 获取指定文件描述符状态 flag, 获取的flag 和通过 open
传递的flag 是一个东西。
3. F_SETFL 设置文件描述符状态 flag, 必选项 O_RDONLY, O_WRONLY, O_RDWR,
可选项： O_APPEND, NONBLOCK, O_APPEND 表示追加数据， NONBLOK 设置能非阻塞。
阻塞和非阻塞： 描述的是函数调用的行为。
*/
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
// 1. 复制文件描述符
/* int fd = open("1.txt", O_RDONLY); */
/* int ret = fcntl(fd , F_DUPFD); */
// 2. 修改或者获取文件状态 flag
int fd = open("1.txt", O_RDWR);
if (-1 == fd) {
perror("open");
return -1;
}
// 获取文件描述符的状态
int flag = fcntl(fd, F_GETFL);
if (-1 == flag) {
perror("fcntl");
return -1;
}
flag |= O_APPEND;
// 修改文件描述符状态的 flag, 给 flag 加入 O_APPEND 这个标记
int ret = fcntl(fd, F_SETFL, flag);
if (-1 == ret) {
perror("fcntl");
return -1;
}
char str[] = "\nhello world from fcntl\n";
write(fd, str, strlen(str));
close(fd);
return 0;
}
2590
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
