哈喽，大家好，这篇文章可以说是一本书了，排版，码字耗费了很长的时间，10万+字 C 语言从入门到精通保姆级教程版，觉得有价值记得一键三连支持。
计数排序（Counting Sort）
计数排序是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，快于任何比较排序算法。
排序思路:
1.找出待排序数组最大值
2.定义一个索引最大值为待排序数组最大值的数组
3.遍历待排序数组, 将待排序数组遍历到的值作新数组索引
4.在新数组对应索引存储值原有基础上+1
简单代码实现:
intmain(){//待排序数组intnums[5]={3,1,2,0,3};//用于排序数组intnewNums[4]={0};//计算待排序数组长度intlen=sizeof(nums)/sizeof(nums[0]);//遍历待排序数组for(inti=0;i<len;i++){//取出待排序数组当前值intindex=nums[i];//将待排序数组当前值作为排序数组索引//将用于排序数组对应索引原有值+1newNums[index]=newNums[index]+1;}//计算待排序数组长度intlen2=sizeof(newNums)/sizeof(newNums[0]);//输出排序数组索引,就是排序之后结果for(inti=0;i<len2;i++){for(intj=0;j<newNums[i];j++){printf("%i\n",i);}}/*//计算待排序数组长度intlen2=sizeof(newNums)/sizeof(newNums[0]);//还原排序结果到待排序数组for(inti=0;i<len2;i++){intindex=0;for(inti=0;i<len;i++){for(intj=0;j<newNums[i];j++){nums[index++]=i;}}}*/return0;}
选择排序
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。
排序思路:
假设按照升序排序
1.用第0个元素和后面所有元素依次比较
2.判断第0个元素是否大于当前被比较元素, 一旦小于就交换位置
3.第0个元素和后续所有元素比较完成后, 第0个元素就是最小值
4.排除第0个元素, 用第1个元素重复1~3操作, 比较完成后第1个元素就是倒数第二小的值
以此类推, 直到当前元素没有可比较的元素, 排序完成
代码实现:
//选择排序voidselectSort(intnumbers[],intlength){//外循环为什么要-1?//最后一位不用比较,也没有下一位和它比较,否则会出现错误访问for(inti=0;i<length;i++){for(intj=i;j<length-1;j++){//1.用当前元素和后续所有元素比较if(numbers[i]<numbers[j+1]){//2.一旦发现小于就交换位置swapEle(numbers,i,j+1);}}}}//交换两个元素的值,i/j需要交换的索引voidswapEle(intarray[],inti,intj){inttemp=array[i];array[i]=array[j];array[j]=temp;}
冒泡排序
冒泡排序(Bubble Sort)是一种简单的排序算法。它重复 地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
排序思路:
假设按照升序排序
1.从第0个元素开始, 每次都用相邻两个元素进行比较
2.一旦发现后面一个元素小于前面一个元素就交换位置
3.经过一轮比较之后最后一个元素就是最大值
4.排除最后一个元素, 以此类推, 每次比较完成之后最大值都会出现再被比较所有元素的最后
直到当前元素没有可比较的元素, 排序完成
代码实现:
//冒泡排序voidbubbleSort(intnumbers[],intlength){for(inti=0;i<length;i++){//-1防止`角标越界`:访问到了不属于自己的索引for(intj=0;j<length-i-1;j++){//1.用当前元素和相邻元素比较if(numbers[j]<numbers[j+1]){//2.一旦发现小于就交换位置swapEle(numbers,j,j+1);}}}}//交换两个元素的值,i/j需要交换的索引voidswapEle(intarray[],inti,intj){inttemp=array[i];array[i]=array[j];array[j]=temp;}
插入排序
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
排序思路:
假设按照升序排序
1.从索引为1的元素开始向前比较, 一旦前面一个元素大于自己就让前面的元素先后移动
2.直到没有可比较元素或者前面的元素小于自己的时候, 就将自己插入到当前空出来的位置
代码实现:
intmain(){//待排序数组intnums[5]={3,1,2,0,3};//0.计算待排序数组长度intlen=sizeof(nums)/sizeof(nums[0]);//1.从第一个元素开始依次取出所有用于比较元素for(inti=1;i<len;i++){//2.取出用于比较元素inttemp=nums[i];intj=i;while(j>0){//3.判断元素是否小于前一个元素if(temp<nums[j-1]){//4.让前一个元素向后移动一位nums[j]=nums[j-1];}else{break;}j--;}//5.将元素插入到空出来的位置nums[j]=temp;}}
intmain(){//待排序数组intnums[5]={3,1,2,0,3};//0.计算待排序数组长度intlen=sizeof(nums)/sizeof(nums[0]);//1.从第一个元素开始依次取出所有用于比较元素for(inti=1;i<len;i++){//2.遍历取出前面元素进行比较for(intj=i;j>0;j--){//3.如果前面一个元素大于当前元素,就交换位置if(nums[j-1]>nums[j]){inttemp=nums[j];nums[j]=nums[j-1];nums[j-1]=temp;}else{break;}}}}
希尔排序
1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
排序思路:
1.希尔排序可以理解为插入排序的升级版, 先将待排序数组按照指定步长划分为几个小数组
2.利用插入排序对小数组进行排序, 然后将几个排序的小数组重新合并为原始数组
3.重复上述操作, 直到步长为1时,再利用插入排序排序即可
代码实现:
intmain(){//待排序数组intnums[5]={3,1,2,0,3};//0.计算待排序数组长度intlen=sizeof(nums)/sizeof(nums[0]);//2.计算步长intgap=len/2;do{//1.从第一个元素开始依次取出所有用于比较元素for(inti=gap;i<len;i++){//2.遍历取出前面元素进行比较intj=i;while((j-gap)>=0){printf("%i>%i\n",nums[j-gap],nums[j]);//3.如果前面一个元素大于当前元素,就交换位置if(nums[j-gap]>nums[j]){inttemp=nums[j];nums[j]=nums[j-gap];nums[j-gap]=temp;}else{break;}j--;}}//每个小数组排序完成,重新计算步长gap=gap/2;}while(gap>=1);}
江哥提示: 对于初学者而言, 排序算法一次不易于学习太多, 咋们先来5个玩一玩, 后续继续讲解其它5个 公众号代码情缘欢迎关注
折半查找
基本思路
在有序表中,取中间元素作为比较对象,若给定值与中间元素的要查找的数相等,则查找成功;若给定值小于中间元素的要查找的数,则在中间元素的左半区继续查找;
若给定值大于中间元素的要查找的数,则在中间元素的右半区继续查找。不断重复上述查找过 程,直到查找成功,或所查找的区域无数据元素,查找失败
实现步骤
在有序表中,取中间元素作为比较对象,若给定值与中间元素的要查找的数相等,则查找成功;
若给定值小于中间元素的要查找的数,则在中间元素的左半区继续查找;
若给定值大于中间元素的要查找的数,则在中间元素的右半区继续查找。
不断重复上述查找过 程,直到查找成功,或所查找的区域无数据元素,查找失败。
代码实现
intfindKey(intvalues[],intlength,intkey){//定义一个变量记录最小索引intmin=0;//定义一个变量记录最大索引intmax=length-1;//定义一个变量记录中间索引intmid=(min+max)*0.5;while(min<=max){//如果mid对应的值大于key,那么max要变小if(values[mid]>key){max=mid-1;//如果mid对应的值小于key,那么min要变}elseif(values[mid]<key){min=mid+1;}else{returnmid;}//修改完min/max之后,重新计算mid的值mid=(min+max)*0.5;}return-1;}
进制转换(查表法)
实现思路:
将二进制、八进制、十进制、十六进制所有可能的字符都存入数组
利用按位与运算符和右移依次取出当前进制对应位置的值
利用取出的值到数组中查询当前位输出的结果
将查询的结果存入一个新的数组, 当所有位都查询存储完毕, 新数组中的值就是对应进制的值
代码实现
#include<stdio.h>voidtoBinary(intnum){total(num,1,1);}voidtoOct(intnum){total(num,7,3);}voidtoHex(intnum){total(num,15,4);}voidtotal(intnum,intbase,intoffset){//1.定义表用于查询结果charcs[]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};//2.定义保存结果的数组charrs[32];//计算最大的角标位置intlength=sizeof(rs)/sizeof(char);intpos=length;//8while(num!=0){intindex=num&base;rs[--pos]=cs[index];num=num>>offset;}for(inti=pos;i<length;i++){printf("%c",rs[i]);}printf("\n");}intmain(){toBinary(9);return0;}
二维数组
所谓二维数组就是一个一维数组的每个元素又被声明为一 维数组,从而构成二维数组. 可以说二维数组是特殊的一维数组。
示例:
int a[2][3] = { {80,75,92}, {61,65,71}};
可以看作由一维数组a[0]和一维数组a[1]组成，这两个一维数组都包含了3个int类型的元素
二维数组的定义
格式:
数据类型 数组名[一维数组的个数][一维数组的元素个数]
其中"一维数组的个数"表示当前二维数组中包含多少个一维数组
其中"一维数组的元素个数"表示当前前二维数组中每个一维数组元素的个数
二维数组的初始化
二维数的初始化可分为两种:
定义的同时初始化
先定义后初始化
定义的同时初始化
inta[2][3]={{80,75,92},{61,65,71}};
先定义后初始化
inta[2][3];a[0][0]=80;a[0][1]=75;a[0][2]=92;a[1][0]=61;a[1][1]=65;a[1][2]=71;
按行分段赋值
inta[2][3]={{80,75,92},{61,65,71}};
按行连续赋值
inta[2][3]={80,75,92,61,65,71};
其它写法
完全初始化,可以省略第一维的长度
inta[][3]={{1,2,3},{4,5,6}};inta[][3]={1,2,3,4,5,6};
部分初始化,可以省略第一维的长度
inta[][3]={{1},{4,5}};inta[][3]={1,2,3,4};
注意: 有些人可能想不明白，为什么可以省略行数，但不可以省略列数。也有人可能会问，可不可以只指定行数，但是省略列数？其实这个问题很简单，如果我们这样写：int a[2][] = {1, 2, 3, 4, 5, 6}; // 错误写法 大家都知道，二维数组会先存放第1行的元素，由于不确定列数，也就是不确定第1行要存放多少个元素，所以这里会产生很多种情况，可能1、2是属于第1行的，也可能1、2、3、4是第一行的，甚至1、2、3、4、5、6全部都是属于第1行的
指定元素的初始化
inta[2][3]={[1][2]=10};inta[2][3]={[1]={1,2,3}}
二维数组的应用场景
二维数组的遍历和存储
二维数组的遍历
二维数组a[3][4],可分解为三个一维数组,其数组名分别为:
这三个一维数组都有4个元素,例如:一维数组a[0]的 元素为a[0][0],a[0][1],a[0][2],a[0][3]。
所以遍历二维数组无非就是先取出二维数组中得一维数组, 然后再从一维数组中取出每个元素的值
示例
charcs[2][3]={{'a','b','c'},{'d','e','f'}};printf("%c",cs[0][0]);//第一个[0]取出一维数组,第二个[0]取出一维数组中对应的元素
charcs[2][3]={{'a','b','c'},{'d','e','f'}};for(inti=0;i<2;i++){//外循环取出一维数组//ifor(intj=0;j<3;j++){//内循环取出一维数组的每个元素printf("%c",cs[i][j]);}printf("\n");}
注意: 必须强调的是,a[0],a[1],a[2]不能当作下标变量使用,它们是数组名,不是一个单纯的下标变量
二维数组的存储
和以为数组一样
给数组分配存储空间从内存地址大开始分配
给数组元素分配空间, 从所占用内存地址小的开始分配
往每个元素中存储数据从高地址开始存储
#include<stdio.h>intmain(){charcs[2][3]={{'a','b','c'},{'d','e','f'}};//cs==&cs==&cs[0]==&cs[0][0]printf("cs=%p\n",cs);//0060FEAAprintf("&cs=%p\n",&cs);//0060FEAAprintf("&cs[0]=%p\n",&cs[0]);//0060FEAAprintf("&cs[0][0]=%p\n",&cs[0][0]);//0060FEAAreturn0;}
二维数组与函数
值传递
#include<stdio.h>//和一位数组一样,只看形参是基本类型还是数组类型//如果是基本类型在函数中修改形参不会影响实参voidchange(charch){ch='n';}intmain(){charcs[2][3]={{'a','b','c'},{'d','e','f'}};printf("cs[0][0]=%c\n",cs[0][0]);//achange(cs[0][0]);printf("cs[0][0]=%c\n",cs[0][0]);//areturn0;}
地址传递
#include<stdio.h>//和一位数组一样,只看形参是基本类型还是数组类型//如果是数组类型在函数中修改形参会影响实参voidchange(charch[]){ch[0]='n';}intmain(){charcs[2][3]={{'a','b','c'},{'d','e','f'}};printf("cs[0][0]=%c\n",cs[0][0]);//achange(cs[0]);printf("cs[0][0]=%c\n",cs[0][0]);//nreturn0;}
#include<stdio.h>//和一位数组一样,只看形参是基本类型还是数组类型//如果是数组类型在函数中修改形参会影响实参voidchange(charch[][3]){ch[0][0]='n';}intmain(){charcs[2][3]={{'a','b','c'},{'d','e','f'}};printf("cs[0][0]=%c\n",cs[0][0]);//achange(cs);printf("cs[0][0]=%c\n",cs[0][0]);//nreturn0;}
形参错误写法
voidtest(charcs[2][])//错误写法{printf("我被执行了\n");}voidtest(charcs[2][3])//正确写法{printf("我被执行了\n");}voidtest(charcs[][3])//正确写法{printf("我被执行了\n");}
二维数组作为函数参数，在被调函数中不能获得其有多少行，需要通过参数传入
voidtest(charcs[2][3]){introw=sizeof(cs);//输出4或8printf("row=%zu\n",row);}
二维数组作为函数参数，在被调函数中可以计算出二维数组有多少列
voidtest(charcs[2][3]){size_tcol=sizeof(cs[0]);//输出3printf("col=%zd\n",col);}
作业
玩家通过键盘录入 w,s,a,d控制小人向不同方向移动,其中w代表向上移动,s代表向 下移动,a代表向左移动,d 代表向右移动,当小人移动到出口位置,玩家胜利
思路:
1.定义二维数组存放地图
#######O#################
2.规定地图的方向
3.编写程序控制方向
当输入w或者W, 小人向上移动. x-1
当输入s 或者S, 小人向下. x+1
当输入a或者A, 小人向左. y-1
当输入d或者D, 小人向右. y+1
4.移动小人
用变量记录小人当前的位置
1)如果小人将要移动的位置是墙,则无法移动
2)如果小人将要移动的位置是路,则可以移动
5.判断是否走出迷宫
字符串的基本概念
字符串是位于双引号中的字符序列
在内存中以“\0”结束,所占字节比实际多一个
字符串的初始化
在C语言中没有专门的字符串变量,通常用一个字符数组来存放一个字符串。
当把一个字符串存入一个数组时,会把结束符‘\0’存入数组,并以此作为该字符串是否结束的标志。
有了‘\0’标志后,就不必再用字符数组 的长度来判断字符串的长度了
初始化
charname[9]="lnj";//在内存中以“\0”结束，\0ASCII码值是0charname1[9]={'l','n','j','\0'};charname2[9]={'l','n','j',0};//当数组元素个数大于存储字符内容时,未被初始化的部分默认值是0,所以下面也可以看做是一个字符串charname3[9]={'l','n','j'};
错误的初始化方式
//省略元素个数时,不能省略末尾的\n//不正确地写法，结尾没有\0，只是普通的字符数组charname4[]={'l','n','j'};//"中间不能包含\0",因为\0是字符串的结束标志//\0的作用：字符串结束的标志charname[]="c\0ool";printf("name=%s\n",name);输出结果:c
字符串输出
如果字符数组中存储的是一个字符串, 那么字符数组的输入输出将变得简单方便。
不必使用循环语句逐个地输入输出每个字符
可以使用printf函数和scanf函数一次性输出输入一个字符数组中的字符串
使用的格式字符串为“%s”,表示输入、输出的是一个字符串 字符串的输出
输出
%s的本质就是根据传入的name的地址逐个去取数组中的元素然后输出，直到遇到\0位置
charchs[]="lnj";printf("%s\n",chs);
注意点:
\0引发的脏读问题
charname[]={'c','o','o','l','\0'};charname2[]={'l','n','j'};printf("name2=%s\n",name2);//输出结果:lnjcool
输入
charch[10];scanf("%s",ch);
注意点:
对一个字符串数组, 如果不做初始化赋值, 必须指定数组长度
ch最多存放由9个字符构成的字符串，其中最后一个字符的位置要留给字符串的结尾标示‘\0’
当用scanf函数输入字符串时,字符串中不能含有空格,否则将以空格作为串的结束符
字符串常用方法
C语言中供了丰富的字符串处理函数,大致可分为字符串的输入、输出、合并、修改、比较、转 换、复制、搜索几类。
使用这些函数可大大减轻编程的负担。
使用输入输出的字符串函数,在使用前应包含头文件"stdio.h"
使用其它字符串函数则应包含头文件"string.h"
字符串输出函数:puts
格式: puts(字符数组名)
功能:把字符数组中的字符串输出到显示器。即在屏幕上显示该字符串。
优点:
自动换行
可以是数组的任意元素地址
缺点
不能自定义输出格式, 例如 puts("hello %i");
charch[]="lnj";puts(ch);//输出结果:lnj
puts函数完全可以由printf函数取代。当需要按一定格式输出时,通常使用printf函数
字符串输入函数:gets
格式: gets (字符数组名)
功能:从标准输入设备键盘上输入一个字符串。
charch[30];gets(ch);//输入:lnjputs(ch);//输出:lnj
可以看出当输入的字符串中含有空格时,输出仍为全部字符串。说明gets函数并不以空格作为字符串输入结束的标志,而只以回车作为输入结束。这是与scanf函数不同的。
注意gets很容易导致数组下标越界，是一个不安全的字符串操作函数
字符串长度
利用sizeof字符串长度
因为字符串在内存中是逐个字符存储的,一个字符占用一个字节,所以字符串的结束符长度也是占用的内存单元的字节数。
charname[]="it666";intsize=sizeof(name);//包含\0printf("size=%d\n",size);//输出结果:6
利用系统函数
格式: strlen(字符数组名)
功能:测字符串的实际长度(不含字符串结束标志‘\0’)并作为函数返回值。
charname[]="it666";size_tlen=strlen(name2);printf("len=%lu\n",len);//输出结果:5
以“\0”为字符串结束条件进行统计
/***自定义方法计算字符串的长度*@paramname需要计算的字符串*@return不包含\0的长度*/intmyStrlen2(charstr[]){//1.定义变量保存字符串的长度intlength=0;while(str[length]!='\0'){length++;//1234}returnlength;}/***自定义方法计算字符串的长度*@paramname需要计算的字符串*@paramcount字符串的总长度*@return不包含\0的长度*/intmyStrlen(charstr[],intcount){//1.定义变量保存字符串的长度intlength=0;//2.通过遍历取出字符串中的所有字符逐个比较for(inti=0;i<count;i++){//3.判断是否是字符串结尾if(str[i]=='\0'){returnlength;}length++;}returnlength;}
字符串连接函数:strcat
格式: strcat(字符数组名1,字符数组名2)
功能:把字符数组2中的字符串连接到字符数组1 中字符串的后面,并删去字符串1后的串标志 “\0”。本函数返回值是字符数组1的首地址。
charoldStr[100]="welcometo";charnewStr[20]="lnj";strcat(oldStr,newStr);puts(oldStr);//输出:welcometolnj"
本程序把初始化赋值的字符数组与动态赋值的字符串连接起来。要注意的是,字符数组1应定义足 够的长度,否则不能全部装入被连接的字符串。
字符串拷贝函数:strcpy- 格式: strcpy(字符数组名1,字符数组名2)- 功能:把字符数组2中的字符串拷贝到字符数组1中。串结束标志“\0”也一同拷贝。字符数名2, 也可以是一个字符串常量。这时相当于把一个字符串赋予一个字符数组。
charoldStr[100]="welcometo";charnewStr[50]="lnj";strcpy(oldStr,newStr);puts(oldStr);//输出结果:lnj//原有数据会被覆盖
本函数要求字符数组1应有足够的长度,否则不能全部装入所拷贝的字符串。
字符串比较函数:strcmp
格式: strcmp(字符数组名1,字符数组名2)
功能:按照ASCII码顺序比较两个数组中的字符串,并由函数返回值返回比较结果。
字符串1=字符串2,返回值=0;
字符串1>字符串2,返回值>0;
字符串1<字符串2,返回值<0。
charoldStr[100]="0";charnewStr[50]="1";printf("%d",strcmp(oldStr,newStr));//输出结果:-1charoldStr[100]="1";charnewStr[50]="1";printf("%d",strcmp(oldStr,newStr));//输出结果:0charoldStr[100]="1";charnewStr[50]="0";printf("%d",strcmp(oldStr,newStr));//输出结果:1
练习
编写一个函数char_contains(char str[],char key)， 如果字符串str中包含字符key则返回数值1，否则返回数值0
字符串数组基本概念
字符串数组其实就是定义一个数组保存所有的字符串
1.一维字符数组中存放一个字符串，比如一个名字char name[20] = “nj”
2.如果要存储多个字符串，比如一个班所有学生的名字，则需要二维字符数组，char names[15][20]可以存放15个学生的姓名(假设姓名不超过20字符)
如果要存储两个班的学生姓名，那么可以用三维字符数组char names[2][15][20] ##字符串数组的初始化
charnames[2][10]={{'l','n','j','\0'},{'l','y','h','\0'}};charnames2[2][10]={{"lnj"},{"lyh"}};charnames3[2][10]={"lnj","lyh"};
指针基本概念
什么是地址
生活中的地址:
内存地址:
地址与内存单元中的数据是两个完全不同的概念
地址如同房间编号, 根据这个编号我们可以找到对应的房间
内存单元如同房间, 房间是专门用于存储数据的
变量地址:
系统分配给"变量"的"内存单元"的起始地址
intnum=6;//占用4个字节//那么变量num的地址为:0ff06charc='a';//占用1个字节//那么变量c的地址为:0ff05
什么是指针
在计算机中所有数据都存储在内存单元中,而每个内存单元都有一个对应的地址, 只要通过这个地址就能找到对应单元中存储的数据.
由于通过地址能找到所需的变量单元，所以我们说该地址指向了该变量单元。将地址形象化的称为“指针”
内存单元的指针(地址)和内存单元的内容是两个不同的概念。
什么是指针变量
在C语言中,允许用一个变量来存放其它变量的地址, 这种专门用于存储其它变量地址的变量, 我们称之为指针变量
示例:
intage;//定义一个普通变量num=10;int*pnAge;//定义一个指针变量pnAge=&age;
定义指针变量的格式
指针变量的定义包括两个内容:
指针类型说明,即定义变量为一个指针变量;
指针变量名;
示例:
charch='a';char*p;//一个用于指向字符型变量的指针p=&ch;intnum=666;int*q;//一个用于指向整型变量的指针q=#
其中,*表示这是一个指针变量
变量名即为定义的指针变量名
类型说明符表示本指针变量所指向的变量的数据类型
指针变量的初始化方法
指针变量初始化的方法有两种:定义的同时进行初始化和先定义后初始化
定义的同时进行初始化
inta=5;int*p=&a;
先定义后初始化
inta=5;int*p;p=&a;
把指针初始化为NULL
int*p=NULL;int*q=0;
不合法的初始化:
指针变量只能存储地址, 不能存储其它类型
int*p;p=250;//错误写法
给指针变量赋值时,指针变量前不能再加“*”
int*p;*p=&a;//错误写法
注意点:
多个指针变量可以指向同一个地址
指针的指向是可以改变的
inta=5;int*p=&a;intb=10;p=&b;//修改指针指向
指针没有初始化里面是一个垃圾值,这时候我们这是一个野指针
野指针可能会导致程序崩溃
野指针访问你不该访问数据
所以指针必须初始化才可以访问其所指向存储区域
访问指针所指向的存储空间
C语言中提供了地址运算符&来表示变量的地址。其一般形式为:
&变量名;
C语言中提供了*来定义指针变量和访问指针变量指向的内存存储空间
在定义变量的时候 * 是一个类型说明符,说明定义的这个变量是一个指针变量
int*p=NULL;//定义指针变量
在不是定义变量的时候 *是一个操作符,代表访问指针所指向存储空间
inta=5;int*p=&a;printf("a=%d",*p);//访问指针变量
指针类型
在同一种编译器环境下,一个指针变量所占用的内存空间是固定的。
虽然在同一种编译器下, 所有指针占用的内存空间是一样的,但不同类型的变量却占不同的字节数
一个int占用4个字节，一个char占用1个字节，而一个double占用8字节；
现在只有一个地址，我怎么才能知道要从这个地址开始向后访问多少个字节的存储空间呢，是4个，是1个，还是8个。
所以指针变量需要它所指向的数据类型告诉它要访问多少个字节存储空间
二级指针
如果一个指针变量存放的又是另一个指针变量的地址,则称这个指针变量为指向指针的指针变量。也称为“二级指针”
charc='a';char*cp;cp=&c;char**cp2;cp2=&cp;printf("c=%c",**cp2);
多级指针的取值规则
int***m1;//取值***m1int*****m2;//取值*****m2
练习
定义一个函数交换两个变量的值
写一个函数，同时返回两个数的和与差
##数组指针的概念及定义
数组元素指针
一个变量有地址,一个数组包含若干元素,每个数组元素也有相应的地址, 指针变量也可以保存数组元素的地址
只要一个指针变量保存了数组元素的地址, 我们就称之为数组元素指针
printf(“%p%p”,&(a[0]),a);//输出结果:0x1100,0x1100
注意: 数组名a不代表整个数组,只代表数组首元素的地址。
“p=a;”的作用是“把a数组的首元素的地址赋给指针变量p”,而不是“把数组a各元素的值赋给 p”
指针访问数组元素
intmain(void){inta[5]={2,4,6,8,22};int*p;//p=&(a[0]);p=a;printf(“%d%d\n”,a[0],*p);//输出结果:2,2}
在指针指向数组元素时,允许以下运算:
加一个整数(用+或+=),如p+1
减一个整数(用-或-=),如p-1
自加运算,如p++,++p
自减运算,如p--,--p
如果指针变量p已指向数组中的一个元素,则p+1
指向同一数组中的下一个元素,p-1指向同 一数组中的上一个元素。
结论: 访问数组元素,可用下面两种方法:
下标法, 如a[i]形式
指针法, *(p+i)形式
注意:
数组名虽然是数组的首地址，但是数组名所所保存的数组的首地址是不可以更改的
intx[10];x++;//错误int*p=x;p++;//正确
指针与字符串
定义字符串的两种方式
字符数组
charstring[]=”Ilovelnj!”;printf("%s\n",string);
字符串指针指向字符串
//数组名保存的是数组第0个元素的地址,指针也可以保存第0个元素的地址char*str="abc"
字符串指针使用注意事项
可以查看字符串的每一个字符
har*str="lnj";for(inti=0;i<strlen(str);i++){printf("%c-",*(str+i));//输出结果:l-n-j}
不可以修改字符串内容
//+使用字符数组来保存的字符串是保存栈里的,保存栈里面东西是可读可写,所有可以修改字符串中的的字符//+使用字符指针来保存字符串,它保存的是字符串常量地址,常量区是只读的,所以我们不可以修改字符串中的字符char*str="lnj";*(str+2)='y';//错误
不能够直接接收键盘输入
//错误的原因是:str是一个野指针,他并没有指向某一块内存空间//所以不允许这样写如果给str分配内存空间是可以这样用的char*str;scanf("%s",str);
指向函数指针
为什么指针可以指向一个函数？
函数作为一段程序，在内存中也要占据部分存储空间，它也有一个起始地址
函数有自己的地址，那就好办了，我们的指针变量就是用来存储地址的。
因此可以利用一个指针指向一个函数。其中，函数名就代表着函数的地址。
指针函数的定义
格式:返回值类型 (*指针变量名)(形参1, 形参2, ...);
intsum(inta,intb){returna+b;}int(*p)(int,int);p=sum;
指针函数定义技巧
1、把要指向函数头拷贝过来
2、把函数名称使用小括号括起来
3、在函数名称前面加上一个*
4、修改函数名称
应用场景
调用函数
将函数作为参数在函数间传递
注意点:
由于这类指针变量存储的是一个函数的入口地址，所以对它们作加减运算(比如p++)是无意义的
函数调用中"(指针变量名)"的两边的括号不可少,其中的不应该理解为求值运算,在此处它 只是一种表示符号
什么是结构体
结构体和数组一样属于构造类型
数组是用于保存一组相同类型数据的, 而结构体是用于保存一组不同类型数组的
例如,在学生登记表中,姓名应为字符型;学号可为整型或字符型;年龄应为整型;性别应为字符型;成绩可为整型或实型。
显然这组数据不能用数组来存放, 为了解决这个问题,C语言中给出了另一种构造数据类型——“结构(structure)”或叫“结构体”。
定义结构体类型
在使用结构体之前必须先定义结构体类型, 因为C语言不知道你的结构体中需要存储哪些类型数据, 我们必须通过定义结构体类型来告诉C语言, 我们的结构体中需要存储哪些类型的数据
格式:
struct结构体名{类型名1成员名1;类型名2成员名2;……类型名n成员名n;};
示例:
structStudent{char*name;//姓名intage;//年龄floatheight;//身高};
定义结构体变量
定好好结构体类型之后, 我们就可以利用我们定义的结构体类型来定义结构体变量
格式:struct 结构体名 结构体变量名;
先定义结构体类型，再定义变量
structStudent{char*name;intage;};structStudentstu;
定义结构体类型的同时定义变量
structStudent{char*name;intage;}stu;
匿名结构体定义结构体变量
struct{char*name;intage;}stu;
第三种方法与第二种方法的区别在于,第三种方法中省去了结构体类型名称,而直接给出结构变量,这种结构体最大的问题是结构体类型不能复用
结构体成员访问
一般对结构体变量的操作是以成员为单位进行的，引用的一般形式为：结构体变量名.成员名
structStudent{char*name;intage;};structStudentstu;//访问stu的age成员stu.age=27;printf("age=%d",stu.age);
结构体变量的初始化
定义的同时按顺序初始化
structStudent{char*name;intage;};structStudentstu={“lnj",27};
定义的同时不按顺序初始化
structStudent{char*name;intage;};structStudentstu={.age=35,.name=“lnj"};
先定义后逐个初始化
structStudent{char*name;intage;};structStudentstu;stu.name="lnj";stu.age=35;
先定义后一次性初始化
structStudent{char*name;intage;};structStudentstu;stu2=(structStudent){"lnj",35};
结构体类型作用域
结构类型定义在函数内部的作用域与局部变量的作用域是相同的
从定义的那一行开始, 直到遇到return或者大括号结束为止
结构类型定义在函数外部的作用域与全局变量的作用域是相同的
从定义的那一行开始,直到本文件结束为止
//定义一个全局结构体,作用域到文件末尾structPerson{intage;char*name;};intmain(intargc,constchar*argv[]){//定义局部结构体名为Person,会屏蔽全局结构体//局部结构体作用域,从定义开始到“}”块结束structPerson{intage;};//使用局部结构体类型structPersonpp;pp.age=50;pp.name="zbz";test();return0;}voidtest(){//使用全局的结构体定义结构体变量pstructPersonp={10,"sb"};printf("%d,%s\n",p.age,p.name);}
结构体数组
结构体数组和普通数组并无太大差异, 只不过是数组中的元素都是结构体而已
格式:struct 结构体类型名称 数组名称[元素个数]
structStudent{char*name;intage;};structStudentstu[2];
结构体数组初始化和普通数组也一样, 分为先定义后初始化和定义同时初始化
定义同时初始化
structStudent{char*name;intage;};structStudentstu[2]={{"lnj",35},{"zs",18}};
先定义后初始化
structStudent{char*name;intage;};structStudentstu[2];stu[0]={"lnj",35};stu[1]={"zs",18};
结构体指针
一个指针变量当用来指向一个结构体变量时,称之为结构体指针变量
格式:struct 结构名 *结构指针变量名
示例:
//定义一个结构体类型structStudent{char*name;intage;};//定义一个结构体变量structStudentstu={“lnj",18};//定义一个指向结构体的指针变量structStudent*p;//指向结构体变量stup=&stu;/*这时候可以用3种方式访问结构体的成员*///方式1：结构体变量名.成员名printf("name=%s,age=%d\n",stu.name,stu.age);//方式2：(*指针变量名).成员名printf("name=%s,age=%d\n",(*p).name,(*p).age);//方式3：指针变量名->成员名printf("name=%s,age=%d\n",p->name,p->age);return0;}
通过结构体指针访问结构体成员, 可以通过以下两种方式
(*结构指针变量).成员名
结构指针变量->成员名(用熟)
(pstu)两侧的括号不可少,因为成员符“.”的优先级高于“”。
如去掉括号写作pstu.num则等效于(pstu.num),这样,意义就完全不对了。
结构体内存分析
给结构体变量开辟存储空间和给普通开辟存储空间一样, 会从内存地址大的位置开始开辟
给结构体成员开辟存储空间和给数组元素开辟存储空间一样, 会从所占用内存地址小的位置开始开辟
结构体变量占用的内存空间永远是所有成员中占用内存最大成员的倍数(对齐问题)
+多实际的计算机系统对基本类型数据在内存中存放的位置有限制,它们会要求这些数据的起始地址的值是 某个数k的倍数,这就是所谓的内存对齐,而这个k则被称为该数据类型的对齐模数(alignment modulus)。
这种强制的要求一来简化了处理器与内存之间传输系统的设计,二来可以提升读取数据的速度。比如这么一种处理器,它每次读写内存的时候都从某个8倍数的地址开始,一次读出或写入8个字节的数据,假如软件能 保证double类型的数据都从8倍数地址开始,那么读或写一个double类型数据就只需要一次内存操作。否则,我们就可能需要两次内存操作才能完成这个动作,因为数据或许恰好横跨在两个符合对齐要求的8字节 内存块上
结构体变量占用存储空间大小
structPerson{intage;//4charch;//1doublescore;//8};structPersonp;printf("sizeof=%i\n",sizeof(p));//16
占用内存最大属性是score, 占8个字节, 所以第一次会分配8个字节
将第一次分配的8个字节分配给age4个,分配给ch1个, 还剩下3个字节
当需要分配给score时, 发现只剩下3个字节, 所以会再次开辟8个字节存储空间
一共开辟了两次8个字节空间, 所以最终p占用16个字节
structPerson{intage;//4doublescore;//8charch;//1};structPersonp;printf("sizeof=%i\n",sizeof(p));//24
占用内存最大属性是score, 占8个字节, 所以第一次会分配8个字节
将第一次分配的8个字节分配给age4个,还剩下4个字节
当需要分配给score时, 发现只剩下4个字节, 所以会再次开辟8个字节存储空间
将新分配的8个字节分配给score, 还剩下0个字节
当需要分配给ch时, 发现上一次分配的已经没有了, 所以会再次开辟8个字节存储空间
一共开辟了3次8个字节空间, 所以最终p占用24个字节
结构体嵌套定义
成员也可以又是一个结构,即构成了嵌套的结构
structDate{intmonth;intday;intyear;}structstu{intnum;char*name;charsex;structDatebirthday;Floatscore;}
在stu中嵌套存储Date结构体内容
注意:
结构体不可以嵌套自己变量,可以嵌套指向自己这种类型的指针
structStudent{intage;structStudentstu;};
对嵌套结构体成员的访问
如果某个成员也是结构体变量，可以连续使用成员运算符"."访问最低一级成员
structDate{intyear;intmonth;intday;};structStudent{char*name;structDatebirthday;};structStudentstu;stu.birthday.year=1986;stu.birthday.month=9;stu.birthday.day=10;
结构体和函数
结构体虽然是构造类型, 但是结构体之间赋值是值拷贝, 而不是地址传递
structPerson{char*name;intage;};structPersonp1={"lnj",35};structPersonp2;p2=p1;p2.name="zs";//修改p2不会影响p1printf("p1.name=%s\n",p1.name);//lnjprintf("p2.name=%s\n",p2.name);//zs
所以结构体变量作为函数形参时也是值传递, 在函数内修改形参, 不会影响外界实参
#include<stdio.h>structPerson{char*name;intage;};voidtest(structPersonper);intmain(){structPersonp1={"lnj",35};printf("p1.name=%s\n",p1.name);//lnjtest(p1);printf("p1.name=%s\n",p1.name);//lnjreturn0;}voidtest(structPersonper){per.name="zs";}
共用体
和结构体不同的是, 结构体的每个成员都是占用一块独立的存储空间, 而共用体所有的成员都占用同一块存储空间
和结构体一样, 共用体在使用之前必须先定义共用体类型, 再定义共用体变量
定义共用体类型格式:
union共用体名{数据类型属性名称;数据类型属性名称;.......};
定义共用体类型变量格式:
union共用体名共用体变量名称;
特点: 由于所有属性共享同一块内存空间, 所以只要其中一个属性发生了改变, 其它的属性都会受到影响
示例:
unionTest{intage;charch;};unionTestt;printf("sizeof(p)=%i\n",sizeof(t));t.age=33;printf("t.age=%i\n",t.age);//33t.ch='a';printf("t.ch=%c\n",t.ch);//aprintf("t.age=%i\n",t.age);//97
共用体的应用场景
（1）通信中的数据包会用到共用体，因为不知道对方会发送什么样的数据包过来，用共用体的话就简单了，定义几种格式的包，收到包之后就可以根据包的格式取出数据。
（2）节约内存。如果有2个很长的数据结构，但不会同时使用，比如一个表示老师，一个表示学生，要统计老师和学生的情况，用结构体就比较浪费内存，这时就可以考虑用共用体来设计。+（3）某些应用需要大量的临时变量，这些变量类型不同，而且会随时更换。而你的堆栈空间有限，不能同时分配那么多临时变量。这时可以使用共用体让这些变量共享同一个内存空间，这些临时变量不用长期保存，用完即丢，和寄存器差不多，不用维护。
枚举
什么是枚举类型?
在实际问题中,有些变量的取值被限定在一个有限的范围内。例如,一个星期内只有七天,一年只有十二个月,一个班每周有六门课程等等。如果把这些量说明为整型,字符型或其它类型 显然是不妥当的。
C语言提供了一种称为“枚举”的类型。在“枚举”类型的定义中列举出所有可能的取值, 被说明为该“枚举”类型的变量取值不能超过定义的范围。
该说明的是,枚举类型是一种基本数据类型,而不是一种构造类型,因为它不能再分解为任何基本类型。
枚举类型的定义
格式:
enum枚举名{枚举元素1,枚举元素2,……};
示例:
//表示一年四季enumSeason{Spring,Summer,Autumn,Winter};
枚举变量
先定义枚举类型，再定义枚举变量
enumSeason{Spring,Summer,Autumn,Winter};enumSeasons;
定义枚举类型的同时定义枚举变量
enumSeason{Spring,Summer,Autumn,Winter}s;
省略枚举名称，直接定义枚举变量
enum{Spring,Summer,Autumn,Winter}s;
枚举类型变量的赋值和使用
enumSeason{Spring,Summer,Autumn,Winter}s;s=Spring;//等价于s=0;s=3;//等价于s=winter;printf("%d",s);
枚举使用的注意
C语言编译器会将枚举元素(spring、summer等)作为整型常量处理，称为枚举常量。
枚举元素的值取决于定义时各枚举元素排列的先后顺序。默认情况下，第一个枚举元素的值为0，第二个为1，依次顺序加1。
也可以在定义枚举类型时改变枚举元素的值
enumSeason{Spring,Summer,Autumn,Winter};//也就是说spring的值为0，summer的值为1，autumn的值为2，winter的值为3
enumSeason{Spring=9,Summer,Autumn,Winter};//也就是说spring的值为9，summer的值为10，autumn的值为11，winter的值为12
全局变量和局部变量
变量作用域基本概念
变量作用域：变量的可用范围
按照作用域的不同，变量可以分为：局部变量和全局变量
局部变量
定义在函数内部的变量以及函数的形参, 我们称为局部变量
作用域：从定义的那一行开始, 直到遇到}结束或者遇到return为止
生命周期: 从程序运行到定义哪一行开始分配存储空间到程序离开该变量所在的作用域
存储位置: 局部变量会存储在内存的栈区中
特点：
相同作用域内不可以定义同名变量
不同作用范围可以定义同名变量，内部作用域的变量会覆盖外部作用域的变量
全局变量
定义在函数外面的变量称为全局变量
作用域范围：从定义哪行开始直到文件结尾
生命周期:程序一启动就会分配存储空间,直到程序结束
存储位置：静态存储区
特点: 多个同名的全局变量指向同一块存储空间
auto和register关键字
auto关键字(忘记)
只能修饰局部变量, 局部变量如果没有其它修饰符, 默认就是auto的
特点: 随用随开, 用完即销
autointnum;//等价于intnum;
register关键字(忘记)
只能修饰局部变量, 原则上将内存中变量提升到CPU寄存器中存储, 这样访问速度会更快
但是由于CPU寄存器数量相当有限, 通常不同平台和编译器在优化阶段会自动转换为auto
registerintnum;
static关键字
对局部变量的作用
延长局部变量的生命周期,从程序启动到程序退出,但是它并没有改变变量的作用域
定义变量的代码在整个程序运行期间仅仅会执行一次
#include<stdio.h>voidtest();intmain(){test();test();test();return0;}voidtest(){staticintnum=0;//局部变量num++;//如果不加static输出111//如果添加static输出123printf("num=%i\n",num);}
对全局变量的作用
全局变量分类：
内部变量:只能在本文件中访问的变量
外部变量:可以在其他文件中访问的变量,默认所有全局变量都是外部变量
默认情况下多个同名的全局变量共享一块空间, 这样会导致全局变量污染问题
如果想让某个全局变量只在某个文件中使用, 并且不和其他文件中同名全局变量共享同一块存储空间, 那么就可以使用static
//A文件中的代码intnum;//和B文件中的num共享voidtest(){printf("ds.c中的num=%i\n",num);}
//B文件中的代码#include<stdio.h>#include"ds.h"intnum;//和A文件中的num共享intmain(){num=666;test();//test中输出666return0;}
//A文件中的代码staticintnum;//不和B文件中的num共享voidtest(){printf("ds.c中的num=%i\n",num);}
//B文件中的代码#include<stdio.h>#include"ds.h"intnum;//不和A文件中的num共享intmain(){num=666;test();//test中输出0return0;}
extern关键字
对局部变量的作用
extern不能用于局部变量
extern代表声明一个变量, 而不是定义一个变量, 变量只有定义才会开辟存储空间
所以如果是局部变量, 虽然提前声明有某个局部变量, 但是局部变量只有执行到才会分配存储空间
#include<stdio.h>intmain(){externintnum;num=998;//使用时并没有存储空间可用,所以声明了也没用intnum;//这里才会开辟printf("num=%i\n",num);return0;}
对全局变量的作用
声明一个全局变量, 代表告诉编译器我在其它地方定义了这个变量, 你可以放心使用
#include<stdio.h>intmain(){externintnum;//声明我们有名称叫做num变量num=998;//使用时已经有对应的存储空间printf("num=%i\n",num);return0;}intnum;//全局变量,程序启动就会分配存储空间
static与extern对函数的作用
内部函数:只能在本文件中访问的函数
外部函数:可以在本文件中以及其他的文件中访问的函数
默认情况下所有的函数都是外部函数
static 作用
声明一个内部函数
staticintsum(intnum1,intnum2);
定义一个内部函数
staticintsum(intnum1,intnum2){returnnum1+num2;}
extern作用
声明一个外部函数
externintsum(intnum1,intnum2);
定义一个外部函数
externintsum(intnum1,intnum2){returnnum1+num2;}
注意点:
由于默认情况下所有的函数都是外部函数, 所以extern一般会省略
如果只有函数声明添加了static与extern, 而定义中没有添加static与extern, 那么无效
Qt Creator编译过程做了什么?
当我们按下运行按钮的时, 其实Qt Creator编译器做了5件事情
对源文件进行预处理, 生成预处理文件
对预处理文件进行编译, 生成汇编文件
对汇编文件进行编译, 生成二进制文件
对二进制文件进行链接, 生成可执行文件
运行可执行文件
Qt Creator编译过程验证
1.编写代码, 保存源文件:
#include<stdio.h>intmain(){printf("hellolnj\n");return0;}
2.执行预处理编译
执行预处理编译后生成的文件
打开预处理编译后生成的文件
处理源文件中预处理相关的指令
处理源文件中多余注释等
3.执行汇编编译
执行汇编编译后生成的文件
打开汇编编译后生成的文件
4.执行二进制编译
执行二进制编译后生成的文件
打开二进制编译后生成的文件
5.执行链接操作
将依赖的一些C语言函数库和我们编译好的二进制合并为一个文件
执行链接操作后生成的文件
6.运行链接后生成的文件
计算机是运算过程分析
1.编写一个简单的加法运算
2.调试编写好的代码, 查看对应的汇编文件
结论:
1.通过地址线找到对应地址的存储单元
2.通过控制线发送内存读取指令
3.通过数据线将内存中的值传输到CPU寄存器中
4.在CPU中完成计算操作
5.通过地址线找到对应地址的存储单元
6.通过控制线发送内存写入指令
7.通过数据线将计算结果传输到内存中
预处理指令
预处理指令的概念
C语言在对源程序进行编译之前，会先对一些特殊的预处理指令作解释(比如之前使用的#include文件包含指令)，产生一个新的源程序(这个过程称为编译预处理),之后再进行通常的编译
为了区分预处理指令和一般的C语句，所有预处理指令都以符号“#”开头，并且结尾不用分号
预处理指令可以出现在程序的任何位置，它的作用范围是从它出现的位置到文件尾。习惯上我们尽可能将预处理指令写在源程序开头，这种情况下，它的作用范围就是整个源程序文件
C语言提供了多种预处理功能,如宏定义、文件包含、条件编译等。合理地使用预处理功能编写的程序便于阅读、修改、移植和调试,也有利于模块化程序设计。
宏定义
被定义为“宏”的标识符称为“宏名”。在编译预处理时,对程序中所有出现的“宏名”,都用宏定义中的字符串去代换,这称为“宏代换”或“宏展开”。
宏定义是由源程序中的宏定义命令完成的。宏代换是由预处理程序自动完成的。在C语言中,“宏”分为有参数和无参数两种。##不带参数的宏定义
格式:#define 标识符 字符串
其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。
#include<stdio.h>//源程序中所有的宏名PI在编译预处理的时候都会被3.14所代替#definePI3.14//根据圆的半径计radius算周长floatgirth(floatradius){return2*PI*radius;}intmain(){floatg=girth(2);printf("周长为：%f",g);return0;}
注意点:
宏名一般用大写字母，以便与变量名区别开来，但用小写也没有语法错误
2)对程序中用双引号扩起来的字符串内的字符，不进行宏的替换操作
#defineR10intmain(){char*s="Radio";//在第1行定义了一个叫R的宏，但是第4行中"Radio"里面的'R'并不会被替换成10return0;}
3)在编译预处理用字符串替换宏名时，不作语法检查，只是简单的字符串替换。只有在编译的时候才对已经展开宏名的源程序进行语法检查
#defineI100intmain(){inti[3]=I;return0;}
宏名的有效范围是从定义位置到文件结束。如果需要终止宏定义的作用域，可以用#undef命令
#definePI3.14intmain(){printf("%f",PI);return0;}#undefPIvoidtest(){printf("%f",PI);//不能使用}
定义一个宏时可以引用已经定义的宏名
#defineR3.0#definePI3.14#defineL2*PI*R#defineSPI*R*R
可用宏定义表示数据类型,使书写方便
#defineStringchar*intmain(intargc,constchar*argv[]){Stringstr="Thisisastring!";return0;}
带参数的宏定义
C语言允许宏带有参数。在宏定义中的参数称为形式参数,在宏调用中的参数称为实际参数。对带参数的宏,在调用中,不仅要宏展开,而且要用实参去代换形参
格式:#define 宏名(形参表) 字符串
//第1行中定义了一个带有2个参数的宏average，#defineaverage(a,b)(a+b)/2intmain(){//第4行其实会被替换成：int a =(10+ 4)/2;，inta=average(10,4);//输出结果为：7是不是感觉这个宏有点像函数呢？printf("平均值：%d",a);return0;}
注意点:
1)宏名和参数列表之间不能有空格，否则空格后面的所有字符串都作为替换的字符串.
#defineaverage(a,b)(a+b)/2intmain(){inta=average(10,4);return0;}注意第1行的宏定义，宏名average跟(a, b)之间是有空格的，于是，第5行就变成了这样：inta=(a,b)(a+b)/2(10,4);这个肯定是编译不通过的
2)带参数的宏在展开时，只作简单的字符和参数的替换，不进行任何计算操作。所以在定义宏时，一般用一个小括号括住字符串的参数。
#include<stdio.h>//下面定义一个宏D(a)，作用是返回a的2倍数值：#defineD(a)2*a//如果定义宏的时候不用小括号括住参数intmain(){//将被替换成int b = 2*3+4;，输出结果10，如果定义宏的时候用小括号括住参数，把上面的第3行改成：#defineD(a)2*(a)，注意右边的a是有括号的，第7行将被替换成intb=2*(3+4);，输出结果14intb=D(3+4);printf("%d",b);return0;}
3)计算结果最好也用括号括起来
#include<stdio.h>//下面定义一个宏P(a)，作用是返回a的平方#definePow(a)(a)*(a)//如果不用小括号括住计算结果intmain(intargc,constchar*argv[]){//代码被替换为:intb=(10)*(10)/(2)*(2);//简化之后：int b = 10*(10/ 2)* 2;，最后变量b为:100intb=Pow(10)/Pow(2);printf("%d",b);return0;}
#include<stdio.h>//计算结果用括号括起来#definePow(a)((a)*(a))intmain(intargc,constchar*argv[]){//代码被替换为:intb=((10)*(10))/((2)*(2));//简化之后：int b =(10* 10)/(2 *2);，最后输出结果：25intb=Pow(10)/Pow(2);printf("%d",b);return0;}
条件编译
在很多情况下，我们希望程序的其中一部分代码只有在满足一定条件时才进行编译，否则不参与编译(只有参与编译的代码最终才能被执行)，这就是条件编译。
为什么要使用条件编译
1)按不同的条件去编译不同的程序部分,因而产生不同的目标代码文件。有利于程序的移植和调试。
2)条件编译当然也可以用条件语句来实现。但是用条件语句将会对整个源程序进行编译,生成 的目标代码程序很长,而采用条件编译,则根据条件只编译其中的程序段1或程序段2,生成的目 标程序较短。##if-#else 条件编译指令
第一种格式:
它的功能是,如常量表达式的值为真(非0),则将code1 编译到程序中,否则对code2编译到程序中。
注意:
是将代码编译进可执行程序, 而不是执行代码
条件编译后面的条件表达式中不能识别变量,它里面只能识别常量和宏定义
#if常量表达式..code1...#else..code2...#endif
#defineSCORE67#ifSCORE>90printf("优秀\n");#elseprintf("不及格\n");#endif
第二种格式:
#if条件1...code1...#elif条件2...code2...#else...code3...#endif
#defineSCORE67#ifSCORE>90printf("优秀\n");#elifSCORE>60printf("良好\n");#elseprintf("不及格\n");#endif
typedef关键字
C语言不仅????供了丰富的数据类型,而且还允许由用户自己定义类型说明符,也就是说允许由用户为数据类型取“别名”。
格式:typedef 原类型名 新类型名;
其中原类型名中含有定义部分,新类型名一般用大写表示,以便于区别。
有时也可用宏定义来代替typedef的功能,但是宏定义是由预处理完成的,而typedef则是在编译 时完成的,后者更为灵活方便。##typedef使用
基本数据类型
typedefintINTEGERINTEGERa;//等价于inta;
也可以在别名的基础上再起一个别名
typedefintInteger;typedefIntegerMyInteger;
用typedef定义数组、指针、结构等类型将带来很大的方便,不仅使程序书写简单而且使意义更为 明确,因而增强了可读性。
数组类型
typedefcharNAME[20];//表示NAME是字符数组类型,数组长度为20。然后可用NAME 说明变量,NAMEa;//等价于chara[20];
结构体类型
第一种形式:
structPerson{intage;char*name;};typedefstructPersonPersonType;
+ 第二种形式:
typedefstructPerson{intage;char*name;}PersonType;
+ 第三种形式:
typedefstruct{intage;char*name;}PersonType;
枚举
第一种形式:
enumSex{SexMan,SexWoman,SexOther};typedefenumSexSexType;
+ 第二种形式:
typedefenumSex{SexMan,SexWoman,SexOther}SexType;
+ 第三种形式:
typedefenum{SexMan,SexWoman,SexOther}SexType;
指针
typedef与指向结构体的指针
//定义一个结构体并起别名typedefstruct{floatx;floaty;}Point;//起别名typedefPoint*PP;
typedef与指向函数的指针
//定义一个sum函数，计算a跟b的和intsum(inta,intb){intc=a+b;printf("%d+%d=%d",a,b,c);returnc;}typedefint(*MySum)(int,int);//定义一个指向sum函数的指针变量pMySump=sum;
宏定义与函数以及typedef区别
与函数的区别
从整个使用过程可以发现，带参数的宏定义，在源程序中出现的形式与函数很像。但是两者是有本质区别的：
1> 宏定义不涉及存储空间的分配、参数类型匹配、参数传递、返回值问题
2> 函数调用在程序运行时执行，而宏替换只在编译预处理阶段进行。所以带参数的宏比函数具有更高的执行效率
typedef和#define的区别
用宏定义表示数据类型和用typedef定义数据说明符的区别。
宏定义只是简单的字符串替换,是在预处理完成的
typedef是在编译时处理的,它不是作简单的代换,而是对类型说明符重新命名。被命名的标识符具有类型定义说明的功能
typedefchar*String;intmain(intargc,constchar*argv[]){Stringstr="Thisisastring!";return0;}#defineStringchar*intmain(intargc,constchar*argv[]){Stringstr="Thisisastring!";return0;}
typedefchar*String1;//给char*起了个别名String1#defineString2char*//定义了宏String2intmain(intargc,constchar*argv[]){/*只有str1、str2、str3才是指向char类型的指针变量由于String1就是char*，所以上面的两行代码等于:char*str1;char*str2;*/String1str1,str2;/*宏定义只是简单替换,所以相当于char*str3,str4;*号只对最近的一个有效,所以相当于char*str3;charstr4;*/String2str3,str4;return0;}
const关键字
const是一个类型修饰符
使用const修饰变量则可以让变量的值不能改变 ##const有什么主要的作用?
(1)可以定义const常量,具有不可变性
constintMax=100;intArray[Max];
(2)便于进行类型检查,使编译器对处理内容有更多了解,消除了一些隐患。
voidf(constinti){.........}
编译器就会知道i是一个常量,不允许修改;
(3)可以避免意义模糊的数字出现,同样可以很方便地进行参数的调整和修改。同宏定义一样,可以做到不变则已,一变都变!如(1)中,如果想修改Max的内容,只需要:const int Max=you want;即可!
(4)可以保护被修饰的东西,防止意外的修改,增强程序的健壮性。还是上面的例子,如果在 函数体内修改了i,编译器就会报错;
voidf(constinti){i=10;//error!}
(5) 可以节省空间,避免不必要的内存分配。
#definePI3.14159//常量宏constdoulbePi=3.14159;//此时并未将Pi放入ROM中......doublei=Pi;//此时为Pi分配内存,以后不再分配!doubleI=PI;//编译期间进行宏替换,分配内存doublej=Pi;//没有内存分配doubleJ=PI;//再进行宏替换,又一次分配内存! const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存中有若干个拷贝。
(6) ????高了效率。编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表 中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。
如何使用const?
(1)修饰一般常量一般常量是指简单类型的常量。这种常量在定义时,修饰符const可以用在类型说明符前,也可以用在类型说明符后
intconstx=2;或constintx=2;
(当然,我们可以偷梁换柱进行更新: 通过强制类型转换,将地址赋给变量,再作修改即可以改变const常量值。)
//const对于基本数据类型,无论写在左边还是右边,变量中的值不能改变constinta=5;//a=666;//直接修改会报错//偷梁换柱,利用指针指向变量int*p;p=&a;//利用指针间接修改变量中的值*p=10;printf("%d\n",a);printf("%d\n",*p);
(2)修饰常数组(值不能够再改变了)定义或说明一个常数组可采用如下格式:
intconsta[5]={1,2,3,4,5};constinta[5]={1,2,3,4,5};
constinta[5]={1,2,3,4,5};a[1]=55;//错误
(3)修饰函数的常参数const修饰符也可以修饰函数的传递参数,格式如下:void Fun(const int Var); 告诉编译器Var在函数体中的无法改变,从而防止了使用者的一些无 意的或错误的修改。
(4)修饰函数的返回值: const修饰符也可以修饰函数的返回值,是返回值不可被改变,格式如 下:
constintFun1();constMyClassFun2();
(5)修饰常指针
const int *A; //const修饰指针,A可变,A指向的值不能被修改
int const *A; //const修饰指向的对象,A可变,A指向的对象不可变
int *const A; //const修饰指针A, A不可变,A指向的对象可变
const int *const A;//指针A和A指向的对象都不可变
技巧
先看“*”的位置如果const 在*的左侧表示值不能修改,但是指向可以改。如果const在*的右侧表示指向不能改,但是值可以改如果在“*”的两侧都有const 标识指向和值都不能改。
内存管理
进程空间
程序，是经源码编译后的可执行文件，可执行文件可以多次被执行，比如我们可以多次打开 office。
而进程，是程序加载到内存后开始执行，至执行结束，这样一段时间概念，多次打开的wps,每打开一次都是一个进程，当我们每关闭一个 office，则表示该进程结束。
程序是静态概念，而进程动态/时间概念。###进程空间图示 有了进程和程序的概念以后，我们再来看一下，程序被加载到内存以后内存空间布局是什么样的
栈内存(Stack)
栈中存放任意类型的变量，但必须是 auto 类型修饰的，即自动类型的局部变量， 随用随开，用完即消。
内存的分配和销毁系统自动完成，不需要人工干预
栈的最大尺寸固定，超出则引起栈溢出
局部变量过多，过大 或 递归层数太多等就会导致栈溢出
intages[10240*10240];//程序会崩溃,栈溢出
#include<stdio.h>intmain(){//存储在栈中,内存地址从大到小inta=10;intb=20;printf("&a=%p\n",&a);//&a=0060FEACprintf("&b=%p\n",&b);//&b=0060FEA8return0;}
堆内存(Heap)
堆内存可以存放任意类型的数据，但需要自己申请与释放
堆大小，想像中的无穷大，但实际使用中，受限于实际内存的大小和内存是否连续性
int*p=(int*)malloc(10240*1024);//不一定会崩溃
#include<stdio.h>#include<stdlib.h>intmain(){//存储在栈中,内存地址从小到大int*p1=malloc(4);*p1=10;int*p2=malloc(4);*p2=20;printf("p1=%p\n",p1);//p1=00762F48printf("p2=%p\n",p2);//p2=00762F58return0;}
malloc函数
#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){/**malloc*第一个参数:需要申请多少个字节空间*返回值类型:void**/int*p=(int*)malloc(sizeof(int));printf("p=%i\n",*p);//保存垃圾数据/**第一个参数:需要初始化的内存地址*第二个初始:需要初始化的值*第三个参数:需要初始化对少个字节*/memset(p,0,sizeof(int));//对申请的内存空间进行初始化printf("p=%i\n",*p);//初始化为0return0;}
free函数
注意: 通过malloc申请的存储空间一定要释放, 所以malloc和free函数总是成对出现
#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){//1.申请4个字节存储空间int*p=(int*)malloc(sizeof(int));//2.初始化4个字节存储空间为0memset(p,0,sizeof(int));//3.释放申请的存储空间free(p);return0;}
calloc函数
#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){/*//1.申请3块4个字节存储空间int*p=(int*)malloc(sizeof(int)*3);//2.使用申请好的3块存储空间p[0]=1;p[1]=3;p[2]=5;printf("p[0]=%i\n",p[0]);printf("p[1]=%i\n",p[1]);printf("p[2]=%i\n",p[2]);//3.释放空间free(p);*///1.申请3块4个字节存储空间int*p=calloc(3,sizeof(int));//2.使用申请好的3块存储空间p[0]=1;p[1]=3;p[2]=5;printf("p[0]=%i\n",p[0]);printf("p[1]=%i\n",p[1]);printf("p[2]=%i\n",p[2]);//3.释放空间free(p);return0;}
realloc函数
注意点:
若参数ptr==NULL，则该函数等同于 malloc
返回的指针，可能与 ptr 的值相同，也有可能不同。若相同，则说明在原空间后面申请，否则，则可能后续空间不足，重新申请的新的连续空间，原数据拷贝到新空间， 原有空间自动释放
#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){//1.申请4个字节存储空间int*p=NULL;p=realloc(p,sizeof(int));//此时等同于malloc//2.使用申请好的空间*p=666;printf("*p=%i\n",*p);//3.释放空间free(p);return0;}
#include<stdio.h>#include<stdlib.h>#include<string.h>intmain(){//1.申请4个字节存储空间int*p=malloc(sizeof(int));printf("p=%p\n",p);//如果能在传入存储空间地址后面扩容,返回传入存储空间地址//如果不能在传入存储空间地址后面扩容,返回一个新的存储空间地址p=realloc(p,sizeof(int)*2);printf("p=%p\n",p);//2.使用申请好的空间*p=666;printf("*p=%i\n",*p);//3.释放空间free(p);return0;}
链表
链表实现了，内存零碎数据的有效组织。比如，当我们用 malloc 来进行内存申请的时候，当内存足够，但是由于碎片太多，没有连续内存时，只能以申请失败而告终，而用链表这种数据结构来组织数据，就可以解决上类问题。
静态链表
#include<stdio.h>#include<stdlib.h>#include<string.h>//1.定义链表节点typedefstructnode{intdata;structnode*next;}Node;intmain(){//2.创建链表节点Nodea;Nodeb;Nodec;//3.初始化节点数据a.data=1;b.data=3;c.data=5;//4.链接节点a.next=&b;b.next=&c;c.next=NULL;//5.创建链表头Node*head=&a;//6.使用链表while(head!=NULL){intcurrentData=head->data;printf("currentData=%i\n",currentData);head=head->next;}return0;}
动态链表
静态链表的意义不是很大，主要原因，数据存储在栈上，栈的存储空间有限，不能动态分配。所以链表要实现存储的自由，要动态的申请堆里的空间。
有一个点要说清楚，我们的实现的链表是带头节点。至于，为什么带头节点，需等大家对链表有个整体的的认知以后，再来体会，会更有意义。
空链表
头指针带了一个空链表节点, 空链表节点中的next指向NULL
#include<stdio.h>#include<stdlib.h>//1.定义链表节点typedefstructnode{intdata;structnode*next;}Node;intmain(){Node*head=createList();return0;}//创建空链表Node*createList(){//1.创建一个节点Node*node=(Node*)malloc(sizeof(Node));if(node==NULL){exit(-1);}//2.设置下一个节点为NULLnode->next=NULL;//3.返回创建好的节点returnnode;}
非空链表
头指针带了一个非空节点, 最后一个节点中的next指向NULL
动态链表头插法
1.让新节点的下一个节点等于头结点的下一个节点
2.让头节点的下一个节点等于新节点
#include<stdio.h>#include<stdlib.h>//1.定义链表节点typedefstructnode{intdata;structnode*next;}Node;Node*createList();voidprintNodeList(Node*node);intmain(){Node*head=createList();printNodeList(head);return0;}/***@briefcreateList创建链表*@return创建好的链表*/Node*createList(){//1.创建头节点Node*head=(Node*)malloc(sizeof(Node));if(head==NULL){returnNULL;}head->next=NULL;//2.接收用户输入数据intnum=-1;printf("请输入节点数据\n");scanf("%i",&num);//3.通过循环创建其它节点while(num!=-1){//3.1创建一个新的节点Node*cur=(Node*)malloc(sizeof(Node));cur->data=num;//3.2让新节点的下一个节点指向头节点的下一个节点cur->next=head->next;//3.3让头节点的下一个节点指向新节点head->next=cur;//3.4再次接收用户输入数据scanf("%i",&num);}//3.返回创建好的节点returnhead;}/***@briefprintNodeList遍历链表*@paramnode链表指针头*/voidprintNodeList(Node*node){Node*head=node->next;while(head!=NULL){intcurrentData=head->data;printf("currentData=%i\n",currentData);head=head->next;}}
动态链表尾插法
1.定义变量记录新节点的上一个节点
2.将新节点添加到上一个节点后面
3.让新节点成为下一个节点的上一个节点
#include<stdio.h>#include<stdlib.h>//1.定义链表节点typedefstructnode{intdata;structnode*next;}Node;Node*createList();voidprintNodeList(Node*node);intmain(){Node*head=createList();printNodeList(head);return0;}/***@briefcreateList创建链表*@return创建好的链表*/Node*createList(){//1.创建头节点Node*head=(Node*)malloc(sizeof(Node));if(head==NULL){returnNULL;}head->next=NULL;//2.接收用户输入数据intnum=-1;printf("请输入节点数据\n");scanf("%i",&num);//3.通过循环创建其它节点//定义变量记录上一个节点Node*pre=head;while(num!=-1){//3.1创建一个新的节点Node*cur=(Node*)malloc(sizeof(Node));cur->data=num;//3.2让新节点链接到上一个节点后面pre->next=cur;//3.3当前节点下一个节点等于NULLcur->next=NULL;//3.4让当前节点编程下一个节点的上一个节点pre=cur;//3.5再次接收用户输入数据scanf("%i",&num);}//3.返回创建好的节点returnhead;}/***@briefprintNodeList遍历链表*@paramnode链表指针头*/voidprintNodeList(Node*node){Node*head=node->next;while(head!=NULL){intcurrentData=head->data;printf("currentData=%i\n",currentData);head=head->next;}}
动态链优化
#include<stdio.h>#include<stdlib.h>//1.定义链表节点typedefstructnode{intdata;structnode*next;}Node;Node*createList();voidprintNodeList(Node*node);voidinsertNode1(Node*head,intdata);voidinsertNode2(Node*head,intdata);intmain(){//1.创建一个空链表Node*head=createList();//2.往空链表中插入数据insertNode1(head,1);insertNode1(head,3);insertNode1(head,5);printNodeList(head);return0;}/***@briefcreateList创建空链表*@return创建好的空链表*/Node*createList(){//1.创建头节点Node*head=(Node*)malloc(sizeof(Node));if(head==NULL){returnNULL;}head->next=NULL;//3.返回创建好的节点returnhead;}/***@briefinsertNode1尾插法插入节点*@paramhead需要插入的头指针*@paramdata需要插入的数据*@return插入之后的链表*/voidinsertNode1(Node*head,intdata){//1.定义变量记录最后一个节点Node*pre=head;while(pre!=NULL&&pre->next!=NULL){pre=pre->next;}//2.创建一个新的节点Node*cur=(Node*)malloc(sizeof(Node));cur->data=data;//3.让新节点链接到上一个节点后面pre->next=cur;//4.当前节点下一个节点等于NULLcur->next=NULL;//5.让当前节点编程下一个节点的上一个节点pre=cur;}/***@briefinsertNode1头插法插入节点*@paramhead需要插入的头指针*@paramdata需要插入的数据*@return插入之后的链表*/voidinsertNode2(Node*head,intdata){//1.创建一个新的节点Node*cur=(Node*)malloc(sizeof(Node));cur->data=data;//2.让新节点的下一个节点指向头节点的下一个节点cur->next=head->next;//3.让头节点的下一个节点指向新节点head->next=cur;}/***@briefprintNodeList遍历链表*@paramnode链表指针头*/voidprintNodeList(Node*node){Node*head=node->next;while(head!=NULL){intcurrentData=head->data;printf("currentData=%i\n",currentData);head=head->next;}}
链表销毁
/***@briefdestroyList销毁链表*@paramhead链表头指针*/voiddestroyList(Node*head){Node*cur=NULL;while(head!=NULL){cur=head->next;free(head);head=cur;}}
链表长度计算
/***@brieflistLength计算链表长度*@paramhead链表头指针*@return链表长度*/intlistLength(Node*head){intcount=0;head=head->next;while(head){count++;head=head->next;}returncount;}
链表查找
/***@briefsearchList查找指定节点*@paramhead链表头指针*@paramkey需要查找的值*@return*/Node*searchList(Node*head,intkey){head=head->next;while(head){if(head->data==key){break;}else{head=head->next;}}returnhead;}
链表删除
voiddeleteNodeList(Node*head,Node*find){while(head->next!=find){head=head->next;}head->next=find->next;free(find);}
作业
给链表排序
/***@briefbubbleSort对链表进行排序*@paramhead链表头指针*/voidbubbleSort(Node*head){//1.计算链表长度intlen=listLength(head);//2.定义变量记录前后节点Node*cur=NULL;//3.相邻元素进行比较,进行冒泡排序for(inti=0;i<len-1;i++){cur=head->next;for(intj=0;j<len-1-i;j++){printf("%i,%i\n",cur->data,cur->next->data);if((cur->data)>(cur->next->data)){inttemp=cur->data;cur->data=cur->next->data;cur->next->data=temp;}cur=cur->next;}}}
/***@briefsortList对链表进行排序*@paramhead链表头指针*/voidsortList(Node*head){//0.计算链表长度intlen=listLength(head);//1.定义变量保存前后两个节点Node*sh,*pre,*cur;for(inti=0;i<len-1;i++){sh=head;//头节点pre=sh->next;//第一个节点cur=pre->next;//第二个节点for(intj=0;j<len-1-i;j++){if(pre->data>cur->data){//交换节点位置sh->next=cur;pre->next=cur->next;cur->next=pre;//恢复节点名称Node*temp=pre;pre=cur;cur=temp;}//让所有节点往后移动sh=sh->next;pre=pre->next;cur=cur->next;}}}
链表反转
/***@briefreverseList反转链表*@paramhead链表头指针*/voidreverseList(Node*head){//1.将链表一分为二Node*pre,*cur;pre=head->next;head->next=NULL;//2.重新插入节点while(pre){cur=pre->next;pre->next=head->next;head->next=pre;pre=cur;}}
文件基本概念
文件流:
C 语言把文件看作是一个字符的序列，即文件是由一个一个字符组成的字符流，因此 c 语言将文件也称之为文件流。
文件分类
文本文件
以 ASCII 码格式存放，一个字节存放一个字符。文本文件的每一个字节存放一个 ASCII 码，代表一个字符。这便于对字符的逐个处理，但占用存储空间 较多，而且要花费时间转换。
.c文件就是以文本文件形式存放的
二进制文件
以补码格式存放。二进制文件是把数据以二进制数的格式存放在文件中的，其占用存储空间较少。数据按其内存中的存储形式原样存放
.exe文件就是以二进制文件形式存放的
文本文件和二进制文件示例
下列代码暂时不要求看懂, 主要理解什么是文本文件什么是二进制文件
#include<stdio.h>intmain(){/**以文本形式存储*会将每个字符先转换为对应的ASCII,*然后再将ASCII码的二进制存储到计算机中*/intnum=666;FILE*fa=fopen("ascii.txt","w");fprintf(fa,"%d",num);fclose(fa);/**以二进制形式存储*会将666的二进制直接存储到文件中*/FILE*fb=fopen("bin.txt","w");fwrite(&num,4,1,fb);fclose(fb);return0;}
内存示意图
通过文本工具打开示意图
文本工具默认会按照ASCII码逐个直接解码文件, 由于文本文件存储的就是ASCII码, 所以可以正常解析显示, 由于二进制文件存储的不是ASCII码, 所以解析出来之后是乱码
文件的打开和关闭
FILE 结构体
FILE 结构体是对缓冲区和文件读写状态的记录者，所有对文件的操作，都是通过FILE 结构体完成的。
struct_iobuf{char*_ptr;//文件输入的下一个位置int_cnt;//当前缓冲区的相对位置char*_base;//文件的起始位置)int_flag;//文件标志int_file;//文件的有效性验证int_charbuf;//检查缓冲区状况,如果无缓冲区则不读取int_bufsiz;//缓冲区大小char*_tmpfname;//临时文件名};typedefstruct_iobufFILE;
fileopen函数
|参数及返回解析 |参数| charfilaname :要打开，或是创建文件的路径。| |参数| charmode :打开文件的方式。| |返回值| FILE* 返回指向文件缓冲区的指针，该指针是后序操作文件的句柄。|
注意点:
Windows如果读写的是二进制文件，则还要加 b,比如 rb, r+b 等。unix/linux 不区分文本和二进制文件
fclose函数
#include<stdio.h>intmain(){FILE*fp=fopen("test.txt","w+");fclose(fp);return0;}
--
一次读写一个字符
写入
#include<stdio.h>intmain(){//1.打开一个文件FILE*fp=fopen("test.txt","w+");//2.往文件中写入内容for(charch='a';ch<='z';ch++){//一次写入一个字符charres=fputc(ch,fp);printf("res=%c\n",res);}//3.关闭打开的文件fclose(fp);return0;}
读取
#include<stdio.h>intmain(){//1.打开一个文件FILE*fp=fopen("test.txt","r+");//2.从文件中读取内容charres=EOF;while((res=fgetc(fp))!=EOF){printf("res=%c\n",res);}//3.关闭打开的文件fclose(fp);return0;}
判断文件末尾
feof函数
#include<stdio.h>intmain(){//1.打开一个文件FILE*fp=fopen("test.txt","r+");//2.从文件中读取内容charres=EOF;//注意:由于只有先读了才会修改标志位,//所以通过feof判断是否到达文件末尾,一定要先读再判断,不能先判断再读while((res=fgetc(fp))&&(!feof(fp))){printf("res=%c\n",res);}//3.关闭打开的文件fclose(fp);return0;}
注意点:
feof 这个函数，是去读标志位判断文件是否结束的。
而标志位只有读完了才会被修改, 所以如果先判断再读标志位会出现多打一次的的现象
所以企业开发中使用feof函数一定要先读后判断, 而不能先判断后读
作业
实现文件的简单加密和解密
#include<stdio.h>#include<string.h>voidencode(char*name,char*newName,intcode);voiddecode(char*name,char*newName,intcode);intmain(){encode("main.c","encode.c",666);decode("encode.c","decode.c",666);return0;}/***@briefencode加密文件*@paramname需要加密的文件名称*@paramnewName加密之后的文件名称*@paramcode秘钥*/voidencode(char*name,char*newName,intcode){FILE*fw=fopen(newName,"w+");FILE*fr=fopen(name,"r+");charch=EOF;while((ch=fgetc(fr))&&(!feof(fr))){fputc(ch^code,fw);}fclose(fw);fclose(fr);}/***@briefencode解密文件*@paramname需要解密的文件名称*@paramnewName解密之后的文件名称*@paramcode秘钥*/voiddecode(char*name,char*newName,intcode){FILE*fw=fopen(newName,"w+");FILE*fr=fopen(name,"r+");charch=EOF;while((ch=fgetc(fr))&&(!feof(fr))){fputc(ch^code,fw);}fclose(fw);fclose(fr);}
一次读写一行字符
什么是行
行是文本编辑器中的概念，文件流中就是一个字符。这个在不同的平台是有差异的。window 平台 '\r\n'，linux 平台是'\n'
平台差异
windows 平台在写入'\n'是会体现为'\r\n'，linux 平台在写入'\n'时会体现为'\n'。windows 平台在读入'\r\n'时，体现为一个字符'\n'，linux 平台在读入'\n'时，体现为一个字符'\n'
linux 读 windows 中的换行，则会多读一个字符，windows 读 linux 中的换行，则没有问题
#include<stdio.h>intmain(){FILE*fw=fopen("test.txt","w+");fputc('a',fw);fputc('\n',fw);fputc('b',fw);fclose(fw);return0;}
写入一行
#include<stdio.h>intmain(){FILE*fw=fopen("test.txt","w+");//注意:fputs不会自动添加\nfputs("lnj\n",fw);fputs("it666\n",fw);fclose(fw);return0;}
遇到\0自动终止写入
#include<stdio.h>intmain(){FILE*fp=fopen("test.txt","w+");//注意:fputs写入时遇到\0就会自动终止写入fputs("lnj\0it666\n",fp);fclose(fp);return0;}
读取一行
最多只能读取N-1个字符
#include<stdio.h>intmain(){FILE*fp=fopen("test.txt","w+");//注意:fputs不会自动添加\nfputs("it666\n",fp);//将FILE结构体中的读写指针重新移动到最前面//注意:FILE结构体中读写指针每读或写一个字符后都会往后移动rewind(fp);charstr[1024];//从fp中读取4个字符,存入到str中//最多只能读取N-1个字符,会在最后自动添加\0fgets(str,4,fp);printf("str=%s",str);//it6fclose(fp);return0;}
遇到\n自动结束
#include<stdio.h>intmain(){FILE*fp=fopen("test.txt","w+");//注意:fputs不会自动添加\nfputs("lnj\n",fp);fputs("it666\n",fp);//将FILE结构体中的读写指针重新移动到最前面//注意:FILE结构体中读写指针每读或写一个字符后都会往后移动rewind(fp);charstr[1024];//从fp中读取1024个字符,存入到str中//但是读到第4个就是\n了,函数会自动停止读取//注意点:\n会被读取进来fgets(str,1024,fp);printf("str=%s",str);//lnjfclose(fp);return0;}
读取到EOF自动结束
#include<stdio.h>intmain(){FILE*fp=fopen("test.txt","w+");//注意:fputs不会自动添加\nfputs("lnj\n",fp);fputs("it666",fp);//将FILE结构体中的读写指针重新移动到最前面//注意:FILE结构体中读写指针每读或写一个字符后都会往后移动rewind(fp);charstr[1024];//每次从fp中读取1024个字符,存入到str中//读取到文件末尾自动结束while(fgets(str,1024,fp)){printf("str=%s",str);}fclose(fp);return0;}
注意点:
企业开发中能不用feof函数就不用feof函数
如果最后一行，没有行‘\n’的话则少读一行
#include<stdio.h>intmain(){FILE*fp=fopen("test.txt","w+");//注意:fputs不会自动添加\nfputs("12345678910\n",fp);fputs("12345678910\n",fp);fputs("12345678910",fp);//将FILE结构体中的读写指针重新移动到最前面//注意:FILE结构体中读写指针每读或写一个字符后都会往后移动rewind(fp);charstr[1024];//每次从fp中读取1024个字符,存入到str中//读取到文件末尾自动结束while(fgets(str,1024,fp)&&!feof(fp)){printf("str=%s",str);}fclose(fp);return0;}
作业:
利用fgets(str, 5, fp)读取下列文本会读取多少次?
1234567891012345123
一次读写一块数据
C 语言己经从接口的层面区分了，文本的读写方式和二进制的读写方式。前面我们讲的是文本的读写方式。
所有的文件接口函数，要么以 '\0'，表示输入结束，要么以 '\n'， EOF(0xFF)表示读取结束。'\0' '\n' 等都是文本文件的重要标识，而所有的二进制接口对于这些标识，是不敏感的。+二进制的接口可以读文本，而文本的接口不可以读二进制
一次写入一块数据
#include<stdio.h>#include<string.h>intmain(){FILE*fp=fopen("test.txt","wb+");//注意:fwrite不会关心写入数据的格式char*str="lnj\0it666";/**第一个参数:被写入数据指针*第二个参数:每次写入多少个字节*第三个参数:需要写入多少次*第四个参数:已打开文件结构体指针*/fwrite((void*)str,9,1,fp);fclose(fp);return0;}
一次读取一块数据
#include<stdio.h>intmain(){//test.txt中存放的是"lnj\0it666"FILE*fr=fopen("test.txt","rb+");charbuf[1024]={0};//fread函数读取成功返回读取到的字节数,读取失败返回0/**第一个参数:存储读取到数据的容器*第二个参数:每次读取多少个字节*第三个参数:需要读取多少次*第四个参数:已打开文件结构体指针*/intn=fread(buf,1,1024,fr);printf("%i\n",n);for(inti=0;i<n;i++){printf("%c",buf[i]);}fclose(fr);return0;}
注意点:
读取时num_bytes应该填写读取数据类型的最小单位, 而count可以随意写
如果读取时num_bytes不是读取数据类型最小单位, 会引发读取失败
例如: 存储的是char类型 6C 6E 6A 00 69 74 36 36 36 如果num_bytes等于1, count等于1024, 那么依次取出 6C 6E 6A 00 69 74 36 36 36 , 直到取不到为止 如果num_bytes等于4, count等于1024, 那么依次取出[6C 6E 6A 00][69 74 36 36] , 但是最后还剩下一个36, 但又不满足4个字节, 那么最后一个36则取不到
#include<stdio.h>#include<string.h>intmain(){//test.txt中存放的是"lnj\0it666"FILE*fr=fopen("test.txt","rb+");charbuf[1024]={0};/*while(fread(buf,4,1,fr)>0){printf("%c\n",buf[0]);printf("%c\n",buf[1]);printf("%c\n",buf[2]);printf("%c\n",buf[3]);}*//*while(fread(buf,1,4,fr)>0){printf("%c\n",buf[0]);printf("%c\n",buf[1]);printf("%c\n",buf[2]);printf("%c\n",buf[3]);}*/while(fread(buf,1,1,fr)>0){printf("%c\n",buf[0]);}fclose(fr);return0;}
注意: fwrite和fread本质是用来操作二进制的
所以下面用法才是它们的正确打开姿势
#include<stdio.h>intmain(){FILE*fp=fopen("test.txt","wb+");intages[4]={1,3,5,6};fwrite(ages,sizeof(ages),1,fp);rewind(fp);intdata;while(fread(&data,sizeof(int),1,fp)>0){printf("data=%i\n",data);}return0;}
读写结构体
结构体中的数据类型不统一，此时最适合用二进制的方式进行读写
读写单个结构体
#include<stdio.h>typedefstruct{char*name;intage;doubleheight;}Person;intmain(){Personp1={"lnj",35,1.88};//printf("name=%s\n",p1.name);//printf("age=%i\n",p1.age);//printf("height=%lf\n",p1.height);FILE*fp=fopen("person.stu","wb+");fwrite(&p1,sizeof(p1),1,fp);rewind(fp);Personp2;fread(&p2,sizeof(p2),1,fp);printf("name=%s\n",p2.name);printf("age=%i\n",p2.age);printf("height=%lf\n",p2.height);return0;}
读写结构体数组
#include<stdio.h>typedefstruct{char*name;intage;doubleheight;}Person;intmain(){Personps[]={{"zs",18,1.65},{"ls",21,1.88},{"ww",33,1.9}};FILE*fp=fopen("person.stu","wb+");fwrite(&ps,sizeof(ps),1,fp);rewind(fp);Personp;while(fread(&p,sizeof(p),1,fp)>0){printf("name=%s\n",p.name);printf("age=%i\n",p.age);printf("height=%lf\n",p.height);}return0;}
读写结构体链表
#include<stdio.h>#include<stdlib.h>typedefstructperson{char*name;intage;doubleheight;structperson*next;}Person;Person*createEmpty();voidinsertNode(Person*head,char*name,intage,doubleheight);voidprintfList(Person*head);intsaveList(Person*head,char*name);Person*loadList(char*name);intmain(){//Person*head=createEmpty();//insertNode(head,"zs",18,1.9);//insertNode(head,"ls",22,1.65);//insertNode(head,"ws",31,1.78);//printfList(head);//saveList(head,"person.list");Person*head=loadList("person.list");printfList(head);return0;}/***@briefloadList从文件加载链表*@paramname文件名称*@return加载好的链表头指针*/Person*loadList(char*name){//1.打开文件FILE*fp=fopen(name,"rb+");if(fp==NULL){returnNULL;}//2.创建一个空链表Person*head=createEmpty();//3.创建一个节点Person*node=(Person*)malloc(sizeof(Person));while(fread(node,sizeof(Person),1,fp)>0){//3.进行插入//3.1让新节点的下一个节点等于头节点的下一个节点node->next=head->next;//3.2让头结点的下一个节点等于新节点head->next=node;//给下一个节点申请空间node=(Person*)malloc(sizeof(Person));}//释放多余的节点空间free(node);fclose(fp);returnhead;}/***@briefsaveList存储链表到文件*@paramhead链表头指针*@paramname存储的文件名称*@return是否存储成功-1失败0成功*/intsaveList(Person*head,char*name){//1.打开文件FILE*fp=fopen(name,"wb+");if(fp==NULL){return-1;}//2.取出头节点的下一个节点Person*cur=head->next;//3.将所有有效节点保存到文件中while(cur!=NULL){fwrite(cur,sizeof(Person),1,fp);cur=cur->next;}fclose(fp);return0;}/***@briefprintfList遍历链表*@paramhead链表的头指针*/voidprintfList(Person*head){//1.取出头节点的下一个节点Person*cur=head->next;//2.判断是否为NULL,如果不为NULL就开始遍历while(cur!=NULL){//2.1取出当前节点的数据,打印printf("name=%s\n",cur->name);printf("age=%i\n",cur->age);printf("height=%lf\n",cur->height);printf("next=%x\n",cur->next);printf("-----------\n");//2.2让当前节点往后移动cur=cur->next;}}/***@briefinsertNode插入新的节点*@paramhead链表的头指针*@paramp需要插入的结构体*/voidinsertNode(Person*head,char*name,intage,doubleheight){//1.创建一个新的节点Person*node=(Person*)malloc(sizeof(Person));//2.将数据保存到新节点中node->name=name;node->age=age;node->height=height;//3.进行插入//3.1让新节点的下一个节点等于头节点的下一个节点node->next=head->next;//3.2让头结点的下一个节点等于新节点head->next=node;}/***@briefcreateEmpty创建一个空链表*@return链表头指针,创建失败返回NULL*/Person*createEmpty(){//1.定义头指针Person*head=NULL;//2.创建一个空节点,并且赋值给头指针head=(Person*)malloc(sizeof(Person));if(head==NULL){returnhead;}head->next=NULL;//3.返回头指针returnhead;}
其它文件操作函数
ftell 函数
#include<stdio.h>intmain(){char*str="123456789";FILE*fp=fopen("test.txt","w+");longcp=ftell(fp);printf("cp=%li\n",cp);//0//写入一个字节fputc(str[0],fp);cp=ftell(fp);printf("cp=%li\n",cp);//1fclose(fp);return0;}
rewind 函数
#include<stdio.h>intmain(){char*str="123456789";FILE*fp=fopen("test.txt","w+");longcp=ftell(fp);printf("cp=%li\n",cp);//0//写入一个字节fputc(str[0],fp);cp=ftell(fp);printf("cp=%li\n",cp);//1//新指向一个流的开头rewind(fp);cp=ftell(fp);printf("cp=%li\n",cp);//0fclose(fp);return0;}
fseek 函数
常用宏
#defineSEEK_CUR1当前文字#defineSEEK_END2文件结尾#defineSEEK_SET0文件开头
#include<stdio.h>intmain(){FILE*fp=fopen("test.txt","w+");fputs("123456789",fp);//将文件指针移动到文件结尾,并且偏移0个单位fseek(fp,0,SEEK_END);intlen=ftell(fp);//计算文件长度printf("len=%i\n",len);fclose(fp);return0;}
#include<stdio.h>intmain(){FILE*fp;fp=fopen("file.txt","w+");fputs("123456789",fp);fseek(fp,7,SEEK_SET);fputs("lnj",fp);fclose(fp);return0;}
最后，码字不易，点赞、在看、关注、转发、一键四连。
