嵌入式C语言实例（达内2013）

1.Switch练习

#include<stdio.h>

int main()

{

       intshu_zi=0;

       printf("请输入一个数:");

       scanf("%d",&shu_zi);

       switch(shu_zi%2)

       {

       case0:

                     printf("结果为假\n");

                     break;

       case1:

                     printf("结果为真\n");

                     break;

       default:

              printf("结果不能为负\n");

              break;

       }

}

 

2.票价

#include<stdio.h>

int main()

{

       intjia_ge=30,ge_shu=3;

       printf("请输入价格和张数:");

       scanf("%d%d",&jia_ge,&ge_shu);

       if(ge_shu<=0)

       {

              printf("张数不合理:\n");

      

       }

       printf("请输入价格和张数:");

       scanf("%d%d",&jia_ge,&ge_shu);

       if(ge_shu<=0)

       {

              printf("张数不合理:\n");

             

       }

    printf("请输入价格和张数:");

       scanf("%d%d",&jia_ge,&ge_shu);

       if(ge_shu<=0)

       {

              printf("张数不合理:\n");

              return0;

       }

       printf("总价格是%d\n",jia_ge*ge_shu);

       return0;

}

 

判断个数

#include<stdio.h>

int main()

{

       intjia_ge=0,ge_shu=0;

       printf("请输入价格和个数:");

       scanf("%d%d",&jia_ge,&ge_shu);

       if(0==ge_shu)

       {

              printf("张数不能为0\n");

       }

       elseif (ge_shu>0)

       {

              if(0==jia_ge)

              {

                     printf("价格不能为0\n");

              }

              elseif (jia_ge>0)

              {

                     printf("总票价是%d\n",jia_ge*ge_shu);

              }

              else{

                     printf("价格不能为负\n");

              }

       }

       else{

              printf("张数不能为负\n");

       }

       return0;

}

 

票价终极版：判断次数

#include<stdio.h>

int main()

{

       intjia_ge=0, ge_shu=0,xun_huan=0;

       for(xun_huan=0;xun_huan<=2;xun_huan++)

       {

       printf("请输入价格和张数:");

       scanf("%d%d",&jia_ge,&ge_shu);

              if(ge_shu<=0){

                     printf("张数不合理\n");

                     continue;//当张数不合理的情况下立刻进行下一次循环

              }

              if(jia_ge<=0){

                     printf("价格不合理\n");

                     continue;

              }

              break;//避免价格和张数都合理的情况下再循环

       }

       if(xun_huan<3){//检查3次是否都输错了

       printf("总价格是%d\n",jia_ge*ge_shu);

       }

       else{

              printf("好差劲哦\n");

       }

       return0;

}

 

3.摘花

#include<stdio.h>

int main()

{

int ge_shu=0,xun_huan=0,zhuang_tai=0;

printf("请输入个数:");

scanf("%d",&ge_shu);

for(xun_huan=0;xun_huan<ge_shu;xun_huan++)

{

       if(0==zhuang_tai){

              printf("她爱我\n");

           zhuang_tai=1;//确保相邻两次不一样

       }

       elseif(1==zhuang_tai)

       {

              printf("她不爱我\n");

              zhuang_tai=0;

       }

 

}

return 0;

}

 

 

4.素数

#include<stdio.h>

#include<math.h>

int main()

{

       intshu_zi=0,xun_huan=0;

       floatgen=0;

       printf("请输入一个数:");

       scanf("%d",&shu_zi);

       gen=sqrt(shu_zi);

       for(xun_huan=2;xun_huan<=gen;xun_huan++)

       {

              if(!(shu_zi%xun_huan))//用户给的数字可以整除当前列举的数字,说明不是素数

              {

                     break;

              }

       }

       if(xun_huan<=gen)//根据判断循环没结束

       {

              printf("数字%d不是素数\n",shu_zi);

       }

       else//循环结束了

       {

              printf("数字%d是素数\n",shu_zi);

       }

       return0;

}

 

10到100间的素数

#include<stdio.h>

#include<math.h>

int main()

{

       intxun_huan_1=0,xun_huan_2=0;

   float gen;

       for(xun_huan_1=10;xun_huan_1<=100;xun_huan_1++)//10到100之间的数

       {

              gen=sqrt(xun_huan_1);

       for(xun_huan_2=2;xun_huan_2<=gen;xun_huan_2++)

       {

              if(!(xun_huan_1%xun_huan_2))//用户给的数字可以整除当前列举的数字,说明不是素数

              {

                     break;

              }

       }

              if(xun_huan_2>=gen)//根据判断循环没结束

              {

                     printf("%d",xun_huan_1);

              }

       }

       printf("\n");

       return0;

}

 

 

5.乘法表

#include<stdio.h>

int main()

{

  int xun_huan_1=0,xun_huan_2=0;

<
1ddc4
p>  for(xun_huan_1=1;xun_huan_1<=9;xun_huan_1++)//行循环
   {

          for(xun_huan_2=1;xun_huan_2<=xun_huan_1;xun_huan_2++)//列循环

          {

                 printf("%d*%d=%d",xun_huan_1,xun_huan_2,xun_huan_1*xun_huan_2);

          }

          printf("\n");

   }

return 0;

}

 

6.面包买法

#include<stdio.h>

int main()

{

       intxun_huan_1=0,xun_huan_2=0,shang_xian=0;

       for(xun_huan_1=0;xun_huan_1<10;xun_huan_1++)

       {

              shang_xian=(200-20*xun_huan_1)/25;//防止负数

              for(xun_huan_2=0;xun_huan_2<shang_xian;xun_huan_2++)

              {

                     if(!((200-10*xun_huan_1-25*xun_huan_2)%30))//看30g的面包能买几个

                     {

                            printf("10g的面包买%d个，25g的面包买%d个，30g的面包买%d个\n",xun_huan_1,xun_huan_2,(200-10*xun_huan_1-25*xun_huan_2)/30);

                     }

              }

       }

       return0;

}

 

7.猜数游戏

#include<stdio.h>

int main()

{

       intshu_zi_1=0,shu_zi_2=0;

       printf("请输入一个数:");

       scanf("%d",&shu_zi_1);

       while(shu_zi_1!=shu_zi_2)

       {

              printf("请猜一个数:");

              scanf("%d",&shu_zi_2);

              if(shu_zi_2>shu_zi_1)

              {

                     printf("猜大了\n");

              }

            else if(shu_zi_2<shu_zi_1)

              {

                     printf("猜小了\n");

              }

               else{

                      printf("猜对了\n");

               }

       }

       return0;

}

 

8.scanf正确读入数据

#include<stdio.h>

int main()

{

       intshu_zi_1=0,shu_zi_2=0;

       printf("请输入一个数:");

       scanf("%d",&shu_zi_1);

       while(!(scanf("%d",&shu_zi_1)))//利用读入错误的情况下会返回0

       {

           scanf("%*[^\n]");

              scanf("%*c");

              printf("请再输入数据:\n");//确保读入一个正确格式的数据

       }

       scanf("%*[^\n]");//确保在正确读入的情况下再清理，比如输入6d时

   scanf("%*c");

   printf("请输入一个数:");

       scanf("%d",&shu_zi_2);

       printf("%d%d\n",shu_zi_1,shu_zi_2);

       return0;

}

 

9.统计字符出现的次数

#include<stdio.h>

int main()

{

       intshu_zi=0,ci_shu[10]={0},xun_huan=0;

printf("请输入一个数:");

scanf("%d",&shu_zi);

/*while(shu_zi)

{

       ci_shu[shu_zi%10]++;

       shu_zi/=10;

}*/

do{//防止输入0时，不运行，所以用do...while

       ci_shu[shu_zi%10]++;

       shu_zi/=10;

}

while(shu_zi);

for(xun_huan=0;xun_huan<=9;xun_huan++)

{

       if(ci_shu[xun_huan])

       {

              printf("数字%d出现了%d次\n",xun_huan,ci_shu[xun_huan]);

       }

}

return 0;

}

 

#include <stdio.h>

 

int func1(int zheng_shu, int shu_zi);//返回次数

int func2(int zheng_shu);

 

int main()

{

       intnum = 0;

      

       printf("请输入一个整数： ");

       scanf("%d",&num);

       func2(num);

      

       return0;

}

 

int func1(int zheng_shu, int shu_zi)//返回次数

{

       intci_shu = 0;

       while(zheng_shu)

       {

              if(shu_zi==zheng_shu%10)

                     ci_shu++;

              zheng_shu=zheng_shu/10;

       }

       returnci_shu;

}

 

int func2(int zheng_shu)

{

       inti = 0, j = 0;

       intstr[10] = {0};

       intshu_zi = 0;

       inta[10] = {0};

 

       for(shu_zi= 0; shu_zi < 10; shu_zi ++){

              str[shu_zi]= func1(zheng_shu, shu_zi); //str <= ci_shu

              if(str[shu_zi]){

                     str[i]= str[shu_zi];

                     a[i]= shu_zi;

                     i++;

              }

       }

       /*

       for(shu_zi= 0; shu_zi < 10; shu_zi ++)

       {

              str[i]= func1(zheng_shu, shu_zi);

              if(str[i]){

                     a[i]= shu_zi;

                     i++;

              }

       }

       */

       for(j= 0; j < i ; j ++)

              printf("  %d 出现 %d 次\n",a[j], str[j]);

       printf("\n");

}

 

