码迷,mamicode.com
首页 > 编程语言 > 详细

嵌入式C语言实例(达内2013)

时间:2016-05-18 19:38:01      阅读:201      评论:0      收藏:0      [点我收藏+]

标签:

1.Switch练习

#include<stdio.h>

int main()

{

int shu_zi=0;

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

scanf("%d",&shu_zi);

switch(shu_zi%2)

{

case 0:

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

break;

case 1:

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

break;

default:

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

break;

}

}

 

2.票价

#include<stdio.h>

int main()

{

int jia_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");

return 0;

}

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

return 0;

}

 

判断个数

#include<stdio.h>

int main()

{

int jia_ge=0,ge_shu=0;

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

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

if(0==ge_shu)

{

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

}

else if (ge_shu>0)

{

if(0==jia_ge)

{

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

}

else if (jia_ge>0)

{

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

}

else {

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

}

}

else {

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

}

return 0;

}

 

票价终极版:判断次数

#include<stdio.h>

int main()

{

int jia_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");

}

return 0;

}

 

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;//确保相邻两次不一样

}

else if(1==zhuang_tai)

{

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

zhuang_tai=0;

}

 

}

return 0;

}

 

 

4.素数

#include<stdio.h>

#include<math.h>

int main()

{

int shu_zi=0,xun_huan=0;

float gen=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);

}

 

return 0;

}

 

10100间的素数

#include<stdio.h>

#include<math.h>

int main()

{

int xun_huan_1=0,xun_huan_2=0;

    float gen;

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

{

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");

return 0;

}

 

 

5.乘法表

#include<stdio.h>

int main()

{

   int xun_huan_1=0,xun_huan_2=0;

   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()

{

int xun_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);

}

}

}

return 0;

}

 

7.猜数游戏

#include<stdio.h>

int main()

{

int shu_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");

 }

}

return 0;

}

 

8.scanf正确读入数据

#include<stdio.h>

int main()

{

int shu_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("请再输入数据:");//确保读入一个正确格式的数据

}

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

    scanf("%*c");

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

scanf("%d",&shu_zi_2);

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

return 0;

}

 

9.统计字符出现的次数

#include<stdio.h>

int main()

{

int shu_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()

{

int num = 0;

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

scanf("%d",&num);

func2(num);

return 0;

}

 

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

{

int ci_shu = 0;

while(zheng_shu)

{

if(shu_zi==zheng_shu%10)

ci_shu ++;

zheng_shu=zheng_shu/10;

}

return ci_shu;

}

 

int func2(int zheng_shu)

{

int i = 0, j = 0;

int str[10] = {0};

int shu_zi = 0;

int a[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()

{

int n,num;

char str1[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);

return 0;

}

 

int fun1(zheng_shu,shu_zi)

{

int i=0;

while(zheng_shu)

{

if(shu_zi==zheng_shu%10)

i++;

zheng_shu=zheng_shu/10;

}

return i;

}

 

void fun2(int zheng_shu)

{

int i=0,n=0;

int str[10]={0};

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

{

static int 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[n]);

}

*/

 

10.银行利率计算

#include<stdio.h>

int main()

{

int li_lv=0,nian=0,xun_huan=0,ge_shu=0;

float qian=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);

}

}

 

变利率

#include<stdio.h>

int main()

{

int li_lv=0,nian=0,xun_huan=0,xun_huan_1=0;

float qian[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;

}

 

变利率个数

#include<stdio.h>

int main()

{

int li_lv=0,nian=0,xun_huan=0,xun_huan_1=0,ge_shu=0;

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

scanf("%d",&ge_shu);

float qian[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;

}

 

11.单位矩阵

#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;

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

int xun_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");

}

return 0;

}

 

12.扫雷布雷游戏

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

int main()

{

int ge_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");

}

return 0;

}

 

13.函数练习

#include<stdio.h>

int jia(int shu_zi_1,int shu_zi_2)

