Linux c高级

2021/8/29 7:06:57

本文主要是介绍Linux c高级,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

目录
  • 一、Linux
    • 1.1、嵌入式
    • 1.2、什么是Linux
    • 1.3、Linux发行版
    • 1.4、Linux体系结构
    • 1.5、虚拟4G内存
    • 1.6、shell 命令
    • 1.7、软件包的管理
    • 1.8、图形界面配置配网
    • 1.9、文件的压缩和归档
    • 1.10、文件相关的内容
    • 1.11、find
    • 1.12、cut
    • 1.13、修改文件的权限、用户、组。
    • 1.14、软链接与硬链接
    • 1.15、通配符
    • 1.16、进程
    • 1.17、man 查询函数、库函数、命令的用法
    • 1.18、用户管理
    • 1.19、磁盘相关的命令
    • 1.20、网络知识
    • 1.21、环境变量
  • 二、shell
    • 2.1、实质:shell命令的有序集合
    • 2.2、shell命令行解释器
    • 2.3、shell脚本
    • 2.4、shell脚本的变量
    • 2.5、shell 处理数组
    • 2.6、read 从终端上输入
    • 2.7、shell输入
    • 2.8、shell的运算
    • 2.9、if else
    • 2.10、循环: while [条件]
    • 2.11、函数
  • 三、c高级
    • 3.1、c语言的本质
    • 3.2、c语言中如何分配内存
    • 3.3、函数
    • 3.4、gcc、gdb
    • 3.5、存储类型
  • 四、makefile
    • 4.1、什么是Makefile
    • 4.2、什么是make
    • 4.3、体验Makefile
    • 4.4、Makefile的规则
    • 4.5、变量
  • 跳转:上一篇、Linux c基础!
  • 跳转:下一篇、数据结构与算法!

统一声明:
博客转载 声 明 : 本博客部分内容来源于网络、书籍、及各类手册。
        内容宗旨为方便查询、总结备份、开源分享。
        部分转载内容均有注明出处,如有侵权请联系博客告知并删除,谢谢!

百度云盘提取码:统一提取码: ziyu

一、Linux

1.1、嵌入式

嵌入式:计算机应用为中心、软硬件可裁剪的系统。

1.2、什么是Linux

  • Linux 多任务、分时 的一个操作系统
  • GNU GNU is Not Unix 它是一个组织;
  • GPL 是一种协议。

1.3、Linux发行版

  • Linux本身指的是一个操作系统内核,只有内核是无法使用的。
  • 我们系统使用操作系统一个包含内核和一批有用的应用集合,这就叫Linux发行版。
    Ubuntu、Redhat就是Linux的不同的发行版。
  • Red Hat 服务器
  • unbutu 桌面性能好 “人道主义”。
  • debian

1.4、Linux体系结构

--------------------------------------------	[0-3G]	0XC000 0000
应用层
	app程序、shell命令、shell脚本、程序
				|					|
				|					|
				|					|
内核层---------------------------系统调用---		[3-4G]	0xffff ffff(代表4G) 1 0000 0000
	文件管理
	内存管理
	进程管理	-->	程序的一次执行过程
	硬件管理
	网络管理
--------------------------------------------
硬件层
	LED LCD CAMERA	鼠标 键盘 

1.5、虚拟4G内存

请添加图片描述

-------------	4G
	内核
-------------	3G
	栈区		自动开辟自动释放
-------------
	堆区		手动malloc
-------------

静态区/数据区	全局/静态

-------------
 字符串常量
-------------
	代码段
-------------	0

1.6、shell 命令

whoami	我是谁
ls
	-a
	-l
	-r	递归查询
	-i 	inode 一个编号,一种节点
	-lh
pwd
cd
	cd dir_name
	cd 	路径 绝对路径 相对路径
	cd ~ 返回目录
	cd
	cd .
	cd ..
	cd - 返回上一步
mkdir 
	-p	递归创建	
rm mkdir dir_name	删除空目录
rm -r dir_name
touch file_name
rm file_name
cp 
	cp 路径 路径 复制文件
	cp -r
		-a	目录的复制
mv
	mv 路径 路径
exit	退出
echo	输出
su		切换用户
sudo 	权限
clear 	清屏	快捷键:Ctrl+L

1.7、软件包的管理

1.7.1、dpkg:(离线安装)

rxvt        _1%3a2.6.4-14               _i386      .deb
|            |  
|            |                            32
|            |       
软件名     主版本号   修订版本号        体系结构   后缀

软件包安装:
  sudo dpkg -i 软件包全称

卸载:
   sudo dpkg -r 软件名

清除软件包的配置文件:
  sudo dpkg -p 软件名

列举软件的相关信息的清单:
  sudo dpkg -L 软件名

查询版本号:
  sudo dpkg -l 软件名

查询软件安装包的状态:
  sudo dpkg -s 软件名

强制安装:
  sudo dpkg -f 软件名

虚拟机自定义伸缩窗口大小
  虚拟机 --> 首选项 --> 显示;

  更新 vmare tools
    点击 虚拟机---> 更新(重装) VMware tools
    跳转到一个界面,界面上有VMwareTools-10.3.10-13959562.tar.gz 这个压缩包,
    把这个安装包解压在家目录 tar -xvf VMwareTools-10.3.10-13959562.tar.gz (一直按enter键直到结束)
    结束后生成一个目录--vmware_tools_distrib, cd 进去这个目录,再执行 ./vmare_install.pl 这个可执行文件就可以了;

1.7.2、把windows的文件复制到Ubuntu中
(1)、拖拽的方式:
  直接把文件拖到终端,在前面加上 mv 移动到某一个路径(mv '/tmp/VMwareDnD/VUayTT/char_arr.c' ./my.c)
  或者在widows上,鼠标右键点击复制,再转到ubuntu上的终端上点击 右键---> paste filenames 也会有一个路径,同样
  在前面加上 mv 移动到当前; ( mv '/tmp/VMwareDnD/VUayTT/char_arr.c' ./)

(2)、创建共享文件夹
  虚拟机 -> 设置 -> 选项 -> 共享文件夹 -> 总是启用 ->选择一个windows中的一个文件夹作为共享文件夹
  终端访问: cd /mnt/hgfs/myshare

  共享文件夹设置失败解决问题:属性,设置兼容性;虚拟机关键。

1.8、图形界面配置配网

1.8.1、编辑 --> 网络编辑器 --> 更改设置 --> 桥接模式 -->选择对应网卡 -->

虚拟机 --> 设置 --> 桥接模式。
			