/*

//1.求一个整数中某个数字出现的个数

//2.输出该整数中含有的不同数字

#include <stdio.h>

 

int fun1(int zheng_shu,int shu_zi);//求一个整数中某个数字出现的个数

void fun2(int zheng_shu);//输出该整数中含有的不同数字

int main()

{

       intn,num;

       charstr1[10]={0},str2[10]={0};

       printf("请输入一个整数：");

       scanf("%d",&num);

      

       printf("请输入要统计的数字：");

       scanf("%d",&n);

       printf("%d含有数字:\n",num);

       fun2(num);

       printf("\n");

       printf("%d有 %d 个 %d\n",num,fun1(num,n),n);

       return0;

}

 

int fun1(zheng_shu,shu_zi)

{

       inti=0;

       while(zheng_shu)

       {

              if(shu_zi==zheng_shu%10)

                     i++;

              zheng_shu=zheng_shu/10;

       }

       returni;

}

 

void fun2(int zheng_shu)

{

       inti=0,n=0;

       intstr[10]={0};

       for(i=0;i<10;i++)

       {

              staticint j=0;

              while(i==zheng_shu%10){//用0~9数和输入的数每位上的数比较，

                      str[j]=i;        //若相等就把这个数字保存到数组str中，

                     j++;               //while就避免了数重复保存到str

                     i=0;            //找到相同的数后，再判断更高位是否相同，在此要0开始比较

                     zheng_shu=zheng_shu/10;                  

              }

              continue;

       }

       for(n=0;n<j;n++)

       printf("%d",str
);

}

*/

 

10.银行利率计算

#include<stdio.h>

int main()

{

       intli_lv=0,nian=0,xun_huan=0,ge_shu=0;

       floatqian=100.0f;

       printf("请输入利率和年数:");

       scanf("%d%d",&li_lv,&nian);//打印表头

       printf("年%7d%%\n",100+li_lv);

       for(xun_huan=1;xun_huan<=nian;xun_huan++)

       {

              qian=(100+li_lv)/100.0f*qian;//用100.0f防止取整

          printf("%d%9.2f\n",xun_huan,qian);

       }

}

 

11.变利率

#include<stdio.h>

int main()

{

       intli_lv=0,nian=0,xun_huan=0,xun_huan_1=0;

       floatqian[5]={100.0f,100.0f,100.0f,100.0f,100.0f};

       printf("请输入最小利率和年数:");

       scanf("%d%d",&li_lv,&nian);

       printf("年");//先打印年

       for(xun_huan=li_lv;xun_huan<=li_lv+4;xun_huan++)

       {

              printf("%8d%%",100+xun_huan);//打印表头

       }

   printf("\n");

       for(xun_huan=1;xun_huan<=nian;xun_huan++)

       {  

              printf("%2d",xun_huan);

       for(xun_huan_1=li_lv;xun_huan_1<=li_lv+4;xun_huan_1++)

              {

                     qian[xun_huan_1-li_lv]=(100+xun_huan)/100.0f*qian[xun_huan_1-li_lv];//用数组记录的上一个钱数来算

                  printf("%9.2f",qian[xun_huan_1-li_lv]);

           }

              printf("\n");//打印一行后换行

}

return 0;

}

 

12.变利率个数

#include<stdio.h>

int main()

{

       intli_lv=0,nian=0,xun_huan=0,xun_huan_1=0,ge_shu=0;

   printf("请输入利率个数:");

       scanf("%d",&ge_shu);

       floatqian[ge_shu];

       for(xun_huan_1=0;xun_huan_1<ge_shu;xun_huan_1++)

       {

              qian[xun_huan]=100.0f;//数组赋值

       }

      printf("请输入最小利率和年数:");

       scanf("%d%d",&li_lv,&nian);

       printf("年");//先打印年

       for(xun_huan=li_lv;xun_huan<=(li_lv+ge_shu-1);xun_huan++)

       {

              printf("%8d%%",100+xun_huan);//打印表头不同利率

       }

   printf("\n");

       for(xun_huan=1;xun_huan<=nian;xun_huan++)

       {  

              printf("%2d",xun_huan);

       for(xun_huan_1=li_lv;xun_huan_1<=li_lv+ge_shu-1;xun_huan_1++)

              {

                     qian[xun_huan_1-li_lv]=(100+xun_huan_1)/100.0f*qian[xun_huan_1-li_lv];//用数组记录的上一个钱数来算

                  printf("%9.2f",qian[xun_huan_1-li_lv]);

           }

              printf("\n");//打印一行后换行

}

return 0;

}

 

13.单位矩阵

#include<stdio.h>

int main()

{

        int shu_zi[4][4]={{1},{0,1},{0,0,1},{0,0,0,1}};

   int xun_huan=0,xun_huan_1=0;

      

       /*intshu_zi[4][4]={[3][3]=1,[2][2]=1,[1][1]=1,[0][0]=1};//指定初始化

       intxun_huan=0,xun_huan_1=0;*/

       for(xun_huan=0;xun_huan<=3;xun_huan++)//行循环

       {

              for(xun_huan_1=0;xun_huan_1<=3;xun_huan_1++)//列循环

              {

                     printf("%d",shu_zi[xun_huan][xun_huan_1]);

              }

              printf("\n");

       }

       return0;

}

 

14.扫雷布雷游戏

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

int main()

{

       intge_shu=0,lei[10][10]={0},hang=0,lie=0;

   srand(time(0));//设置种子

       while(ge_shu<10)//【判断雷的个数是否小于10来循环，不用for循环，因为雷的位置可能重叠

       {

              hang=rand()%10;

              lie=rand()%10;

              if(!lei[hang][lie])//没有雷，布雷

              {

                 lei[hang][lie]=1;

                    ge_shu++;

              }

       }

       for(hang=0;hang<=9;hang++)//显示雷的位置

       {

              for(lie=0;lie<=9;lie++)

              {

                     printf("%c",lei[hang][lie]?'o':'');//用三目运算符判断有雷用o表示，每雷空格

              }

              printf("\n");

       }

       return0;

}

 

15.函数练习

#include<stdio.h>

int jia(int shu_zi_1,int shu_zi_2)

{

       returnshu_zi_1+shu_zi_2;

}

int main()

{

   int shu_zi_1=0;//修改形参的值对实参没有影响

       shu_zi_1=jia(2,3)+4;

       printf("%d\n",shu_zi_1);

   return 0;

}

 

 

16.变一维数组

#include<stdio.h>//题目显示一个一维变长数组

/*

void xian_shi(int shu_zi[]) {//数组作参数，从参数拿到的数组本身不是数组，是别的东西

printf("sizeof(shu_zi)是%d\n",sizeof(shu_zi));//参数中数组使用sizeof得到的结果不是数组所占空间的大小，跟数组大小没关系

*/

void xian_shi(int shu_zi[],int ge_shu)  {//数组作参数，只能在变量中增加参数的个数，知道变量中数组的个数

       intxun_huan=0;

       for(xun_huan=0;xun_huan<=(ge_shu-1);xun_huan++)//循环遍历每个变量的下标

       {

              printf("%d",shu_zi[xun_huan]);

       }

       printf("\n");

}

int main()

{

       intge_shu=0;

       printf("请输入变量的个数:");

       scanf("%d",&ge_shu);

       intshu_zi[5]={1,2,3,4,5};//没初始化，打印的是随机数

   xian_shi(shu_zi,5);

       return0;

}

 

17.二维数组显示

#include<stdio.h>

void xian_shi(int shu_zi[],int zu,intge_shu)  {//显示二维数组，任何二维数组作参数时只能当成一维数组使用，不需要intshu_zi[][]

       intxun_huan=0,xun_huan_1=0;

       for(xun_huan=0;xun_huan<=(zu-1);xun_huan++)

       {

 

       for(xun_huan_1=0;xun_huan_1<=(ge_shu-1);xun_huan_1++)

       {

              printf("%d",shu_zi[xun_huan*ge_shu+xun_huan_1]);//注意打印时下标折算

       }

       printf("\n");

}

}

int main()

{

      

       intshu_zi[3][2]={1,2,3,4,5,6};

   xian_shi(shu_zi,3,2);

       return0;

}

 

18.变长数组

#include<stdio.h>//变长数组

int main()

{

int ge_shu=0,xun_huan=0;

printf("请输入个数:");

scanf("%d",&ge_shu);

int shu_zi[ge_shu];//这样写可以，但vc运行不了

for(xun_huan=0;xun_huan<ge_shu;xun_huan++)

{

       printf("请输入数字:");

       scanf("%d",&shu_zi[xun_huan]);

}

for(xun_huan=ge_shu-1;xun_huan>=0;xun_huan--)

{

       printf("%d",shu_zi[xun_huan]);

}

return 0;

}

 

 