{

return shu_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;

}

 

 

14.变一维数组

#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)  {//数组作参数,只能在变量中增加参数的个数,知道变量中数组的个数

int xun_huan=0;

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

{

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

}

printf("\n");

}

int main()

{

int ge_shu=0;

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

scanf("%d",&ge_shu);

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

    xian_shi(shu_zi,5);

return 0;

}

 

15.二维数组显示

#include<stdio.h>

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

int xun_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()

{

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

    xian_shi(shu_zi,3,2);

return 0;

}

 

16.变长数组

#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;

}

 

 

17.阶乘及递归

#include<stdio.h>

int main()

{

int shu_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);

return 0;

}

 

递归阶乘

#include<stdio.h>

int jie_cheng(int shu_zi) {

    int jie_guo=1;

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

{

return 1;

}

else

{

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

}

}

int main()

{

int shu_zi=0,jie_guo=1;

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

scanf("%d",&shu_zi);

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

}

 

18.最大公约数

#include<stdio.h>

int yue(int xiao,int da) {

if(!(da%xiao))

{

return xiao;

}

else {

return  yue(da%xiao,xiao);

}

}

int main()

{

int xiao=0,da=0;

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

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

yue(xiao,da);

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

return 0;

}

 

19.汉诺塔算法练习

#include<stdio.h>

void han(int ge_shu,char yuan,char zhong,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()

{

int ge_shu=0;

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

scanf("%d",&ge_shu);

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

return 0;

}

 

20.fabnacci数列

a.循环做

#include<stdio.h>

int main()

{

int shu_zi=0, xun_huan=0,shu_zi_1=1,shu_zi_2=1;//数字shu_zi_1,shu_zi_2分别记录编号01,注意赋值为1

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

scanf("%d",&shu_zi);

if(shu_zi<=1)

{

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

}

else

{

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

{

int shu=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)

{

return 1;

}

else

{

return f(shu_zi-2)+f(shu_zi-1);//编号减-1,和-2

}

}

 

int main()

{

int shu_zi=0;

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

scanf("%d",&shu_zi);

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

return 0;

}

 

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])

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

}

else

{

return shu[shu_zi];

}

}

int main()

{

int shu_zi=0;

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

scanf("%d",&shu_zi);

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

return 0;

}

21.栈的练习

#include <stdio.h>

 

int shu_zi[10];

int ge_shu;

int f(){

int shu_zi=3;

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

}

int f1(){

int shu_zi=5;

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

}

int kong()

{

if(!ge_shu)

{

return 1;

}

else

{

return 0;

}

}

 

int man()

{

if(10==ge_shu)

{

return 1;

}

else

{

return 0;

}

}

 

void push(int shu)

{

shu_zi[ge_shu]=shu;

ge_shu++;

}

 

int pop()

{

ge_shu--;

return shu_zi[ge_shu];

}

 

int main()

{

kong();

man();

push(6);

pop();

f();

f1();

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

return 0;

}

 

22.指针练习

#include <stdio.h>

 

void jia_huan(int a,int b)

{

int t;

t=a;

    a=b;

b=t;

}

int main()

{

int a=3,b=7;

jia_huan(a,b);

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

return 0;

}//3,7

 

/*

void jia_huan(int shu_zu[])

{

int t;

t=shu_zu[0];

shu_zu[0]=shu_zu[1];

shu_zu[1]=t;

}

int main()

{

int shu_zi[2]={3,7};

jia_huan(shu_zi);

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

return 0;

}//7,3

*/

/*

void jia_huan(int *a,int *b)

{

int t;

t=*a;

    *a=*b;

*b=t;

}

int main()

{

int a=3,b=7;

jia_huan(&a,&b);

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

return 0;

}//7,3

*/

23.指针返回值练习

#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()

{

int shu_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);

return 0;

}

 

24.指针和数组比较

#include<stdio.h>

int main()

