Linux/UNIX系统编程手册gg

最新推荐文章于 2025-05-26 15:43:17 发布

原创

最新推荐文章于 2025-05-26 15:43:17 发布 · 2.1k 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#linux #unix #运维

Linux系统： “所见皆文件”

一个比较好的博客

一.Linux基础操作

Linux系统目录：

bin：存放二进制可执行文件

boot：存放开机启动程序

dev：存放设备文件：字符设备、块设备

home：存放普通用户

etc：用户信息和系统配置文件 passwd、group

lib：库文件：libc.so.6

usr：用户资源管理目录

Linux系统文件类型： 7/8 种

普通文件：-

目录文件：d

字符设备文件：c

块设备文件：b

软连接：l

管道文件：p

套接字：s

未知文件。

show files:

list show :ls -l(list) -a(all)

? match a character

* match some chars

create files:

touch file_name

copy files:

cp sourse destination

but directories

rename:

cp source source_new_name

-l hard linck

-s symbo linck

less 一页一页读取,切不一次性读取所有文件

head -n 数字取文件前几行

tail -nf 数字取文件最后几行, f代表持续探测

od 二进制读取

软连接：快捷方式

为保证软连接可以任意搬移，创建时务必对源文件使用绝对路径。

硬链接：

ln file file.hard

操作系统给每一个文件赋予唯一的 inode，当有相同inode的文件存在时，彼此同步。

删除时，只将硬链接计数减一。减为0时，inode 被释放。

创建用户：

sudo adduser 新用户名 --- useradd

修改文件所属用户：

sudo chown 新用户名待修改文件。

sudo chown wangwu a.c

删除用户：

sudo deluser 用户名

创建用户组：

sudo addgroup 新组名

修改文件所属用户组：

sudo chgrp 新用户组名待修改文件。

sudo chgrp g88 a.c

删除组：

sudo delgroup 用户组名

使用chown 一次修改所有者和所属组：

sudo chown 所有者：所属组待操作文件。

find命令：找文件

-type 按文件类型搜索 d/p/s/c/b/l/ f:文件

-name 按文件名搜索

find ./ -name "*file*.jpg"

-maxdepth 指定搜索深度。应作为第一个参数出现。

find ./ -maxdepth 1 -name "*file*.jpg"

-size 按文件大小搜索. 单位：k、M、G

find /home/itcast -size +20M -size -50M

-atime、mtime、ctime 天 amin、mmin、cmin 分钟。

-exec：将find搜索的结果集执行某一指定命令。

find /usr/ -name '*tmp*' -exec ls -ld {} \;

-ok: 以交互式的方式将find搜索的结果集执行某一指定命令

-xargs：将find搜索的结果集执行某一指定命令。当结果集数量过大时，可以分片映射。

find /usr/ -name '*tmp*' | xargs ls -ld

-print0：
find /usr/ -name '*tmp*' -print0 | xargs -0 ls -ld

grep命令：找文件内容

grep -r 'copy' ./ -n

-n参数：:显示行号

ps aux | grep 'cupsd' -- 检索进程结果集。

软件安装：

1. 联网

2. 更新软件资源列表到本地。 sudo apt-get update

3. 安装 sudo apt-get install 软件名

4. 卸载 sudo apt-get remove 软件名

5. 使用软件包（.deb）安装： sudo dpkg -i 安装包名。

tar压缩：

1. tar -zcvf 要生成的压缩包名压缩材料。

tar zcvf test.tar.gz file1 dir2 使用 gzip方式压缩。

tar jcvf test.tar.gz file1 dir2 使用 bzip2方式压缩。

tar解压：

将压缩命令中的 c --> x

tar zxvf test.tar.gz 使用 gzip方式解压缩。

tar jxvf test.tar.gz 使用 bzip2方式解压缩。

rar压缩：

rar a -r 压缩包名（带.rar后缀）压缩材料。

rar a -r testrar.rar stdio.h test2.mp3

rar解压：

unrar x 压缩包名（带.rar后缀）

zip压缩：

zip -r 压缩包名（带.zip后缀）压缩材料。

zip -r testzip.zip dir stdio.h test2.mp3

zip解压：

unzip 压缩包名（带.zip后缀）

unzip testzip.zip