19.阶乘及递归

1.循环阶乘

#include<stdio.h>

int main()

{

       intshu_zi=0,xun_huan=0,jie_guo=1;//jie_guo不能赋值0

       printf("请输入一个数:");

       scanf("%d",&shu_zi);

       for(xun_huan=1;xun_huan<=shu_zi;xun_huan++)

       {

              jie_guo*=xun_huan;

       }

       printf("结果是%d\n",jie_guo);

       return0;

}

 

2.递归阶乘

#include<stdio.h>

int jie_cheng(int shu_zi) {

   int jie_guo=1;

       if(1==shu_zi)//不要忘了

       {

              return1;

       }

       else

       {

              return(jie_guo=shu_zi*jie_cheng(shu_zi-1));//递归阶乘

       }

}

int main()

{

       intshu_zi=0,jie_guo=1;

       printf("请输入数字:");

       scanf("%d",&shu_zi);

       printf("%d!= %d\n",shu_zi,jie_cheng(shu_zi));

}

 

20.最大公约数

#include<stdio.h>

int yue(int xiao,int da) {

       if(!(da%xiao))

       {

              returnxiao;

       }

       else{

              return  yue(da%xiao,xiao); 

}

}

int main()

{

       intxiao=0,da=0;

       printf("请分别输入小数和大数:");

       scanf("%d%d",&xiao,&da);

       yue(xiao,da);

       printf("最大公约数是%d\n",yue(xiao,da));//注意写法yue(xiao,da),而不是da%xiao

       return0;

}

 

21.汉诺塔算法练习

#include<stdio.h>

void han(int ge_shu,char yuan,charzhong,char mu_di) {

       if(1==ge_shu)

       {

              printf("%d:%c-->%c\n",ge_shu,yuan,mu_di);

       }

       else

       {

              han(ge_shu-1,yuan,mu_di,zhong);//把上面ge_shu-1个盘子移动到中转柱上

              printf("%d:%c-->%c\n",ge_shu,yuan,mu_di);//把最后一个盘子从初始位置移动到目的柱上

              han(ge_shu-1,zhong,yuan,mu_di);//把中转柱上的ge_shu-1个盘子移到目的柱上

       }

}

int main()

{

       intge_shu=0;

       printf("请输入盘子的个数:");

       scanf("%d",&ge_shu);

   han(ge_shu,'A','B','C');

return 0;

}

 

22.fabnacci数列

a.循环实现

#include<stdio.h>

int main()

{

       intshu_zi=0, xun_huan=0,shu_zi_1=1,shu_zi_2=1;//数字shu_zi_1,shu_zi_2分别记录编号0和1，注意赋值为1

   printf("请输入数字编号:");

       scanf("%d",&shu_zi);

       if(shu_zi<=1)

       {

              printf("结果是1\n");

       }

       else

       {

       for(xun_huan=3;xun_huan<=shu_zi;xun_huan++)

       {

              intshu=shu_zi_1+shu_zi_2;

              shu_zi_1=shu_zi_2;//注意将结果送给下一个数，以进行下一次循环

              shu_zi_2=shu;

       }

       printf("结果是%d\n",shu_zi_2);

       }

}

//数列 1 1 2 3 5 8 13

 

b.递归实现

#include<stdio.h>

 

int f(int shu_zi) {

       if(shu_zi<=1)

       {

              return1;

       }

       else

       {

              returnf(shu_zi-2)+f(shu_zi-1);//编号减-1，和-2

       }

}

 

int main()

{

       intshu_zi=0;

   printf("请输入数字编号:");

       scanf("%d",&shu_zi);

       printf("结果是%d\n",f(shu_zi));

       return0;

}

 

C.数列用数组记录变量（加快递归速度）

#include<stdio.h>

int shu[100]={1,1};///放在外面作全局变量，速度要快很多

int f(int shu_zi)

{

      

       if(!shu[shu_zi])//不是编号0和编号1的时候

       {

              shu[shu_zi]=f(shu_zi-2)+f(shu_zi-1);//不要写成f(shu[shu_zi-2])

              returnshu[shu_zi];//用数组作返回值加快运行速度

       }

       else

       {

              returnshu[shu_zi];

       }

}

int main()

{

       intshu_zi=0;

   printf("请输入数字编号:");

       scanf("%d",&shu_zi);

       printf("结果是%d\n",f(shu_zi));

       return0;

}

23.栈的练习

#include <stdio.h>

 

int shu_zi[10];

int ge_shu;

int f(){

       intshu_zi=3;

printf("%d\n",shu_zi);

}

int f1(){

       intshu_zi=5;

printf("%d\n",shu_zi);

}

int kong()

{

       if(!ge_shu)

       {

              return1;

       }

       else

       {

              return0;

       }

}

 

int man()

{

       if(10==ge_shu)

       {

              return1;

       }

       else

       {

              return0;

       }

}

 

void push(int shu)

{

       shu_zi[ge_shu]=shu;

       ge_shu++;

}

 

int pop()

{

       ge_shu--;

       returnshu_zi[ge_shu];

}

 

int main()

{

       kong();

       man();

       push(6);

       pop();

       f();

       f1();

       printf("%d",shu_zi[6]);

       return0;

}

 

24.交换两数

#include <stdio.h>

 

void jia_huan(int a,int b)

{

       intt;

       t=a;

   a=b;

       b=t;

}

int main()

{

       inta=3,b=7;

       jia_huan(a,b);

       printf("%d,%d",a,b);

       return0;

}//3,7

 

/*

void jia_huan(int shu_zu[])

{

       intt;

       t=shu_zu[0];

       shu_zu[0]=shu_zu[1];

       shu_zu[1]=t;

}

int main()

{

       intshu_zi[2]={3,7};

       jia_huan(shu_zi);

       printf("%d,%d",shu_zi[0],shu_zi[1]);

       return0;

}//7,3

*/

/*

void jia_huan(int *a,int *b)

{

       intt;

       t=*a;

   *a=*b;

       *b=t;

}

int main()

{

       inta=3,b=7;

       jia_huan(&a,&b);

       printf("%d,%d",a,b);

       return0;

}//7,3

*/

25.指针返回值练习

#include <stdio.h>

 

int *zui_da(int *p_shu_zi_1,int*p_shu_zi_2)

{

       return*p_shu_zi_1>*p_shu_zi_2 ? p_shu_zi_1 : p_shu_zi_2;

 

}

int main()

{

       intshu_zi_1=0,shu_zi_2=0;

       int*p_shu=NULL;

       printf("请输入两个整数 ：");

       scanf("%d%d",&shu_zi_1,&shu_zi_2);

       p_shu=zui_da(&shu_zi_1,&shu_zi_2);

       printf("最大数字是 %d\n",*p_shu);

       return0;

}

 

26.指针和数组比较

#include<stdio.h>

int main()

{

       intshu[5]={1,2,3,4,5},xun_huan=0;

       int*p_shu_zi=shu;//注意可以这样写

   for(xun_huan=0;xun_huan<=4;xun_huan++)

//     for(xun_huan=0;xun_huan<=4;p_shu_zi++)不可以这样写

       {

              printf("%d",shu[xun_huan]);//和下面几个结果一样

              printf("%d",*(shu+xun_huan));

              printf("%d",p_shu_zi[xun_huan]);

              printf("%d\n",*(p_shu_zi+xun_huan));

       }

       for(xun_huan=0;xun_huan<=4;xun_huan++,p_shu_zi++)//可以这样实现指针变量的自增

              {

                     printf("%d",*p_shu_zi);

              }

       printf("\n");

       return0;

}

 

27.读取字符串

#include <stdio.h>

 

int main()

{

       charzi_fu_chuan[10];

       printf("请输入字符串：");

       fgets(zi_fu_chuan,10,stdin);

       //scanf("%s",zi_fu_chuan);

       printf("%s\n",zi_fu_chuan);

       return0;

}

 

28.字符串函数

#include <stdio.h>

#include <string.h>

 

int main()

