嵌入式第十六天

最新推荐文章于 2024-02-03 09:31:13 发布
最新推荐文章于 2024-02-03 09:31:13 发布
阅读量194 收藏
点赞数
分类专栏： linux 文章标签： linux及c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cgj19960119/article/details/81506136
版权

复习：
指针：
二级指针：
int a=12;
int *q=&a;
int **p;
p=&q;

*p **p p &p &q

数组指针:指针 

指针数组：数组 
int (*p)[3]
int *p[3]

局部变量
全局变量

static 
    局部变量 
    全局变量 
    函数 

extern
    全局变量 
    
函数：
int fun(int a,int b)//a=m b=n
{
    return a;
}
int main()
{
    int x=fun(m,n);
}

void void*

void * p;
void a;  
    
递归：
 栈空间
 
指针函数


一、函数指针：本质是指针 存函数地址 指向一类函数
函数指针3步：
    定义 
    赋值 
    调用

1.定义函数指针：根据函数定义函数指针
    int max()
    {

    }

    int min()
    {

    }

    int add()
    {

    }

    int (*p)();//定义函数指针p 可以指向返回值类型为int 没有形参的一类函数
    
2.赋值
    p=max；//将函数max的首地址 赋值给函数指针p
3.调用
    (*p)();//*p()也可以

    无参：
     #include<stdio.h>
    int max()
    {
        int a=90;
        int b=20;
        return a>b?a:b;
    }
    int main()
    {
        int (*p)()=NULL;
        p = max;
        int ret = (*p)();//max();
        printf("%d\n",ret);

        return 0;
    }
    
    有参：
    #include<stdio.h>
    int max(int a,int b)
    {
        return a>b?a:b;
    }
    int main()
    {
        int c=90;
        int d=89;
        int (*p)(int,int)=NULL;
        p = max;
        int ret = (*p)(c,d);//max();
        printf("%d\n",ret);

        return 0;

    }
    
    练习：定义函数指针
    定义函数指针指向void *malloc(size_t size);
    void*(*pfun)(size_t);
    定义函数指针指向void fun()
    void (*p)();
    
    练习：定义一函数指针 指向一个函数 函数功能：求两个数的和
    #include<stdio.h>
    void add(int a,int b)
    {
        printf("%d\n",a+b);
    }
    int main()
    {
        int c=90;
        int d=89;
        void (*p)(int,int)=NULL;
        p = add;
       (*p)(c,d);//max();
        return 0;
    }


    例子：
    #include<stdio.h>
    int max(int a,int b)
    {
        return a>b?a:b;
    }
    
    int min(int a,int b)
    {
        return a<b?a:b;
    }
    int main()
    {
        int c=90;
        int d=89;
        int ret,choose;
        
        int (*p)(int,int)=NULL;
        
/*        
        p = max;
        ret = (*p)(c,d);//max();
        printf("%d\n",ret);
        
        p=min;
        ret = (*p)(c,d);//max();
        printf("%d\n",ret);
*/
        puts("1.max 2.min");
        scanf("%d",&choose);
        switch(choose)
        {
            case 1:
                p=max;
                break;
            case 2:
                p=min;
                break;
            default:
                puts("error!");
                break;        
        }        
        
        ret = (*p)(c,d);
        printf("%d\n",ret);

        return 0;
    }
    
    练习：函数指针版本-计算器 
    #include<stdio.h>
    #include<stdlib.h>
    void add(int a,int b)
    {
        printf("%d\n",a+b);
    }
    void sub(int a,int b)
    {
        printf("%d\n",a-b);
    }
    void mul(int a,int b)
    {
        printf("%d\n",a*b);
    }
    void _div(int a,int b)
    {
        printf("%d\n",a/b);
    }
    int main()
    {
        int choose;
        int x,y;

        void (*pfun)(int,int)=NULL;
        while(1)
        {
            puts("input op1 op2");
            scanf("%d%d",&x,&y);

            puts("1.add 2.sub 3.mul 4.div 5.exit");
            scanf("%d",&choose);
            switch(choose)
            {
                case 1:
                    pfun = add;
                    break;
                case 2:
                    pfun = sub;
                    break;
                case 3:
                    pfun = mul;
                    break;
                case 4:
                    pfun = _div;
                    break;
                case 5:
                    exit(0);//正常退出
                default:
                    puts("choose error!");
                    continue;
            }
            (*pfun)(x,y);
            sleep(1);
            system("clear");
        }
        return 0;

    }