{

int shu[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");

return 0;

}

 

25.读取字符串

#include <stdio.h>

 

int main()

{

char zi_fu_chuan[10];

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

fgets(zi_fu_chuan,10,stdin);

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

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

return 0;

}

 

26.字符串函数

#include <stdio.h>

#include <string.h>

 

int main(0

{

char zi_fu_chuan[]="abc";

char zi_fu_chuan_1[]="xyz";

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

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

)}

 

 

 

27.static的作用

#include<stdio.h>

void f() {

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

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

shu_zi++;

}

int main()

{

f();

f();

f();

return 0;

}

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

#include<stdio.h>

int *f()

{

int shu_zi=3;

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

}

int *f1()

{

int shu_zi=5;

int shu_zi_1=7;

int shu_zi_2=shu_zi+shu_zi_1;

return NULL;

}

int main()

{

int *p_shu_zi=NULL;

p_shu_zi=f();

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

f1();//这时35所在位置是同一位置

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

return 0;

}

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

 

29.数字时钟练习

#include<stdio.h>

#include<time.h>

int main()

{

int shi_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使用

}

return 0;

}

 

30.指针实现交换两数

#include<stdio.h>

void jiao_huan(int *p_shu_zi_1,int *p_shu_zi_2)

{

//int *p_shu_zi_1,*p_shu_zi_2;

int shu=*p_shu_zi_1;

*p_shu_zi_1=(*p_shu_zi_2);

*p_shu_zi_2=shu;

}

int main()

{

int shu_zi_1=7,shu_zi_2=3;

jiao_huan(&shu_zi_1,&shu_zi_2);

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

    return 0;

}

 

31.用指针实现返回最大数:

#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()

{

int shu_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);

return 0;

}

 

32.交换两数

#include<stdio.h>

void jiao_huan(int shu_zi,int shu_zi_1)  {

int shu=shu_zi;

shu_zi=shu_zi_1;

shu_zi_1=shu;

printf("shu_zi%d,shu_zi_1%d\n",shu_zi,shu_zi_1);//写在这里也可以实现交换,也可用下面的数组实现交换

}

/*

void jiao_huan(int shu_zi[2])  {//注意前面加int

    int shu=shu_zi[0];//注意前面加int

shu_zi[0]=shu_zi[1];

shu_zi[1]=shu;

}

*/

int main()

{   int shu_zi=3,shu_zi_1=7;

   // int shu_zi[2]={3,5};

jiao_huan(3,7);

printf("shu_zi%d,shu_zi_1%d\n",shu_zi,shu_zi_1);//若写在这里不实现交换

// jiao_huan(shu_zi);//注意调用函数时的写法

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

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

return 0;

}

 

 

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

#include<stdio.h>

int *f()

{

int shu_zi=3;

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

}

int main()

{

int *p_shu_zi=NULL;

p_shu_zi=f();

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

return 0;

}

34.指针变量自增

#include<stdio.h>

int main()

{

int shu[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);

}

return 0;

}

 

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)

{

return p_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;

 

// return p;

}

int main()

{

char zi_fu_chuan_1[10]="abc";

//str_cpy(zi_fu_chuan _1,"xy");

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

return 0;

}

 

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);//指针就是字符变量的首地址

return 0;

}

 

37.模拟登陆

#include<stdio.h>

#include<string.h>

int main()

{

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

char mi_ma[10]="123456\n";

char ming[10],ma[10];

int xun_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");

}

return 0;

}

 

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.宏练习

一.条件编译(点菜)

#include<stdio.h>

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

int main()

{

int cai =0;

printf("请点菜:");

scanf("%d",&cai);

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

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

if(1==cai)

{

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

}

else {

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

}

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

{

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

}

# endif

return 0;

}

 

二.折扣练习(条件编译)

#include <stdio.h>

 

int main()

{

#if defined(JINGPING)

printf("120%%\n");

#elif !defined(GONGCHANG)

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

#else

printf("80%%\n");

#endif

return 0;

}

 

  