{

       charzi_fu_chuan[]="abc";

       charzi_fu_chuan_1[]="xyz";

       printf("长度是 %d\n",strlen(zi_fu_chuan));

       printf("合并结果是%d\n",strcat(zi_fu_chuan,zi_fu_chuan_1);

}

 

29.static的作用

#include<stdio.h>

void f() {

       staticint shu_zi=3;//加static相当于全局变量定义，生命周期整个程序运行周期，作用域不变，第二次调用时不执行，直接跳过

       printf("shu_zi是%d\n",shu_zi);

       shu_zi++;

}

int main()

{

       f();

       f();

       f();

       return0;

}

30.局部变量地址不能做返回值

#include<stdio.h>

int *f()

{

       intshu_zi=3;

       return&shu_zi;//局部变量的地址不能作为返回值，因为函数结束时局部变量不存在，有警告

}

int *f1()

{

       intshu_zi=5;

       intshu_zi_1=7;

       intshu_zi_2=shu_zi+shu_zi_1;

       returnNULL;

}

int main()

{

       int*p_shu_zi=NULL;

       p_shu_zi=f();

       printf("%d\n",*p_shu_zi);//其实输出3是巧合，局部变量已释放，能输出3是没有其他操作。

       f1();//这时3和5所在位置是同一位置

       printf("%d\n",*p_shu_zi);

       return0;

}

//结论：绝对不能将局部变量作为返回值使用

 

31.数字时钟练习

#include<stdio.h>

#include<time.h>

int main()

{

       intshi_jian=0,shi=0,fen=0,miao=0;

       while(1)//实现死循环

       {

              shi_jian=time(0);

              miao=shi_jian%60;

              fen=shi_jian%3600/60;//从这一小时经过的秒数

              shi=shi_jian%(24*3600)/3600;//从这一天开始经过的秒数

              shi=(shi+8)%24;//调整时区

              printf("%02d:%02d:%02d\r",shi,fen,miao);//\r是在原位置覆盖输出，Linux下结合在printf后加fflush(stdout);使用

           //while(shi_jian==time(0));//控制当前这秒还没完的话不进行下一次循环

             sleep(1);//这个函数是Linux平台的要结合unistd.h使用

       }

       return0;

}

 

 

32.用指针实现返回最大数：

#include<stdio.h>

int zui_da(int *p_shu_zi_1,int *p_shu_zi_2){//返回的不是数，是最大的变量，要找到变量的地址，通过指针保存变量的地址数据

       return*p_shu_zi_1>*p_shu_zi_2?p_shu_zi_1:p_shu_zi_2;//返回的是地址

}

int main()

{

       intshu_zi_1=0,shu_zi_2=0;

       int*p_shu;

       printf("请输入两个数:");

       scanf("%d%d",&shu_zi_1,&shu_zi_2);

       p_shu=zui_da(&shu_zi_1,&shu_zi_2);

       printf("最大的数是%d\n",*p_shu);

       return0;

}

 

33.局部变量地址不能做返回值

#include<stdio.h>

int *f()

{

       intshu_zi=3;

       return&shu_zi;//局部变量的地址不能作为返回值，因为函数结束时局部变量不存在，有警告

}

int main()

{

       int*p_shu_zi=NULL;

       p_shu_zi=f();

       printf("%d\n",*p_shu_zi);

       return0;

}

34.指针变量自增

#include<stdio.h>

int main()

{

       intshu[5]={1,2,3,4,5},xun_huan=0;

       int*p_shu_zi=shu;//注意可以这样写

   for(xun_huan=0;xun_huan<=4;xun_huan++)

//     for(xun_huan=0;xun_huan<=4;p_shu_zi++)不可以这样写

       {

              printf("%d",shu[xun_huan]);//和下面几个结果一样

              printf("%d",*(shu+xun_huan));

              printf("%d",p_shu_zi[xun_huan]);

              printf("%d\n",*(p_shu_zi+xun_huan));

       }

       for(xun_huan=0;xun_huan<=4;xun_huan++,p_shu_zi++)//可以这样实现指针变量的自增

       {

              printf("%d",*p_shu_zi);

       }

       return0;

}

      

 

35.strcpy错误

#include<stdio.h>

char *str_cpy(char *p_zi_fu_chuan_1,char*p_zi_fu_chuan_2)

{

       if(!p_zi_fu_chuan_1||!p_zi_fu_chuan_2)

       {

              returnp_zi_fu_chuan_1;

       }

 

       while(*p_zi_fu_chuan_2)

       {

              *p_zi_fu_chuan_1=*p_zi_fu_chuan_2;

              p_zi_fu_chuan_1++;

              p_zi_fu_chuan_2++;

       }

       //*p_zi_fu_chuan_1='\0';

    char *p=p_zi_fu_chuan_1;

 

//     returnp;

}

int main()

{

       charzi_fu_chuan_1[10]="abc";

       //str_cpy(zi_fu_chuan_1,"xy");

       printf("%s\n",str_cpy(zi_fu_chuan_1,"xy"));

       return0;

}

 

36.字符指针可以表字符串

#include<stdio.h>

int main()

{

       char*p_zi_fu_chuan="abc";//相当于p_zi_fu_chuan[]="abc";//char zi_fu_chuan=”abc”;没有‘\0’字符的数组不能当字符串使用

       printf("%s\n","abc");

       printf("%s\n",p_zi_fu_chuan);//指针就是字符变量的首地址

       return0;

}

 

37.模拟登陆

#include<stdio.h>

#include<string.h>

int main()

{

       charyong_hu[10]="admin\n";//注意要加/n

       charmi_ma[10]="123456\n";

       charming[10],ma[10];

       intxun_huan=0;

       for(xun_huan=0;xun_huan<3;xun_huan++)//控制用户名输入3次

       {

              printf("请输入用户名:");

              fgets(ming,10,stdin);

              if(strcmp(ming,yong_hu))

              {

                     printf("用户名输入错误\n");

                     continue;

              }

break;

       }

       for(xun_huan=0;xun_huan<3;xun_huan++)//控制密码输入3次

       {

           printf("请输入用户密码:");

              fgets(ma,10,stdin);

              if(strcmp(ma,mi_ma))

              {

                     printf("密码输入错误\n");

                     continue;

              }    

              break;

       }

       if(xun_huan<3)

       {

              printf("登陆成功\n");

       }

       else

       {

              printf("登陆失败\n");

       }

       return0;

}

 

38.Main函数echo作用

#include <stdio.h>

 

int main(int argc,char *argv[])

{

       int xun_huan = 0;

       for(xun_huan = 0;xun_huan < argc;xun_huan ++)

       {

               printf("%s\n",argv[xun_huan]);

       }

        return 0;

}

 

 

39.宏练习

（1）条件编译（点菜）

#include<stdio.h>

#define zhaobenshan//没参，只是叫这个名字的宏，这个名字可以用

int main()

{

       intcai =0;

       printf("请点菜:");

       scanf("%d",&cai);

   #ifdef zhaobenshan//叫名字的宏被定义过

   //#if defined(zhaobenshan)//效果与上面相同，运用广，可以与或非，加()构成逻辑表达式，定义过为真，没定义过为假

       if(1==cai)

       {

              printf("这个菜没有\n");

       }

       else{

              printf("这个菜有\n");

       }

# else//普通人点菜,可以将前面定义的宏注释掉

       {

              printf("这个菜有\n");

       }

# endif

       return0;

}

 

（2）折扣练习（条件编译）

#include <stdio.h>

 

int main()

{

#if defined(JINGPING)

       printf("120%%\n");

#elif !defined(GONGCHANG)

       printf("100%%\n");//#elif defined将代码分成更多组

#else

       printf("80%%\n");

#endif

       return0;

}

 

 

（3）宏的运算符#   ##

#include<stdio.h>//宏的运算符练习

#define STR(n) #n  //#运算符只能用在带参数的宏里，

//这个参数转换成字符串字面值

int main()

{

       printf("结果是%s\n",STR(5-4));

       return0;

}//结果：5-4

 

#include<stdio.h>

//运算符可以把参数所代表的标识符和其他内容合并成为

//一个新的标识符，目的是有别于其他的标识符

#define global(n)  g_##n //

int global(shu_zi);//定义全局变量

int main()

{

       intglobal(shu_zi)=3;

       printf("%d\n",global(shu_zi));

       return0;

}

 

/*#include<stdio.h>

#define local(n)  l_##n //

//int local(shu_zi);

int main()

{

       intlocal(shu_zi)=3;//定义局部变量

       printf("%d\n",local(shu_zi));

       return0;

}

*/

gcc -E wenjian.c如下：

int main()

{

 intl_shu_zi=3;//   l_shu_zi=3取代了local(shu_zi)=3

 printf("%d\n",l_shu_zi);

 return 0;

}

 

（4）gcc内置的宏

#include <stdio.h>

int main()

{

       printf("行号是%d\n",__LINE__);//输出此输出语句所在行

       printf("文件是%s\n",__FILE__);//输出当前文件名

       printf("日期是%s\n",__DATE__);//输出当前日期

       printf("时间是%s\n",__TIME__);//输出当前时间

       printf("%sC标准\n",__STDC__ ? "支持" : "不支持");//判断支不支持C标准

       return0;

}

 

（5）宏求面积

#include<stdio.h>

#define pi 3.14f

#define zhou_chang(r) 2*pi*r

#define mian_ji(r)    pi*r*r

int main()

{

       floatban_jing=0;

       printf("请输入半径:");

       scanf("%d",&ban_jing);

       printf("%g\n",zhou_chang(ban_jing));

       printf("%g\n",mian_ji(ban_jing));

       return0;

}

 

（6）宏与形参区别

#include<stdio.h>

#define SHE_ZHI(shu_zi)  shu_zi=5//注意不要只写5，写成shu_zi=5

int han(int shu_zi) {

       shu_zi=3;

}

int main()

{

       intshu_zi=4;

       han(shu_zi);

       printf("%d\n",shu_zi);

   SHE_ZHI(shu_zi);//会修改变量shu_zi的数值，因为宏是直接被文

       //字替换的，因此参数就是宏内部使用的变量

       printf("%d\n",shu_zi);

       return0;

}//答案： 4  5

 

（7）宏的整体性

#include<stdio.h>

#define cheng_ji(x,y)  ((x)*(y))//注意保证宏的完整性,不然结果不对

int main()

{

       printf("%d\n",cheng_ji(2+3,5-3));

       printf("%d\n",20/cheng_ji(3+2,5-3));

       return0;

}

 

（8）宏自增  (避免用到)

#include<stdio.h>

#define ping_fang(x) x*x

int main()

{

       intshu_zi=7;

       printf("%d\n",ping_fang(7));

       printf("%d\n",ping_fang(++shu_zi));//不要使用自增自减的结果作为宏的参数，原因是宏不是函数，直接进行两次自增

       return0;

}

 

 

（9）宏作数组

#include<stdio.h>

#define HANG 10

#define LIE  10

#define ge_shu(shu_zu)  sizeof(shu_zu)/sizeof(shu_zu[0][0])

int main()

{

       intLEI[HANG][LIE];

   float shu_zu[3][4];

       printf("变量个数是%d\n",ge_shu(LEI));//结果100

       printf("变量个数是%d\n",ge_shu(shu_zu));

       return0;

}

（10）带参数的宏和函数的区别

#include<stdio.h>

//每个宏都应该被包含在一对小括号中

//这样可以强制把宏当成一个整体

//宏的每个参数都应该用小括号包围

//这样可以保证每个参数先计算出结果

//然后在进行宏计算

#define zhuan_huan(s)  (s)/(24 * 3600)

int main()

{

       printf("天数是%d",zhuan_huan(48*3600));

   return 0;

}

 

（11）宏实现字符大小写转换

#include<stdio.h>

#define zhuan_huan(c)  c<='z'&&c>='a'?c-'a'+'A':c//当成数

#define zhuan_huan1(c) c=(c<='z'&&c>='a'?c-'a'+'A':c)//当成复杂的处理过程。注意这种写法//时加c=

int main()

{

       charzi_fu=0;

       printf("请输入字符:");

       scanf("%c",&zi_fu);

       printf("%c\n",zhuan_huan(zi_fu));

   zhuan_huan1(zi_fu);//两种写法

       printf("%c\n",zi_fu);

       return0;

}           

             

40.scanf读入正确格式的数据

（scanf输入格式要和语句中一样，为避免键盘输入误输，而导致重新按格式输入，以下就是解决办法）

#include<stdio.h>

int readint() {

       intshu_zi=0;

       while(!scanf("%d",&shu_zi))//读错的话，返回是0

       {

              scanf("%*[^\n]");//清理缓冲区

              scanf("%*c");

              printf("请再输入一个数:");

       }

   scanf("%*[^\n]");//再次清理缓冲区

       scanf("%*c");

    return shu_zi;//注意是return shu_zi,而不是readint

}

int main()

{

       intshu_zi=0;

       printf("请输入一个数:");

       //scanf("%d",&shu_zi);

       shu_zi=readint();//使用这个函数读取整数，不使用scanf

       printf("数是%d\n",shu_zi);

       return0;

}

        

41.多文件处理

#ifndef __READINT_H__

#define __READINT_H__

void readInt();

int jie_guo;

#endif//_READINT_H__

/*头文件声明*/

 

#include<stdio.h>

#include"readInt.h"

extern int jie_guol;//声明全局变量，读到的数放在全局变量

void readInt() {

       intshu_zi=0;

       while(!scanf("%d",&shu_zi))//读错的话，返回是0

       {

              scanf("%*[^\n]");//清理缓冲区

              scanf("%*c");

              printf("请再输入一个数:");

       }

   scanf("%*[^\n]");//再次清理缓冲区

       scanf("%*c");

   return jie_guo;//注意是return jie_guo

}

 

#include<stdio.h>

#include"readInt.h"

int main()

{

       intshu_zi=0;

       printf("请输入一个数:");

       //scanf("%d",&shu_zi);

       jie_guo=readint();//使用这个函数读取整数，不使用scanf

       printf("数是%d\n",jie_guo);

       return0;

}

 

42.Makefile文件

简化多文件程序编译过程，下例为上面多文件的Makefile：

readint: readint.o main.o readInt.h

       gcc readint.o main.o -o readint

readint.o: readint.c readInt.h

       gcc -c readint.c -o readint.o

main.o: main.c readInt.h

       gcc -c main.c -o main.o

clean:

       rm -rf *.o

 

 

43.结构体

#include<stdio.h>

int main()

{

       structren {//结构体声明

              floatshen_gao;//没有声明变量，只是描述了变量shen_gao和结构体之间的关系

              intnian_ling;

              charxing_bie;

       }ren1;

       structren ren2={1.78,23,'f'};//结构体变量声明及初始化

       printf("身高是%g 年龄是%d 性别是%c\n",ren2.shen_gao,ren2.nian_ling,ren2.xing_bie);//通过结构体变量的名称获得其中各个简单变量

       return0;

}

 

（1）结构体指针（typedef)