4.函数指针做形参
    函数指针定义：函数调用时
    函数指针赋值：实参传递给形参时
    函数指针调用：函数体内
    例子1：
    #include<stdio.h>
    int max(int a,int b)
    {
        return a>b?a:b;
    }
    void fun(int (*p)(int,int),int m,int n)//p=max  m=x n=y
    {
        
        int ret = (*p)(m,n);//-->max(x,y)
        printf("%d\n",ret);
    }
    int main()
    {
        int x=90;
        int y=89;
        fun(max,x,y);
    }

    例子2：
    #include<stdio.h>
    int max(int a,int b)
    {
        return a>b?a:b;
    }
    int min(int a,int b)
    {
        return a<b?a:b;
    }

    int add(int a,int b)
    {
        return a+b;
    }
    void fun(int (*p)(int,int),int m,int n)//p=max  m=x n=y
    {
        
        int ret = (*p)(m,n);//-->max(x,y)
        printf("%d\n",ret);
    }
    int main()
    {
        int x=90;
        int y=89;
        fun(max,x,y);
        fun(min,x,y);
        fun(add,x,y);
    }

    练习：函数指针形参版本计算器
    #include<stdio.h>
    #include<stdlib.h>
    void add(int a,int b)
    {
        printf("%d\n",a+b);
    }
    void sub(int a,int b)
    {
        printf("%d\n",a-b);
    }
    void mul(int a,int b)
    {
        printf("%d\n",a*b);
    }
    void _div(int a,int b)
    {
        printf("%d\n",a/b);
    }

    void fun(void (*p)(int,int),int a,int b)
    {
        (*p)(a,b);
    }
    int main()
    {
        int choose;
        int op1,op2;
        while(1)
        {
            puts("input op1 op2");
            scanf("%d%d",&op1,&op2);

            puts("1.add 2.sub 3.mul 4.div 5.exit");
            scanf("%d",&choose);
            switch(choose)
            {
                case 1:
                    fun(add,op1,op2);
                    break;
                case 2:
                    fun(sub,op1,op2);
                    
                    break;
                case 3:
                    fun(mul,op1,op2);
                    break;
                case 4:
                    fun(_div,op1,op2);
                    break;
                case 5:
                    exit(0);//正常退出
                default:
                    puts("choose error!");
                    break;
            }
            sleep(1);
            system("clear");
        }
        return 0;

    }

5.函数指针数组:代替大型switch语句
    int (*p[2])(int,int);
    int (*p[2])(int,int)={max,min};
    p[0]=max;
    p[1]=min;
     
    #include<stdio.h>
    int max(int a,int b)
    {
        return a>b?a:b;
    }
    int min(int a,int b)
    {
        return a<b?a:b;
    }


    int main()
    {
        int choose;
        int (*p[2])(int,int)={max,min};//p[0]->max  p[1]min  *p p[0]
        for(;;)
        {
            puts("1.max  2.min");
            scanf("%d",&choose);//1
            printf("%d\n",p[choose-1](3,7));
        }
    }

    练习：函数指针数组版本计算器
    #include<stdio.h>
    #include<stdlib.h>
    void add(int a,int b)
    {
        printf("%d\n",a+b);
    }
    void sub(int a,int b)
    {
        printf("%d\n",a-b);
    }
    void mul(int a,int b)
    {
        printf("%d\n",a*b);
    }
    void _div(int a,int b)
    {
        printf("%d\n",a/b);
    }

    int main()
    {
        void (*p[4])(int,int)={add,sub,mul,_div};
        int choose;
        int op1,op2;
        while(1)
        {
            puts("input op1 op2");
            scanf("%d%d",&op1,&op2);

            puts("1.add 2.sub 3.mul 4.div ");
            scanf("%d",&choose);
            p[choose-1](op1,op2);
            sleep(1);
            system("clear");
        }
        return 0;

    }

二、const：c语言关键字 用来定义一个常量
1.
#include<stdio.h>

int main()
{
    int const a=100;//定义一个常量a 其值为100
    a = 200;//因为a是常量 不可以被赋值
    printf("%d\n",a);
    return 0;

}
2.const和指针关系
(1)int const *p;//等价于const int *p
    #include<stdio.h>

    int main()
    {
        int a;
        a=100;
        
        int const *p=80;
        //p=&a;//可以 因为p是变量
        *p = 80;//错 因为*p是常量 不能放赋值符号左边
        printf("%d\n",*p);
        return 0;
    }