二.vim基础知识

显示行数:

set nu(末行模式)

跳转到指定行：

1. 88G （命令模式）

2. :88 (末行模式)

跳转文件首：

gg （命令模式）

跳转文件尾：

G（命令模式）

自动格式化程序：

gg=G（命令模式）

大括号对应：

% （命令模式）

光标移至行首：

0 （命令模式）执行结束，工作模式不变。

光标移至行尾：

$ （命令模式）执行结束，工作模式不变。

删除单个字符：

x （命令模式）执行结束，工作模式不变。

替换单个字符：

将待替换的字符用光标选中， r （命令模式），再按欲替换的字符

删除一个单词：

dw（命令模式）光标置于单词的首字母进行操作。

删除光标至行尾：

D 或者 d$（命令模式）

删除光标至行首：

d0 （命令模式）

删除指定区域：

按 V （命令模式）切换为 “可视模式”，使用 hjkl挪移光标来选中待删除区域。按 d 删除该区域数据。

删除指定1行：

在光标所在行，按 dd （命令模式）

删除指定N行：

在光标所待删除首行，按 Ndd （命令模式）

复制一行：

粘贴：
p：向后、P：向前。

查找：
1. 找设想内容：

命令模式下，按 “/” 输入欲搜索关键字，回车。使用 n 检索下一个。

2. 找看到的内容：

命令模式下，将光标置于单词任意一个字符上，按 “*”/ “#”

单行替换：

将光标置于待替换行上，进入末行模式，输入 :s /原数据/新数据

通篇替换：

末行模式， :%s /原数据/新数据/g g:不加，只替换每行首个。 sed

指定行的替换：

末行模式， :起始行号，终止行号s /原数据/新数据/g g:不加，只替换每行首个。

:29,35s /printf/println/g

撤销、反撤销：

u、ctrl+r（命令模式）

分屏：
sp：横屏分。 Ctrl+ww 切换。

vsp：竖屏分。Ctrl+ww 切换。

跳转至 man 手册：

将光标置于待查看函数单词上，使用 K（命令模式）跳转。指定卷， nK

查看宏定义：

将光标置于待查看宏定义单词上，使用 [d 查看定义语句。

在末行模式执行shell命令：

:!命令 :! ls -l

可能会用到fg指令

----------------------------------------------------------------

三.gcc gdb Makefile

gcc编译：

4步骤：预处理、编译、汇编、连接。

-I：指定头文件所在目录位置。

-c：只做预处理、编译、汇编。得到二进制文件！！！

-g：编译时添加调试语句。主要支持 gdb 调试。

-Wall：显示所有警告信息。

-D：向程序中“动态”注册宏定义。 #define NAME VALUE

库文件制作

静态库制作及使用步骤：

1. 将 .c 生成 .o 文件

gcc -c add.c -o add.o

2. 使用 ar 工具制作静态库

ar rcs lib库名.a add.o sub.o div.o

3. 编译静态库到可执行文件中：

gcc test.c lib库名.a -o a.out

头文件守卫：防止头文件被重复包含

#ifndef _HEAD_H_

#define _HEAD_H_

......

#endif

动态库制作及使用：

1. 将 .c 生成 .o 文件，（生成与位置无关的代码 -fPIC）

gcc -c add.c -o add.o -fPIC

2. 使用 gcc -shared 制作动态库

gcc -shared -o lib库名.so add.o sub.o div.o

3. 编译可执行程序时，指定所使用的动态库。 -l：指定库名(去掉lib前缀和.so后缀) -L：指定库路径。

gcc test.c -o a.out -lmymath -L./lib

4. 运行可以执行程序 ./a.out 出错！！！！ --- ldd a.out --> "not found"

error while loading shared libraries: libxxx.so: cannot open shared object file: No such file or directory

原因：
链接器：工作于链接阶段，工作时需要 -l 和 -L

动态链接器：工作于程序运行阶段，工作时需要提供动态库所在目录位置。

解决方式：

【1】通过环境变量： export LD_LIBRARY_PATH=动态库路径

./a.out 成功！！！（临时生效，终端重启环境变量失效）

【2】永久生效：写入终端配置文件。 .bashrc 建议使用绝对路径。

1) vi ~/.bashrc