#include<stdio.h>

typedef struct ren {

       floatshen_gao;

       intnian_ling;

       charxing_bie;

} ren;

ren *du(ren *p_ren) {//结构体变量的指针作为函数的参数和返回值，可以提高程序运行效率

//     renren1={0.0f,0,0};

       printf("请输入身高、年龄、性别:");

       scanf("%f%d%c",&(p_ren->shen_gao),&(p_ren->nian_ling),&(p_ren->xing_bie));//注意此//时的写法    通过结构体变量地址表示其中简单变量的语法要使用  ->

       returnp_ren;//返回结构体变量的地址

}

int main()

{  ren ren1={0.0f,0,0};//养成初始化的习惯

       ren*p_ren= NULL;

       p_ren=du(&ren1);

       printf("身高是%g,年龄是%d,是%c\n",p_ren->shen_gao,p_ren->nian_ling,p_ren->xing_bie);
       return0 ;

}//结果性别显示不出来

 

（2）Typedef练习

#include<stdio.h>

typedef struct ren {

       floatshen_gao;

       intnian_ling;

       charxing_bie;

} ren;

ren du() {//ren的结构体变量做返回值

       renren1={0.0f,0,0};

       printf("请输入身高、年龄、性别:");

       scanf("%f%d%c",&ren1.shen_gao,&ren1.nian_ling,&ren1.xing_bie);

       returnren1;//使用读函数读，不在主函数读，这样可以，但不好，在调用的时候参数和返回值都会复制，因为ren1在栈里，不同的栈里

}

int main()

{  ren ren1={0.0f,0,0};//养成初始化的习惯

       ren1=du();

       printf("身高是%g,年龄是%d,性别是%c\n",ren1.shen_gao,ren1.nian_ling,ren1.xing_bie);

       return0 ;

}

 

（3）结构体的对齐与补齐

#include <stdio.h>

typedef struct{//结果：大小是8个字节

       charzi_fu;

       charzi_fu_1;

       intshu_zi;

}jie_gou;

 

typedef struct{//结果：大小是8个字节

       intshu_zi;

       charzi_fu;

       charzi_fu_1;

}jie_gou;

 

typedef struct{//结果：大小是12个字节 这个结果变大是因为不同类型变量产生间隙，字节变大，因而相同类型变量相邻可减小字节

       charzi_fu;

       intshu_zi;

       charzi_fu_1;

}jie_gou;

 

int main()

{

       printf("sizeof(jie_gou)是 %d\n",sizeof(jie_gou));

       return0;

}

 

（4）typedef（位域）

#include<stdio.h>

typedef struct {

       charlei:1;//后面用冒号表示有几个二进制位,位域不适合浮点型数据

       charge_shu:4;

       charzhuang_tai:2;  //结果：1    7位，没满8位按8位算，即1字节

}wei_zhi;

typedef struct {//没有用使用域

       charlei;

       charge_shu;

       charzhuang_tai;

}wei_zhi_1;

int main()

{  

       wei_zhiwei;

       printf("sizeof(wei_zhi)是%d\n,sizeof(wei_zhi_1)是%d\n",sizeof(wei_zhi),sizeof(wei_zhi_1));

//     printf("%p",&(wei.ge_shu));//位域在字节里面，没有地址，字节才有地址

       return0;

}

（5）联合及大小端

#include <stdio.h>

 

union lian_he{//是指两个不同字节的不同使用方式，你可以把它当

       //成字符来用，也可以当成整数来用，占的是同一地址

       intshu_zi;

       charzi_fu[2]; 

}lian_he_1;

int main()

{

       printf("sizeof(lian_he_1)是 %d\n",sizeof(lian_he_1));

       printf("%p\n%p\n",&lian_he_1.shu_zi,&lian_he_1.zi_fu[0]);

       lian_he_1.shu_zi= 0x12345678;

       printf("x%x%\n",lian_he_1.zi_fu[0]);//大端，小端，本系统采用小端

       return0;

}

 