三.宏的运算符#   ##

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

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

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

int main()

{

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

return 0;

}//结果 :5-4

 

#include<stdio.h>

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

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

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

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

int main()

{

int global(shu_zi)=3;

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

return 0;

}

 

/*#include<stdio.h>

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

//int local(shu_zi);

int main()

{

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

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

return 0;

}

*/

gcc -E wenjian.c如下:

int main()

{

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

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

 return 0;

}

 

四.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标准

return 0;

}

 

五.宏求面积

#include<stdio.h>

#define pi 3.14f

#define zhou_chang(r) 2*pi*r

#define mian_ji(r)    pi*r*r

int main()

{

float ban_jing=0;

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

scanf("%d",&ban_jing);

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

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

return 0;

}

 

六.宏与形参区别

#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()

{

int shu_zi=4;

han(shu_zi);

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

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

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

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

return 0;

}//答案: 4  5

  

七.宏的整体性

#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));

return 0;

}

 

八.宏自增  (避免用到)

#include<stdio.h>

#define ping_fang(x) x*x

int main()

{

int shu_zi=7;

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

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

return 0;

}

 

 

九.宏作数组

#include<stdio.h>

#define  HANG 10

#define  LIE  10

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

int main()

{

int LEI[HANG][LIE];

    float shu_zu[3][4];

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

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

return 0;

}

十.带参数的宏和函数的区别

#include<stdio.h>

int main()

{

int shu[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);

}

return 0;

}

 

十.秒转天

#include<stdio.h>

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

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

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

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

//然后在进行宏计算

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

int main()

{

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

    return 0;

}

 

十一.宏实现字符大小写转换

#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()

{

char zi_fu=0;

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

scanf("%c",&zi_fu);

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

    zhuan_huan1(zi_fu);//两种写法

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

return 0;

}

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

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

#include<stdio.h>

int readint() {

int shu_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()

{

int shu_zi=0;

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

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

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

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

return 0;

}

 

41.多文件处理

#ifndef __READINT_H__

#define __READINT_H__

void readInt();

int jie_guo;

#endif//_READINT_H__

/*头文件声明*/

 

#include<stdio.h>

#include"readInt.h"

extern int jie_guo//声明全局变量,读到的数放在全局变量

void readInt() {

int shu_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()

{

int shu_zi=0;

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

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

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

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

return 0;

}

 

42.Makefile文件

简化多文件程序编译过程

 

43.结构体

#include<stdio.h>

int main()

{

struct ren {//结构体声明

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

int nian_ling;

char xing_bie;

} ren1;

struct ren ren2={1.78,23,‘f‘};//结果体变量声明及初始化

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

return 0;

}

 

44.结构体指针(typedef)

#include<stdio.h>

typedef struct ren {

float shen_gao;

int nian_ling;

char xing_bie;

} ren;

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

// ren ren1={0.0f,0,0};

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

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

return p_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);

return 0 ;

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

 

45.Typedef练习

#include<stdio.h>

typedef struct ren {

float shen_gao;

int nian_ling;

char xing_bie;

} ren;

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

ren ren1={0.0f,0,0};

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

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

return ren1;//使用读函数读,不在主函数读,这样可以,但不好,在调用的时候参数和返回值都会复制,因为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);

return 0 ;

}

 

46.结构体的对齐与补齐

#include <stdio.h>

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

char zi_fu;

char zi_fu_1;

int shu_zi;

}jie_gou;

 

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

int shu_zi;

char zi_fu;

char zi_fu_1;

}jie_gou;

 

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

char zi_fu;

int shu_zi;

char zi_fu_1;

}jie_gou;

 

int main()

{

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

return 0;

}

 

47.typedef(位域)

#include<stdio.h>

typedef struct {

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

char ge_shu:4;

char zhuang_tai:2;  //结果:1    7位,没满8位按8位算,即1字节

}wei_zhi;

