十三天学会C语言笔记
day1
Linux C基础课程~
【1】操作系统的介绍
内核：linux unix
操作系统：ubuntu redhat centos deepin
linux内核的功能：文件管理内存管理设备管理进程管理网络管理ubuntu:是一个以桌面应用为主的Linux操作系统。
Ubuntu基于Debian发行版和GNOME桌面环境，与
Debian的不同在于它每6个月会发布一个新版本。
Ubuntu的目标在于为一般用户提供一个最新的、同
时又相当稳定的主要由自由软件构建而成的操作系
统。Ubuntu具有庞大的社区力量，用户可以方便地
从社区获得帮助
【2】Linux文件系统的结构
操作系统中通过什么方式组织和管理文件：文件系统
windows的文件系统将一块硬盘分为
C D E F盘，然后在各个盘中保存用户
的数据或者文件。linux文件系统是一颗倒置的树，它分为根目录和
子目录。在根目录下有一些特定功能的目录。比如
/bin /etc /home /lib等，如果你在外接一个U盘
也是通过目录的形式来访问。linux文件系统中的各个目录的功能不是用户随意指定的
它是根据FHS(Filesystem Hierarchy Standard)标准规定
各个目录下存放的内核及功能/bin 可基本用户命令二进制文件
/boot 和系统驱动相关的文件
/dev 设备文件（通过此文件访问设备驱动）
/etc 系统配置文件
/home/linux 用户家目录
/lib 可执行程序需要连接的库文件
/sbin 系统二机制文件
/mnt/hgfs/share 共享目录
......
【3】linux系统常用命令
终端的打开方式
1、点击
2、ctrl+alt+t
3、打开一个终端后再打开一个新的终端
ctrl+shift+n
关闭终端：exit
终端字体的调整
放大：ctrl+shift+"+"
缩小：ctrl+"-"linux @ ubuntu : ~ $ | | | | | |
用户名 间隔 主机名 间隔 用户的家目录 用户的类型
whoami hostname /home/linux/$:普通用户
#:超级用户
【2】linux系统常用的命令
linux系统是多用户多任务分时操作系统
$:普通用户 linux
#:超级用户 root
linux -----> su root ----> rootsu root 切换到root用户
su linux 切换到linux用户
sudo -i 同样可以切换到root用户sudo passwd root 设置root用户的密码sudo :让本次操作具备root权限
su :切换用户[1]ls命令ls 显示当前目录下的文件或者目录ls -l 显示文件或者目录的属性信息ls -a 显示所有文件包含隐藏文件（以.开头的文件就是隐藏文件）ls -lh h按照文件大小单位来显示ls -i 显示文件的inode号ls -R 递归显示文件d rwx rwx r-x
| | | |
文件的类型 用户的权限 组的权限 其它用户的权限
5 linux linux 4096 Jul 15 2016 arch| | | | | |
链接数 用户名 组 大小 时间 文件名、目录文件的类型(7种)：bsp-lcd
-：普通文件，二进制文件
d: 目录
l: 链接文件（类似于windows快捷方式）
c: 字符设备驱动文件类型
b: 块设备驱动文件类型
p: 管道文件（进程间通讯）
s: 套接字文件文件的权限：r 4 w 2 x 1 - 0读 写 可执行 没权限0664 ：前面的0代表八进制0775链接数：文件：链接个数目录：子目录的个数[2]cd命令cd：切换目录的命令cd 要进入的目录cd .. 或cd ../ 退到上一级目录下cd -cd ~ 或者cdcd /
day2 cd - 进入到上一次操作的目录下cd ~ 或 cd 回到linux用户的家目录 /home/linuxcd / 进入根目录在/home/linux目录下进入etc目录的方法cd /etccd ../../etccd 绝对路径（从根目录开始访问）cd 相对路径（通过目录间的位置关系访问）【1】pwd命令查看当前位置【2】clear命令clear 清屏命令ctrl+l【3】touch命令（创建文件）如果文件不存在，创建文件touch 文件名touch 1.ctouch 2.c 3.c 4.txt如果文件存在，更新文件的时间戳，不会改变文件的内容。touch 1.c【4】mkdir命令（创建目录）mkdir hello :在当前目录下创建一个hello的目录mkdir 目录1 目录2 ...可以同时创建多个目录，这些创建的目录是在同一级的。mkdir -p 1/2/3 创建具备层级关系的1 2 3这些目录mkdir -m 0664 test2 创建目录，目录的权限是0664mkdir -m 0777 test3 创建0777权限的目录，目录的背景色会换成绿色【5】删除目录rmdir :只能用来删除空目录【6】rm命令删除文件rm 1.txt 删除1.txt文件rm *.c 删除所有的.c文件删除目录rm 1 -r 删除1目录 （-r递归删除）rm test -rf (-f强制删除)rm test* -rf 删除所有已test开头的文件rm * -rf 删除所有的当前目录下的文件sudo rm * -rf 删除所有的当前目录下的文件作业：1.复习课上指令2.删除除1.c之外所有文件和目录linux@ubuntu:~/DC20021$ ls1.c 1.txt 2.c 3.c hello testrm !(1.c) -rf
【1】cp命令（拷贝）
拷贝文件
cp 源文件的路径/名字 目标路径
cp /home/linux/test.c /etc
拷贝/home/linux目录下的test.c到/etc目录下
拷贝目录
cp 路径/原目录 目标路径 -r (递归拷贝)
cp 路径/原目录 目标路径 -a (递归拷贝)拷贝的同时进行重命名
cp /home/linux/test.c ~/hello.c
cp ~/DC20021 ~/tools/123 -r拷贝的同时进行重命名练习：1.将/etc下的passwd文件拷贝到家目录DC20021目录下cdmkdir DC20021cp /etc/passwd ~/DC20021/2.将etc下的groff拷贝到DC20021目录下cp /etc/groff/ ./ -r3.将etc下的passwd文件拷贝到家目录DC20021目录下test.ccp /etc/passwd ./DC20021/test.c4.将etc下的groff拷贝到DC20021目录下hellocp /etc/groff/ ./hello -r
【2】mv命令
移动(目标路径存在)
mv 源文件 目标路径
mv 源目录 目标路径
mv test.c DC20021 //将test.c移动到DC20021目录下
mv test DC20021 //将test目录移动到DC20021目录下重命名(目标路径不存在)
mv 源文件名字 目标文件名字
mv test.c hello.c
mv test hello
day3Linux C基础课程第三天
【2】windows和ubuntu文件互传
1.共享目录
虚拟机->设置->选项->共享文件夹->总是启用
选择windows上的一个目录即可D:\share
windows D:\share
ubuntu /mnt/hgfs/share
2.直接拖vm tools3.借助服务器samba windows ubuntuwinSCP <----> sudo apt-get install ssh
【3】命令
echo 打印命令
echo “1231123”—>在终端上显示
echo 12312312 > 123.c 将12312312放到123.c的文件中
echo 12312312 >> 123.c 将12312312追加123.c的文件中
> :重定向 （清空文件后将echo后面的内容写到文件中）
>>:追加cat 查看
cat 123.c 将123.c文件中的内容显示到终端上
【4】linux系统中文件编辑器的使用
vi/vim编辑器
打开文件touch 文件名vi 文件名 / vim 文件名
使用命令行模式：1.打开文件的时候，默认处在命令行模式2.从插入模式进入到命令行模式的Esc插入模式：1.从命令行进入插入模式，按下键盘的i底行模式1.从命令行模式进入底行模式 shift + ::w 保存:q 退出:q! 不保存退出:wq 或者 x 保存退出:wq! 强制保存退出
【2】vim编辑器
vi test.c
命令行：按下键盘Esc键拷贝yy 拷贝光标所在的行3yy 拷贝光标所在的向下三行nyy 拷贝光标所在向下的n行yG 拷贝光标所在向下到尾行鼠标选中想要拷贝的行，按下键盘的y剪切dd 剪切光标所在的行4dd 剪切贯标所在的向下4行ndd 剪切贯标所在的向下n行鼠标选中想要剪切的行，按下键盘的d粘贴p 撤销u （反向撤销ctrl+r）文件收尾快速跳转调到首行gg跳转到尾行G(shift+g)让单词高亮显示 /你想高亮的单词/^main 以main开头/main$ 以main结尾/^main$ 以main开头并main结尾n :跳到下一个单词N :跳到上一个单词代码对齐的功能：gg=G 对齐本文件鼠标选中想要对齐的行，按下键盘的=（对齐选中的行）删除：ndd鼠标选中想要剪切的行，按下键盘的ddG 删除光标到文件尾部的所有的行dgg 删除光标到文件头部的所有的行x ：删除光标所在位置的字符或者进入插入模式backspace插入模式：按下键盘的i键I :在光标所在行首进入插入模式i :在光标所在前进入插入模式A :光标所在行尾进入插入模式a :在光标所在后进入插入模式O :在光标所在上一行进入插入模式o :在光标所在行下一行进入插入模式底行模式：按下键盘的shift+:保存、退出:q:q!:w:wq 或者 x:wq!:wqa取消高亮:nohl设置光标（ubuntu文件内容向拷贝到windows）set mouse= 可以右键拷贝set mouse=a 不可以右键拷贝或按着shift键，鼠标选中想要拷贝的行，松开shift，右键拷贝（12.04）按着shift键，鼠标选中想要拷贝的行，不松松开shift，右键拷贝（16.04） 跳转到对应行号:n :10设置行号是否显示:set nonu 取消行号:set nu 显示行号拷贝、剪切替换文件另存打开多个文件
day4Linux C基础课程 第四天
【1】复习
vim编辑器的使用
命令行模式
Esc
yy nyy 鼠标选中y
dd ndd 鼠标选中d
p
ugg G/hello n N /^hello /hello$dG dgg x
F2: 显示文件中的变量，函数，宏
F3: 显示当前文件目录下的文件或者目录插入模式:iIaAoO
底行模式:
保存退出
:q
:q!
:w
:wq 或 :x
:wq!
:wqa取消高亮显示
:nohl行号显示与否
set nu
set nonu拷贝（通过终端向windows拷贝）
按下shift ,鼠标选中想要拷贝的行，右键拷贝
set mouse=
set mouse=a行跳转(vi 文件名 +行号)
:50拷贝、剪切
:3,4y 拷贝3-4行
:3,$y 拷贝3-尾行的内容
:12,19d 剪切12-19行
:3,$d 剪切3-尾行替换
:%s/旧的字符串/新的字符串/g 全局替换
:%s/旧的字符串/新的字符串/ 替换每一行第一次出现的旧字符串
:11,12s/旧的字符串/新的字符串/g 替换11-12行的旧字符串
:11,12s/旧的字符串/新的字符串/
:11,$s/旧的字符串/新的字符串/g 替换11到尾行的内容
:11,$s/旧的字符串/新的字符串/ 替换11到尾行的内容（第一次出现的字符串）
文件另存
:w 路径/文件的新的名字文件的插入
:r 路径/文件名 将文件中的内容插入到光标所在的位置打开多个文件
:vsp 路径/新文件的名字 左右打开
:sp 路径/新文件的名字 上下打开
【2】写一个helloworld
vi 01helloworld.c //打开一个新的文件
#include <stdio.h> //包含头文件（printf的头文件）
//#include 包含头文件的固定用法
//<> stdio.h在系统的/include /usr/include
//"" 代表的是当前的路径//main是入口函数 ,后面的是参数
int main(int argc, const char *argv[])
{printf("hello world.\n"); //printf是一个打印语句// '\n'换行printf("hello DC20021 everyone\n"); return 0; //函数的返回值，如果返回的是0,（代码执行成功）//return -1; 返回负数代表代码执行失败了
} //c语言每句话结束都要使用;使用c语言编写的是语言文件，它是不能够直接执行的，
原因机器只能识别0和1二进制。
源文件 ----->编译------>二进制文件（可以执行）编译：
gcc 01helloworld.c -o helloworld执行：
./helloworld结果：
hello world.
hello DC20021 everyone
【3】gcc编译器
gcc<-gnu(开源组织)
gcc -v 查看gcc的版本gcc version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5) gcc编译的代码只能够在ubuntu（x86）上执行,不能够在手机上执行，因为手机（arm架构的）一、预处理1、将头文件进行替换，对宏进行替换，对条件编译替换，它不会对语法检查。
gcc -E 01helloworld.c -o helloworld.i| | | |预处理的参数 | 指定后面要生成程序的名字 || |源文件 预处理后的文件
二、编译对语法进行检查的，将预处理后的文件编译成汇编文件gcc -S helloworld.i -o helloworld.s三、汇编将汇编文件编译成可执行文件，这个文件没有连接库gcc -c helloworld.s -o helloworld.o参数：ESc 后缀：iso
四、链接将依赖的库连接到可执行程序中libc.a 静态库：在编译的时候直接将所依的所有内容编译到可执行程序中libc.so动态库：编译的时候只是将符号链接编译进去执行的时候会反过来找这个库gcc helloworld.o -o helloworld编译：gcc 01helloworld.c -o helloworldgcc 01helloworld.c ----->//生成可执行程序的名字a.out
PM:
【1】计算机的组成
1.输入输出
2.控制器
3.总线
4.运算单元ALU
5.存储设备
存储设备：
硬盘：机械硬盘，固态硬盘emmc内存：SDROM DDR4（掉电丢失）iROM:只读存储器，只能被写入一次，存放启动代码iRAM:随机存储器，（掉电丢失）cache：高速缓存cpu ---->register--->------>内存--->硬盘| ||->cache->
【2】存储大小的单位
bit 只能用来存储1或者0
byte(字节)=8bit
kb = 1024 byte
Mb = 1024 Kb = 1024*1024byte
Gb = 1024Mb
Tb = 1024Gb
【3】数据的类型（ubuntu 32位）
基本类型
字符类型
char 1字节
signed char 有符号的字符类型
unsigned char 无符号的字符类型
整形短整型short 或者short int 2字节signed shortunsigned short整形int 4字节长整形long 或者long int 4字节长长整形long long 或者 long long int 8字节实型（浮点类型）float 单精度的浮点类型 4字节double 双精度的浮点类型 8字节枚举类型(下一门课程讲解)enum
构造类型数组char buf[2];结构体(下一门课程讲解)struct共用体(下一门课程讲解)union
指针类型(都是4字节)char *;int *;long *;void *
空类型void
【4】常量
字符常量(char)（只能赋值给字符类型）
man ascii 查看字符常量对应的值
'\n' 'a' 'A' 't' :单引号引起来的是字符10 97 65 116'0' 0 '\0'48 0 0整形常量(short int long)0 10 100 500 -2 -1 -10 0b110106640xac8f
实型常量（浮点）（float double）3.14 2.85 3.14e-1 0.314E2字符串常量(在c中没有字符串类型)"helloworld""c program"标识常量（宏）(保留)char a = 'a';
char b = -10;
short c = 10
int d = 1000;
long y = 500;
float t = 3.14;
double v = 2e-3;
【5】进制转化
二进制（逢二进一）(0b是二进制的开头)
0b110110 = 转化为10进制 = 125+1*24+122+1*21
十进制（逢十进一）
65 = 0b100 000
50 = 0b?00110010?
12 = 0b1100八进制（逢八进一）（0是八进制）
0 1 2 3 ... 7
0664 = 6*8^2+6*8^1+4*8^0 = 436= 0b110 110 100
0775 = 0b111 111 101 7 = 4 + 2 + 1 = 0b111注意八进制中的一位转化成二进制对应的是三位十六进制（逢十六进一）（0x代表十六进制）
0 1 2 3 4 ... 9 a b ...f（10-15是通过字符来表示的）
0xa38f = 0b1010 0011 1000 1111
0x1b0 = 0b0001 1011 0000f = 15 = 8 + 4 + 2 + 1注意十六进制中的一位转化成二进制对应的是四位07531 = 0b111 101 011 001
0x3876fc = 0b0011 1000 0111 0110 1111 1100
23 = 0b1 0111= 16+4+2+1
day5Linux C基础课程 第五天
【1】复习
数据类型：
char signed char unsigned char 1字节
short (short int) 2字节
int 4字节
long (long int) 4字节
long long int 8字节
float 4字节
double 8字节
long double 12字节
数组 不确定
int [2] 8字节
void *
char * 4字节
int *void 空类型常量：字符常量(man ascii)'\n' 10'\0' 0'0' 48'A' 65'a' 97整型常量10 100 0b1101 0664 0xaf 实型常量3.14 5.69 0.012e2 0.012E-2字符串常量"hello world""100""0"标识常量（宏）进制转换二进制0b1101八进制0664十进制57十六进制0xaf练习进制转化0x4cfd81 转化为八进制0b 010 011 001 111 110 110 000 0010231766010x4003f 转化为二进制0b0100 0000 0000 0011 1111061345 转化为二进制0b110 001 011 100 10137 转化为二进制 37 = 32 + 4 + 10b 0010 0101
【2】变量
<存储类型> <变量类型> 变量名;
存储类型6中：
auto register extern static volatile const
<变量类型> 变量名;
char a;
int tt;1.变量名只能由数字，字母，下划线组成，不能以数字开头tyx t123_ _123t 1ttw (错误) ww% (错误)
2.变量名在写的时候不能和关键字重复，关键字（32个）auto register static volatile const extern 6void char short int long struct union enumfloat double signed unsigned 12typedef 1sizeof 求类型大小的关键字 1if else switch case do while goto for 8return continue break default 43.见名知意4.区分大小写Max maxint light_on;
int LightOn;变量存储数据的能力
char : 127 - (-128)
unsigned char :0 - 255short: (2^15-1) - (-(2^15))) 32767 - (-32768)
unsigned short : 0-65535int:(2^31-1) - (-(2^31)) 2147483647 - (-2147483648)变量的符号
char 8bit1 0000000| |符号位 数据位1：代表负数0：代表正数0 111 1111 = 2^7-1 = 2^6+2^5+2^4+2^3+2^2+2^1+2^0unsigned char:0000 0000 都是数据位1111 1111char = signed char 都是有符号的变量存储的方式（数据是以补码存放的）
源码，反码，补码
反码：除符号位外，其他的位取反
补码：在反码的基础上加1正数的源码反码和补码是一样的
5 = 0101 = 0101 = 0101-5 = 1000 0101 = 1111 1010 = 1111 1011源码 反码 补码char a = 128;
128 = 1000 0000 补码 1111 1111 反码1000 0000 源码-128129 = 1000 0001 补码1111 1110 反码1111 1111 源码-127
【3】数据打印的格式
%c 字符
%d 整数
%ld 长整形
%lld长长整形
%f 实型 (默认是小数点后六)
%.3f (小时小数点后三位)
%g 实型 (显示小数点后的有效位)
%Lf 显示long double
%s 显示的是字符串
%o 显示八进制
%#o 显示八进制并显示前缀
%x 显示16进制
%#x 显示16进制的数并显示前缀
PM:
【1】标识常量宏
第一种用法
#define M 10
1.含义：使用M代替10这个数字
2.可以让数据具备对应的含义，减少魔鬼数字的出现。
3.可以通过宏让代码中使用数字的所有一块改变
4.宏在定义的时候写成大写。
5.宏的最后的位置不需要使用";"
6.宏是预处理阶段完成的替换第二种用法#define M 10#define N M+10x = N+N;y = N*N;printf("x = %d,y = %d\n",x,y); //40,120第三种用法#define S(a) #aprintf("S(10) = %s\n",S(10)); //"10"这里的一个#代表的是字符串化S(10) #10| |数字10 "10"第四种用法#define NAME(a,b) a##b#define HW "helloworld"int hello = 1000;printf("hello = %d\n",NAME(h,ello));printf("hello = %d\n",NAME(he,llo));printf("HW = %s\n",NAME(H,W));这里的“##”表示的是字符串拼接h##ello ==>helloH##W ===>HWNAME(h,ello) h##ello ==>hello第五中用法#define MAX(a,b) ({int max; if(a>b)max=a;else max=b;max; })max = MAX(5,10);在宏中如果有多句话，需要使用({})宏的最后一句话执行的结果就是返回值
自己写的： #define MAX(a,b) (do{int max;if(a>b)max=a;else max=b;max;}while(0))
day6Linux c基础课程 第六天
【1】复习
宏：
1.
#define M 10
2.
#define N M+10
x = N+N; //10+10+10+10 = 40y = N*N; //M+10*M+10 = 10+10*10+10 = 120#define ADD(x) x+xint m=1,n=2,k = 3;int sum;sum = ADD(m+n)*k; = m+n+m+n*k = 1+2+1+2*3 = 10;printf("sum = %d\n",sum);//宏替换是在预处理阶段进行，m+n = 3在执行的//时候才会出现结果，所以是先完成了替换在执//行了运算
3.#define S(a) #a在宏中#代表字符串化传入的是一个整数，#会帮你转化为字符串4.#define NAME(a,b) a##b这里的##代表的是字符串拼接int hello = 1000;NAME(he,llo) ==>hello5. #define MAX(a,b) ({int max; if(a>b)max=a;else max=b;max; })max = MAX(5,10);在宏中如果有多句话，需要使用({})宏的最后一句话执行的结果就是返回值
【2】运算符号
单目运算符
+ 正
- 负
++ 自加
注：自加是每次增加1，
1.++i,先对i进行自加1，本次直接加上去了。
2.i++先执行了加1，但是本次加1没加上去，
在执行下一句的时候就会加上去。
– 自减是每次减去1
–i:本句话减去1了
i–:下一话才减去1
&:取地址符号，
例如：int a=100; &a = 0xbf8a00dc
*:取地址中的内容 *&a = 100
!:取反 真取反是假，假取反是真。
0假，非0就是真
~:按位取反比如char a = 0xc3; //1100 0011a = ~a; //0011 1100强制类型转化int b =100;char a;a = (char)b;算术运算符+ 加 c = a+b- 减 c = a-b* 乘 c = a*b/ 除 c = a/b; 2/3 = 0 如果分子小于分母结果是0% 取余数（取模）:这个符号不能和实型的数结合使用int a;a = 2%3;a = 2.0%3;a = 2/3.0;
PM:(大家进入直播间回复下)
【1】
移位运算符
<< 左移动
>> 右移动
如果一个数是正数，不管是左移动还是右移动都补充的是0如果一个数是负数，左移补充的是0，右移补充的是10000 01001<<2 = 41<<3 = 88>>1 = 48>>3 = 11<<20 = 使用十六进制表示int =>4字节=>32bit0000 0000 0001 00000000 0000 0000 0000 = 0x100000关系运算符> 大于 < 小于== 等于 != 不等于>= 大于等于<= 小于等于与运算符(位)&1&0 = 00&0 = 01&1 = 10和任何数相与都为0，1和任何数相与都为任何数int a = 0xfc //====>1111 1100请使用&将a变量的第三位清零，并不改变其他的位。a & 1111 0100 =>1111 0100;a = a & (~(1<<3));1<<3 ===> 0000 1000~(1<<3) ===>1111 1111 1111 11111111 1111 1111 0111异或运算符（位）^相异为真，相同为假1^1 = 00^1 = 10^0 = 0int x = 10;x = x ^ x;x = ?int a=5,b=10;请使用异或交换两个变量的值？a = a ^ b; b = a ^ b;a = a ^ b;0101 =>a^1010 =>b--------------1111 => a^1010 =>b--------------0101 =>b^1111 =>a-------------1010 =>a或运算符（位）| 1|0 = 11|1 = 10|0 = 01和任何数相或都为10和任何数相或都为任何数int a = 0xfc 请使用|将a变量的第0和1位设置为1，并不改变其他的位。a = a | ( 1<<0 | 1<<1);逻辑运算符（这个不是按位操作的，它是整体操作的）|| 或if(weight>100 || weight<10){printf("please take care your healty\n");} 1.如果||符号前的表达式成立，||后面的表达式就不会执行了2.如果||符号前的表达式不成立成立，||后面的表达式就会执行了&& 与if(weight<=100 && weight>=10){printf("your are healty\n");} 1.如果&&符号前的表达式不成立成立，&&后面的表达式就不会执行了2.如果&&符号前的表达式成立成立，&&后面的表达式就会执行了条件运算符(三目运算符)?:d=a?b:c如果a为真，将b赋值给d如果a为假，将c赋值给d赋值运算符= 赋值运算符+= 先加后赋值-= 先减后赋值*=/=%=>>=<<=
逗号运算符, 它取出的结果是逗号后的结果
补全的修改：
vi ~/.vim/snippets/c.snippets
:71行是一个折叠的代码，使用键盘的z o
69 # main()70 snippet main71 #include <stdio.h>72 73 int main(int argc, const char *argv[])74 {75 +--- 2 lines: ${1}---------------------------------------------------------------------77 }
~ 经过上述的修改，新打文件之后，输入main按下键盘
的tab键。就可将上述的代码补全到你的新文件中了。
day7Linux C基础课程 第七天
【1】复习
运算符
单
算
移
关
与
异或
或
逻辑
条件
赋值
逗号
运算符优先级问题：单算移关与，异或逻条赋，逗上述的运算符是有优先级的，从上往下优先级逐渐降低的。
同种类型的运算符如何计算：单 条 赋 从右向左结合剩余的运算符都是从左向右作业：1. 执行下列程序段后，变量a,b,c的值分别是 int x=10,y=9;int a,b,c;a=(--x==y++)?--x:++y; // a=8 x=8 y=10;b=x++; //b= 8 x=9 y=10c=y; //c=10A、a=9,b=9,c=9 B、a=9,b=10,c=9 C、a=1,b=11,c=10 D、a=8,b=8,c=10 2.将一个32位的无符号的整数，实现高低位反转，比如31反转后再0位，30位反转后在第1位......(不能定义新的变量)思想：1.相邻位交换 2.相邻的两位交换3.相邻的四位交换
【2】输出
printf("控制格式",变量列表);
功能：向终端上显示要打印的信息
参数：@控制格式 %d %c %s @参数列表 （变量,变量）unsigned int a;
printf("%c\n",a); 打印字符类型
printf("%d\n",a); 打印整形
printf("%u\n",a); 打印无符号整形
printf("%ld\n",a);打印长整形
printf("%lld\n",a);打印长长整形
printf("%#o\n",a);打印八进制 #代表显示八进制的前缀
printf("%#x\n",a);打印十六进制 #代表显示十六进制的前缀
printf("%f\n",a); 打印浮点类型，小数点后6位
printf("%.2f\n",a);打印浮点类型，小数点后2位
printf("%g\n",a); 打印浮点类型，小数点后有效位
printf("%e\n",a); 打印浮点类型，会以指数的形式显示
printf("%Lf\n",a); 打印long double类型浮点数据
printf("%p\n",&a); 打印一个变量的地址
printf("%s\n",&a); 打印的是字符串printf("%04d\n",a); 占用四个位置，没数据的位补充0
printf("%4d\n",a); 占用四个位置，没数据的位补充空
printf("%-4d\n",a); 占用四个位置，-左对齐
printf("%d\t%d\n",a,a); 这里的\t是一个制表符 （\t=>Tab）printf("%%\n"); 打印一个%号printf中的转译字符printf("abc\067\n"); ==>\067 => '7'printf("abc\67\n"); ==>\67 => '7'printf("adc\x65\n") ==>\x65 => 'e'printf("hello \"wo\"rld\n");=>\" 代表打印 "printf("hello \'wo\'rld\n"); =>\' 代表打印 ' '\n' =>回车'\t' =>Tab'\a' =>发出一个“咚”'\b' =>退格'\r' =>回滚行首
【3】输入
scanf(“控制格式”,地址列表);
功能：从终端向读取控制格式的内容
参数：
@控制格式 %c %d %u %s
@地址列表 &a,&b
返回值：
成功读取到的项目的个数
失败返回EOF(-1)
练习如下实例~~~~~~~~~~~~
scanf("%d",&a); 输入一个整数
scanf("%d%c",&b,&a); //同时输入两个字符 10c 回车
scanf("%d,%c",&b,&a); //同时输入两个字符 10,c 回车
scanf("%d %c",&b,&a); //同时输入两个字符 10 c 回车scanf("%d",&b); //先输入一个整数10，回车
scanf("%*c%c",&a);//c回车 注：%*c它会吃掉回车scanf("\n%d",&b);
scanf("\t%d",&b); //输入的时候会跳过回车、tab、空格
scanf(" %d",&b);scanf("%d\n",&b);
scanf("%d\t",&b);//输入整数后，回车，tab,空格
scanf("%d ",&b); //都没反应在随便输入一个字符，//就可以结束程序了char a[10]; //这是一个char类型有10成员的数组，a数组名//a是数组的首地址
// scanf("%s",a); //不能够hello w ,遇到空格 tab 结束了
scanf("%[\n]",a);//%[\n]:除了’\n’之外的所有字符全输入
printf(“a = %s\n”,a);
实例1：
1.输入三角形边长，求面积(开根号sqrt)
s = (a+b+c)/2;
area = √s*(s-a)*(s-b)*(s-c)man sqrt
#include <math.h> //头文件
double sqrt(double x);
功能：开根号
Link with -lm. //连接库验证：输入3 4 5 结果是=>6
注释：
// 单行注释
/* */ 多行注释
#if 0 多行注释
#endif
day8Linux C基础课程 第八天
【2】输入、输出
int putchar(int c);
功能：向终端上输出一个字符
常见的用法如下：
putchar(a); //char a = 100;
putchar('\n'); //'\n'
putchar(65); //65
//'\n' 65 'A' =>数值=>向终端上输出的时候重新转化成字符int getchar(void);
从终端读取一个字符常见的用法：
char a;
a = getchar(); //从终端读入一个字符，输入a ，a= 'a'//输入10 ，a= '1'
getchar(); //用来吃掉终端上输入的'\n'//它和scanf("%*c")功能相同gets(char s[]);
功能：从终端向数组中读入多个字符
在读入的字符最后会加上'\0',当输出字符串的时候
遇到'\0'才会结束。
注意：gets非常傻，即使读取的字符超出
自己能够承受的范围，也会接着往下读，
这样是不安全的。尽量不要使用这个函数，
或者使用的时候注意越界问题即可。puts(char s[]);
功能:将数组中的内容输出到终端上（多个字符）
在输出的时候会字符加上'\n'
【3】c语言中的控制语句
1.if/else if/else
if(条件1){ //条件1成立，语句1执行
语句1;
}
if(条件1){ //条件1成立，语句1执行语句1;}else if(条件2){ //条件2成立，语句2执行语句2;}else { //如果条件1 条件2都不成立，执行else中的语句3语句3;}if(条件1){语句1;}else{语句2;}注意if可以单独使用，else不能单独使用2.switch/case/default/break
switch(变量){case 常量1: 语句1;case 常量2: 语句2;break;default: 语句n;
} 1.switch对应的括号中是变量（字符或整形）
2.当变量和常量1相等的时候执行语句1.
3.case后面跟的break是结束switch/case语句如果没有break;继续向下执行。
4.如果变量和case后的常量都没比较成功，会执行default语句。
5.case后跟的是常量，常量，常量！！！3.do/while /while 循环语句do{循环体;}while(循环条件)注意：do/while循环体总会被执行一次如果循环条件为真，会继续执行循环体。如果条件为假，退出循环。while(循环条件){循环体;}注意：如果循环条件成立，循环体会被执行，如果循环条件不成立，退出循环执行。4.for循环for (语句1; 语句2; 语句3){ 循环体;} 先执行语句1，接着执行语句2，如果语句2为真，执行循环体。循环体执行完执行语句3，在执行语句2，如果语句2为真再次执行循环体。int i,sum=0;for(i=1; i<=100; i++){sum+=i;} printf("sum = %d\n",sum); for语句可以嵌套******************************5.break;1.可以结束switch/case语句；1.可以结束一层循环（while for）；
day9Linux c基础课程 第九天
【2】控制语句剩余部分
goto 跳转语句
用法：loop:goto loop;1.goto只能在当前函数内跳转，不能跳转到其它函数。
2.goto是跳转语句，效率低。一般使用goto语句，做统一出错处理。其他的情况一般不使用goto。continue:它会执行下一次循环语句，本次continue语句后面的语句就不会执行了。for(i=0; i<=100;){if(i%2 != 0){ i++;continue; //执行下次循环，sum+=i++; } //就不会去执行了。 sum+=i++; } return:功能用来结束一个函数。return后面的数字，代表函数执行的结果如果整数都是自己固定的函数，如下int get_leap_year(){if((year%4 == 0 && year%100 !=0)||year%400 == 0){ return 1; //代表闰年}return 0;//代表平年}如果返回的是负数，表示程序执行出错了。
【3】数组(格式如下)
char a[10]; //字符数组
int b[10]; //整形数组
1.数组属于构造类型，它是基本数据类型元素的组合
2.数组中的成员在内存上是连的
3.a:代表的是数组名，它同时又代表数组的首地址。a是一个常量（不可以a++，++a）,可以做a+1;
4.[10]:[]数组的格式，10数组的成员有十个。a[0] a[1] a[2] ... a[9]|代表的是数组的下标
5.编译器不对数组越界检查。a[-1] 不会出错a[10] 不会出错输入的使用：定义的时候赋值：int a[10] = {1,2,3,4,5,6,7,8,9,10};int a[10] = {1,2,3,4,5,};a[0]-a[4] 他里面的值1,2,3,4,5a[5]-a[9] 这里的值都是0int a[10] = {0};数组中的成员都是0int a[] = {1,2,3,4};这里a没指定数组成员的个数，但是初始化的时候给了4个处理，编译器就会给他4个int类型的大小先定义变量，在赋值int a[5];a[0] = 1;a[1] = 2;a[2] = 3;a[3] = 4;a[4] = 5;练习：在终端上输入5个数，将这个5个数打印出来
PM:
【1】数组的首地址的问题
int a[5];
a：数组的首地址a+1 => 4字节 移动的是int类型&a:对数组的首地址取地址&a+1 =>20字节 移动的是int [5]类型&a[0]:取第0个元素的地址&a[0]+1 =>4字节 移动的是int类型/\
| 变量 4 |
|-----------------|
| 数组 20 |
|-----------------|
|数组地址的地址 |
\/ |
升维 降维
【2】数组的排序问题
冒泡排序：拿相邻的两个数比较，如果前面
的数字大，就将这个两个数进行交换。否者不
交换
50 2 -10 100 30 第几趟 比较次数
2 -10 50 30 100 i=0 4
-10 2 30 50 i=1 3
-10 2 30 i=2 2
-10 2 i=3 1趟：i=0 ===> i<N-1
趟内比较的次数:j=0 ===> j=N-1-i选择排序：
从数组中随机选择一个数，和数组中的
其他成员挨个比较，如果这个数比数组中
的数小就交换数据。
day10Linux c基础课程 第十天
【1】复习
控制语句：
1.goto
2.continue
3.return
数组int a[5] = {1,2,3,};int a[5] = {0};int a[] = {1,2,3,4,5};1.a++ 错误2.编译器不会对数组的越界检查3.认识下面内容a[0]+1 数值a[0]加上1&a[0]+1 向后移动4个字节a+1 向后移动4个字节&a+1 向后移动4*5个字节数组的排序问题：1.冒泡排序2.选择排序作业：1.对选择排序效率进行优化，思想如下：通过比较数组中的两数，将最大数的数组的下标记下，当本趟比较结束后，进行一次数据交换即可。2.日历程序代码链接：https://github.com/daizhansheng/LIVE_NOTE/注意：大家把代码下载下来，给10分钟的时间，看不明白的地方直接问**/如果能看懂，今天晚上尝试自己在写一遍 /**
【1】字符数组
char a[5];
字符数组和整形的数组的特性是一样的，但是
字符数组在赋值的时候，赋值的是字符。
第一种情况：
char a[10] = {'h','e','l','l','o'};for(i=0; i<10; i++) //它会把数组中的putchar(a[i]); //成员全部遍历一遍printf("%s\n",a); //%s打印的时候，遇到'\0' //就结束了第二种情况：
char a[] = {'h','e','l','l','o','\0'}; for(i=0; i<5; i++) //它会把数组中的putchar(a[i]); //成员全部遍历一遍printf("%s\n",a);
//%s打印的时候，遇到'\0'就结束了
//但是上述的数组中没有'\0'的成员，但是
//的时候可能，有可能不正确，如果想让让它
//正确，必须在最后的位置补充'\0'元素第三种情况
char a[] = "hello";
printf("%s\n",a); //正确的，赋值了6个成员//最后一个是'\0'成员
PM:
【1】字符数组
1.字符串的拷贝
在终端上输入一个字符串，将这个字符串
保存在a[50]数组中 ，请将a[50]数组中的
字符拷贝到b[50]中。将b数组的内容打印
一下。
while(a[i])
b[j++] = a[i++];
2.字符串拼接请将b数组中的内容拼接到a数组后a[100] = 从终端上输入的b[50] = "no zuo no die"a[] = "hello worldno zuo no die"//1.找到a的尾部while(a[i]) i++; //hello'\0'a[i++] = ' ';//2.将b追加到a的尾部while(b[j])a[i++] = b[j++];3.求字符串的长度//1.找到a的尾部while(a[i]) i++; printf("len = %d\n",i);4.字符串的比较(作业)a[50] = "hello world";b[50] = "hello worlc"拿a数组中的字符和b数组中的字符做减法运算，如果差值大于0 a大小于0 b大等于0 接着比较下一个字符，如果到a,b的结尾都是相等的，认为这两个字符串相等。
【2】二维数组
int a[4][3];
1.二维数组在内存上也是连续的
2.二维数组的数组名也不允许做自加操作应为a也是常量
3.a[4] [3]| |行下标 列下标
4.在定义数组的时候行下标可以省略，列下标不能省略二维数组的初始化
int a[3][2] = {1,2,3,4,5,6};
int a[3][2] = {{1,2},{3,4},{5,6}};
int a[][2] = {{1,2},{3,4},{5,6}};
int a[3][] = {{1,2},{3,4},{5,6}}; //错误的二维数组如何访问(遍历)
a[0][0]
a[0][1]
a[1][0]练习：
1.将二维数组中最大值的行和列的下标打印出来2.打印杨辉三角（前10行）1 1 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1 int a[10][10];作业：1.字符串的比较(作业)a[50] = "hello world";b[50] = "hello worlc"拿a数组中的字符和b数组中的字符做减法运算，如果差值大于0 a大小于0 b大等于0 接着比较下一个字符，如果到a,b的结尾都是相等的，认为这两个字符串相等。2.打印如下内容int a[4][3];&a a a[0] &a[0][0] 打印四个地址加1后移动的字节的个数&a+1a+1a[0]+1&a[0][0]+1
day11Linux c基础课程 第十一天
【1】复习
字符数组
char a[10] = {‘h’,‘e’,‘l’,‘l’,‘o’};
char a[] = {‘h’,‘e’,‘l’,‘l’,‘o’,’\0’};
char a[] = “hello”;
for(i=0;i<10;i++)putchar(a[i]);printf("%s",a);
puts(a);二维数组int a[4][3] = {1,2,3,4,5,};int a[4][3] = {{1,2,3},{1,},{2,3,4}};int a[][3] = {{1,2,3},{1,},{2,3,4}};二维数组的遍历方式：两层for循环for(i=0; i<4; i++){for(j=0; j<3; j++){printf("%d\n",a[i][j]); }}
作业：
1.字符串的比较(作业)
a[50] = “hello world”;
b[50] = “hello worlc”
拿a数组中的字符和b数组中的字符做减法运算，如果差值大于0 a大小于0 b大等于0 接着比较下一个字符，如果到a,b的结尾都是相等的，认为这两个字符串相等。
2.打印如下内容int a[4][3]; int b[3]&a a a[0] &a[0][0] 打印四个地址加1后移动的字节的个数&a+1 =>48a+1 =>12a[0]+1=>4&a[0]+1=>12&a[0][0]+1=>4int a[3];&a+1 12 a+1 4&a[0]+1 4二维数组 一维数组 变量
<-----------升维-----------
------------降维-----------> 如果要计算一个地址加1移动的字节的个数：
地址加1 ==>降维 ==> 降维之后类型占用多少个字节就代表向后移动多少个字节。
如果地址+1，这个地址前有"&",代表升降维度抵消。二维字符数组char a[10][10] = {"hello","hahaha"};char a[][10] = {"hello","hahaha"};char a[10][10] = {{'h','e','l','l'},{'r',}};for(i=0;i<2;i++){//printf("%s",a[i]);printf("%s",&a[i][0]);}
【2】指针
地址：存储器的每一个字节都有编号，这个编号就是地址
指针：地址就是指针，指针就是地址
指针变量：指向变量地址的变量就是指针变量。
以后再用的时候，统称为指针。指针的格式char *p; short *t;int *q;long *b;注意：在定义变量的时候，这里的*只代表定义的变量是指针变量，并没有代表取地址中的内容的函数。
认识两符号：& ：取地址* ：在指针变量前加*，代表可以读写这块内存指针实例：int a = 10; int *p = &a; printf("*p = %d\n",*p); //10*p = 100;printf("a = %d\n",a); //100printf("&a = %p,p = %p,&p = %p\n",&a,p,&p);| | |a的地址 a的地址 p变量的地址
PM：
【1】指针占用内存大小
在32位操作系统上，所有的指针都是
占用4字节。因为32位操作系统存储设备
的编址是用4字节来表示的。
指针变量加1移动的大小是它指向的变量类型
的大小。short a = 10;
short *p = &a;p+1==>short=>2字节
【2】指针变量的应用
指针变量使用必须遵从如下三个步骤
1.定义指针变量
2.为指针变量分配内存
3.使用指针变量
注：如果在定义完指针后，没有给指针
赋初值，这个指针就是野指针，这个野指针
可能导致不可预期的后果。如何规避野指针，在定义指针的时候赋NULL;https://github.com/daizhansheng/LIVE_NOTE/04point.c
【3】指针和一维整形数组
int a[5] = {1,2,3,4,5};
int *p = a;
a[i]<===>*(a+i)<===>p[i]<===>*(p+i);实例见：05point.c06point.c
【4】指针和一位字符数组的结合
char a[] = “hello world”;
char *p = a;
printf(“a = %s\n”,a);
printf(“p = %s\n”,p);
char a[] = "hello world";
char *p = "hello world";
*a = 'w'; //正确的
// *p = ‘w’; //错误的
// a++; //错误的
p++; //正确的 p = p + 1;
p = a; //正确的 p = a
【5】应用层内存段的划分
|-----------------------------------
|堆区：使用malloc函数分配的
| 内存就在这个区间。
|-----------------------------------
|栈区：用户的函数的执行，函数
| 内部定义的局部变量，都在
| 栈区。
|-----------------------------------
|静态区 |.data:
| |存放的是已初始化的全局变量，
| |static修饰的已初始化的全局变量。
| |-----------------------------
| |.bss（这里的初值都是0）
| |未初始化的全局变量，static修饰的
| |未初始化的变量
| |-----------------------------
| |.ro (.rodata)（只读的数据段）
| |char *p = “hell world”;
| |-----------------------------
| |.text：存放程序代码
| |
|------|-----------------------------
【6】作业：
char a[100] = {0};
a数组中的内容是从终端上输入的
char b[50] = "hello";在a对应的字符串口，查找b字符串，如果找到了b
字符串将a中这个b字符串的首地址返回。a b | |
char *strstr(char *src,char *sub);
{//your code如果查找成功返回，src中b字符串的首地址如果没找到返回NULL
}
day12Linux c基础课程 第十二天
【1】复习
指针：
int t;
char *a;
short *b;
int *c;
c = &t;*c = 10;
指针占用内存（32位）4字节指针加1移动的大小指向的类型所占的内存的大小指针和数组的关系：int *p;int a[] = {1,2,3,4,5};p = a;*p++;a[i]===*(a+i)====*(p+i)===p[i]p = &a[2];p[-1] = 100;char a[] = "hello world";char *p = a;printf("%s\n",a);printf("%s\n",p);char a[] = "hello world";char *p = "hello world";a++; //错误*a = '2'; //正确p++; //正确的*p = 'r'; //错误p = a; //正确的a = p; //错误的作业：char a[100] = {0};a数组中的内容是从终端上输入的char b[50] = "hello";在a对应的字符串口，查找b字符串，如果找到了b字符串将a中这个b字符串的首地址返回。a b | |char *strstr(char *src,char *sub);{//your code如果查找成功返回，src中b字符串的首地址如果没找到返回NULL}
【2】二级指针
char **q;
int **p;
二级指针是指向一级指针的地址
int a = 10;
int *p = &a;
int **q = &p;&a = p = *q
&p = qa = *p = **q二级指针是指向以及指针的地址，一般
在函数调用的时候使用。作业：实现字符串比较的函数。int strcmp(char *s1, char *s2);
PM:
【1】指针数组
定义的格式：
char *p[5];
int *t[5];
指针数组的含义：指针数组它是一个数组，数组中的内容全部是指针指针数组的用法： int b[3] = {50,100,150};int *a[3],i;a[0] = &b[0];a[1] = &b[1]; a[2] = &b[2];for(i=0; i<3; i++){printf("%d\n",*a[i]);}用法二：
int main(int argc, const char *argv[])
argc:命令行参数的格式
argv:执行命令行传递的字符串for(i=0; i<argc; i++){printf("%s\n",argv[i]);
} 命令执行代码的方式 ./a.out fsdf sfdsdf 123 1231 12312argv[0] = "./a.out"
argv[1] = "fsdf"
argv[2] = "sfdsdf"
argv[3] = "123"将字符串转化为整数的函数
./a.out "123" "456"p
val = 0;
val += val*10 + (*p++ - '0');#include <stdlib.h>int atoi(const char *nptr);
功能：将字符串转化为整数
参数：@nptr:字符串的首地址
返回值：转化得到的整数
【2】数组指针
格式：
char (*p)[3];
int (*q)[3];
含义：
它是一个指针，执行一个二维数组赋值：int (*q)[3];int a[4][3];q = a;理解的方法：把a[4]看成一个整体，由于a[i] = p[i] = *(a+i) = *(p+i);所以它和*p是一样的，那a[][3] = (*p)[3]即q = a;总结：
a[i][j] <====> *(a[i]+j) <===>*(*(a+i)+j)
p[i][j] <====> *(p[i]+j) <===>*(*(p+i)+j)a： 二维数组的名字,二维数组的首地址
a[0]: 第0行的首地址
a[0][0]: 二维数组首个元素
&a[0][0] 二维数组首个元素的地址
&a[0] 取第0行的地址
&a 取二维数组的地址int (*p)[3]; //数组指针，指针，它指向一个二维数组
int *p[3]; ：//指针数组，数组，数组中是指针
练习题：
用变量a给出下面的定义
a) 一个整型数
int a;
b) 一个指向整型数的指针
int *a;
c) 一个指向指针的的指针，
它指向的指针是指向一个整型数
int **a;
d) 一个有10个整型数的数组
int a[10];
e) 一个有10个指针的数组，该指针
是指向一个整型数的
int *a[10];
f) 一个指向有10个整型数数组的指针
int (*a)[10];
练习题：
1.int a[5][4], (p)[4]=a;，数组a
的首地址为100，(p+2)+3等于_C_
A、116 B、118 C、144 D、122p+1: 4*4=16
a+1: 4*4=16
p+2: 16*2 = 32
*(p+2) = p[2] => a[2] 行地址*(p+2) + 3 = 32 + 3*4; = 44
练习：求p[-1]、p[-5]的值
（此题重点在于负号，很简单，考察对指针了解的广度方面）
#include <stdio.h>
int main(void)
{
char* p = NULL;
char* tmp = “12345678”;
p = (char* )(tmp+4);
//p[-1] = ?, p[-5] = ?。
printf("%s\n",p);
return 0;
}
4，不确定
第3题：求p[0]–p[5]的值（这个才有点点挑战）
#include <stdio.h>
int main(void)
{
char* data = “12345678”;
short* tmp = NULL;
char p[6] = {0};
tmp = (short *)&p[2];
*tmp = atoi(&data[4]);
//p[0] = ?, p[1] = ?,
//p[2] = ?, p[3] = ?,
//p[4] = ?, p[5] = ?。
//结果使用十六进制表示return 0；
}结果：
0 0 0x2e 0x16 0 0
请判断一个机器是大端还是小端
小端：数据底位在底地址中存放，高位在高地址中存放
大端：数据底位在高地址中存放，高位在底地址中存放
int a = 0x12345678;
char b = (char)a;
if(b ==0x78){小端
}else{大端（0x12）
}
作业：
有一个以空格为分隔符的
字符串"this is a book"，
以单词为单元将其逆置，
变为"book a is this" (不允许定义新数组)
char buf[100] = "this is a book";思路：1.将这个字符串先进行一次前后位置的颠倒koob a si siht2.以空格为风格为，进行单词的颠倒book a si this
day13Linux C基础课程 第十三天
【1】复习
二级指针：指向一级指针的指针
int a = 10;
int *p = &a;
int **q = &p;a:变量 地址：0xc0 存放的值：10
p:指针 地址：0xd0 存放的值：0xc0
q:二级指针 地址：0xf0 存放的值：0xd0q:是二级指针它存放的是以及指针的地址q = &p;*q = p; *q代表去二级指针中的值*q++ ==>q++ 在取**q++ ===> 0xc0;q ===> 0xd4;
(*q)++ ==>p++;===> p = 0xc4 **q ==>a-------------------------------
q = &p;p++;
p => 0xc4
q => 0xd0(*q)++ ==>p++;===> p = 0xc4 p => 0xc4
q => 0xd0指针数组：char *p[3];//注意：如果有括号，先读括后面的内容//如果没有括号，从前往后读。它是一个数组，数组中存放的是指针p[0] = "he"p[1] = "he"p[2] = "he"printf("%s\n",p[0]); //%s后面跟的是地址putchar(*p[0]); ==> 'h'数组指针char (*p)[3];char a[3][3];a[i][j]=*(a[i]+j)=*(*(a+i)+j)p[i][j]=*(p[i]+j)=*(*(p+i)+j)
作业：
有一个以空格为分隔符的
字符串"this is a book"，
以单词为单元将其逆置，
变为"book a is this" (不允许定义新数组)
char buf[100] = "this is a book";思路：1.将这个字符串先进行一次前后位置的颠倒koob a si siht2.以空格为分割符，进行单词的颠倒book a si this
PM:
【1】函数（组成c语言的最基本的单元，函数）
函数的定义格式
<存储类型> <返回值类型><函数名字>(参数列表)
{函数体;return ;
}函数的三要素：1.功能唯一2.有固定的输入3.有固定的输出封装函数的原则：高内聚，低耦合函数的返回值类型：void 无返回值void * charchar *int int *long long *floatfloat *double double *等等函数名字定义格式：1.函数名必须是数字，字母，下划线组成的2.函数做到见名知意3.函数命名格式void check_word(void){}void CheckWord(void){}
函数的参数列表：1.函数如果没有参数列表，可以不写，或者写成void2.传递的的参数2.1.值传递：在函数中修改形参数的值，实参拿不到修改后的结果2.2.地址传递2.3.传递数组：不是将数组的所有成员都传递过来了，是传递过来了首地址。void access_array(int a[3]){printf("sizeof a = %d\n",sizeof(a)); //结果是4}3.参数列表一般小于等于4个效率最好函数的返回值：函数的返回值要和函数的返回值类型相同函数嵌套问题：在一个函数内，你可以调用一次或者多次另一个函数。在一个函数内，你可以调用自己（递归）求n!使用递归函数实现n! = n *(n-1)*(n-2)...2*1;int fact(int n){if(n==1) return 1; //递归一定要注意结束条件return n*(fact(n-1));}指针函数（函数的返回值是一个指针。）
char *chang_word_position()
{return 地址;
}eg:(如下写法是错误的)int * return_number(void){int a = 10;//a是一个局部变量，在函数调用的时候被分配内存，当函数执行结束，这个内存就被操作系统释放了 return &a; }函数指针int (*func)(int a,int b);它是一个指针，它指向了一个函数。int add(int a,int b){return (a+b);}int (*func)(int,int) = add; printf("sum = %d\n",add(5,10));printf("sum = %d\n",func(5,10));printf("sum = %d\n",(*func)(5,10));
【2】c语言中的存储类型（6个）
auto:(自动类型)
在定义变量的时候，变量前默认就是auto
auto int a; 等于 int a
非自动类型的变量：1.全局变量2.static修饰的变量register:寄存器类型的变量register int a;寄存器类型的变量，要不普通的变量执行效率要高。在一个soc（system on chip）上寄存器的个数是有限在（A53:40）static:static 修饰的变量如果没有初始化默认为0；static int a;printf("a = %d\n",a); //结果是0作用：1.延长变量的生命周期void static_fun(){static int a = 1;a ++; printf("a = %d\n",a); }static_fun(); //2static_fun(); //32.限制作用域static修饰的函数或者变量只能在本文件中使用。const:（只读变量）const int a=10;a = 100; //错误int a = 10;int b = 1000;const int *p = &a; *p = 100; 错误的p = &b; 正确的表示p执行的内容不能修改，但是p是可以修改的。int a = 10;int b = 1000;int const *p = &a; *p = 100; 错误的p = &b; 正确的表示p执行的内容不能修改，但是p是可以修改的。int a = 10;int b = 1000;int * const p = &a; *p = 100; 正确的p = &b; 错误的*p可以修改，p不允许修改const int * const p = &a;代表*p和p都是只读的。extern:extern int a;extern int add(int a,int b);a或add函数定义没有在当前的.c中，它是在另外一个.c中定义的。volatile:(容易改变的)volatile int *p = (volatile int *)0x8000000; （地址中保存的是10）*p 取出地址中的值10; //(硬件将0x8000000地址中的值改为了100);//由于地址中的数据不是别这个程序修改的，//所以下面这个式子在运算的时候，还是拿的之前的//数据y = *p + 1; //不加volatile是11 //如果加volatile就是101总结：防止编译器对变量优化，每次在使用这个变量的值的时候，都需要重新从内存上取值。
十三天学会C语言笔记相关推荐
- 10讲学会C语言之第一讲：编程前的准备
文章目录 前言 一.必要的说明 二.环境准备与第一个C程序 三.调试 前言 大家好,我是卷卷.今天呢我给大家带来一套C语言图文教程.这个教程呢,也是我在CSDN上传的第一个教程.希望大家多多支持.本教 ...
- 如何用最短的时间学会C语言，并掌握C语言的精髓所在？
点击上方蓝字关注我,了解更多咨询 及C语言,我想凡是学过它的朋友都有这样一种感觉,那就是"让我欢喜让我忧."欢喜的是,C语言功能非常强大.应用广泛,一旦掌握了后,你就可以理直气壮地 ...
- C语言笔记：格式化输入输出（fprintf、fscanf、sscanf...)
C语言笔记:格式化输入输出(fprintf.fscanf.sscanf-) 包含以下函数的基本库:stdlib.h fprintf int fprintf(FILE *stream, const ch ...
- 合并相同数据的行_R语言笔记（六）：数据框重塑(reshape2)
数据处理主要内容包括: 1. 特殊值处理 1.1 缺失值 1.2 离群值 1.3 日期 2. 数据转换(base vs. dplyr) 2.1 筛选(subset vs. filter/select/ ...
- 语句拼接_第2课：一个周末学会R语言数据处理：表拆分和拼接
从一线收集了两百个文件,要整合到一起?总部一张全国两百个城市的汇总表,拆成两百个小文件?开什么玩笑,难道要复制粘贴到天荒地老... 不用这么麻烦,一个循环,一个语句,实现快速表拆分和表拼接,从此告别复 ...
- 【C语言笔记结构体】
我们都知道C语言中变量的类型决定了变量存储占用的空间.当我们要使用一个变量保存年龄时可以将其声明为int类型,当我们要使用一个变量保存某一科目的考试成绩时可以将其声明为float. 那么,当我们要做一 ...
- 全国计算机二级c 笔记,[IT认证]全国计算机等级考试二级C语言笔记.doc
[IT认证]全国计算机等级考试二级C语言笔记 全国计算机等级考试概述 考试时间:一年两次,前半年是3月最后一个周末,下半年是9月第三个周末. 开考等级及科目:1级:MS Office.B.WPS Of ...
- 【C语言程序设计进阶-浙大翁恺】C语言笔记 文件
[C语言程序设计进阶-浙大翁恺]C语言笔记 文件 文件 格式化输入输出 文件输入输出 二进制文件 位运算 按位运算 移位运算 位运算例子 位段 文件 格式化输入输出 %-nd:数字左对齐,且输出要占n ...
- Go语言笔记----GoMoudle
Go语言笔记----GoMoudle Go Path模式 gopath缺陷 GoMoudle Go mod命令 go mod环境变量 通过 go env来查看环境变量 使⽤Go Modules初始化项 ...
- 这一次我要真正学会C语言
题图来自pexel 不知道从什么时候开始,我的脑海里就植入了一个想法,"我要学会C语言".虽然我在大学时学过C语言,还参加过C语言等级考试,但是我现在能写的代码也就是"h ...
最新文章
- python 调用api上传物流信息,python实现快递鸟API物流查询接口 数据签名方法
- mysqlsql varchar类型只取前四个_Apache Doris0.12.0 发布，进入 Apache 孵化器后第四个正式版本...
- ad09机械层说明_悉数PCB上的各种层
- 北大OJ百练——4073:最长公共字符串后缀（C语言）
- Java基础——深入理解Java线程池
- SpringBoot2.0整合Mybatis-Plus多数据源
- 求整数 在二进制表示中有多少个1的方法
- 大数据分析引擎Apache Flink升级成为Apache顶级项目
- 计算机二级c语言作弊技巧,计算机等级考试二级C语言题型分析与应试技巧
- 【超分辨率】何凯明新作:Masked Autoencoders Are Scalable Vision Learners
- 和平精英微信和qq不是一个服务器,和平精英qq和微信能一起玩吗 qq微信数据互通吗...
- word 插入图片偏右问题
- STM32学习——直接存储器访问(DMA)
- BR/EDR控制器: 链接管理协议LMP(Link Manager protocol)
- html表格 内容间距,html怎么设置表格间距
- jquery简单赋值取值
- 培训班出来的人后来都怎么样了？（二）
- html选择确认,增值税发票选择确认平台
- Unity初级教程贪吃蛇实现（Snake）带工程源码
- antva-table中使用rowSpan合并单元格