（6）枚举

#include <stdio.h>

 

int main()

{

       enumji_jie{SPR,SUM,AUT=6,WIN};

       //printf("SPR是 %d\n",SPR);//第一个枚举子从0开始

       //printf("WIN是 %d\n",WIN);//是前一个枚举子加1，但不能以减法换算

       enumji_jie season;

       season=SUM;

       printf("season是 %d\n",season);

       return0;

}

 

//对枚举型的变量赋整数值时，需要进行类型转换。

#include <stdio.h>

enum DAY { MON=1, TUE, WED, THU, FRI, SAT,SUN };

void main()

 {

    enum DAY yesterday, today, tomorrow;

    yesterday = TUE;

     today = (enum DAY) (yesterday + 1); //类型转换

   tomorrow = (enum DAY) 30; //类型转换

   //tomorrow = 3; //错误

   printf("%d %d %d \n", yesterday, today, tomorrow); //输出：2 3 30

}

 

44.Void指针练习

#include<stdio.h>

enum type {CHAR,INT,FLOAT};

void xian_shi(intlei_xing,void*p_shu)//void仅说明指针变量，没说什么类型

{

       switch(lei_xing){

       caseCHAR:

              printf("%c\n",*((char*)p_shu));//void*数据使用前要强制转换字符类型指针，不能通过地址去拿

              break;

       caseINT:

              printf("%d\n",*((int*)p_shu));

              break;

       caseFLOAT:

              printf("%f\n",*((float*)p_shu));

              break;

       }

}

int main()

{

       charzi_fu='a';

       intshu=3;

       floatshu_zi=3.5f;

       printf("%c\n",'a');//验证跟下一行显示结果是不是一样

   xian_shi(CHAR,&zi_fu);

       printf("%d\n",3);

   xian_shi(INT,&shu);

       printf("%f\n",3.5f);

   xian_shi(FLOAT,&shu_zi);

       return0;

}

      

45.内存分配（堆）

（1）malloc

/*#include<stdio.h>

int main()

{

       intshu[3]={0},xun_huan=0;//分配在栈里

       for(xun_huan=0;xun_huan<3;xun_huan++)

       {

              printf("请输入一个数:");

              scanf("%d",shu+xun_huan);//可以这样读入一个数

       }

       for(xun_huan=2;xun_huan>=0;xun_huan--)

       {

              printf("%d",shu[xun_huan]);

       }

       return0;

}

*/

#include<stdio.h>

#include<stdlib.h>

int main()

{

       int*p_shu_zi=NULL,xun_huan=0;

       p_shu_zi=(int*)malloc(3*sizeof(int));//malloc(3*sizeof(int))从堆中分配3个字节，得到首字节地址，但是是任意的void*类型，后强制转换p_shu_zi可以当成数组（栈里）用，但在堆里

       if(!p_shu_zi)//分配失败返回NULL

       {

              printf("内存分配失败\n");

              return0;

       }

       for(xun_huan=0;xun_huan<3;xun_huan++)

       {

              printf("请输入一个数:");

              scanf("%d",p_shu_zi+xun_huan);//可以这样读入一个数

       }

       for(xun_huan=2;xun_huan>=0;xun_huan--)

       {

              printf("%d\n",p_shu_zi[xun_huan]);//或者*(p_shu_zi+xun_huan)

       }

       free(p_shu_zi);//释放从堆中分配的所有变量

       p_shu_zi=NULL;//释放掉从堆中变量后，p_shu_zi就成为了野指针，

       //必须把指针变量设置为NULL,释放完空间后要把指针变量设置成NULL

       return0;

}

             

（2）realloc, calloc练习

#include<stdio.h>

#include<stdlib.h>

int main()

{

       int*p_shu_zi=NULL, *p_shu_zi_1=NULL,xun_huan=0;

 

//     p_shu_zi=(int*)malloc(3*sizeof(int));不保证所有变量都被清0

       p_shu_zi=(int*)calloc(3,sizeof(int));//保证所有变量都被清0了

       if(p_shu_zi)//内存分配成功

       {

              printf("%p\n",p_shu_zi);

       for(xun_huan=0;xun_huan<3;xun_huan++)

       {

              printf("%d\n",*(p_shu_zi+xun_huan));

          *(p_shu_zi+xun_huan)=xun_huan+1;

 

       }

       int*p_shu_zi_1=realloc(p_shu_zi,6*sizeof(int));//把原来的三个整数空间调整六个整数空间，//realloc原有不变，但不清0

       if(p_shu_zi_1){//如果成功

       printf("%p%p\n",p_shu_zi,p_shu_zi_1);//测试新旧两个地址

       p_shu_zi=p_shu_zi_1;//用新地址覆盖掉旧地址

       for(xun_huan=0;xun_huan<6;xun_huan++)//打印新空间变量的个数

       {

              printf("%d",*(p_shu_zi+xun_huan));

       }

       printf("\n");

       }

 

       }

       return0;

}

46.用函数指针排序

/*

#include <stdio.h>

 

int bi_jiao_1(const void* p_shu_zi_1, constvoid* p_shu_zi_2)

{

       return0-bi_jiao(p_shu_zi_1,p_shu_zi_2);

}

 

int bi_jiao(const void* p_shu_zi_1, constvoid* p_shu_zi_2)

{

       if(*(int*)p_shu_zi_1>*(int *)p_shu_zi_2)

       {

              return1;

       }

       elseif(*(int *)p_shu_zi_1<*(int *)p_shu_zi_2)

       {

              return-1;

       }

       else

       {

              return0;

       }

}

 

void pai_xu(int shu_zi[],int ge_shu,int(*p_func)(const void *,const void *))

{

       if(1==p_func(&shu_zi[0],&shu_zi[1]))

       {

              intshu=shu_zi[0];

              shu_zi[0]=shu_zi[1];

              shu_zi[1]=shu;

       }

      

}

int main()

{

       intshu_zi[2]={7,2};

       pai_xu(shu_zi,2,bi_jiao);

       printf("%d%d\n",shu_zi[0],shu_zi[1]);

      

       pai_xu(shu_zi,2,bi_jiao_1);

       printf("%d%d\n",shu_zi[0],shu_zi[1]);

}

*/

 

#include <stdio.h>

#include <stdlib.h>

 

int bi_jiao_1(const void* p_shu_zi_1, constvoid* p_shu_zi_2)

{

       return0-bi_jiao(p_shu_zi_1,p_shu_zi_2);

}

 

int bi_jiao(const void* p_shu_zi_1, constvoid* p_shu_zi_2)

{

       if(*(int*)p_shu_zi_1>*(int *)p_shu_zi_2)

       {

              return1;

       }

       elseif(*(int *)p_shu_zi_1<*(int *)p_shu_zi_2)

       {

              return-1;

       }

       else

       {

              return0;

       }

}

 

int main()

{

       intshu_zi[2]={7,2};

       qsort(shu_zi,2,sizeof(int),bi_jiao);

       printf("%d%d\n",shu_zi[0],shu_zi[1]);

       qsort(shu_zi,2,sizeof(int),bi_jiao_1);

       printf("%d%d\n",shu_zi[0],shu_zi[1]);

}

 

 

47.Const指针

/*#include<stdio.h>

int main()

{

       intshu_zi=3;

const int *p_shu_zi=NULL;//不可以通过这个指针修改别的变量但是指针本身可以被修改

//int* const p_shu_zi_1=NULL;

       p_shu_zi=&shu_zi;

       //*p_shu_zi=5;//不可以通过指针去修改，const指针指向的变量不可以被修改

       printf("请输入一个数:");

       //scanf("%d",p_shu_zi);//编译出现警告

       scanf("%d",&shu_zi);//shu_zi本身数值可以改的，但不能通过p_shu_zi指针修改

       printf("%d%d\n",p_shu_zi,shu_zi);

       return0;

}

*/

#include<stdio.h>

int main()

{

       intshu_zi=3;

   int *const p_shu_zi=&shu_zi;//指针本身不可以被修改，但是可以通过它修改别的变量

       //p_shu_zi=&shu_zi;

   //*p_shu_zi=5;

       printf("请输入一个数:");

       scanf("%d",p_shu_zi);

       //scanf("%d",&shu_zi);

       printf("%d%d\n",*p_shu_zi,shu_zi);

       return0;

}

48.二级指针

#include <stdio.h>

 

int main()

{

       intshu_zi = 3;

       int*p_shu_zi = &shu_zi;

       int**pp_shu_zi = &p_shu_zi;

       printf("%d%p %p\n",**pp_shu_zi,*pp_shu_zi,pp_shu_zi);

      

return 0;

}

 

#include<stdio.h>

#include<stdlib.h>