网络图标:	-->	edit conections --> 自动 / 静态
												ip:192.168.9.123
												子网掩码:255.255.255.0
												网关: 192.168.9.1

相关命令:	ifconfig   		查看当前ip地址
			ctrl+c     		结束当前进程
			ping + ip地址  	连接某个ip

1.8.2、apt 需要外网
软件源:
   /ect/apt/sources.list

下载的路径:
   /var/cache/apt/archives/

更新源:
   sudo apt-get update

下载一个软件:
   sudo apt install 软件名:

卸载:
   sudo apt-get remove 软件名

清空:
   sudo apt-get clean 软件名

下载源码:
   sudo apt-get source 软件名

1.9、文件的压缩和归档

1.9.1、压缩

针对的是文件
		实质:
			把文件里的tab/空格等压缩。
			压缩的时候,原文件就没有了,生成了压缩文件;
			解压的时候压缩文件也变成了原文件;
	
								速率	大小
.gz:							最慢	最小
	gzip  1.c  -->	1.c.gz		
.bz2:							次之	次之
	bzip2 1.c  -->	1.c.bgz2	
.xz								最快	最大
	xz 1.c 	   -->	1.c.xz	

1.9.2、解压

gunzip 1.c.gz 	-->	1.c
bunzip 1.c.bz2	-->	1.c
unxz 1.c.xz		-->	1.c

1.9.3、归档

归档:针对的是一个目录	“把一个目录变成一个文件”
归档的时候源文件依旧存在,生成一个新的归档文件。
释放的时候,压缩文件也存在。

tar	参数 归档的文件	目录
	c 	创建归档
	v 	显示过程
	f 	后面接文件
	x	释放后归档的文件还在
	
	z:	压缩成gzip
	j:	压缩成bzip2
	J:	压缩成xz
	eg:压缩
		tar -cvf test.tar test	-->	test.tar
		释放:
		tar -xvf test.tar -->	test

1.9.4、压缩的实质就是归档并压缩

压缩:
	tar -	vzcf day1.tar.tar.gz day1	-->		day1.tar.gz
解压:
	tar -	xzvf day1.tar.tar.gz 

万能解压:
	tar -xvf test.tar.*	(* 代表各种格式的压缩包)。

1.10、文件相关的内容

1.10.1、vi 三种模式
新建文件 vi toch
(1)、命令行模式

复制:nyy
粘贴:p
剪切:ndd
撤销:u
返向撤销:Ctrl + r

查找:
	/string  向下查找n	向上查找N
	/^string 查找以string开头的字符串
去光标移到到结尾:	G
光标移到到开头:	g
调整格式:gg=G

(2)、插入模式

a 	/	i 	/	b

(3)、底行模式

w
q
wq
q!
wq!
x
:num	去到某一行
srtnumer:设置行号
vsp 
替换:
	.当前
	$最后
	g所有
	%全文
	s/str1/sre2/g	替换
	
	范围:s/str1/sre2/g
	.,$ s/str1/sre2/g
	% s/str1/sre2/g
块复制:
	: 1,3 y 	--> 复制 1~3行

1.10.2、查看文件

cat head tail 	nore less(不要)
	cat	文件名		//查看文件
	cat	-n 文件名	//连同行号一起查看
	
	head -n 文件名	//查看前n行
	head -5	文件名	//查看前5行
	
	tail -n 文件名	//查看后n行
	tail -1	文件名	//查看最后1行

1.10.3、> 重定向

cat 1.c > 2.c	//把1.c里面的内容放到2.c里面,相当于复制
				
diff	比较一个文件一不一样,若没有输出内容,文件内容就一样;

>>	追加
	cat 1.c >> 2.c	//把1.c里面的内容追加到2.c

| 管道:把前面的结果作为后面的输入。
“|”是管道命令操作符,简称管道符。
	利用Linux所提供的管道符“|”将两个命令隔开,管道符左边命令的输出就会作为管道符右边命令的输入。
	连续使用管道意味着第一个命令的输出会作为 第二个命令的输入,第二个命令的输出又会作为第三个命令的输入,依此类推。
	
	练习:把一个文件的第5行输出到终端上。
		①
		head -5 /etc/passwd > 1.c 
		tail -l 1.c
		②
		head -5 /etc/passwd	| tail -l

1.10.4、grep 搜索

grep “string” 参数 文件 
	参数:
		-n	行号
		-R  递归搜索
		-i 	不区分大小写
		-w	精确查找,字符串前后如果有内容就查询不到;

grep "include" -n 4.linux_高阶进阶.c

1.11、find

find 路径 -name 文件名

1.12、cut

cut -d : -f 1,2 filename
	/etc/passwd
	
		farsight: x  :1000:1000:ubuntu,,,: /home/farsight: /bin/bash
			用户名   密码  uid  gid       描述   主目录
	练习:
		查一下当前用户
			用户名:UID:GID
				head -34 /etc/passwd | tail -1 | cut -d : -f 1,3,4
		查一下当前用户行号
			cat /etc/passwd | grep "farsight" -n | cut -d : -f 1

1.13、修改文件的权限、用户、组。

ls -l

	-rw-rw-r--    1    farsight farsight 18672  6月 15 08:48 4.linux_高阶进阶.c
		权限   链接数	用户		组
-:
	文件的类型	bcd-lsp
rw-:用户的权限	u
rw-:组的权限	g
r--:其他权限	o
所有权限:		ugo	或者   a
ls -l 列出属性
drwxr-xr-x
一个10个字符。第一个字符表示文件类型,后面9个字符表示文件权限。
rwx:r(可读)、w(可写)、x(可执行)。
第一组:表示文件属主权限。
第二组:表示属主所在的组用户的权限。
第三组:表示其他用户的权限。
r:4	w:2	x:1		最高权限:777
r	可读	4
w   可写    2
x   可执行  1
-	无权限	0
有了这个编码规则,则drwxr-xr-x	编码后为755
三个为一组:		   7  5  5

(1)修改权限:

第一种修改权限的方法		***
要把	drwxr--r--	则对应的编码为744
修改命令:chmod 744 文件名
第二种修改权限的方法:		
在原来的权限基础上修改,即增加或减少某权限。
三个组用户的编码依次为:属主u	属主所在的组g	其他用户o
如属主增加可执行权限	chmod u+x 文件名
其他用户增加可写权限	chmod o+w 文件名
属主所在组用户去掉可执行权限	chmod g+x 文件名

	chmod 777 2.c 赋最高权限
	ls -l 2.c 
	-rwxrwxrwx 1 farsight farsight 431  6月 16 09:24 2.c
	 chmod u-x 2.c 
	 ls -l 2.c 
	-rw-rwxrwx 1 farsight farsight 431  6月 16 09:24 2.c
	 chmod g-x 2.c
	 ls -l 2.c 
	-rw-rw-rwx 1 farsight farsight 431  6月 16 09:24 2.c
	 chmod o-w-x 2.c 
	 ls -l 2.c
	-rw-rw-r-- 1 farsight farsight 431  6月 16 09:24 2.c

