C语言学习笔记
创建项目
vs2019创建C语言项目流程
- 新建项目,选中C++
- 选择空项目并填写项目名称和存储位置
- 找到右侧窗口的解决方案资源管理器,右键新建>添加>新建项,选择C++文件,把后缀名改为.c
- 创建成功
c语言文件后缀类型
- .c - 源文件
- .h - 头文件
stdio.h:standard input output 标准输入输出,程序中输入输出都要包含该头文件
main函数:主函数,程序的入口,一个文件中必须有且只能有一个
printf()函数:在控制台打印输出
scanf()函数:使用键盘输入
-
scanf("%d",&num);
将输入的数值存入num的地址;
&:取地址符号
注意:C语言的变量不能声明在函数的中间,要在开头就声明变量
数据类型
数据类型
- char:字符数据类型,1字节
- short:短整型,2字节,0~2^16-1
- int:整型,4字节,取值范围 0~2^32-1
- long:长整型,4/8字节
- long long:更长的整型,8字节
- float:单精度浮点数,4字节
- double:双精度浮点数,8字节
计算机单位
- 字节:Byte
- 比特:bit
- 1Byte=8bit
使用printf函数打印不同的数据类型,需要使用不同类型所对应的格式化符号。
char c = 'c';
printf("%c\n",c);
输出格式化符号
- %c:字符
- %d:整数
- %f:单精度浮点数
- %lf:双精度浮点数
- %p:一个指针
- %X:无符号十六进制数
变量
定义变量的方法:类型 变量名 = 值;
全局变量:定义在代码块之外的变量是全局变量
局部变量:定义在方法体内的变量是局部变量
当一个方法体内出现和全局变量相同的局部变量时,局部变量优先级更高
变量作用域
- 局部变量的作用域在它所在的代码块内
- 全局变量的作用域是整个工程
声明变量
a文件中定义的全局变量 int num 如果要想在b文件中使用,需要对全局变量num进行声明。
extern int num;
变量生命周期
- 局部变量生命周期:进入作用域生命周期开始,出作用域生命周期结束
- 全局变量生命周期:整个程序的生命周期
常量
C语言中的常量分为以下几种:
-
字面常量,直接写一个数字就是字面常量
-
const修饰的常变量,使用const修饰的变量无法修改,如果修改编译器会报错
const int num;
-
#define定义的标识符常量
#define MAX 10
-
枚举常量,枚举关键字 - enum
enum Sex { MALE,//0 FEMALE//1 };
浮点数
注意事项:整型数字除于整数只会得到整数。如果要想得到浮点数,分母或分子要至少有一个为浮点数。
表达式
一个表达式是一系列运算符和算子的组合,用来计算一个值
- 运算符(operator)是指进行运算的动作,比如加法运算符"+",减法运算符"-"
- 算子(operand)是指参与运算的值,这个值可能是常数,也可能是变量,还可能是一个方法的返回值
运算符包括:+ - * / % 加减乘除取余
运算优先级
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2EdfTptO-1627649549126)(E:\MYZ\笔记\image\image-20210722165829292-16269443145161.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QC719dLZ-1627649549129)(E:\MYZ\笔记\image\image-20210722165939536.png)]
交换变量
两种解决思路:
-
不使用其它的空间
int a = 5;
int b = 6;
a = a+b;
b = a%b;
a = a-b; -
使用额外的空间
int a = 5; int b = 6; int c = a; a = b; b = c;
复合赋值
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kBaj0NDo-1627649549131)(E:/MYZ/%E7%AC%94%E8%AE%B0/image/image-20210722173701467.png)]
递增递减运算符
- count++ count = count + 1
- count-- count = count -1
递增递减运算符前缀后缀
- ++和–可以放在变量的前面,叫做前缀形式,也可以放在变量的后面,交后缀形式
- a++的值是a加1以前的值,而++a的值是加了1之后的值,无论哪个,a自己的值都加了1
int main(){
int a = 0;
printf("a++=%d\n",a++);
printf("a=%d\n",a);
a = 0;
printf("++a=%d\n",++a);
printf("a=%d\n",a);
return 0;
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oP4jo8Jb-1627649549136)(E:/MYZ/%E7%AC%94%E8%AE%B0/image/image-20210722174715940.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tlqjd7Ez-1627649549138)(E:/MYZ/%E7%AC%94%E8%AE%B0/image/image-20210722174839223.png)]
条件判断语句
if else判断语句
-
if(){}else{} 如果满足判断条件,则执行代码块1,否则执行代码块2
if(判断条件){ 代码块1; }else{ 代码块2; }
-
if(){}else if(){}else{} 如果满足判断条件1,执行代码块1,否则再次进行判断条件2是否满足,如果满足执行代码块2,不满足执行代码块3。if后面可以跟无数个else if语句,用法一样
if(判断条件1){ 代码块1; }else if(判断条件2){ 代码块2; }else{ 代码块3; }
-
if()…else… 不带大括号的条件判断语句,不带大括号的情况下,if和else后面的一行是执行语句
if(判断条件) 代码块1;else 代码块2;
关系运算
计算两个值之间的关系,叫做关系运算
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tgNNY63a-1627649549141)(E:/MYZ/%E7%AC%94%E8%AE%B0/image/image-20210722180246672.png)]
结果
比较结果有两种,true或false。即条件成立为true,条件不成立为false
优先级
关系运算优先级比数学运算符低,比赋值运算高。
实例:找零计算器
#include<stdio.h>int main(){ float price = 0; float bill = 0; printf("请输入账单金额:"); scanf("%f",&bill); printf("请输入支付金额:"); scanf("%f",&price); if(price-bill<0){ printf("提示:支付金额不足,还差%f元\n",bill-price); }else if(price-bill>0){ printf("找零%f元\n欢迎下次光临",(price-bill)); }else{ printf("无需找零,欢迎下次光临"); } return 0;}
嵌套的if else判断语句
当if的条件满足或者不满足的时候要执行的语句也可以是一条if或if-else语句,这就是嵌套的if语句
if(条件1){ if(条件2){ 执行体1; }else{ 执行体2; }}else{ if(条件3){ 执行体3; }else{ 执行体4; }}
else的匹配规则:总是和最近的else进行匹配
注意事项
- 在if或else后面总是用{}
- 即使是只有一条语句的时候
if语句常见的错误总结
- 忘带大括号
- if后面多加分号
- 错误使用==和=
- 使人困惑的else
代码风格
- 在if和else之后必须加上大括号形成的语句块
- 大括号内的语句缩进一个tab的位置
switch分支语句
switch语句可以看做是一种基于计算的跳转,计算控制表达式的值后,程序会跳转到相匹配的case(分支标号)处。分支标号只是说明switch内部位置的路标,在执行完分支中的最后一条语句后,如果后面没有break,就回顺序执行到下面的case中去,直到遇到一个break,或者switch结束为止
switch(控制表达式){ case 常量: 语句; break; case 常量: 语句; break; ... default: 执行体n+1; }
可以把switch中的语句看做是一系列连续的语句,相匹配的case可以看做一个入口,如果case中没有break,那么语句会一直往下执行,直到遇到break或default执行完毕
实例:成绩评分
int main(){ int score; printf("请输入你的成绩:"); scanf("%d",&score); score = score/10; switch(score){ case 10: printf("你的成绩评分为:S\n"); break; case 9: printf("你的成绩评分为:A\n"); break; case 8: printf("你的成绩评分为:B\n"); break; case 7: printf("你的成绩评分为:C\n"); break; case 6: printf("你的成绩评分为:D\n"); break; default: printf("你的成绩评分为:E\n"); } return 0;}
循环
while循环
- 当while循环的循环条件满足时,会重复执行大括号中的循环体语句。当循环条件不满足时推出while循环
- 循环执行之前会有一次是否满足循环条件的判断,所以有可能循环一次也没有被执行
- 条件成立时循环继续的条件
while(循环条件){ 循环体;}
实例:使用while循环判断数字的位数
int main(){ int i = 0; int count = 1; printf("请输入一个数字:"); scanf("%d",&i); i /= 10; while(i>0){ count++; i /= 10; } printf("这个数字一共 %d 位",count); return 0;}
do while循环
在进入循环的时候不做检查,而是在执行完一轮循环体的代码之后,再来检查循环的条件是否满足,如果满足则继续下一轮循环,不满足则结束循环
do{ 循环体;}while(循环条件);
while循环和do while循环的区别
- while循环是先判断循环条件,再决定是否执行循环体
- do while循环则是先执行循环体,在判断是否满足条件
实例:使用do while循环来判断数字的位数
int main(){ int i; int count = 0; printf("输入一个数字:"); scanf("%d",&i); do{ i /= 10; count++; }while(i>0); printf("你输入的是%d位数字",count); return 0;}
注意:while循环的循环体内要有跳出循环的机会,否则将永远无法离开循环,成为死循环
程序的调试
- 测试程序常使用边界数据,如有效范围两端的数据、特殊的倍数等
- 在程序适当的地方插入printf来输出变量的内容
猜数字游戏
使用随机数生成函数rand()需要引入stdlib.h包,为了每次生成的随机数不一样,我们需要生成随机数种子,我们使用时间来帮助生成随机数种子,因此要引入time.h包。
生成随机数种子方法:
srand((unsigned)time(NULL));
#include<stdio.h>#include<stdlib.h>#include<time.h>//猜数字游戏int main(){ int i = 0; int a = 0; int c = 0; srand((unsigned)time(NULL)); i = rand()%100; printf("猜数字游戏,请输入1-100的数字\n"); do{ printf("输入数字:"); scanf("%d",&a); c++; if(a>i){ printf("太大了\n"); }else if(a<i){ printf("太小了\n"); } }while(a!=i); printf("恭喜你猜对了,使用了%d次机会",c); return 0;}
整数逆序
int main(){ int i = 1234567800; int ret = 0; int t = 0; while(i>0){ ret = i%10; t = t*10 + ret; i /= 10; printf("%d",ret); } //printf("%d",t); return 0;}
for循环
for循环的运行步骤为
-
判断条件是否满足,满足:执行循环体,不满足:退出for循环
-
执行完循环体后,执行改变动作
-
再次进行循环条件的判断
重复以上操作…
-
直到判断条件为假,退出for循环
for(初始值;判断条件;改变动作){ 循环体;}
for循环求阶乘
int main(){ int n = 3;//求n的阶乘 int fact = 1; int i; for(i=2;i<=n;i++){ fact *= i; } printf("%d",fact); return 0;}
for循环改造为while循环,只需要将for循环的初始值放在外面,判断条件作为while循环的退出条件,改变初始值的操作放在while循环的循环体内,例如:
int main(){ int n = 3;//求n的阶乘 int fact = 1; int i=2; while(i<=n){ fact *=i; i++; } printf("%d",fact); return 0;}
几类循环的使用场景
- for:有固定循环次数
- do while:必须先执行一次
- while:其他情况
跳出循环
- break:跳出循环
- continue:跳过这轮循环剩下的语句,进入下一轮循环
- goto:可以直接到达程序指定的位置。
break和continue都只能跳出当前层的循环,如果我们需要跳出多层循环,有两种方法,使用break接力或使用goto语句。
演示
#include<stdio.h>//break接力和金手指goto语句 int main(){ int a=0; int b=0; int c=0;//在break接力方法中,我们使用c作为标志位 for(a=1;a<5;a++){ for(b=1;b<5;b++){ //我们假设当a=3时跳出所有循环 if(a==3){ c=1; break; } } if(c==1){ break; } printf("%d",a); } //goto语句可以跳转到代码中指定的地方 for(a=1;a<5;a++){ for(b=1;b<5;b++){ //我们假设当a=3时跳出所有循环 if(a==3){ goto out; } } printf("%d",a); } out: return 0;}
循环嵌套
- 循环里面还是循环
练习
练习:输出100以内的素数
#include<stdio.h>//练习:输出100以内的素数int main(){ int s=2; while(s<=100){ int sign = 0;//标志,0为素数,1不是素数 int i = 0; for(i=2;i<s;i++){ if(s%i==0){ sign = 1; break; } } if(sign==0){ printf("%d ",s); } s++; } return 0;}
练习:凑硬币,使用1角、2角、5角凑出指定的金额
#include<stdio.h>//练习:使用1角,2角,5角凑指定的金额(可以是小数)int main(){ int one; int two; int five; float m; printf("请输入需要凑的金额(元):"); scanf("%f",&m); for(five=0;five<=m*10/5;five++){ for(two=0;two<=m*10/2;two++){ for(one=0;one<=m*10;one++){ if(five*5+two*2+one==m*10){ printf("%d个5角 %d个2角 %d个1角\n",five,two,one); } } } } return 0;}
练习:1+1/2+1/3+…+1/n
#include<stdio.h>int main(){ int i=0; int n=0; double sum; printf("求1到1/n的和,输入:"); scanf("%d",&n); for(i=1;i<=n;i++){ sum+=1.0/i; } printf("1到1/%d的和为:%f",n,sum);}
练习:1-1/2+1/3-1/4+…+1/n
#include<stdio.h>//练习:1-1/2+1/3-1/4+...+1/nint main(){ int i=0; int n=0; double sum; printf("求1到1/n的和,输入:"); scanf("%d",&n); for(i=1;i<=n;i++){ if(i%2==0){ sum-=1.0/i; }else{ sum+=1.0/i; } } printf("1到1/%d的加和减为:%f",n,sum);}
练习:正序分解整数
#include<stdio.h>//练习:正序分解整数int main(){ int x = 0; int temp= 0;//临时容器,用于保存x的初始值 int size = 1;//输入数字长度 printf("输入:"); scanf("%d",&x); temp=x; while(x>9){ size*=10; x/=10; } do{ printf("%d ",temp/size); temp=temp%size; size/=10; }while(size>0); return 0;}
练习:求两个整数的最大公约数
#include<stdio.h>//求两个整数的最大公约数 int main(){ int a = 0; int b = 0; int min; int ret = 1; int max = ret; printf("输入两个数:"); scanf("%d %d",&a,&b); if(a>b){ min = b; }else{ min = a; } for(ret = 1;ret<=min;ret++){ if(a%ret==0){ if(b%ret==0){ if(ret>max){ max = ret; } } } } printf("%d 和 %d 的最大公约数为:%d",a,b,max); return 0;}
补充:使用辗转相除法求两个整数的最大公约数
#include<stdio.h>//使用辗转相除法求两个整数的最大公约数 /* 如果b等于0,计算结束,a就是最大公约数 否则,计算a除以b的余数,让b等于b,而b等于那个余数 回到第一步 a b t 12 18 12 18 12 6 12 6 0 6 0*/int main(){ int a = 0; int b = 0; int t; printf("输入两个数:"); scanf("%d %d",&a,&b); while(b!=0){ t = a%b; a = b; b = t; } printf("最大公约数为:%d",a,b,a); return 0;}
练习:输出指定条件的整数集
#include<stdio.h>/* 给定不超过6的整数A,考虑从A开始的连续4个数字,请输出所有由他们组成的无重复数字的3位数 要求:从小到大输出,每行6个整数,行末不能有空格 */ int main(){ int a; int cnt=0; int i,j,k; printf("输入一个数:"); scanf("%d",&a); if(a>6){ printf("输入数字超过6"); return 0; } for(i=a;i<=a+3;i++){ for(j=a;j<=a+3;j++){ for(k=a;k<=a+3;k++){ if(i!=j && j!=k && i!=k){ printf("%d%d%d",i,j,k); cnt++; if(cnt%6==0){ printf("\n"); }else{ printf(" "); } } } } } return 0;}
练习:水仙花数
#include<stdio.h>/* 给定一个数字n,水仙花数是每位上的数字的n次幂之和等于它本身 要求输出3<=N<=7 */int main(){ int x; //x是输入的位数 int i=1; int first = 1; scanf("%d",&x); while(i<x){ first*=10; //输入是4时,输出1000 i++; } i=first; while(i<first*10){ //加入输入是3 i=100 first*10=1000 输出100-999的水仙花数 int t = i; //临时变量t,用来记录该轮循环的i的值 int sum = 0; //如果i的每一位的n次幂,等于sum,则说明这个数是水仙花数 while(t!=0){ //先取出数字每一位的值 int d = t%10; int p = 0; int a = 1; t /= 10; while(p<x){ a *= d; p++; } sum +=a; } if(sum==i){ //判断每一位的n次幂的和与初始值是否相等 printf("%d\n",i); } i++; } return 0;}
练习:打印九九乘法表
#include<stdio.h>//练习:九九乘法表 int main(){ int i = 0; int j = 0; for(i=1;i<10;i++){ for(j=1;j<=i;j++){ printf("%d*%d=%d ",j,i,i*j); } printf("\n"); }}
练习:求序列前n项和
#include<stdio.h>
//求序列前n项和 2/1+3/2+5/3...
int main(){
int i,j;
double k=2;
double p=1;
double sum=0;
printf("input:");
scanf("%d",&i);
for(j=1;j<=i;j++){
sum+=k/p;
double t=k;
k = k+p;
p = t;
}
printf("output:%f",sum);
return 0;
}
数据类型(翁帆)
-
整数
char、short、int、long、long long
-
浮点数
float、double、long double
-
逻辑
bool
-
指针
-
自定义类型
sizeof
- 是一个运算符,给出某个类型或变量在内存中所占据的字节数
负数的表达
在c语言中,负数以补码的形式来表达。
例如:char类型的数据,00000000-111111111 表示的是从-128~127
1000000011111111表示的是-128 -1,当这个数据的二进制最高位为1时,被认为是以补码的形式表示的负数。
如果不想要表示负数,可以在数据生命前加unsigned关键字
当我们使用代码来验证时,a输出的是-1,b输出的是255
#include<stdio.h>int main(){ char a = 255; unsigned char b = 255; printf("%d\n",a); printf("%d\n",b); return 0;}
整数是以纯二进制方式进行计算的
- 11111111+1 ===> 100000000 ===> 0
- 01111111+1 ===> 10000000 ===> -128
- 10000000-1 ===> 01111111 ===> 127
8进制和16进制
- 一个以0开始的数字字面量是8进制
- 一个以0x开始的数字字面量是16进制
- %0用于8进制,%x用于16进制
- 8进制和16进制只是如何把数字表达为字符串,与内部如何表达数字无关
选择整数类型
为什么整数要有那么多种?
- 为了准确表达内存,做底层程序的需要
没有特殊需要,就选择int
- 现在的CPU的字长普遍是32位或64位,一次内存读写就是一个int,一次计算也是一个int,选择更短的类型不会更快,甚至可能更慢
- 现代的编译器一般会设计内存对齐,所以更短的类型实际在内存中有可能也占据一个int的大小
unsigned与否只是输出的不同,内部计算是一样的
浮点类型
- float 4字节 字长32位 scanf:%f printf:%f,%e
- double 8字节 字长64位 scanf:%lf printf:%f,%e
- float类型只有小数点后7位是有效地,double类型小数点后15位是有效的,超过有效位的数值会出现误差
%e 表示数值以科学记数法表达
浮点数输出精度
- 在%和f之间加上.n可以指定输出小数点后几位,这样的输出是做四舍五入
例如:输出结果保留两位小数
#include<stdio.h> int main(){ double d = 2; printf("%.2f",d); return 0;}//输出结果:2.00
超过范围的浮点数
- printf输出inf表示超过范围的浮点数:±∞
- printf输出nan表示不存在的浮点数
- 无穷大不能用整数来表示,只能在浮点数的运算中出现
浮点运算的精度
- 带小数点的字面量是double而不是float
- float需要用f或F后缀来表明身份
浮点数的内部表达
- 浮点数在计算时是由专用的硬件部件实现的
- 计算double和float所用的部件是一样的
选择浮点数类型
- 如果没有特殊需要,只是用double
- 现代CPU能直接对double做硬件运算,性能不会比float差,在64位的计算机中,数据存储的速度也不会比float慢
字符类型
char是一种整数,也是一种特殊的类型:字符。这是因为
- 用单引号表示的字符字面量:‘a’,‘1’
- ''也是一个字符
- printf和scanf里用%c来输出字符
字符的输出输出
如何输入’1’这个字符给char c?
#include<stdio.h> int main(){ char c; scanf("%c",&c); //以整数类型输出 printf("%d\n",c); //以字符类型输出 printf("%'c'\n",c); return 0;}//输入:1 输出结果为:49 'c'
字符计算
- 一个字符加一个数字得到ASCII码表中那个数之后的字符
- 两个字符的减,得到它们在表中的距离
大小写转换
- 字母在ASCII表中是顺序排列的
- 大写子母和小写字母是分开排列的,并不在一起
- ‘a’-'A’可以得到两个字母在ASCII表中的距离
逃逸(转义)字符
用来表达无法打印出来的控制字符或特殊字符,它由一个反斜杠“\”开头,后面跟上另一个字符,这两个字符合起来,组成一个字符
- \b 回退一格
- \t 到下一个表格位
- \n 换行
- \r 回车
- \" 双引号
- \’ 单引号
- \\ 反斜杠本身
自动类型转换
当运算符的两边出现不一致的类型时,会自动转换成较大的类型
- 大的意思是能表达的数的范围更大
- char->short->int->long->long long
- int->float->double
强制类型转换
要把一个量强制转换成另一个类型,通常是把较大的类型强制转换成较小的类型
- (类型)值
- 强制类型转换的优先级高于四则运算
此时需要注意安全性问题,因为小的变量有时候无法表达大的量
逻辑类型bool
必须首先导入头文件#include<stdbool.h>,之后才可以使用bool和true、false。但是在c语言中true和false依然是用整数1、0来表示,所以printf输出时依然使用%d
逻辑运算
逻辑运算符
逻辑运算是对逻辑量进行的运算,结果只有0或1。逻辑量是关系运算或逻辑运算的结果。
- ! 逻辑非 !a 如果a是true结果就是false,如果a是false结果就是true
- && 逻辑与 a&&b 如果a和b都是true,结果就是true;否则就是false
- || 逻辑或 a||b 如果a和b一个是true,结果就是true;两个都是false,结果为false
优先级
- ! > && >||
短路
逻辑运算是自左向右进行的,如果左边的结果已经能够决定结果了,就不会做右边的计算。
条件运算
条件运算符
- count=(count>20)?count-10:count+10;
- 结果=条件?条件满足时操作:条件不满足时操作
优先级
- 条件运算符的优先级高于赋值运算符,但是低于其它运算符
函数
什么是函数?
- 函数是一块代码,接收零个或多个参数,做一件事情,并返回零个或一个值
- 可以先想象成数学中的函数y=f(x)
函数结构
返回值类型 函数名(参数){ 函数体;}//当函数无返回值时,返回值类型使用void;有返回值类型时,需要在函数体中return对应类型的返回值
调用函数
//函数名(参数);#include<stdio.h>void cheer(){ printf("cheer\n");}//函数调用 int main(){ cheer(); return 0;}
函数原型
上面的函数在main方法的前面,如果自定义函数要放在main方法的后面,需要在程序的开始声明函数的原型。否则有可能会报错。
- 函数头,一份好结尾,就构成了函数的原型
- 函数原型的目的是告诉编译器这个函数长什么样子(名称、参数、返回类型)
//函数名(参数);#include<stdio.h>void cheer();//函数声明//函数调用 int main(){ cheer(); return 0;}void cheer(){ printf("cheer\n");}
参数传递
- 调用函数时给的值与参数的类型不匹配是C语言传统上最大的漏洞
- 编译器总是悄悄替你把类型转换好,但是这很可能不是你所期望的
- 后续的语言,C++、Java在这方面更严格
- C语言在调用函数时,只会传值给函数
局部变量
- 函数的每次运行,就产生了一个独立的变量空间,在这个空间中的变量,是函数的这次运行所独有的,称为局部变量
- 定义在函数内部或方法内部的变量都是局部变量
- 参数也是局部变量
变量的生存周期
- 函数开始运行到函数运行结束
变量的作用域
- 局部变量的作用域在函数内部
数组
c语言支持数组数据结构,它可以存储一个固定大小的相同类型元素的顺序集合。数组中的特定元素可以通过索引访问,第一个索引值为0
声明数组
数组类型 数组名[数组容量]
初始化数组
数组类型 数组名[数组容量] = {元素1,元素2...}
需要注意的是,如果初始化数组时数组容量不为空,则数组的元素个数不能大于数组容量。
//初始化数组int arr[5] = {1,2,3,4,5}; //有初始容量int arr[] = {1,2,3,4,5,6}; //无初始容量
访问数组元素
数组元素可以通过数组名加索引进行访问。元素的索引放在方括号内
printf("%d",arr[0]);//输出:1
二维数组
-
int a[3][5];
-
通常可以理解为a是一个3行5列的矩阵
二维数组的遍历
使用一个双层for循环进行遍历。例如:
#include<stdio.h>
int main(){
//二维数组初始化
int a[2][2] = {1,2,3,4};
int i,j;
//二维数组遍历
for(i=0;i<2;i++){
for(j=0;j<2;j++){
printf("%d ",a[i][j]);
}
}
}
数组变量是特殊的指针
- 数组变量本身表达地址,所以,int a[10];int *p=a; //无需用取地址符&
- 但是数组的单元表达的是变量,需要用&取地址,a==&a[0]
- []运算符可以对数组做,也可以对指针做:p[0]<==>a[0]
- *运算符可以对指针做,也可以对数组做:*a=25;
- 数组int b[] 等价于 int *const b
枚举enum
枚举是C语言中的一种基本数据类型,它可以让数据更简洁,更易读。语法:
enum 枚举名{
枚举元素1,枚举元素2,...
}枚举变量;
练习:输出张三 李四 王五三个人的年龄
#include<stdio.h>
int main(){
enum Name{
zhangsan=21,lisi=22,wangwu=23
}name;
printf("张三的年龄:%d\n",name = zhangsan);
printf("李四的年龄:%d\n",name = lisi);
printf("王五的年龄:%d\n",name = wangwu);
return 0;
}
取地址符号&
- scanf("%d",&i)里的&
- 获得变量的地址,它的操作数必须是变量
练习:输出某个变量的地址
#include<stdio.h>
int main(){
int i;
printf("%p",&i);
return 0;
}
指针变量
- 指针变量的值是内存的地址,是具有实际值的变量在内存中存放的地址
- 普通变量的值是实际的值
指针变量的声明
int i;
int* p = &i;
int* p,q;//指针变量p,整数变量q
int *p,q;//指针变量p,整数变量q
//指针变量的声明推荐星号离变量近
int *p;
在上面声明指针变量的例子中,我们这样描述:指针变量p指向整形变量i,因为p存放的是i在内存中的地址
使用指针输出地址变量
#include<stdio.h>
//使用指针输出变量地址
int main(){
int i=0;
int *p = &i;
printf("%p",p);
return 0;
}
//输出:000000000062FE14
访问地址符号*
- *是一个单目运算符,用来访问指针的值所表示的地址上的变量
- 可以做右值也可以做左值 int k = *p; *p = k+1;
指针访问和修改变量
#include<stdio.h>
//指针访问和修改变量
int main(){
int i=0;
int *p = &i;
//访问变量
printf("使用指针访问,i:%d\n",*p);
//修改变量
printf("使用指针修改变量后,i:%d\n",*p=26);
return 0;
}
//输出:0 26
练习:输出一个整形数组的最大值和最小值
#include<stdio.h>
void swap(int a[],int len,int *min,int *max);
int main(){
int arr[6]={2,45,6623,7,43,2};
int min,max;
minmax(arr,6,&min,&max);
printf("arr最小值:%d\n",min);
printf("arr最大值:%d\n",max);
}
void minmax(int a[],int len,int *min,int *max){
int i;
*min=a[0];
*max=a[0];
for(i=0;i<len;i++){
if(*min>a[i]){
*min=a[i];
}
if(*max<a[i]){
*max=a[i];
}
}
}
//输出:arr最小值:2 arr最大值:6623
指针最常见的错误
- 定义了指针变量,还没有指向任何变量,就开始使用指针
c语言求数组长度
求c语言中数组的长度,我们可以先使用sizeof方法获取数组的所占的字节数,然后再除以数组元素的长度,即得到数组的长度
#include<stdio.h>
int main(){
int a[3]={1,2,3};
int size = sizeof(a)/sizeof(a[0]);
printf("%d\n",size);
return 0;
}
//输出:3
使用指针获取数组指定元素的值
#include<stdio.h>
int main(){
int arr[6]={1,2,3,4,5,6};
int *p = &arr[0];
printf("数组arr第2个元素值:%d\n",*(p+1));
printf("数组arr第3个元素值:%d\n",arr[0]+2);
return 0;
}
数组变量是特殊的指针
- 数组变量本身表达地址,所以,int a[10];int *p=a; //无需用取地址符&
- 但是数组的单元表达的是变量,需要用&取地址,a==&a[0]
- []运算符可以对数组做,也可以对指针做:p[0]<==>a[0]
- *运算符可以对指针做,也可以对数组做:*a=25;
- 数组int b[] 等价于 int const *b
指针与const
int i;
const int *p1 = &i;
int const *p2 = &i;
int *const p3 = &i;
//分别是什么意思?
判断哪个被const了的标志是const在*的前面还是后面。如果const在*前面,表示它所指向的东西不能被修改。如果const在*后面,表示指针不能被修改。
因此,前两种const在*前面,表示两个指针所指向的东西不能修改。第三种const在*后面,表示指针不能被修改。
转换
-
总是可以把一个非const的值转换成const的
void f(const int *x); int a = 15; f(&a); const int b = a;
-
当要传递的参数的类型比地址大的时候,这是常用的手段:既能用比较少的字节传递值给参数,又能避免函数对外面的变量的修改
const数组
- const int a[] = {1,2,3,4,5,6};
- 数组变量已经是const的指针了,这里的const表明数组的没个单元都是const int
- 所以只能通过初始化进行赋值
保护数组值
-
因为把数组传入函数时传递的是地址,所以那个函数内部可以修改数组的值
-
为了保护数组不被函数破坏,可以设置参数为const
int sum(const int a[],int length); //这样,传入的数组就无法被修改
指针运算
-
给一个指针加1表示要让指针指向下一个变量
int a[10]; int *p = a; *(p+1) ——> a[1] *(p+n) <==> a[n] //等价
-
如果指针不是指向一片连续分配的空间,如数组,则这种运算没有意义
*p++
- 取出指针p所指的那个数据来,之后顺便把p移到下一个位置去
- *的优先级虽然高,但是没有++高
- 常用于数组类的连续空间操作
- 在某些CPU上,这可以直接被翻译成一条汇编指令
#include<stdio.h>
//遍历整型数组
int main(){
int a[] = {1,2,3,4,5};
int i=0;
for(i=0;i<sizeof(a)/sizeof(a[0]);i++){
printf("%d ",a[i]);
}
return 0;
}
指针的类型
- 无论指针指向什么类型,所有的指针的大小都是一样的,因为都是地址
- 指向不同类型数据的指针最好不要直接互相赋值,避免不必要的错误
指针的类型转换
-
void*表示不知道指向什么类型数据的指针,计算时和char*相同
-
指针也可以强制转换类型
int *p = &i; void *q = (void\*)p;
-
指针的转换类型没有改变p指向的变量的类型,只是改变了指针的类型
动态分配内存
在c99之后,直接使用变量定义数组所占空间,但是在之前需要使用malloc函数申请指定大小的空间,并且使用完后要使用free释放空间(谨记)
int *a = (int*)malloc(n*sizeof(int));
free(a);
练习:使用malloc函数构建数组
#include<stdio.h>
#include<stdlib.h>
//使用malloc函数动态构建数组
int main(){
int n = 5;
int i = 0;
int s = 0;
int *a = (int*)malloc(n*sizeof(int));
for(i=0;i<n;i++){
scanf("%d",&a[i]);
}
for(i=0;i<n;i++){
printf("%d ",a[i]);
}
free(a);
return 0;
}
练习:测试可以向系统申请的最大空间
#include<stdio.h>
#include<stdlib.h>
//测试可以向系统申请的最大空间
int main(){
int *p;
int c = 0;
while((p=malloc(100*1024*1024))){ //一次循环100M
c++;
}
printf("系统最大申请空间:%dM",100*c);
return 0;
}
字符串
- 以0结尾的一串字符,0和’\0’是一样的
- 0标志字符串的结束,但它不是字符串的一部分,计算字符串的长度时不包含这个0
- 字符串以数组的形式存在,以数组或指针的形式访问
- string.h里有很多字符串的函数
字符串变量
- char *str = “Hello”;
- char word[] = “Hello”;
- char line[10] = “Hello”;
字符串常量
- “Hello”,它会被编译器变成一个字符数组放在某处,这个数组的长度为6,其中字符串内容占5个字节,但是结尾还有表示结束的0
- 两个相邻的字符串常量会被自动连接起来
总结
- C语言的字符串是以数组的形态存在的
- 不能用运算符对字符串做运算
- 通过数组的方式可以遍历字符串
- C语言的字符串特殊的地方是字符串常量可以用来初始化字符数组
创建字符串
- 使用指针创建字符串:char *s = “hello”;等价于 const char *s = “hello”;
- 使用数组创建字符串:char s[] = “hello”;
- 它们的区别在于,使用指针创建的字符串只能读,使用数组创建的字符串不仅可以读,而且可以修改。
#include<stdio.h>int main(){ char s[] = "Hello"; printf("%c\n",s[0]); printf("Hello字符串的长度:%d,因为它还有末尾表示字符串的标志位0,也占一个字节",sizeof(s)/sizeof(char)); return 0;}
char*是否是字符串?
- 字符串可以用char*的形式表示
- char*并不一定是字符串,有可能是指向字符的指针
- 只有char*指向的字符数组有结尾的0时,才能说它所指的是字符串
字符串输入输出
char string[8];scanf("%s",string);printf("%s",string);
字符串可以用%s来输入和输出
#include<stdio.h>
int main(){
char s[6];
//scanf键盘输入
scanf("%5s",s);
printf("%s",s);
return 0;
}
安全的输入
如何避免输入的字符串数量越界问题,我们可以在%s中间加入最大字符的数量,来避免这个问题
字符串数组
两种方式
-
char a\[][10] = {"Hello","World"};
-
char *a[] = {"Hello","World"};
第一种方式是指,创建一个字符串数组,每个元素的最大长度不能超过10。
第二种方式是指,创建一个字符串数组,每个元素都是一个指向一个字符串的指针变量。
单字符输入输出
putchar
-
int putchar(int c);
-
向标准输入写一个字符
-
返回写了几个字符,EOF (-1) 表示写失败
#include<stdio.h>
int main(){
int ch;
while((ch = getchar())!=EOF){
putchar(ch);
}
return 0;
}
字符串函数
strlen
返回字符串的长度;
int strLen(char str[]){
int index = 0;
while(str[index]!="\0"){
index++;
}
return index;
}
strcmp
int strcmp(const char *s1,const char *s2);
比较两个字符串,返回:
- 0:s1==s2
- 1:s1>s2
- -1:s1<s2
strcpy
-
char *strcpy(char \*restrict dst,const char\* restrict src);
-
把src的字符串拷贝到dst,restrict表明src和dst不重叠
-
返回dst
#include<stdio.h>
#include<string.h>
int main(){
char a[5];
char b[5] = {"abc"};
strcpy(a,b); //将字符串数组b拷贝给a
printf("%s",a);
return 0;
}
strcat
-
char *strcat(char *restrict s1,const char *restrict s2);
-
把s2拷贝到s1的后面,形成一个长的字符串,返回s1。过程会改变s1
-
s1必须具有足够的空间
#include<stdio.h>
#include<string.h>
int main(){
char a[10] = {"ab"};
char b[3] = {"cde"};
strcat(a,b);
printf("%s",a);
}
安全问题
strcpy和strcat都可能出现安全问题,如果目的地没有足够的空间使用这两个函数就会出现越界问题。
安全版本
int strncmp(s1,s2,n); //字符串比较函数
char *strncpy(s1,s2,n); //n表示s1所能接受的最大字符数量
char *strcat(s1,s2,n); //n表示s1所能接受的最大连接字符数量
strchr
strchr函数是在一个字符串中搜索一个字符,如果有就返回该字符的地址,如果没有就返回NULL
#include<stdio.h>
#include<string.h>
int main(){
char s[] = "hello";
char *p = strchr(s,'l');
printf("%s",p);
char *q = (char*)malloc(strlen(p)+1);
strcpy(q,p);
printf("%s",q);
free(q);
return 0;
}
strstr
strstr(s1,s2); //在一个字符串中找另一个字符串
结构类型
声明结构形式
struct 结构名{
结构体;
}变量名;
//在结构体声明中,结构名或变量名可以忽略,但是不能同时忽略,因此就出现了三种声明形式
struct data{ //单纯声明结构体,不带变量名
int year;
};
struct{ //不带结构体名,直接生成变量,这种形式可以理解为一次性生成两个变量
int year;
}y1,y2;
struct data{ //带结构体名,带变量名
int year;
}y1,y2;
结构变量赋值的三种方式
#include<stdio.h>
struct data{
int year;
int month;
int day;
};
int main(){
//第一种结构变量赋值方式
struct data today;
today.year = 2021;
today.month = 7;
today.day = 29;
//第二种结构变量赋值方式
struct data t1 = {2020,7,29};
//第三种结构变量赋值方式
struct data t2 = {.year=2019,.month=7};
printf("today:%d年%d月%d日\n",today.year,today.month,today.day);
printf("t1:%d年%d月%d日\n",t1.year,t1.month,t1.day);
printf("t2:%d年%d月%d日\n",t2.year,t2.month,t2.day);
return 0;
}
结构变量取地址
#include<stdio.h>
struct data{
int year;
int month;
int day;
};
int main(){
struct data t1 = {1,2,3};
struct data *p = &t1;
printf("%p",p);
return 0;
}
结构与函数
结构作为函数参数
int funcTion(struct data d)
- 结构体可以作为参数的值传入函数,并不是传结构变量本身
- 这时候是在函数内部新建一个结构变量,并赋值调用者的结构的值
- 结构体也可以作为返回值
结构指针
- 用->表示指针所指的结构变量中的成员
#include<stdio.h>
struct data{
int year;
int month;
int day;
}today;
//使用指针访问结构体变量的方式为 指针->变量值
int main(){
struct data *p = &today;
p->year=2020;
p->month = 7;
p->day = 29;
printf("%d,%d,%d",p->year,p->month,p->day);
return 0;
}
结构数组
typedef自定义数据类型
- C语言提供了一个叫做typedef的功能来声明一个已有的数据类型的新名字。比如:typedef int Length,使Lenght成为int类型的别名。
- 因此,Length就可以代替int出现在变量定义和参数声明的地方。Length a,b,len; Length num[10];
#include<stdio.h>
/*
使用typedef关键字后,结构体声明struct Data d1 等价于 data d1
*/
typedef struct Data{
int year;
int month;
int day;
}data;
int main(){
struct Data p = {2021,2,1};
data d = {2020,2,1};
printf("%d,%d,%d\n",p.year,p.month,p.day);
printf("%d,%d,%d",d.year,d.month,d.day);
return 0;
}
union
- 存储:所有成员共享一个空间,同一时间只有一个成员有效,union大小是其最大的成员
- 初始化:对第一个成员做初始化
全局变量
- 定义在函数外面的变量是全局变量
- 全局变量具有全局的生存周期和作用域,在所有函数中都可以使用它们
全局变量初始化
- 没有做初始化的全局变量会得到0值,指针会得到NULL值
- 只能用编译时刻已知的值来初始化全局变量
- 全局变量的初始化发生在main函数之前
#include<stdio.h>
int A = 2; //声明全局变量
int main(){
printf("%d",A);
}
静态本地变量
- 在本地变量定义时加上static修饰符就成为静态本地变量
- 当函数离开的时候,静态本地变量会继续存在并保持该值
- 静态本地变量的初始化只会在第一次进入这个函数时做,以后进入函数时会保持上次离开的值
#include<stdio.h>
void f();
int main(){
f();
f();
}
void f(){
static int all = 1;
all++;
printf("%d\n",all);
}
- 静态本地变量实际上是特殊的全局变量,它和全局变量在相同的内存区域
- 静态本地变量具有全局的生存周期,函数内的局部作用域,static在这里的意思是局部作用域
总结:静态本地变量的生存周期是全局的,作用域是本地的。
返回指针的函数
- 返回本地变量的地址是危险的
- 返回全局变量或静态本地变量的地址是安全的
- 返回在函数内malloc的内存是安全的,但是容易造成问题
- 最好的做法是返回作为参数传入的指针
宏定义
编译预处理指令
- #开头的是编译预处理指令
- 它们不是C语言的成分,但是C语言程序离不开它们
- #define用来定义一个宏
#include<stdio.h>
#define MAX 100
int main(){
printf("%d",MAX);
}
- #define 名字 值
- 注意结尾没有分号,因为不是C语句
- 名字必须是一个单词,值可以是各种东西
- 编译预处理程序会把程序中的MAX换成100
宏
- 如果一个宏的值中有其它宏的名字,也是会被替换
- 如果一个宏的值超过一行,最后一行之前的行末要添加\
- 宏的值后面出现的注释不会被当做宏的值的一部分
没有值的宏
#define _DEBUG
这类宏是用于条件编译的,后面有其它的编译预处理指令来检查这个宏是否已经被定义过
预定义的宏
- _LINE_:行数
- _FILE_:文件路径
- _DTAE_:日期
- _TIME_:时间
带参数的宏
#include<stdio.h>
#define MAX(x) (x)*(x)*(x)
int main(){
printf("%d",MAX(5));
return 0;
}
使用原则
-
一切都要括号,整个值要括号,参数出现的每个地方都要带括号
-
#define MAX(x) (x)*(x)*(x)
-
定义宏时,结尾一定不要加分号
多个源代码文件
- main()函数里的代码太长了适合分成几个函数
- 一个源代码文件太长了适合分成几个文件
- 两个独立的源代码文件不能编译形成可执行的程序
项目
- 在Dev C++中新建一个项目,然后把几个源代码文件加入进去
- 对于项目,Dev C++的编译会把一个项目中所有的源代码文件都编译后,连接起来
- 有的IDE有分开的编译和构建两个按钮,前者是对单个源文件编译,后者是链接整个项目
头文件
把函数原型放到一个头文件(以.h结尾)中,在需要调用这个函数的源代码文件(.c文件)时,#include这个头文件,就能让编译器在编译的时候知道函数的原型
#include
- #include是一个编译预处理指令,和宏一样,在编译之前进行处理
- #include把那个文件的全部文本内容插入到#include所在的地方
""还是<>
- #include有两种形式来指出要插入的文件,双引号要求编译器首先在当前目录寻找这个文件,如果没有再到编译器指定的目录寻找,尖括号是让编译器只在指定的目录去找这个文件
- 编译器自己知道自己的标准库的头文件在哪
- 环境变量和编译器命令行参数也可以指定寻找头文件的目录
头文件
- #include其实就是将文件中可能使用到的函数的原型,从对应的.h文件中拷贝到当前文件的开头。
- 在使用和定义这个函数的地方都应该#include这个头文件
- 一般的做法就是任何.c都有对应的同名的.h文件,把所有对外公开的函数的原型和全局变量的声明都放进去
不对外公开的函数
- 在函数前面加上static就使得它成为只能在所在的编译单元中被使用的函数
- 在全局变量前面加上static就使它成为只能在所在的编译单元中被使用的全局变量
声明
声明全局变量的方法:在.h文件中加上
extern int All;
声明和定义
声明是不产生代码的东西
- 函数原型
- 变量声明
- 结构声明
- 宏声明
- 枚举声明
- inline函数
定义时产生代码的东西
重复声明
- 在同一个编译单元里,同名的结构不能被重复声明
- 如果你的头文件里有结构的声明,很难这个头文件不会在一个编译单元里被#include多次
- 所以需要标准头文件结构
标准头文件结构
使用max.h文件举例
#ifndef _MAX_H_ //判断语句,判断是否定义过_MAX_H_,false:执行下列语句。true:跳过
#define _MAX_H_ //宏定义 #_MAX_H_
double max(double a,double b);
extern int All;
#endif //结束
- 运用条件编译和宏,保证这个头文件在一个编译单元中只会被#include一次
- #pragma once 也能起到相同的作用,但不是所有的编译器都支持
格式化输入输出
%[flags][width][.prec][hlL]type
flag
- - 左对齐
- + 在前面放+或-
- (space) 正数留空
- 0 零填充
width或prec
- number 最小字符数
- * 下一个参数是字符数
- .number 小数点后的位数
- .* 下一个参数就是小数点后的位数
type
- i或d:int
- u:unsigned int
- o:八进制
- x:十六进制
- X:字母大写的十六进制
- f或F:float,6
- e或E:指数
- g:float
- G:float
- a或A:十六进制浮点数
- c:char
- s:字符串
- p:指针
- n:读入/写出的个数
scanf:%[flag]type
flag
- *:跳过
- 数字:最大字符数
- hh:char
- h:short
- l:long,double
- ll:long long
- L:long double
type
- d:int
- i:整数,可能为十六进制或八进制
- u:unsigned int
- o:八进制
- x:十六进制
- a,e,f,g:float
- c:char
- s:字符串
- p:指针
printf和scanf的返回值
- scanf:输出的字符数
- printf:读入的项目数
在要求严格的程序中,应该对scanf和printf的返回值进行判断,判断程序是否出错
文件输入输出
用>和<做重定向
打开文件的标准代码
FILE *fp = fopen("file","r");
if(fp){
fscanf(fp,...);
fclose(fp);
}else{}
fopen函数
- r:打开只读
- r+:打开读写,从文件头开始
- w:打开只写,如果不存在则新建,如果存在则清空
- w+:打开读写。如果不存在则新建,如果存在则清空
- a:打开追加。如果不存在则新建,如果存在则从文件尾开始
- …x:只新建,如果文件已存在则不能打开
二进制文件
按位运算
按位运算的运算符:
- &:按位的与
- |:按位的或
- ~:按位取反,0变1,1变0
- ^:按位的异或
- <<:左移,左移一位等价于乘2,移两位等价于乘4,移n位等价于乘2^n
- >>:右移,右移n位等价于除以2^n,对于unsigned类型,右移后原来的位置填入0,而对于signed类型,右移后最高位不变。例如:signed 1000右移1位,得到1100。最高位依然是原来的数。unsigned 1000右移1位,得到0100,最高位填充0。
位段
- 可以直接用位段的成员名称来访问,比移位、与、或更方便
- 编译器会安排其中的位的排列,不具有可移植性
- 当所需的位超过一个int时会采用多个int
可变数组
- Array arrayCreate(int init_size); 创建一个数组
- void arrayFree(Array *a); 回收数组空间
- int arraySize(const Array *a); 查询数组可用空间数量
- int *arrayAt(Array *a,int index); 返回指定的数组元素
- void arrayInflate(Array *a,int more_size); 让数组变大
头文件array.h
#ifndef _ARRAY_H_
#define _ARRAY_H_
typedef struct{
int *array;
int size;
}Array;
Array arrayCreate(int init_size); //创建一个数组
void arrayFree(Array *a); //回收数组空间
int arraySize(const Array *a); //查询数组可用空间数量
int *arrayAt(Array *a,int index); //返回指定的数组元素
void arrayInflate(Array *a,int more_size); //让数组变大
void travelArr(const Array *a); //遍历数组
#endif
源文件array.c
#include <stdio.h>
#include <stdlib.h>
#include "array.h"
const block=5;
//主函数入口
int main(){
Array a = arrayCreate(5);
printf("%d\n",arraySize(&a));
int s = 0;
int cnt = 0;
while(s!=-1){
scanf("%d",&s);
*arrayAt(&a,cnt)=s;
cnt++;
}
travelArr(&a);
arrayFree(&a);
return 0;
}
//创建一个数组
Array arrayCreate(int init_size){
Array a;
a.size = init_size;
a.array = (int*)malloc(sizeof(int)*a.size);
return a;
}
//回收数组空间
void arrayFree(Array *a){
free(a->array);
a->array = NULL;
a->size = 0;
}
//查询数组空间数量
int arraySize(const Array *a){
return a->size;
}
//返回指定的数组元素
int *arrayAt(Array *a,int index){
if(index>=a->size){
arrayInflate(a,block );
}
return &(a->array[index]);
}
//让数组变大
void arrayInflate(Array *a,int more_size){
int *p = (int*)malloc(sizeof(int)*(a->size+more_size));
int i;
for(i=0;i<a->size;i++){
p[i] = a->array[i];
}
free(a->array);
a->array = p;
a->size += more_size;
}
//遍历数组
void travelArr(const Array *a){
int i=0;
printf("arr:[");
for(i=0;i<a->size;i++){
if(a->array[i]==-1){
break;
}
printf(" %d ",a->array[i]);
}
printf("]");
}
链表结构
链表结构体定义:
typedef struct _node{ //链表名
int val; //类型
struct _node *next;
}Node; //链表变量名
//在后续的使用中,可以直接使用链表的变量名定义链表
创建链表结点:
//头结点定义
Node *head = (Node*)malloc(sizeof(Node));
head->next = NULL;
//普通结点定义
Node *p = (Node*)malloc(sizeof(Node));
p->val = 100;
p->next = NULL;
练习:创建链表并实现以下功能
- 链表尾部添加元素
- 打印链表元素
- 删除某个元素
- 指定下标插入元素
- 修改指定下标的元素
- 获取链表长度
#include <stdio.h>
#include <stdlib.h>
#include "LinkList.h"
int main(int argc, char *argv[]) {
Node *head = (Node*)malloc(sizeof(Node));
head->next = NULL;
int i;
for(i = 0;i<10;i++){
add(head,i);
}
print(head);
printf("%d\n",getSize(head));
reMove(head,5);
print(head);
printf("%d\n",getSize(head));
insert(head,0,222);
print(head);
revise(head,4,10000);
print(head);
return 0;
}
//打印链表
void print(Node *head){
Node *temp;
for(temp = head->next;temp;temp=temp->next){
printf("%d ",temp->val);
}
printf("\n");
}
void add(Node *head,int val){
//创建结点
Node *p = (Node*)malloc(sizeof(Node));
p->val = val;
p->next = NULL;
//找到链表的最后结点
Node *last = head;
while(last->next!=NULL){
last = last->next;
}
//将新创建结点添加到最后结点后面
last->next = p;
}
//删除指定元素
void reMove(Node *head,int i){
Node *temp = head;
while(temp->next!=NULL){
if(temp->next->val==i){
temp->next = temp->next->next;
break;
}else{
temp = temp->next;
}
}
}
//指定下标插入元素
void insert(Node *head,int index,int val){
Node *p = head;
Node *t = (Node*)malloc(sizeof(Node));
t->next=NULL;
t->val = val;
int cnt;
for(cnt=0;cnt<index;cnt++){
p=p->next;
}
if(p){
printf("插入元素不存在\n");
}
t->next = p->next;
p->next = t;
}
//获取链表长度
int getSize(Node *head){
int i=0;
Node *p = head->next;
for(p = head->next;p;p=p->next){
i++;
}
return i;
}
//修改指定元素
void revise(Node *head,int index,int val){
Node *p = head->next;
int c=0;
for(p=head->next;p;p=p->next){
if(c==index){
p->val = val;
break;
}
c++;
}
}
LinkList.h头文件
#ifndef _LinkList_
#define _LinkList_
//定义链表结构体
typedef struct _node{
struct _node *next;
int val;
}Node;
//添加链表元素
void add(Node *head,int val);
//打印链表元素
void print(Node *head);
//删除指定元素
void reMove(Node *head,int i);
//插入元素
void insert(Node *head,int index,int val);
//修改元素
void revise(Node *head,int index,int val);
//获取链表长度
int getSize(Node *head);
#endif