void chai_fen(char *zi_fu_chuan,char**pp_zi_fu) {//第一个参数表示要用来拆分的字符串，第二个参数表示字符指针地址，用来放拆分好得到新字符串地址

       intxun_huan=0;

       char*p_zi_fu=NULL;

       while(*(zi_fu_chuan+xun_huan)!=':')

       {    

              xun_huan++;

       }    

       p_zi_fu=(char*)malloc(xun_huan+1);//自动分配空间

       xun_huan=0;

       while(*(zi_fu_chuan+xun_huan)!=':')

       {

              *(p_zi_fu+xun_huan)=*(zi_fu_chuan+xun_huan);//复制到新字符对应的位置

              xun_huan++;

       }

       *(p_zi_fu+xun_huan)='\0';//用0也可以，遇到结束

       *pp_zi_fu=p_zi_fu;//p_zi_fu是首地址

} 

int main()

{

       charzi_fu_chuan[]="1234:5678:9012";

       char*p_zi_fu=NULL;

       chai_fen(zi_fu_chuan,&p_zi_fu);//用字符指针变量地址

       printf("拆分结果是%s\n",p_zi_fu);//p_zi_fu用来记录得到的字符串首地址

       free(p_zi_fu);

       p_zi_fu=NULL;

       return0;

}

 

49函数指针

#include <stdio.h>

 

int jia(int x,int y)

{

       returnx + y;

}

 

int main()

{

       int(*p_func)(int,int);

       p_func= jia;

       printf("函数的地址是 %p和%p\n",jia,p_func);

       return0;

}

 

50.排序

（1）排序函数

/*#include<stdio.h>

int bi_jiao(const void* p_shu_zi_1,const void* p_shu_zi_2)

{

       if(*(int*)p_shu_zi_1>*(int*)p_shu_zi_2)

       {

              return1;

       }

       elseif(*(int*)p_shu_zi_1<*(int*)p_shu_zi_2)

       {

              return-1;

       }

       else

       {

              return0;

       }

}

int bi_jiao_1(const void* p_shu_zi_1,constvoid* p_shu_zi_2)

{

       returnbi_jiao(p_shu_zi_1,p_shu_zi_2);

}

void pai_xu(int shu_zi[],int ge_shu)

{

       if(1==bi_jiao(&shu_zi[0],&shu_zi[1]))

       {

              intshu=shu_zi[0];

              shu_zi[0]=shu_zi[1];

              shu_zi[1]=shu;

       }

}

int main()

{

       intshu_zi[2]={7,2};

       pai_xu(shu_zi,2);

       printf("%d%d",shu_zi[0],shu_zi[1]);

       return0;

}

*/

 

 

#include<stdio.h>

int bi_jiao(const void* p_shu_zi_1,const void*p_shu_zi_2)

{

 

       if(*(int*)p_shu_zi_1>*(int*)p_shu_zi_2)

       {

       return1;

       }

       elseif(*(int*)p_shu_zi_1<*(int*)p_shu_zi_2)

       {

              return-1;

       }

       else

       {

              return0;

       }

}

int bi_jiao_1(const void* p_shu_zi_1,constvoid*p_shu_zi_2)

{

       return0-bi_jiao(p_shu_zi_1,p_shu_zi_2);

}

/*void pai_xu(int shu_zi[],int ge_shu,int(*p_func)(const void*, const void*))//改成函数指针

{

       if(1==p_func(&shu_zi[0],&shu_zi[1]))//注意

       {

              intshu=shu_zi[0];

              shu_zi[0]=shu_zi[1];

              shu_zi[1]=shu;

       }

}

*/

int main()

{

       intshu_zi[2]={7,2};

   //pai_xu(shu_zi,2,bi_jiao);//这样可以在main()里修改哪个排序

       qsort(shu_zi,2,sizeof(int),bi_jiao);//用qsort函数进行排序

       printf("%d%d",shu_zi[0],shu_zi[1]);

       return0;

}

 

 

（2）qsort数组排序（指针数组）

#include<stdio.h>

#include<stdlib.h>

//qsort函数bi_jiao函数必须以这种形式写int bi_jiao(const void * p_shu_zi_1,const void * p_shu_zi_2)

int bi_jiao(const void*p_shu_zi_1,constvoid*p_shu_zi_2)

{

//指针变量的地址，用二级指针来描述，为拿到整数变量的地址，加**

       int shu_zi_1=**((int**)p_shu_zi_1),shu_zi_2=**((int**)p_shu_zi_2);

       if(shu_zi_1>shu_zi_2)

       {

              return1;

       }

       elseif(shu_zi_1<shu_zi_2)

       {

              return-1;

       }

       else

       {

              return0;

       }

}

 

int main(int argc,int*argv[])

{

       intshu_zi[5]={1,2,4,-3,6},xun_huan=0;

       int*p_shu_zi[]={shu_zi,shu_zi+1,shu_zi+2,shu_zi+3,shu_zi+4};

       qsort(p_shu_zi,5,sizeof(int*),bi_jiao);

       for(xun_huan=0;xun_huan<=4;xun_huan++)

       {

              printf("%d",*p_shu_zi[xun_huan]);

       }

       return0;

}

 

 

（3）qsort 字符串排序

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

 int bi_jiao(const void*p_str,const void *p_str_1)

 {

        returnstrcmp(*(char**)p_str,*(char**)p_str_1);

 }

 intmain()

 {

        char*str[]={"China","Russia","American","Frence","England"};

        int xun_huan=0;

        qsort(str,5,sizeof(char*),bi_jiao);

        for(xun_huan=0;xun_huan<=4;xun_huan++)

        {

               printf("结果是%s\n",str[xun_huan]);

        }

        return 0;

 }

 

51.指针数组

#include <stdio.h>

#include <stdlib.h>

//qsort函数bi_jiao函数必须以这种形式写int bi_jiao(const void * p_shu_zi_1,const void * p_shu_zi_2)

int bi_jiao(const void * p_shu_zi_1,constvoid * p_shu_zi_2)

{

       //指针变量的地址，用二级指针来描述，为拿到整数变量的地址，加**

       intshu_zi_1=**(int**)p_shu_zi_1,shu_zi_2=**(int**)p_shu_zi_2;

       if(shu_zi_1>shu_zi_2)

       {

              return1;

       }

       elseif(shu_zi_1<shu_zi_2)

       {

              return-1;

       }

       else

       {

              return0;

       }

}

int main(int argc,int*argv[])

{

       intshu_zi[]={9,5,-7,-3,13},xun_huan=0;

       int*p_shu_zi[]={shu_zi,shu_zi+1,shu_zi+2,shu_zi+3,shu_zi+4};

       qsort(p_shu_zi,5,sizeof(int*),bi_jiao);

       for(xun_huan=0;xun_huan<5;xun_huan++)

       {

              printf("%d  ",*(p_shu_zi[xun_huan]));

       }

       printf("\n");

       return0;

}

 

52.数组指针

#include <stdio.h>

 

int main()

{

       intshu_zi[3]={1,2,3};

       intshu_zi_1[2][3]={1,2,3,4,5,6};

       int(*p_shu_zi)[3];// 声明数组指针，和int p_shu_zi[][]效果一样

       //p_shu_zi=NULL;

       p_shu_zi=&shu_zi;//数组指针用来记录数组的地址

       printf("p_shu_zi是 %p,*p_shu_zi是 %p\n",p_shu_zi,*p_shu_zi);

       //p_shu_zi是 0012FF34,*p_shu_zi是 0012FF34  一样的，这就是数组指针的特点

       printf("shu_zi_1是 %p,*shu_zi_1是 %p\n",shu_zi_1,*shu_zi_1);

       //shu_zi_1是 0012FF24,*shu_zi_1是 0012FF24 一样

       p_shu_zi=shu_zi_1;

       printf("p_shu_zi+1是 %p,*p_shu_zi+1是%p\n",p_shu_zi+1,*p_shu_zi+1);

       //数组指针相当二维数组，二维数组+1跨越一组变量，

       //数组指针与二维数组的区别就在于数组指针可以被赋值，二维数组名称不可赋值

       return0;

}

53.指针数组（字符串）

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

 

 intbi_jiao(const void *p_str,const void *p_str_1)

 {

        returnstrcmp(*(char**)p_str,*(char**)p_str_1);

               //转成二级指针，取一级指针比较两字符串

 }

 intmain()

 {

        char*str[]={"China","Russia","American","Frence","England"};

        int xun_huan=0;

        qsort(str,5,sizeof(char*),bi_jiao);

        for(xun_huan=0;xun_huan<=4;xun_huan++)

        {

               printf("结果是%s\n",str[xun_huan]);

        }

        return 0;

 }

 

54.文件操作

（1）rewind，fseek,ftell位置调整

//rewind 将文件位置指针移到文件的开头

//fseek 将文件位置指针移到文件任意位置

//ftell 告诉当前文件位置在哪儿

 

/*#include <stdio.h>

 

int main()

{

       FILE*p_file=NULL;

       charzi_fu=0;

       p_file=fopen("a.txt","r");

       if(p_file)

       {

              zi_fu=fgetc(p_file);

              printf("%c",zi_fu);

              zi_fu=fgetc(p_file);

              printf("%c",zi_fu);

              zi_fu=fgetc(p_file);

              printf("%c",zi_fu);

              printf("\n");

              rewind(p_file);

              fclose(p_file);

              p_file=NULL;

       }

       return0;

}*/