(2)修改用户:

chown
	sudo chown 	用户名	文件	修改文件所属的用户
	sudo chown	用户名:组名	修改文件用户和组
chgrp
	sudo chgrp root 2.c			修改文件的组

1.14、软链接与硬链接

1.14.1、软链接:相当于windows的快捷方式

创建软连接文件:ln -s 源文件名 符号连接文件名
reg:ln -s src.c linker.c 	linker.c就是src.c的一个符号连接文件

ln -s 源文件 链接文件
	ln -s a.out app 
结论:
	(1)app 相当于a.out 的快捷方式;
	(2)app 是一个链接文件, a.out 是普通文件;
	(3)a.out 的链接数不变;
	(4)把源文件删除或者移动到其他路径,链接文件就不可以用了;
	(5) 用绝对路径创建软链接,把链接文件移动到其他路径是可以用的;
	eg:
		 ls -n  /home/farsight/210501/day1/day1/a.out  app

			ls -l app
			lrwxrwxrwx 1 farsight farsight 37  6月 16 14:05 app -> /home/farsight/210501/day1/day1/a.out
			

1.14.2、硬连接:对文件起别名

ln 源文件名 连接文件
硬连接实际上和源文件在硬盘中是同一个东西,效果类似于硬盘上的一个文件。

结论:
	(1)链接数变了
	(2)两个文件的iNode号是一样的
	(3)硬链接的文件可有移动1到其他路径下使用
	(4)硬链接文件是一个普通文件

1.15、通配符

* :	匹配所有字符
? :	匹配一个字符

[]:
	[字符1字符2]		匹配字符1和字符2中的任意一个字符,不能同时匹配两个字符;[1234] == [1,2,3,4]
		ls name[12].c
	[字符1 - 字符2]		匹配到从字符1 至 字符2 的所有字符
		ls name[A-F].c
			如果出问题,清除本地化设置
				export LC_ALL = C
				还原:
					unset LC_ALL

{}:touch name{1,2,3,4,5}.c		同时创建多个文件;

1.16、进程

程序的一次执行过程
ps
ps -aux
ps -aux | grep a.out 查询a.out这个进程
top 动态检测进程

kill 4797 //kill 进程号 --> 杀死一个进程

1.17、man 查询函数、库函数、命令的用法

man -a 		查询所有
man	1 ls	1.表示查询的是Linux命令
man	2 xx	2.表示查询的是Linux api	系统调用
man	3 xx	3.表示查询的是Linux库函数

1.18、用户管理

1.18.1、添加用户

adduser	用户名
	/etc/skel	模板文件
	/etc/passwd	用户信息
	/etc/group	组的信息

1.18.2、切换用户

su 用户名
	新用户用不了sudo
		解决:
			sudo su root				//进入root用户
			chmod u+w /etc/sudoers		//修改可执行权限
			sudo vi /etc/sudoers		//进入权限为普通用户修改
				添加:
					test ALL = (ALL:ALL) ALL	//添加普通用户
				chmod u-w /etc/sudoers	//把权限修改回来

1.18.3、删除用户

deluser 用户名

1.18.4、关机和重启

sudo shutdown -h now		立即关机
sudo shutdown -h 16:00		关机
init 0						关机
sudo shutdown -r now		立即重启
sudo reboot					重启

1.18.5、usermod

sudo usermod -aG farsight mytest  把mytest这个用户追加到farsight这个组里;
	用 id 用户名	可以看到效果:	id  mytest

sudo usermod -c hello mytest 把mytest这个用户的第五个描述修改为hello;

sudo usermod -d /home/farsight mytest  把mytest 这个用户的家目录改为 /home/farsiht 
 
sudo usermod -g farsight mytest 把mytest这个用户的组改为 farsight
	id mytest
	uid=1003(mytest) gid=1000(farsight) groups=1000(farsight)
sudo usermod -l test1 mytest 把mytest这个用户名改为test1
 
	注意:不要在用户登录的时候修改信息。若果还是报错,把当前终端退出, (exit)

1.18.6、修改密码

sudo passwd user1	为名为user的用户设置密码

1.19、磁盘相关的命令

1.19.1、查看磁盘的相关信息
sudo fdisk -l
  /dev/sda: 系统盘 --> Disk /dev/sda: 21.5 GB, 21474836480 bytes

1.19.2、查看磁盘分区信息
df -h

1.19.3、将U盘挂载在Ubuntu上: USB/2.0 3.0
虚拟机 -> 可移动设备 -> flush disk
在家目录创建:mkdir ~/udisk
挂载: sudo mount /dev/sdb1 ~/udisk
就可以进入到udisk中访问u盘:
取消挂载:
   sudo umout /dev/sda1 ~/udisk

1.20、网络知识

域名解析服务器:
8.8.8.8
114.114.114.114.114
自己的ip地址: 192.168.6.81

sudo vi /etc/network/interfaces 打开配置文件
		 auto lo
		 iface lo inet loopback
  
		 auto    eth0
		 iface   eth0    inet    dhcp  //两个字符串之间是tab键的距离

sudo /etc/init.d/networking restart  让配置文件生效

如果没有图标:
sudo vi /etc/NetworkManager/NetworkManager.conf 
	 
	  2 [main]
	  3 plugins=ifupdown,keyfile
	  4 dns=dnsmasq
	  5 
	  6 no-auto-default=00:0C:29:A4:5E:47,00:0C:29:85:E8:39,00:0C:29:02:7A:D6,
	  7 
	  8 [ifupdown]
	  9 managed=true  //把false 改成 true

1.21、环境变量