typedef struct {//没有用使用域

char lei;

char ge_shu;

char zhuang_tai;

}wei_zhi_1;

int main()

{   

wei_zhi wei;

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

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

return 0;

}

48.联合及大小端

#include <stdio.h>

 

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

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

int shu_zi;

char zi_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("0x%x\n",lian_he_1.zi_fu[0]);//大端,小端,本系统采用小端

return 0;

}

 

49.枚举

#include <stdio.h>

 

int main()

{

enum ji_jie{SPR,SUM,AUT=6,WIN};

//printf("SPR%d\n",SPR);

//printf("WIN%d\n",WIN);

enum ji_jie season;

season=SUM;

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

return 0;

}

 

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

#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

}

 

50.Void指针练习

#include<stdio.h>

enum type {CHAR,INT,FLOAT};

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

{

switch(lei_xing) {

case CHAR:

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

break;

case INT:

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

break;

case FLOAT:

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

break;

}

}

int main()

{

char zi_fu=‘a‘;

int shu=3;

float shu_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);

return 0;

}

51.内存分配(堆)

一.malloc

/*#include<stdio.h>

int main()

{

int shu[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]);

}

return 0;

}

*/

#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");

return 0;

}

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

return 0;

}

三.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");

}

 

}

return 0;

}

52.用函数指针排序

/*

#include <stdio.h>

 

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

{

return 0-bi_jiao(p_shu_zi_1,p_shu_zi_2);

}

 

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)

{

return 1;

}

else if(*(int *)p_shu_zi_1<*(int *)p_shu_zi_2)

{

return -1;

}

else

{

return 0;

}

}

 

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]))

{

int shu=shu_zi[0];

shu_zi[0]=shu_zi[1];

shu_zi[1]=shu;

}

}

int main()

{

int shu_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, const void* p_shu_zi_2)

{

return 0-bi_jiao(p_shu_zi_1,p_shu_zi_2);

}

 

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)

{

return 1;

}

else if(*(int *)p_shu_zi_1<*(int *)p_shu_zi_2)

{

return -1;

}

else

{

return 0;

}

}

 

int main()

{

int shu_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]);

}

 

 

53.Const指针

/*#include<stdio.h>

int main()

{

int shu_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);

return 0;

}

*/

#include<stdio.h>

int main()

{

int shu_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);

return 0;

}

54.二级指针

#include <stdio.h>

 

int main()

{

int shu_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) {//第一个参数表示要用来拆分的字符串,第二个参数表示字符指针地址,用来放拆分好得到新字符串地址

int xun_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()

{

char zi_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;

return 0;

}

 

55.函数指针

#include <stdio.h>

 

int jia(int x,int y)

{

return x + y;

}

 

int main()

{

int (*p_func)(int,int);

p_func = jia;

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

return 0;

}

 

56.排序

/*#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)

{

return 1;

}

else if(*(int*)p_shu_zi_1<*(int*)p_shu_zi_2)

{

return -1;

}

else

{

return 0;

}

}

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

{

return 0-bi_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]))

{

int shu=shu_zi[0];

shu_zi[0]=shu_zi[1];

shu_zi[1]=shu;

}

}

int main()

{

int shu_zi[2]={7,2};

pai_xu(shu_zi,2);

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

return 0;

}

*/

 

 

#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)

{

return 1;

}

else if(*(int*)p_shu_zi_1<*(int*)p_shu_zi_2)

{

return -1;

}

else

{

return 0;

}

}

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

{

return 0-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]))//注意

{

int shu=shu_zi[0];

shu_zi[0]=shu_zi[1];

shu_zi[1]=shu;

}

}

*/

int main()

{

int shu_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]);

return 0;

}

 

 

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,const void*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)

{

return 1;

}

else if(shu_zi_1<shu_zi_2)

{

return -1;

}

else

{

return 0;

}

 

}

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

{

int shu_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]);

}

return 0;

}

 

 