2) 写入 export LD_LIBRARY_PATH=动态库路径保存

3）. .bashrc/ source .bashrc / 重启终端 ---> 让修改后的.bashrc生效

4）./a.out 成功！！！

【3】拷贝自定义动态库到 /lib (标准C库所在目录位置)

【4】配置文件法

1）sudo vi /etc/ld.so.conf

2) 写入动态库绝对路径保存

3）sudo ldconfig -v 使配置文件生效。

4）./a.out 成功！！！--- 使用 ldd a.out 查看

拓展:数据段合并

GDB调试

gdb调试工具：大前提：程序是你自己写的。 ---逻辑错误

基础指令：
-g：使用该参数编译可以执行文件，得到调试表。

gdb ./a.out

list： list 1 列出源码。根据源码指定行号设置断点。

b： b 20 在20行位置设置断点。

run/r: 运行程序

n/next: 下一条指令（会越过函数）

s/step: 下一条指令（会进入函数）

p/print：p i 查看变量的值。

continue：继续执行断点后续指令。

finish：结束当前函数调用。

quit：退出gdb当前调试。

其他指令：

run：使用run查找段错误出现位置。

set args：设置main函数命令行参数（在 start、run 之前）

run 字串1 字串2 ...: 设置main函数命令行参数

info b: 查看断点信息表

b 20 if i = 5：设置条件断点。

ptype：查看变量类型。

bt：列出当前程序正存活着的栈帧。

frame：根据栈帧编号，切换栈帧。

display：设置跟踪变量

undisplay：取消设置跟踪变量。使用跟踪变量的编号。

Makefile基础

makefile：管理项目。

命名：makefile Makefile --- make 命令

1 个规则：

目标：依赖条件
（一个tab缩进）命令

1. 目标的时间必须晚于依赖条件的时间，否则，更新目标

2. 依赖条件如果不存在，找寻新的规则去产生依赖条件。

ALL：指定 makefile 的终极目标。

2 个函数：