env		查看环境变量
查看单个环境变量:
	echo $PATH
		PATH	它是用来保存系统可执行程序路径的变量
					/usr/lib/lightdm/lightdm:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/home/farsight/OpenWrt-SDK-ar71xx-for-linux-i686-gcc-4.8-linaro_uClibc-0.9.33.2/staging_dir/toolchain-mips_34kc_gcc-4.8-linaro_uClibc-0.9.33.2/bin:/home/farsight/gcc-4.6.4/bin
	echo $HOME	主目录
	
	如何使得a.out可以直接使用:
		①只针对当前终端有效。
			export PATH=${PATH}:./
			export	导入环境变量
			PATH	环境变量
			=		赋值
			${PATH}	引用环境变量path 里的内容
			:		起到分割的作用
			./		把当前路径加上去
		②在当前用户下生效
			vi .bashrc	打开
			在最后的位置添加:
				//export PATH=${PATH}:./
				//export PATH=${PATH}:./home/farsight	在主目录下生效
		③在所有文件下省效
			PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/game    
			s:/home/farsight/OpenWrt-SDK-ar71xx-for-linux-i686-gcc-4.8-linaro_uClibc-0.9.33.2/staging_dir/
			toolchain-mips_34kc_gcc-4.8-linaro_uClibc-0.9.33.2/bin:/home/farsight"
			source	/etc/environment	//让过程更改的环境变量生效
			或者 sudo reboot	重启;

二、shell

2.1、实质:shell命令的有序集合

把shell脚本放在一个文件中,那么这个文件就是shell脚本

2.2、shell命令行解释器

sh
csh
ksh
bash --> ubuntu

2.3、shell脚本

2.3.1、后缀为.sh

eg:(1)在家目录创建一个目录 mydir
	(2)把 /etc/passwd 和 /etc/groff 复制到mydir
	(3)压缩并归档位mydir.tar.gz
eg:#!/bin/bash
	cd
	mkdir mydir
	cp /etc/passwd ./mydir
	cp -a /etc/groff ./mydir
	tar -cvzf mydir.tar.gz mydir

2.3.2、shell脚本为解释器语言,不需要编译

2.3.3、运行
(1)创建脚本 :vi demo.sh
在开头加上:#!/bin/bash

(2)修改权限:
chmod 777 demo.sh 修改为可执行的文件

(3)执行脚本

./demo.sh
bash demo.sh
source demo.sh
	三种运行方式的区别:
		(1)./执行的时候需要赋上可执行的权限,后两者可以直接执行;
		(2)./和bash在执行的时候会新开一个字终端,最后把结果直接返回给终端。
		(3)source 执行的时候在当前终端执行,一般用来让某个脚本生效;

2.4、shell脚本的变量

2.4.1、变量的定义
没有数据类型,不需要提前定义直接使用;
给变量赋值的时候等号左右不能有空格
每一行语句不需要加‘;’
变量名见名知意;
赋值给变量都默认为字符串;

2.4.2、变量的引用
$var
$(var)

2.4.3、在给吧变量赋值的时候可以加双引号和单引号,也可以不加:

单引号和双引号的区别:
	单引号和双引号内都可以加空格;
	单引号里面不能引用变量
给变量赋值的时候不需要加上 $ 
var=10
var=11; // 再次赋值

eg:#!/bin/bash
	a=22
	b="open book"
	c="$a open"

	echo $a
	echo $b
	echo $c
输出:
	22
	open book
	22 open

单行注释:	#
多行注释:	:<<EOF
				被注释的内容
			EOF
			或者
			:<<!
				被注释的内容
			!

2.4.4、删除变量:变量被删除后不能再次使用

unset var1		
eg:myur1="www.baidu.com"
	unset myur1
	echo $myur1
输出:
			//空格

2.4.5、命令置换

把命令赋值给了一个变量
var=`ls`
或者
var=$(ls)		//不输出不会执行
eg:
	var=`ls`
	var1=$(ls)
	echo $var
	echo $var1

2.4.6、位置变量

$0	$1	$2	$3...
$# 	$*	$@ 	$$

$0	用./ 和 bash执行 代表shell脚本文件名,用source执行代表bash
$1	shell脚本文件名后面第一个参数
$2	shell脚本文件后面第二个参数

$*	和	$@	表示shell文件名后面的所有参数,不包含文件名
$#	表示shell文件名后面所有的参数,不包含文件名
$$	表示进程号
练习:
	用一个变量1保存PATH, 变量2保存HOME, ----> 交换;
	var1=${PATH}
	var2=${HOME}
	echo var1: $var1
	echo var2: $var2
	var3=$var1
	var1=$var2
	var2=$var3
	echo var1: $var1
	echo var2: $var2

2.4.7、shell处理字符串
(1)、字符串的复制

str=hello
strl=$str
eg:#!/bin/bash
	str=hello
	str1=$str

	echo $str
	echo $str1
输出:	hello
		hello

(2)、字符串的连接

str=hello
str2="$str hello"
eg:#!/bin/bash
	str=hello
	str1=$str
	str2="$str1 hello"
	echo $str
	echo $str1
	echo $str2
输出:	hello
		hello
		hello hello

(3)、字符串的长度