#include <stdio.h>

 

int main()

{

       FILE*p_file=NULL;

       charzi_fu=0;

       p_file=fopen("a.txt","r");//a.txt中Hello World!

       if(p_file)

       {

              fseek(p_file,6,SEEK_SET);//把位置指针移动到从文件头开始向后6个字节处的位置

              zi_fu=fgetc(p_file);

              printf("%c",zi_fu);

              fseek(p_file,-2,SEEK_END);//把位置指针移动到从文件尾开始向前2字节处的位置

              zi_fu=fgetc(p_file);

              printf("%c",zi_fu);

              fseek(p_file,-3,SEEK_CUR);//把位置指针移动到从当前位置向前3字节的位置

              zi_fu=fgetc(p_file);

              printf("%c\n",zi_fu);

              printf("当前位置指针的位置是%d\n",ftell(p_file));

              //ftell告诉当前文件位置在哪儿

              fclose(p_file);

              p_file=NULL;

       }

       return0;

}

 

fseek，rewind练习

#include<stdio.h>

int main()

{

       FILE*p_file=NULL;

       charzi_fu=0;

       p_file=fopen("a.txt","r");

       if(p_file)

       {

              fseek(p_file,-3,SEEK_END);//第一个参数文件指针，第二个偏移量，第三个，基准位置

              zi_fu=fgetc(p_file);

              printf("%c",zi_fu);

              //rewind(p_file);//用rewind移动到文件开头

              zi_fu=fgetc(p_file);

              printf("%c",zi_fu);

              zi_fu=fgetc(p_file);

              printf("%c\n",zi_fu);

              fclose(p_file);

           p_file=NULL;

       }

       return0;

}

（2）读/写文件

#include<stdio.h>

int main()

{

       FILE*p_file=NULL;

       charzi_fu=0;

       p_file=fopen("a.txt","r");

       if(p_file)

       {

              while(zi_fu!=EOF)

              {

                     zi_fu=fgetc(p_file);

                     //if(zi_fu!=EOF)

                     //{

                            printf("%c",zi_fu);

              //     }

              }

       }    

fclose(p_file);

p_file=NULL;

return 0;

}

 

写文件

#include<stdio.h>

int main()

{

       FILE*p_file=NULL;

       charstr[]="Hello World!";

       intxun_huan=0;

       p_file=fopen("a.txt","w");

      

       if(p_file)

       {

              while(str[xun_huan]){

                     if(EOF== fputc(str[xun_huan],p_file)){

                            break;

                     }

                     xun_huan++;

              }

              fclose(p_file);

           p_file=NULL;

       }

       return0;

}

 

（3）文件复制

#include<stdio.h>

int main()      

{

       charzi_fu=0;

       FILE*p_src=NULL, *p_dest=NULL;

       p_src=fopen("a.txt","r");

       if(p_src)

       {

              p_dest=fopen("b.txt","w");

              if(p_dest)

              {

                     while(zi_fu!=EOF)

                     {

                            zi_fu=fgetc(p_src);

                            if(zi_fu!=EOF)

                            {

                                   fputc(zi_fu,p_dest);

                            }

                     }

              fclose(p_dest);

              p_dest=NULL;

       }

       fclose(p_src);

       p_src=NULL;

       }

       return0;

}

 

（4）格式化文件操作

//fprintf和fscanf

/*#include <stdio.h>

 

int main()

{

       FILE*p_file=NULL;

       charzi_fu=0;

       p_file=fopen("d.txt","w");

       if(p_file)

       {

              fprintf(p_file,"%d%c %g\n",15,'t',1.8f);

              fclose(p_file);

              p_file=NULL;

       }

       return0;

}*/

 

#include <stdio.h>

 

int main()

{

       FILE*p_file=NULL;

       charzi_fu=0;

       chara_char=0;

       intvalue=0;

       floata_float=0.0f;

       p_file=fopen("d.txt","r");

       if(p_file)

       {

              fscanf(p_file,"%d%c %g",&value,&a_char,&a_float);

              printf("%d%c %g\n",value,a_char,a_float);

              fclose(p_file);

              p_file=NULL;

       }

       return0;

}

55.变长参数函数

//printf和scanf都是变长参数函数

/*#include <stdio.h>

#include <stdarg.h>

///* #include <stdarg.h>

 

      void va_start(va_list ap, last);

      type va_arg(va_list ap, type);

      void va_end(va_list ap);

      void va_copy(va_list dest, va_list src);

 *///

void func(int cnt,...)//通过确定的参数确定不确定的参数   

{

       intxun_huan=0;

       va_listv;

       va_start(v,cnt);//找到不确定的参数

       for(xun_huan=0;xun_huan<cnt;xun_huan++)

       {

              printf("%d",va_arg(v,int));//拿到所有int型的参数

       }

       printf("\n");

       va_end(v);//清理

}

int main()

{

       func(3,9,-6,17);

       func(5,1,8,-15,-27,2);

       return0;

}

*/

 

//printf和scanf都是变长参数函数

#include <stdio.h>

#include <stdarg.h>

 

int max(int cnt,...)//通过确定的参数确定不确定的参数

{

       intres=1<<31;//最小整数

       intxun_huan=0;

       va_listv;

       va_start(v,cnt);//找到不确定的参数

       for(xun_huan=0;xun_huan<cnt;xun_huan++)

       {

              intvalue=va_arg(v,int);//拿到所有int型的参数

              if(value> res)

              {

                     res= value;

              }

       }

       va_end(v);//清理

       returnres;

}

int main()

{

       printf("最大数是 %d\n",max(3,9,-6,17));

       printf("最大数是%d\n",max(5,1,8,-15,-27,2));

       return0;

}

 

 

56.二进制文件批量处理

/*#include <stdio.h>

 

int main()

{

       FILE*p_file=NULL;

       intvalues[3]={1,2,3},num=0;

       p_file=fopen("a.bin","w+b");

       if(p_file)

       {

              num=fwrite(values,sizeof(int),3,p_file);

              printf("写入%d个整数\n",num);

              fclose(p_file);

              p_file=NULL;

       }

       return0;

}

*/

#include <stdio.h>

 

int main()

{

       FILE*p_file=NULL;

       intvalues[3]={0},num=0;

       p_file=fopen("a.bin","rb");

       if(p_file)

       {

              num=fread(values,sizeof(int),3,p_file);

              printf("读入%d个整数\n",num);

              printf("%d%d %d\n",values[0],values[1],values[2]);

              fclose(p_file);

              p_file=NULL;

       }

       return0;

}

 

57.文本文件批量处理

//fputs和fgets

#include <stdio.h>

 

int main()

{

       FILE*p_file=NULL;

       charzi_fu=0;

       p_file=fopen("c.txt","w");

       if(p_file)

       {

              fputs("xyzabc",p_file);//失败返回EOF

              fclose(p_file);

              p_file=NULL;

       }

       return0;

}

/*

#include <stdio.h>

 

int main()

{

       FILE*p_file=NULL;

       charzi_fu=0;

       p_file=fopen("c.txt","r");

       if(p_file)

       {

              fgets("xyzabc",p_file);//失败返回EOF

              fclose(p_file);

              p_file=NULL;

       }

       return0;

}

*/

58.sprintf和sscanf

#include <stdio.h>

 

int main()

{

       chara_char='t';

       intvalue=27;

       floata_float=3.8f;

       charstr[20];

       sprintf(str,"%c%d %g\n",a_char,value,a_float);

       //按格式将三个变量打印到str

       printf("%s",str);

       a_char=0;

       value=0;

       a_float=0.0f;

       sscanf(str,"%c%d %g\n",&a_char,&value,&a_float);

       printf("%c%d %g\n",a_char,value,a_float);

       return0;

}

59.数字函数（atoi 和atof）

#include <stdio.h>

 

int main()

{

       intvalue=0;

       floata_float=0.0f;

       value=atoi("297");

       printf("数字是 %d\n",value);

       a_float=atof("4.7");

       printf("数字是 %g\n",a_float);//结果：297, 4.7

       return0;

}

 

指针相关：

int shu_zi;//整数变量

 

int *p_shu_zi;//指针变量，记录整数变量的地址

int shu_zu[3];//数组变量

 

int (*p_shu_zu)[3];//数组指针，记录数组的地址

int shu_zu[2][3];//二维数组

 

int *p_shu_zi[3];//指针数组，就是数组，存的是指针变量

int **p_shu_zi;//二级指针，记录一级指针变量的地址

 

int f();//函数，函数名称本身代表了函数的开始地址

int (*p)();//函数指针，记录函数地址

int *p();//指针函数，就是函数，函数把地址数据当返回值使用

 

NULL//空指针,0地址

野指针//任何指针变量记着无效地址数据，又不是空地址  为避免野指针，声明指针变量时要初始化，知道有野指针，立刻清成空地址

void*//可记录任何地址数据，使用时首先要转换类型

FILE*//文件指针