(2)int *const p;
    #include<stdio.h>

    int main()
    {
        int a;
        a=100;
        
        int *const p=&a;
        //p=&a;//错 因为p是常量 不能放赋值符号左边
        *p = 80;//可以 
        printf("%d\n",*p);
        return 0;
    }
(3)int const *const p;//p和*p都是常量


三.宏定义:机械替换
(1)宏定义可以嵌套
    #define 宏名 宏值
    #define N 3 

    #include<stdio.h>
    #define N 2
    #define M N+1
    int main()
    {
        int a=M*M;//N+1*N+1=2+1*2+1=5
        printf("%d\n",a);//5
        return 0;
    }

(2)带参宏
    例子1：
    #include<stdio.h>
    #define SQUARE(x) x*x
    int main()
    {
        int a=SQUARE(3);
        printf("%d\n",a);//9
        return 0;

    }    
    例子2：    
    #include<stdio.h>
    #define SQUARE(x) x*x
    int main()
    {
        int a=SQUARE(2+3);//2+3*2+3=2+6+3=11
        printf("%d\n",a);//11
        return 0;
    }    
        
    应该是：
    #include<stdio.h>
    #define SQUARE(x) (x)*(x)
    int main()
    {
        int a=SQUARE(2+3);//2+3*2+3=2+6+3=11
        printf("%d\n",a);//11
        return 0;
    }    
    
    练习：实现一个宏MAX 能求两个数最大值 
    #define MAX(a,b) (a)>(b)?(a):(b)
    
    练习：定义一个宏 传入一个字符 如果是大写 转为小写 若是小写 则不变
    #include<stdio.h>
    #define TOS(x) (x)>='A'&&(x)<='Z'?((x)+32):(x)
    int main()
    {
        char ch;
        while(1)
        {
            ch=getchar();
            getchar();
            ch=TOS(ch);
            printf("%c\n",ch);
        }    
        return 0;

    }

    带参宏与函数调用区别：
    带参宏：编译阶段替换 运行效率高 但编译会导致代码量增大
    函数调用：运行时调用  

    代码量小 使用带参宏
    代码量大 函数调用 

四、条件编译(可以实现让某一部分代码参加编译或不参加编译)
1.#ifdef 标识符
   程序段
  #endif 

    #include<stdio.h>
    #define A 
    int main()
    {
    #ifdef A  //如果定义A 则下边的语句参加编译 否则不执行
    puts("hahahaha");//输出
    #endif
        return 0;

    }


    方法2：
    #include<stdio.h>
    int main()
    {
    #ifdef A
        puts("hahahaha");//输出
    #endif
        return 0;
    }
    gcc -D A y.c  //-D 带宏编译

2.#ifdef 标识符 //如果标识符已经定义 则编译程序段1 否则编译程序段2
    程序段1
  #else 
    程序段2 
  #endif
  
  #include<stdio.h>
    int main()
    {
    #ifdef A
    puts("hahahaha");
    #else 
    puts("heiheihei~");
    #endif
        return 0;

    }

3。#if 常量/常量表达式  //如果为真 则编译程序段 否则 不编译  主要用于调试程序
    程序段 
   #endif     

    #include<stdio.h>
    int main()
    {
    #if 1
        puts("pleaes input the num of stu:");
        puts("hahahaha");
    #endif
        puts("heiheihei~");

        return 0;

    }

4.#if 常量/常量表达式   //如果为真则编译程序段1 否则编译程序段2
  程序段1 
  #else 
  程序段2 
  #endif       

    #include<stdio.h>
    int main()
    {
    #if 0
        puts("pleaes input the num of stu:");
        puts("hahahaha");
    #else
        puts("heiheihei~");
    #endif
        return 0;

    }

5.自定义头文件
(1) 头文件：
    系统头文件<>
    自定义头文件""
    
    
    //y.h 
    #ifndef Y_H
    #define Y_H

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #endif

    //y.c 
    #include"y.h"
    int a=90;
    int main()
    {
        if(a>=90)
        {
            printf(">=\n");
            exit(-1);
        }
        return 0;
    }    
    gcc y.c 
    ./a.out


(2)头文件中条件编译作用：避免头文件重复包含
    //a.h 
    #ifndef A_H 
    #define A_H

    int max=100;

    #endif 
    //b.h 
    #include"a.h"

    //main.c 
    #include"a.h"  //int max=100;
    #include"b.h" 
    int main()
    {
        
    }
    