string=“hdsjf”
echo $(#string)

(4)、字符串的提取

	strstr()      str1[] = "hello world"  str2[]= "world"
							 
① ${str:start:len}
		从左边的0开始数,数到start的位置,从这个位置输出len个字符;
		eg:str="www.baidu.com"
			echo ${str:3:4}
				结果:
					.bai
② ${str:start}
	从左边的0开始数,数到start的位置,从这个位置开始输出直到最后一个字符结束;
		eg:str="www.baidu.com"
			echo ${str:3}
			结果:
				.baidu.com
③ ${str:0-start:len}
	从右边的0开始数,数到start的位置,从这个位置的后一个字符开始输出len个字符;
		eg:str="www.baidu.com"
			echo ${str:0-4:3}
			结果:
				.co
④ ${str:0-start}
	从右边的0开始数,数到start的位置,从这个位置的后一个字符输出直到最后一个字符结束;
		eg:str="www.baidu.com"
			echo ${str:0-7}
				结果:
				idu.com

⑤ ${str#*sub} 从左边开始数,第一遇到 sub , 输出它后面的所有内容;		
		eg: str="www.baidu.com www.baidu.com www.baidu.com" 针对于:⑤-⑧
			echo ${str#*bai}
			结果:du.com www.baidu.com www.baidu.com

⑥ ${str##*sub} 从左边开始数,最后一次遇到 sub , 输出它后面的所有内容;
		eg:str="www.baidu.com www.baidu.com www.baidu.com"
			echo ${str##*bai}
			 结果
				du.com
⑦${str%sub*}  从右边开始数,第一次遇到 sub ,输出它前面的所有内容;
~                      			eg:str="www.baidu.com www.baidu.com www.baidu.com"
			echo ${str%bai*}
				结果:
					www.baidu.com www.baidu.com www.

⑧${str%%sub*}   从右边开始数, 最后一次遇到 sub ,输出它前面的所有内容;
		eg:str="www.baidu.com www.baidu.com www.baidu.com"	
			echo ${str%%bai*}
				结果:
					www.

2.5、shell 处理数组

数组定义:
arr=(1 2 3 4)依次对数组赋值;数组的下标也从0开始数的。
arr=([0]=aaa [2]=bbb) 对数组里面的部分元素
注意:没有被赋值到的地方就为空(不是零)。

2.5.1、数组的引用:数组的下标也是从0开始数的
${数组名字[下标]}

2.5.2、引用整个数组
${arr[*]} 或者 ${arr[@]}

2.5.3、求数组元素的长度
echo ${#arr1[0]} //arr1[0]整个数组的长度

2.5.4、求整个数组里面被赋值的元素的个数
echo ${#arr1[@]}

2.5.5、清空数组
unset arr[0] 清空这个元素
unset arr[*] 清空整个数组

2.5.6、arr=(${arr[*]} "how are you") 在数组后面添加内容
arr=("hello" ${arr[*]}) 在数组前加内容

eg:
	#!/bin/bash
	arr=(1 2 3 4)
	echo ${arr[0]}
	echo ${arr[2]}
	echo ${arr[*]}
	echo ${arr[@]}
	arr[2]=20;
	arr[5]=10
	echo ${arr[5]}
	echo ---------------
	arr1=([0]=hello [3]=56 [6]=bbb)
	echo arr1:${arr1[0]}
	echo arr3:${arr1[3]}
	echo arr6:${arr1[6]}
	echo arr2:${arr1[2]}

	echo ${#arr1[0]}
	echo ${#arr1[@]}

	unset arr1[0]
	echo ${arr1[0]}
	echo ................
	unset arr1[*]
	echo ${arr1[*]}
	
结果:	1
		3
		1 2 3 4
		1 2 3 4
		10
		---------------
		arr1:hello
		arr3:56
		arr6:bbb
		arr2:
		5
		3

		................

2.6、read 从终端上输入

read 变量

2.6.1、如果输入两个变量

用法:read var1 var2
	var1 和 var2 的复制通过第一个空格来分割,
		//空格前面的内容赋值给var1,后面的所有内容赋值给var2

单次输入
eg:#!/bin/bash
	echo "please enter a var ->:"
	read var
	echo var:$var

两次输入:			// 两次输入即可输入带空格的字符串;
	read var1
	read var2

2.6.2、read -p "提示" var //输入提示性的东西

2.6.3、read -a arr (数组名) //输入一个数组
read -p "请输入一个数组" -a arr // read -a arr
echo ${arr[*]}

2.6.4、read -n num var
read -n 5 var //输入5个字符以后直接退出

2.6.5、read -t 秒钟 var //在规定的时间内输入,超时自动退出

2.6.6、read -s var //输入的没有回显

eg:
		read -p "请输入用户名" var1
		read -p "请输入密码" -s var2 
		echo var1 = $var1
		echo var2 = $var2
			
结果:	请输入用户名farsight
		请输入密码 
		var1 = farsight
		var2 = 1

2.7、shell输入

echo $var
echo hello
echo "hello"
echo 'hello'
echo -n "hello world" 不换行

2.8、shell的运算

+	-	*	/	%		
>	<
++	--
**	幂运算
+=	-=	*=	/=
&&	||	!
>	<	==	=(shell也可以用来做等于)
&	|	~	^

2.8.1、(( ))
((表达式))
((表达式1,表达式2,表达式3)) 执行最后一个表达式的结果

取值:$((表达式))

(1)表达式里面取变量的时候可以加$,也可以不加;
(2)可以运算结果赋值给一个变量
	ret=$((表达式))
(3)可以支持自加或者自减运算
	((var1++))
	echo $var1
(4)运算的时候可以加空格
(5)$?	执行成功,返回上一次执行过程(上一次逻辑为真返回0,上一次逻辑为假返回1)
(6)支持整数运算,不支持字符串运用
eg:#/bin/bash
	var1=10
	var2=20
	var3=$((var1+var2))
	echo var1+var2 = $var3
	var3=$(($var1 + $var2))
	echo var1+var2 = $var3

	ret=$(($var1+$var2))
	echo ret = $ret

	((var1++))
	echo var1=$var1

	((mm=3**2))
	echo mm=$mm

	echo $((mm=3**2))

	#复杂运算
	echo $((var1 > var2))
	echo $((var1 < var2))
	echo $?	#返回上一次执行结果
	((var2 > var1))
	echo $?		#shell 逻辑为真返回0,为假返回1

输出:	var1+var2 = 30
		var1+var2 = 30
		ret = 30
		var1=11
		mm=9
		9
		0
		1
		0
		0

2.8.2、$ [ ]
ret=$[表达式]

ret=$[表达式1,表达式2,表达式3,......]

(1)需要把执行结果赋值给一个变量
(2)可以支持自加,自加的时候不能加$
(3)在运算的时候变量也可以加$,也可以不加
(4)如果有多个表达式则执行右边的结果
(5)支持整数运算,不支持字符串运用
eg:#/bin/bash
	var1=10
	var2=20

	ret=$[var1++]
	ret=$[$var1+$var2]
	echo $ret
	echo $var1

	ret=$[1,2,3,3+4]
	echo $ret

	ret=$var
	echo $ret
	ret=$[var+1]
	echo $ret

	ret=$[var * 3]
	echo $ret
	ret=$[var / 3]
	echo $ret
输出:	31
		11
		7

		1
		0
		0

2.8.3、expr

(1)支持整数运算并且支持字符串的相关操作
(2)expr	可以直接输出结果
(3)expr 的运算需要加空格
(4)expr 的运算,变量的引用需要加$
(5)expr 在赋值的时候需要命令置换
	①var=`expr $var1 + $var2`
	②var=$(expr $var1 + $var2)
(6)expr	不支持自加
(7)expr 不支持幂运算
(8)expr 识别不了*,需要加\字符
	\*
	\>
	\<
	\(\) 不加默认为数组
eg:#/bin/bash
	var1=10
	var2=20

	expr var1+var2
	expr $var1+$var2
	expr $var1 + $var2

	var=`expr $var1 + $var2`
	echo $var
	var=$(expr $var1 + $var2)
	echo $var

	expr $var1++ #不支持自加
	expr ++$var1
	expr $var1

	expr mm=3**2
	echo $mm

	ret=$(expr $mm=3**2)
	echo ret =	$ret
	
	expr $var1 \* $var2

输出:	var1+var2
		10+20
		30
		30
		30
		10++
		++10
		10
		mm=3**2
		ret = =3**2
		200

2.8.4、字符串操作
匹配字符串:
expr match $var "sub" //从开头匹配字符串,有多少个字符相同就返回多少的数

eg:str="hellowoed"
	#str="hell owoed"	#error	不能加空格
	expr match $str "hel"
	expr match $str he
	expr match $str "wor"
	expr match $str w
	expr length $str	#求字符串长度

输出:	3
		2
		0
		0
		9

2.9、if else

if [条件]
then
		shell语句1
else	
		shell语句2
fi

if [条件]
then
		shell语句1
elif [条件]
		shell语句2
then
		shell语句3
else
		shell语句4
fi
				
判断:
①[表达式]	-->		表达的前后必须加空格\[\]前后也要加空格;
②test 前后加空格

2.9.1、数字大小判断

-eg 	等于
-ne 	不等于
-gt 	大于
-ge 	大于等于
-lt 	小于
-le 	小于等于

2.9.2、逻辑的判断

&&	-->		-a
||	-->		-o
!	-->		!
练习:输入一个成绩, 
	[90-100] A
	[70-90) B
	[60-70) C
	[0-60] D
eg:#/bin/bash
	read -p "please enter a sore:>" num
	if test $num -gt 100 -o $num -lt 0
	then
		echo "error  ---> [0-100]"
		exit 1
	fi

	if test $num -ge 90 -a $num -le 100
	then
		echo A
	elif test $num -ge 70 -a $num -lt 90
	then
		echo B
	elif test $num -ge 60 -a $num -lt 70
	then
		echo C
	else
		echo D
	fi
		#bash if_score.sh
		#. if_score.sh # ./if_score.sh
		source if_score.sh	

exit num 
num == 1 非正常退出
num == 0  正常退出

shell文件中:再次调用脚本
	 #bash if_score.sh
	 #. if_score.sh # ./if_score.sh
	 source if_score.sh

2.9.3、字符串的判断
-n 判断字符串非空
-z 判断字符串为空
= 判断字符串相等
!= 判断字符串不等
> 比较字符串的大小
<

if test -n "$var1" -a -n "$var2"
1参数放前面
2变量的引用需要加" ",不然输入空的时候会报错。

练习:从终端输入两个字符串,判断是否为空,如果不为空则比较大小;
eg:#!/bin/bash
	read var1
	read var2

	if test -n $var1 -a -n $var2
	then
		if test $var1 \> $var2
		then
			echo "$var1 > $var2"
		else
			echo "$var1 < $var2"
		fi
	else
		echo "不空"
	fi

2.9.4、文件判断
bsp-lcd
-b 判断文件是否存在,并且判断是否为块设备文件
-s 判断文件是否存在,并且判断是否为套接字文件
-p 判断文件是否存在,并且判断是否为管道文件
-f 判断文件是否存在,并且判断是否为普通文件
-c 判断文件是否存在,并且判断是否为字符设备文件
-L 判断文件是否存在,并且判断是否为链接文件
-d 判断文件是否存在,并且判断是否为目录文件
-e 判断文件是否存在,
-s 判断文件是否存在,且判断文件是否为空,文件大小大于0,返回真值。

练习:输入一个文件名字。判断是普通文件还是目录文件
eg:#!/bin/bash
	file="/home/farsight/HuaQing_vision/qrs210501/2.linux_c高级/day4/"

	#read -p "请输入一个文件名:" file

	if [ -f $file ]
	then
		echo "普通文件"
	elif [ -d $file ]
	then
		echo "目录文件"
	else
		echo "文件不存在"
	fi

2.9.5、判断文件的权限

-w 	判断写权限
-r  判断有没有读权限
-x  判断有没有执行权限	

2.9.6、判断文件的时间戳
-nt 比较两个文件的时间戳更新
-ot 比较两个文件的时间戳更旧

练习:输入一个文件名,判断是否具有写权限,如果有,那么将helloworld写在这个文件里,如果没有添加权限再写进去;
eg:#!/bin/bash
read -p "请输入一个文件名" filename
if test -w $filename
then
	 echo "helloworld" > $filename
else
	echo "没有写权限"
	chmod u+w $filename
	echo "helloworld" > $filename
练习:输入两个文件名,判断时戳
eg:#!/bin/bash
	read -p "enter file1>:" file1
	read -p "enter file2>:" file2

	if test -e $file1 -a -e $file2
	then
		if test $file1 -nt $file2
		then
			cat $file1 > $file2
		else
			cat $file2 > $file1
		fi
	else
		echo "文件不存在"
	fi

2.9.7、case 表达式 in

参数1
	shell 语句1
	;;
参数2
	shell 语句2
	;;
参数3
	shell 语句3
	;;
参数4
	shell 语句4
	;;
esac
eg:echo '输入 1 到 4 之间的数字:'
	echo '你输入的数字为:'
	read aNum
	case $aNum in
		1)  echo '你选择了 1'
		;;
		2)  echo '你选择了 2'
		;;
		3)  echo '你选择了 3'
		;;
		4)  echo '你选择了 4'
		;;
		*)  echo '你没有输入 1 到 4 之间的数字'
		;;
	esac
*	-->	所有
练习:模拟一个软件的下载的过程
#!/bin/bash
read -p "enter num :" app
read -p "请选择命令[Y/N/Q]" cmd

case $cmd in
	Y|YES|yes|)
		echo "$app 正在下载....."
		;;
	N|NO|no|)
		echo "取消下载 $app....."
		;;
	Q|quit|q|)
		exit 0
esac

2.10、循环: while [条件]

		do
			语句
		done
		
无限循环:	while true
			do
				echo "***"
			done
练习:写一个加法计算器, 输入一个值就一直累加,输入 exit 退出;
eg:#!/bin/bash
		while read -p "请输入一个整数或者输入q 退出:" num
		do
			if test $num = q
			then
				exit 0
			else
				((sum+=$num))
				echo ret: $sum
			fi
		done
用法1:
	for((表达式1;表达式2;表达式3))
	do
			shell语句块
用法2:
	for var in 单词列表
	do
		shlle语句
	done
	
	单词列表:
		1)如果是散乱的列表,列表中用空格作为分割;
		2)顺序的列表: {start..end}
					eg:
						for var int {1..100}