qsort 字符串排序

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

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

 {

 return strcmp(*(char**)p_str,*(char**)p_str_1);

 }

 int main()

 {

 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;

 }

 

指针数组

#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,const void * 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)

{

return 1;

}

else if(shu_zi_1<shu_zi_2)

{

return -1;

}

else

{

return 0;

}

}

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

{

int shu_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");

return 0;

}

 

57.数组指针

#include <stdio.h>

 

int main()

{

int shu_zi[3]={1,2,3};

int shu_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_zi0012FF34,*p_shu_zi0012FF34  一样的,这就是数组指针的特点

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

//shu_zi_10012FF24,*shu_zi_10012FF24 一样

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跨越一组变量,

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

return 0;

}

58.指针数组(字符串)

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

 

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

 {

 return strcmp(*(char**)p_str,*(char**)p_str_1);

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

 }

 int main()

 {

 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;

 }

 

59.文件操作

一.rewindfssek,ftell位置调整

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

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

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

 

/*#include <stdio.h>

 

int main()

{

FILE *p_file=NULL;

char zi_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;

}

return 0;

}*/

#include <stdio.h>

 

int main()

{

FILE *p_file=NULL;

char zi_fu=0;

p_file=fopen("a.txt","r");//a.txtHello 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;

}

return 0;

}

 

fseekrewind练习

#include<stdio.h>

int main()

{

FILE *p_file=NULL;

char zi_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;

}

return 0;

}

二.读/写文件

#include<stdio.h>

int main()

{

FILE *p_file=NULL;

char zi_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;

char str[]="Hello World!";

int xun_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;

}

return 0;

}

 

三.文件复制

#include<stdio.h>

int main()

{

char zi_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;

}

return 0;

}

 

四.格式化文件操作

//fprintffscanf

/*#include <stdio.h>

 

int main()

{

FILE *p_file=NULL;

char zi_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;

}

return 0;

}*/

 

#include <stdio.h>

 

int main()

{

FILE *p_file=NULL;

char zi_fu=0;

char a_char=0;

int value=0;

float a_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;

}

return 0;

}

60.变长参数函数

//printfscanf都是变长参数函数

/*#include <stdio.h>

#include <stdarg.h>

 

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

{

int xun_huan=0;

va_list v;

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);

return 0;

}

*/

 

//printfscanf都是变长参数函数

#include <stdio.h>

#include <stdarg.h>

 

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

{

int res=1<<31;//最小整数

int xun_huan=0;

va_list v;

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

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

{

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

if(value > res)

{

res = value;

}

}

va_end(v);//清理

return res;

}

int main()

{

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

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

return 0;

}

 

 

61.二进制文件批量处理

/*#include <stdio.h>

 

int main()

{

FILE *p_file=NULL;

int values[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;

}

return 0;

}

*/

#include <stdio.h>

 

int main()

{

FILE *p_file=NULL;

int values[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;

}

return 0;

}

 

62.文本文件批量处理

//fputsfgets

#include <stdio.h>

 

int main()

{

FILE *p_file=NULL;

char zi_fu=0;

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

if(p_file)

{

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

fclose(p_file);

p_file=NULL;

}

return 0;

}

/*

#include <stdio.h>

 

int main()

{

FILE *p_file=NULL;

char zi_fu=0;

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

if(p_file)

{

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

fclose(p_file);

p_file=NULL;

}

return 0;

}

*/

63.sprintfsscanf

#include <stdio.h>

 

int main()

{

char a_char=‘t‘;

int value=27;

float a_float=3.8f;

char str[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);

return 0;

}

64.数字函数(atoi atof

#include <stdio.h>

 

int main()

{

int value=0;

float a_float=0.0f;

value=atoi("297");

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

a_float=atof("4.7");

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

return 0;

}

 

指针相关:

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*//文件指针

 

 

 

 

 

 

嵌入式C语言实例(达内2013)

标签:

原文地址:http://blog.csdn.net/quanshenyue/article/details/51405725

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!