五、结构体大小-内存对齐
规则：
(1)数据成员对齐：第一个数据存放到相对结构体起始位置偏移为0的地址
(2)以后每个数据成员存储的起始位置从该成员大小的整数倍开始
(3)结构体大小 也就是sizeof的结果 必须是其内部最大成员与机器字长比较 
 按小的对齐  也就是结果是小的的整数倍 不足补齐
  
 机器字长：CPU一次能处理数据位数

(4)特殊情况 如果结构体作为成员 则存储要从其内部最大元素大小的整数倍开始存储
(5)设置对齐参数
 #include<stdio.h>
    struct  stu 
    {
        char a;
        short b;
        char c;
    };
    int main()
    {
        struct stu s1;
        printf("&s1.a:%p &s1.b:%p &s1.c:%p\n",&s1.a,&s1.b,&s1.c);
        printf("%d\n",sizeof(s1));//6
        return 0;
    }
    &s1.a:0xbfc88aaa &s1.b:0xbfc88aac &s1.c:0xbfc88aae
    0 1 2 3 4 5 6 7 8 
    a   b 


    #include<stdio.h>
    struct  stu 
    {
        char a;
        short b;
        char c;
        short d;
    };
    int main()
    {
        struct stu s1;
        printf("&s1.a:%p &s1.b:%p &s1.c:%p\n",&s1.a,&s1.b,&s1.c);
        printf("%d\n",sizeof(s1));//8
        return 0;
    }
    
    #include<stdio.h>
    struct s
    {
        double f;
        char ch;
    };
    int main()
    {
        printf("%d\n",sizeof(struct s));//12
    }
    
    #include<stdio.h>
    #pragma pack(3)   //#pragma pack(n) n表示c编译器将按照n个字节对齐  n必须是2的次方
    struct s
    {
        int f;
        char ch;
    };
    int main()
    {
        printf("%d\n",sizeof(struct s));//6
    }
    
    练习： 
    struct p 
    {
        char a;
        int b;
        char c 
    }
    
    struct q 
    {
        char ch;
        struct p class;
    }
    
    sizeof(q) 12 
    
    
    
        
    


 