2.11、函数

函数的一般形式:
function 函数名()
{

}

(1)shell函数没有形式参数,没有返回值(也可以有)
(2)函数中的变量为全局变量
(3)将命令执行的结果作为作为单词列表
(4)for var in `ls`
				1.function 代表这是一个函数
(5)使用local 修饰是局部变量
函数的调用:
函数名	
	函数名:argv[1]		argv[2]	...
	|
	|
	|
	$0			$1			$2
eg:#!/bin/bash
	function add(){
		sum=$((10+20))
	}
	add
	echo $sum
	
	function add1(){
		sum=$(($1+$2))
	}
	add1 50 60
	echo $sum

	function add2(){
		local sum=$(($1+$2))
		return $sum
	}
	add2 $1 $2
	echo $?

三、c高级

3.1、c语言的本质

操作虚拟的内存

3.2、c语言中如何分配内存

3.2.1、数据类型
(1)、基本数据类型

int float char short long double 

(2)、用户自定义的数据类型

数组: 在内存中连续开辟相同数据类型的空间
					
结构体:描述一个对象,对象具有很多的属性 

		关键字: struct
		
		结构体的数据类型 == 关键字+结构体名

		结构体指针 (01struct.c)
		结构体数组 (02struct_arr.c)

		字节对齐:32位系统下,4字节对齐, 会画图