src = $(wildcard ./*.c): 匹配当前工作目录下的所有.c 文件。将文件名组成列表，赋值给变量 src。 src = add.c sub.c div1.c

obj = $(patsubst %.c, %.o, $(src)): 将参数3中，包含参数1的部分，替换为参数2。 obj = add.o sub.o div1.o

clean: (没有依赖)

-rm -rf $(obj) a.out “-”：作用是，删除不存在文件时，不报错。顺序执行结束。

3 个自动变量：

$@: 在规则的命令中，表示规则中的目标。

$^: 在规则的命令中，表示所有依赖条件。

$<: 在规则的命令中，表示第一个依赖条件。如果将该变量应用在模式规则中，它可将依赖条件列表中的依赖依次取出，套用模式规则。

模式规则：

%.o:%.c
gcc -c $< -o %@

静态模式规则：

$(obj):%.o:%.c
gcc -c $< -o %@

伪目标：

.PHONY: clean ALL

参数：
-n：模拟执行make、make clean 命令。

-f：指定文件执行 make 命令。 xxxx.mk

hello.c是主函数, 其余时加减乘除四个文件.

makefile的进化之旅

ALL:a.out

a.out:hello.o add.o sub.o div1.o #mul.o
	gcc hello.o add.o sub.o div1.o -o a.out

add.o:add.c
	gcc -c add.c -o add.o
sub.o:sub.c
	gcc -c sub.c -o sub.o
hello.o:hello.c
	gcc -c hello.c -o hello.o
div1.o:div1.c
	gcc -c div1.c -o div1.o

#mul.o:mul.c
#    gcc -c mul.c -o mul.o




src = $(wildcard *.c) 	# add.c sub.c div1.c hello.c
obj = $(patsubst %.c, %.o, $(src))	# add.o sub.o div1.o hello.o

ALL:a.out

a.out: $(obj)
	gcc $(obj) -o a.out

add.o:add.c
	gcc -c add.c -o add.o
sub.o:sub.c
	gcc -c sub.c -o sub.o
hello.o:hello.c
	gcc -c hello.c -o hello.o
div1.o:div1.c
	gcc -c div1.c -o div1.o




src = $(wildcard *.c) 	# add.c sub.c div1.c hello.c
obj = $(patsubst %.c, %.o, $(src))	# add.o sub.o div1.o hello.o

ALL:a.out

a.out: $(obj)
	gcc $(obj) -o a.out

add.o:add.c
	gcc -c add.c -o add.o
sub.o:sub.c
	gcc -c sub.c -o sub.o
hello.o:hello.c
	gcc -c hello.c -o hello.o
div1.o:div1.c
	gcc -c div1.c -o div1.o

clean:
	-rm -rf $(obj) a.out #"-"出错依然执行




src = $(wildcard *.c) 	# add.c sub.c div1.c hello.c
obj = $(patsubst %.c, %.o, $(src))	# add.o sub.o div1.o hello.o

ALL:a.out

a.out: $(obj)
	gcc $^ -o $@

add.o:add.c
	gcc -c $< -o $@
sub.o:sub.c
	gcc -c $< -o $@
hello.o:hello.c
	gcc -c $< -o $@
div1.o:div1.c
	gcc -c $< -o $@

clean:
	-rm -rf $(obj) a.out




src = $(wildcard *.c) 	# add.c sub.c div1.c hello.c
obj = $(patsubst %.c, %.o, $(src))	# add.o sub.o div1.o hello.o

ALL:a.out

a.out: $(obj)
	gcc $^ -o $@

%.o:%.c
	gcc -c $< -o $@

clean:
	-rm -rf $(obj) a.out




src = $(wildcard ./src/*.c)  # ./src/add.c ./src/sub.c ...
obj = $(patsubst ./src/%.c, ./obj/%.o, $(src))  # ./obj/add.o ./obj/sub.o ...

inc_path=./inc

myArgs= -Wall -g 


ALL:a.out

a.out: $(obj)
	gcc $^ -o $@ $(myArgs) 

$(obj):./obj/%.o:./src/%.c
	gcc -c $< -o $@ $(myArgs) -I $(inc_path)  

clean:
	-rm -rf $(obj) a.out

.PHONY: clean ALL

作业：编写一个 makefile 可以将其所在目录下的所有独立 .c 文件编译生成同名可执行文件。

四.基本IO

open函数：

int open(char *pathname, int flags) #include <unistd.h>

参数：
pathname: 欲打开的文件路径名

flags：文件打开方式： #include <fcntl.h> file control

返回值：
成功：打开文件所得到对应的文件描述符（整数）

失败： -1，设置errno

int open(char *pathname, int flags， mode_t mode) 123 775

参数：
pathname: 欲打开的文件路径名

mode: 参数3使用的前提，参2指定了 O_CREAT。取值8进制数，用来描述文件的访问权限。 rwx 0664

创建文件最终权限 = mode & ~umask

返回值：
成功：打开文件所得到对应的文件描述符（整数）

失败： -1，设置errno

close函数：

int close(int fd);

错误处理函数：与 errno 相关。

printf("xxx error: %d\n", errno);

char *strerror(int errnum);

printf("xxx error: %s\n", strerror(errno));

void perror(const char *s);

perror("open error");

read函数：

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

参数：
fd：文件描述符

buf：存数据的缓冲区

count：缓冲区大小

返回值：

0：读到文件末尾。

成功； > 0 读到的字节数。

失败： -1，设置 errno

-1：并且 errno = EAGIN 或 EWOULDBLOCK, 说明不是read失败，而是read在以非阻塞方式读一个设备文件（网络文件），并且文件无数据。

write函数：

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

参数：
fd：文件描述符

buf：待写出数据的缓冲区

count：数据大小

返回值：

成功；写入的字节数。

失败： -1，设置 errno

cp命令实现

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

int main(int argc, char *argv[])
{
    char buf[1024];
    int n  = 0;

    int fd1 = open(argv[1], O_RDONLY);  // read
    if (fd1 == -1) {
        perror("open argv1 error");
        exit(1);
    }

    int fd2 = open(argv[2], O_RDWR|O_CREAT|O_TRUNC, 0664);
    if (fd2 == -1) {
        perror("open argv2 error");
        exit(1);
    }

    while ((n = read(fd1, buf, 1024)) != 0) {
        if (n < 0) {
            perror("read error");
            break;
        }
        write(fd2, buf, n);
    }

    close(fd1);
    close(fd2);

    return 0;
}