不为人知的小小鸟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
蓝桥杯嵌入式第十四届程序源码
03-25
【标题】"蓝桥杯嵌入式第十四届程序源码"所涉及的知识点主要集中在嵌入式系统开发和蓝桥杯竞赛的编程实践中。蓝桥杯是一项旨在推动软件和信息技术专业人才培养的全国性赛事，尤其关注在嵌入式领域的应用。在第十四届...
第十五届蓝桥杯嵌入式省赛真题题目和答案
最新发布
04-13
### 第十五届蓝桥杯嵌入式省赛真题题目解析及知识点梳理 #### 嵌入式系统基础知识概述 嵌入式系统是计算机科学的一个分支，它涉及到将微处理器、外围设备和软件集成到一个单一的产品中，以执行特定的任务。这类...
大写转换成小写
2012回首嵌入式学习两年历程
05-30 628
<br />#include <stdio.h><br /><br /><br /><br /> int main()<br /> {<br />     char p;<br />     for(;;)<br />     {<br />         printf("请输入要转换的大写字符/n");<br />         for (;;)<br />         {<br />                 scanf ("%c",&p);<br />        
嵌入式系统开发（二）——字母的大小写转换
weixin_30329623的博客
08-20 475
　　在H文件中加入： static inline ubase_t ToUpperCase(u8_t c) { if(!IsLowerCaseAlphabetChar(c)) return c; return c - 32; } static inline ubase_t ToLowerCase(u8_t c) { if(!IsUpperCaseAlphab...
【嵌入式 C】C语言中转换大小写的另外一种简便算法
Nonoas的博客
05-05 258
平常我们在写转换字符串大小写的算法时，一般的思路就是先依次判断单个字符的 ASCII 码值：位于 45~90 的为字母的大写，转换成对应的小写就是+32；位于 97~122 的为字母的小写，转换成对应的大写就是-32。其实还有一种更加简单的方法，利用的原理就是大小写之间相差 32，即转换成 2 进制之后第五位为 1 则为小写，第五位为 0 则为大写；举个例子就懂了：‘A’...
把输入字符的小写转换成大写并输出
嵌入式Linux
03-08 3899
#include #include #include /******************************* *把小写字母转成大写字母 ********************************/ int main(void) { char *src=NULL; unsigned char i=0; char *new_1=NULL; char *new_2=NUL
从键盘上输入一个字符，如果是小写字母，则转换成大写字母输出。其他的则不变
热门推荐
fd315063004的专栏
09-21 3万+
#include int main() { char a,b; printf("Please input a character:\n"); scanf("%c",&a); b=a>=97&&a printf("%c\n",b); } //从键盘上输入一个字符，如果是小写字母，则转换成大写字母输出。其他的则不变。 这里依然是条件表达式的灵活应用。
0202 嵌入式第十六天
m0_74848773的博客
02-03 939
共用体类型可以是函数参数，也可以是函数返回值类型。如果一个变量只有几种可能的值，则可以定义成枚举。一枚一枚列举，逐个列举定义为枚举。将变量的值一一定义出来。
最全 第六届到第十二届 蓝桥杯 嵌入式 省赛 决赛 历届真题汇总 嵌入式设计与开发项目 客观题答案+程序设计题
04-06
最全 第六届到第十二届 蓝桥杯 嵌入式 省赛 决赛 历届真题汇总 嵌入式设计与开发项目 客观题答案+程序设计题 21_第十二届省赛蓝桥杯嵌入式程序设计题.pdf 20_第十二届省赛蓝桥杯嵌入式客观试题_答案.pdf 20_第十二...
蓝桥杯嵌入式真题第九届省赛-客观题-答案解析
10-24
第九届省赛中包含了客观题部分，对参赛者的专业知识和综合技能进行考察。通过题目解析，我们可以学习到以下知识点： 1. STM32F103RBT6微控制器的性能参数：例如APB1总线的最高运行频率为36MHz；ADC分辨率为12位，...
小写字母转化成大写字母
06-25
用起来比较好，一般情况下完全满足初级学习者的要求。请大家有时间看一看。
第十四届蓝桥杯嵌入式省赛
02-23
"第十四届蓝桥杯嵌入式省赛"是针对这一技术进行的专业竞赛，旨在考察参赛者的嵌入式系统设计与应用能力。 一、嵌入式系统基础 嵌入式系统是指以应用为中心，以计算机技术为基础的，软硬件可裁剪的专用计算系统。它...
【微机原理 实验】大小写字母的转换实验 （含汇编代码）
yxp189的博客
06-18 1万+
实验八 大小写字母的转换实验 更多微机实验：https://blog.csdn.net/yxp189/column/info/39992 汇编语言-微机原理与接口技术-实验 注意：未经允许，请勿转载！ 转载请标明出处~ 适用课程：微机原理与接口技术（实验） 选用教材：微型计算机原理与接口技术-中国科学技术...
C实现大小写字母的转换
嵌入式
09-10 472
#include <stdio.h> int main(int argc, const char *argv[]) { char ch; printf("input one charactor:"); ch = getchar(); #if 0 if(ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z') putchar(ch > 'Z' ? ch - 32 : ch + 32
windows下cmd窗口连接CentOs虚拟机下的redis服务器
cgj19960119的博客
03-01 755
安装telnet服务 先检查CentOS7.0是否已经安装以下两个安装包:telnet-server、xinetd。 命令如下： # rpm -qa telnet-server # rpm -qa xinetd 如果没有安装，则先安装。 安装命令： # yum install telnet-server # yum install xinetd 安装完成后，将xinetd服务加入开机自启...
ftp上传文件的坑
cgj19960119的博客
10-12 306
ftp上传文件到CentOs8环境报Software caused connection abort: recv failed 这是一个java 7 在windows上的bug 解决办法： 用administrator用户登陆使用命令行执行： netsh advfirewall set global StatefulFTP disable 即可 java ...
ftp的坑
cgj19960119的博客
10-09 291
CentOS中vsftp服务安装、配置、卸载 1.检查centos是否安装vsftpd 　　[root@localhost zhangzhuo]# rpm -aq vsftpd 　　vsftpd-3.0.2-22.el7.x86_64 #查询的返回结果，表明已安装 　　若要卸载Vfstpd: 　　　　[root@localhost zhangzhuo]# rpm -e vsftpd-3...
java连接redis常见问题
cgj19960119的博客
03-01 256
(error) MISCONF Redis is configured to save RDB snapshots, but is currently not able to persist on disk. Commands that may modify the data set are disabled. Please check Redis logs for details about t...
"嵌入式程序员必知16个基本问题
第十六，注重团队意识和项目管理能力。嵌入式系统开发通常是一个团队合作的过程，嵌入式程序员需要具备团队意识和项目管理能力，以确保项目的顺利进行和高质量的交付。 总之，成为一名嵌入式程序员需要全面掌握上述...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值