共用体:类似于结构体

		关键字: union
		特性1:共用体中每个成员都共用同一个内存起始地址,共用体占用的内存等于最大的成员占用的内存
		特性2:如果对新的成员赋值,会把原来的成员的值覆盖掉

(3)、指针类型

(1)基本用法
	& : 取出变量的地址
	* : 取出地址的值
	
	05pointer.c

(2)特点 : 指针是有粗细的

(3)数组指针(行指针)	07shuzu_zhizhen.c	

(4)指针数组  08zhizhen_shuzu.c

(5)二级指针 09erji_pointer.c

(6)不定类型的指针 : void *
		
		pthread_create();

3.2.2、程序员手动开辟内存空间
malloc free

#include <stdio.h>
#include <stdlib.h>		//malloc包含头文件					 			 
int main(void)
{
	// 需要一个1000个int类型元素的数组
	
	// 第一步:申请和绑定
	int *p = (int *)malloc(1000*sizeof(int));
	
	// 第二步:检验分配是否成功
	if (NULL == p)
	{
		printf("malloc error.\n");
		return -1;
	}
	
	// 第三步:使用申请到的内存
	//p = NULL;
	//p = &a;		// 如果在free之前给p另外赋值,那么malloc申请的那段内存就丢失掉了
					// malloc后p和返回的内存相绑定,p是那段内存在当前进程的唯一联系人
					// 如果p没有free之前就丢了,那么这段内存就永远丢了。丢了的概念就是
					// 在操作系统的堆管理器中这段内存是当前进程拿着的,但是你也用不了
					// 所以你想申请新的内存来替换使用,这就叫程序“吃内存”,学名叫内存泄漏
	//申请后使用
	*(p+0) = 1;
	*(p+1) = 2;
	printf("*(p+0) = %d.\n", *(p+0));
	printf("*(p+1) = %d.\n", *(p+1));	
	
	*(p+222) = 133;
	*(p+223) = 222;	
	
	// 第四步:释放
	free(p);
	p = NULL;		//释放之后p指针就没有指向了;p=NULL,防止野指针
	
	printf("*(p+222) = %d.\n", *(p+222));
	printf("*(p+223) = %d.\n", *(p+223));

	return 0;
}

3.3、函数

3.3.1、函数形式
返回值 函数名(参数)
{

}

3.3.2、函数传参
值传递
地址传递

3.3.3、函数封装
main.c : 主函数, 函数调用
fun.c : 各种方法
fun.h : 函数声明、结构体

3.3.4、指针函数:返回值是一个地址的函数

3.3.5、函数指针:本质是一个指针,指向一个函数
vi指定复制:shift+鼠标选择

3.3.6、函数指针数组:本质上是一个数组,保存的是一个函数指针。

3.3.7、递归函数:自己调用自己。注意必须有终止条件。

3.3.8、回调函数:点餐, 服务员, 厨师
回调函数模型请添加图片描述

3.4、gcc、gdb

3.4.1、使用gcc对代码进行编译

  • 1>预处理
    gcc -E 1.c -o 1.i 预处理:用于将所有头文件以及宏定义替换成其真正的内容,预处理之后得到的仍然是文本文件,但文件体积会大很多。

  • 2>编译
    gcc -S 1.c -o 1.s 生成汇编语言源代码文件

  • 3>汇编
    gcc -c 1.c -o 1.o 将上一步的汇编代码转换成机器码,二进制格式

  • 4>链接
    gcc 1.c 生成可执行文件,将多个目标文件以及所需要的库文件(.so等)链接成最终的可执行文件

3.4.1、使用gdb对代码进行调试
编译的时候需要添加一个-g的参数
gcc 08malloc.c -g

使用gdb运行程序
gdb a.out

获取帮助信息:
(gdb)help

查看代码
l 默认显示的是前10行

l 可以向下查看下面的10行
l - 向前显示10行

添加断点
b 行号

如何查看断点
info b

删除断点
delete 断点号

运行代码:
r 运行代码,在断点的位置会停掉

查看数据
p 变量
watch 变量

单步运行
n 单步运行,当遇到函数时不会显示函数执行过程
s 单步运行,当遇到函数时显示函数执行过程

继续运行
c 没有错误就继续向下运行,在断点的位置会停掉

退出调试:
q 退出

3.5、存储类型

存储类型(6种) auto static register extern volatile const

3.5.1、auto: 在定义变量的时候,默认存储类型为auto。
全局变量和局部变量:

#include <stdio.h>

int x=10;
void func(void)
{
	printf("x = %d\n",x);
}

int main(int argc, const char *argv[])
{
	auto int x=5; //作用域 花括号
	printf("x = %d\n",x);  //5

	{
		auto int x=7;//作用域 花括号
		printf("x = %d\n",x); //7
	}	

	printf("x = %d\n",x); //5
	
	func(); //10

	return 0;
}

3.5.2、extern :可以用来声明变量或者函数是在其他文件中

#include <stdio.h>
extern int a, b;
extern int fun(int , int );	

int main()
{
	printf("a = %d\n", a);
	printf("b = %d\n", b);
	printf("a+b = %d\n", fun(a,b));
}

#include <stdio.h>
int a = 12, b = 13;

#include <stdio.h>
int fun(int a, int b)
{
	return a+b;
}

3.5.3、static
(1)、延长变量的生命周期

#include <stdio.h>
				
void func(void)
{
	static int a=1;
	static int b;
	//如果a没有被static修饰,默认a在栈上存放,当函数被调用的使用分配栈空间,当函数调用完,栈就会被释放了。所有这里打印的a的值都是2;
	
	//如果加上了static修饰,并且static修饰的变量被赋值了,static修饰的变量在静态区种的.data存放着,在函数执行结束的时候,data段不会被释放,所以打印的结果是2 3 4
		
	//static修饰的变量如果没有被初始化,变量在.bss段存放着
		
	a++;
	printf("b = %d\n",b);
	printf("a = %d\n",a);
}

int main(int argc, const char *argv[])
{
	func();
	func();
	func();
	return 0;
}

(2)、限定作用域(对象可以是函数,也可以是变量)
static修饰的变量或者函数只能在当前文件中使用

3.5.4、const :只读的变量
const int a=10;
a=100; //错误的,const修饰的变量不允许修改

(1)、const修饰局部变量 --> 可以改变值 栈区

(2)、const修饰全局变量 --> 不能改变值 只读区

#include <stdio.h>

const int b=500; //只读区

int main(int argc, const char *argv[])
{
	const int a=10; //栈
	//a=100;  //错误的,const修饰的变量不允许修改
	
	int *p=(int *)&a;
	*p=100;

	printf("*p = %d,a = %d\n",*p,a);
	
	p=(int *)&b;
	*p=123;
	printf("*p = %d,b = %d\n",*p,b);

	return 0;
}	

(3)、const修饰指针

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int a=100;
	int b=234;

//第一种	
	const int *p=&a;
	*p=50;  //p指向的地址中的内容不能修改
	p=&b;   //p指向的地址可以修改

//第二种
	int const *p=&a;
	*p=50;	//p指向的地址中的内容不能修改
	p=&b;	//p指向的地址可以修改

//第三种
	int *const p=&a;
	*p=50;	//p指向的地址中的内容可以修改
	p=&b;	//p指向的地址不能修改

//第四种
	const int *const p=&a;
	*p=50;	//p指向的地址中的内容不能修改
	p=&b;	//p指向的地址不能修改

	return 0;
}

3.5.5、register :(寄存器)
register int a;

定义的register类型的变量要比不加register的时候执行的速率要快。
问题1:寄存器类型的变量执行的速率快,能不能把所有的变量都定义成寄存器类型的变量?
答案:不能,在芯片内部寄存器是有个数限制的,比如在A53硬件平台上只有40个寄存器。

问题2:在定义变量的时候const和volatile能不能同时使用?
答案:可以的,只读的状态寄存器

3.5.6、volatile:(易变的)
volatile int a;

(1)、编译器优化 -O3
volatile int *a=&b; //防止编译器对代码进行优化
*a = 110;
*a = 120;

(2)、防止cpu值取数据从缓存(cache register)中取
volatile修饰的变量每次都从内存中取出

(3)、在开发过程中需要定义变量的时候需要加volatile
   1.在定义硬件地址的时候。(比如:状态寄存器)
   2.在中断处理函数中访问的非自动变量时,需要添加volatile
   3.多个线程访问的同一个变量

例如:向0x80000000地址中写入0x12345678值

   volatile unsigned int *p=(volatile unsigned int *)0x80000000

   *p=0x12345678;

四、makefile

4.1、什么是Makefile

一个文件,对项目进行管理
Makefile可以体现你是否具备大型项目的开发能力

4.2、什么是make

是一个工程管理器,管理较多的文件
是一个可执行程序,通过读取Makefile内容,调用编译器进行编译工作
(本质工作还是GCC在做)

根据文件时间戳来编译文件(文件更新时间)
只编译修改后的文件,而不用全部编译,节省时间。
Makefile是make读入的唯一配置工具

4.3、体验Makefile

all:  //---标签
	gcc -E test.c  -o test.i 
	gcc test.c -Wall -o test  //--要做的事情,前面是一个tab键!
clean:  //---标签
	rm test.i test
	
	1.make默认执行all标签下内容
	2.make clean 会执行clean标签后的内容,删除文件
	
	
all: //---标签
	gcc -E test.c  -o test.i 
	gcc test.c -Wall -o test  
.PHONY:		//伪指令
clean:
	rm test.i test
伪目标:不生成目标文件的目标为伪目标
.PHONY:	的作用是将clean文件属性屏蔽掉,只单纯的任务就是一个伪目标

4.4、Makefile的规则

目标:依赖文件
   操作

out:main.o fun1.o fun2.o
	gcc main.o fun1.o fun2.o -o out
main.o:main.c
	gcc -c main.c -o main.o
fun1.o:fun1.c
	gcc -c fun1.c -o fun1.o	
fun2.o:fun2.c
	gcc -c fun2.c -o fun2.o

4.5、变量

节省繁复的操作,方便替换
类似shell脚本中的变量
CC=gcc
$(CC)

CC=arm-linux-gcc 

out:main.o fun1.o fun2.o
	$(CC) main.o fun1.o fun2.o -o out
main.o:main.c
	$(CC) -c main.c -o main.o
fun1.o:fun1.c
	$(CC) -c fun1.c -o fun1.o	
fun2.o:fun2.c
	$(CC) -c fun2.c -o fun2.o
	
	CC		默认值gcc CC = arm-linux-gcc
	RM		默认值为rm 删除命令
	CFLAGS  编译器的参数选项
	LDFLAGS	编译器链接文件及路径
	APP     文件最后生成的可执行程序a.out
	SRCS	所有的.c文件
	OBJS	依赖文件
	
	eg:
#编译时的编译选项
CFLAGS = -Wall -o2 -g -std=gnu99 -pthread -I./include -DMYDBG
LDFLAGS = -L./lib/x86/ -lcam -L./lib/x86/ -lserial -L./lib/x86/ -ltcp -ljpeg -lpthread 

#用户自定义变量,保存 可执行程序的名字
APP = server

#自定义变量,用来保存某个目录下的所有 C文件 
SRCS	 = $(wildcard ./src/*.c)

#自定义变量,将某个变量中的所有C文件,替换成 .o 文件
OBJS	 = $(patsubst %.c, %.o,$(SRCS))

CC = gcc
#CC = arm-linux-gcc
all: $(APP)

$(APP): $(OBJS)
	$(CC) -o $(APP) $^ $(LDFLAGS)
	$(RM) $(OBJS)
	
clean:
	$(RM) $(OBJS) $(APP)

更多详情makefile 可参考文档 跟我一起学makefile 百度云下载链接:https://pan.baidu.com/s/1McHYZuCSGjpOK19UOqLQeQ

跳转:上一篇、Linux c基础!

待更新。。。

跳转:下一篇、数据结构与算法!

跳转:下一篇、数据结构与算法!

跳转:开头



这篇关于Linux c高级的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程