精华内容
下载资源
问答
  • 实际项目中经常遇到很多类似操作,比如命令码对应执行函数等,对于此类操作,比较好的方式是使用const...以串口命令解析执行为例,首先定义一个结构体,定义操作函数指针类型: struct T_ShellInfo { string...

    实际项目中经常遇到很多类似操作,比如命令码对应执行函数等,对于此类操作,比较好的方式是使用const数组,将命令码和操作函数绑定在一起,通过查表方式找到操作函数,并执行操作函数。这样可以简化代码,降低复杂度,在c中这种方式很好实现,在c++中会稍微麻烦一些。

    以串口命令解析执行为例,首先定义一个结构体,定义操作函数的指针类型:

    struct T_ShellInfo
    {
        string cmd;
        void (* DealFunc)(const vector<string> &vectStr);
        string desc;
    };

    定义命令解析执行类,处理函数一定要定义成static,定义一个const static的数组:

    class CShell
    {
    public:
        CShell();
        ~CShell();
        void RecvCmd();
    private:   
        enum{SHELL_INFO_NUM_MAX=10};
        void GetCmd(const char *cmdStr, vector<string> &vectStr);
        void Deal(const vector<string> &vectStr);
    
        static void CmdHelp(const vector<string> &vectStr);
        static void CmdLed(const vector<string> &vectStr);
        static void CmdTask(const vector<string> &vectStr);
        static void CmdDisk(const vector<string> &vectStr);
        static void CmdTime(const vector<string> &vectStr);
        static void CmdReboot(const vector<string> &vectStr);
    
        CShell *_self;
        const static T_ShellInfo _shellInfo[SHELL_INFO_NUM_MAX]; 
    };

    实现时,先初始化数组

    const T_ShellInfo CShell::_shellInfo[SHELL_INFO_NUM_MAX]=
    {
        {"?",       CmdHelp,    "show all cmd"},
        {"help",    CmdHelp,    "show all cmd"},
        {"time",    CmdTime,    "show sys time"},
        {"task",    CmdTask,    "show all task info"},
        {"disk",    CmdDisk,    "disk cmd [info ls cat rm format]"},
        {"led",     CmdLed,     "set led [normal charge alarm]"},
        {"reboot",  CmdReboot,  "reboot sys"},
    
        {"",NULL,""}
    
    };

    串口收到命令后,只要遍历此数组,找到相同命令码的执行函数并执行即可

    void CShell::Deal(const vector<string> &vectStr)
    {
        for (u8 i = 0; i< SHELL_INFO_NUM_MAX; i++)
        {
            if (_shellInfo[i].cmd.length() == 0)
            {
                break;
            }
            if (_shellInfo[i].cmd == vectStr[0])
            {
                _shellInfo[i].DealFunc(vectStr);
                return;
            }
        }
        printf("cmd \"%s\" err!\r\n", vectStr[0].c_str());
    }

    然后逐个实现对应操作函数:

    void CShell::CmdTask(const vector<string> &vectStr)
    {
        u8 pcWriteBuffer[500]={0};
        //u8 *pcWriteBuffer = new u8[500]; //这个值要小心,太小会导致数组溢出,太大会导致堆栈溢出
        printf("=================================================\r\n");
        printf("任务名      任务状态 优先级   剩余栈 任务序号\r\n");
        vTaskList((char *)&pcWriteBuffer);
        printf("%s\r\n", pcWriteBuffer);
        //delete[] pcWriteBuffer;
    展开全文
  • 详解C语言指针函数、函数指针、函数指针数组

    万次阅读 多人点赞 2018-07-09 11:08:24
    而在指针中,指针函数、函数指针、指针函数数组、函数指针数组、指向函数指针数组的指针等等概念看着又绕又头疼。本问总结了一下以上一些概念以及用法,并给出例程深化理解。 1. 指针函数 指针函数就是返回指针值...

    在C语言中,指针是一个很重要但是又很容易弄错的概念,也可以说指针就是C语言的灵魂,所以说学好指针对于完全掌握C语言是一个必须的过程。而在指针中,指针函数、函数指针、指针函数数组、函数指针数组、指向函数指针数组的指针等等概念看着又绕又头疼。本问总结了一下以上一些概念以及用法,并给出例程深化理解。

    1. 指针函数

    指针函数就是返回指针值的函数,本质是一个函数。所以指针函数等价于“返回值为指针的函数”。

    声明形式:type *func (参数列表)

    #include <iostream>
    using namespace std;
    
    
    int *GetNum(int x); //指针函数声明形式
    
    
    void main(void)
    {
        cout << "===============start================" << endl;
        int num;
        cout << "Please enter the number between 0 and 6: ";
        cin >> num;
        cout << "result is:" << *GetNum(num) << endl;    //输出返回地址块中的值
        system("pause");
    }
    
    int *GetNum(int x) {
        static int num[] = { 0,1,2,3,4,5,6 };
        return &num[x];  //返回一个地址
    }
    

    2. 函数指针

    函数指针就是一个指向函数的指针。每个函数在编译时,会被分配一个入口地址,一般用函数名来表示,这个地址就是该函数的指针。

    声明形式:type (*func)(参数列表 )

    从上面的定义形式可以看出,函数指针和指针函数的直观上区别在于指针符号*与函数名/指针名有没有用括号()包裹起来,从这一点来看是很容易区分两者的。

    #include <iostream>
    using namespace std;
    
    int max(int a, int b) {
        return a>b ? a : b;
    }
    
    void main(void)
    {
        cout << "===========start===========" << endl;
        int(*func)(int, int);       //定义一个指向该函数形式的指针变量
        func = max;
        int a, b;
        cout << "Please enter two numbers:";
        cin >> a >> b;
        cout << "max=" << (*func)(a, b) << endl;    //运用指针变量调用函数
        cout << "max=" << max(a, b) << endl;        //使用原函数调用
        cout << "max=" << func(a, b) << endl;       //使用函数指针名调用,func = max
        system("pause");
    }
    

    上例给出了函数指针的两种最普遍的调用形式,一个是直接用定义的指针变量(* func)调用,一个是用指针名调用,后者看起来就像是将原函数使用了新名称去调用一样,可以看成函数的别名。再次强调一下:指针变量名和指针符号 * 一定要用括号包裹起来。函数指针还有一种常用的使用方式,就是使用typedef定义后再使用。将上例稍作修改如下:

    #include <iostream>
    using namespace std;
    
    int max(int a, int b) {
        return a>b ? a : b;
    }
    
    typedef int(*func)(int, int);
    
    void main(void)
    {
        cout << "===========start===========" << endl;
        func maxfunc = max;
        int a, b;
        cout << "Please enter two numbers:";
        cin >> a >> b;
        cout << "max=" << (*maxfunc)(a, b) << endl; //运用指针变量调用函数
        cout << "max=" << max(a, b) << endl;        //使用原函数调用
        cout << "max=" << maxfunc(a, b) << endl;        //使用函数指针名调用,func = max
        system("pause");
    }
    

    3. 函数指针数组

    顾名思义,就是每个元素都是函数指针的数组,直接在函数指针名后面加上数组符号[ ]即可。

    声明形式:type (*func[ ])(参数列表 )

    #include<iostream>
    using namespace std;
    
    void fun1()
    {
        cout << "调用函数fun1" << endl;
    }
    void fun2()
    {
        cout << "调用函数fun2" << endl;
    }
    void fun3()
    {
        cout << "调用函数fun3" << endl;
    }
    int main()
    {
        //定义三个函数指针
        void(*pfun)() = &fun1;
        void(*pfun2)() = &fun2;
        void(*pfun3)() = &fun3;
        //接下来就是定义一个数组把他们三个装进去。
        void(*pfunarr[3])();
        void(*pfunarr[3])();
        pfunarr[0] = pfun;
        pfunarr[1] = pfun2;
        pfunarr[2] = pfun3;
        /*  或者这样赋值
        pfunarr[0] = &fun1;
        pfunarr[1] = &fun2;
        pfunarr[2] = &fun3;
        */
        //调用运行
        pfunarr[0]();
        pfunarr[1]();
        pfunarr[2]();
        /*  或者这样调用
        (*pfunarr[0])();
        (*pfunarr[1])();
        (*pfunarr[2])();
        */
        system("pause");
        return 0;
    }
    

    4. C语言函数不可以定义为数组,只能通过函数指针来操作定义函数指针数组。

    5. 指向函数指针数组的指针

    声明形式:type (* (*func )[ ])(参数列表 )

    #include<iostream>
    using namespace std;
    
    void fun1()
    {
        cout << "调用函数fun1" << endl;
    }
    void fun2()
    {
        cout << "调用函数fun2" << endl;
    }
    void fun3()
    {
        cout << "调用函数fun3" << endl;
    }
    int main()
    {
    
        //void(*pfun)() = &fun1;
        //void(*pfun2)() = &fun2;
        //void(*pfun3)() = &fun3;
        //接下来就是定义一个数组把他们三个装进去。
        void(*pfunarr[3])();
        void(*(*pfunarr2)[3])();
        //在这里呢看着个指针数组,他就是一个具有3个以函数指针为内容的元素的函数指针数组。
        pfunarr[0] = &fun1;
        pfunarr[1] = &fun2;
        pfunarr[2] = &fun3;
    
        pfunarr2 = &pfunarr;
        (*pfunarr2)[0]();
        pfunarr[0]();
        system("pause");
        return 0;
    }
    

    分析其定义形式:void(*(*pfunarr2)[3])()
    其中(* pfunarr2)[3]表示数组指针,而void(* )( )表示函数指针,两者结合起来就是指向函数指针数组的指针。

    展开全文
  • 指针数组 首先从名字就可以知道这是一个数组,是存放指针的数组。 先看几种指针数组: int * 数组指针 函数指针 函数指针数组 指向函数指针数组的指针

    指针数组

    首先从名字就可以知道这是一个数组,是存放指针的数组。
    先看几种指针数组:
    int *arr1[10];
    char *arr2[5];
    char **arr3[6];
    因为 [ ] 的优先级是高于 * 的,所以数组名会先于 [ ] 相结合组成数组。 再于 int * / char *类型结合,组成存放该类型的数组。



    指针数组因为存放的都是指针所以不管是 int *   char * 还是 char ** 其大小都是四个字节。

    数组指针

    从名字看就知道是指针,是指向一个数组的指针。

    int (*p)[10];
    char (*p)[10];
    由数组指针知道 [ ] 的优先级是高于 *  的,所以用()来提升指针先结合。

    int (*p)[10];  //  是一个指向10个整形的一维数组的指针
    char (*p)[10]; //  是一个指向10个字符型的一维数组的指针

    数组的存储方式



    因为指向的是一个数组,所以大小由数组决定


    函数指针

    指向函数的指针,通俗的说也就是函数的地址
    void(*pfun)();
    pfun 先和*结合,说明pfun是指针,指针指向的是一个函数,指向的函数无参数,返回值类型为void
    也就是说 其可以保存函数的地址



    函数指针数组

    int (*parr[3])();
    parr先与 [ ]结合,说明是一个数组,再与*结合,说明数组存放的是指针,指针都指向的是函数
    函数指针数组的使用(转移表)
    例子:计算器
    #include<stdio.h>
    
    int add( x, y)
    {
    	return x + y;
    }
    int sub(x,y)
    {
    	return x - y;
    }
    int mul(x,y)
    {
    	return x * y;
    }
    int div(x,y)
    {
    	return x / y;
    }
    int main()
    {
    	int x, y;
    	int input = 1;
    	int ret = 0;
    	int(*parr[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
    	while (input)
    	{
    		printf("*******************************\n");
    		printf("***** 1.add         2.sub *****\n");
    		printf("***** 3.mul         4.div *****\n");
    		printf("*******************************\n");
    		printf("请选择:");
    		scanf("%d", &input);
    		if ((input > 0 && input < 5))
    		{
    			printf("输入你要计算的数:\n");
    			scanf("%d  %d", &x, &y);
    			ret = (*parr[input])(x, y);
    		}
    		else
    			printf("输入有误!\n");
    		printf("%d\n", ret);
    	}
    	return 0;
    }
    输出结果:


    指向函数指针数组的指针 

    这是一个指针,指向一个数组,这个数组是一个函数指针数组,数组中的元素都是函数指针

    定义方式:

    #include<stdio.h>
    void test(const char *str)
    {
    	printf("%s\n", str);
    }
    int main()
    {
    	void (*pfun)(const char*) = test;
    	//函数指针pfun
    	void (*pfunArr[5])(const char* str);
    	//函数指针的数组pfunArr
    	void (*(*ppfunArr)[10])(const char* str) = &pfunArr;
    	//指向函数指针数组pfunArr的指针ppfunArr
    	return 0;
    }




    展开全文
  • 一、函数指针数组1.1函数指针数组的声明 函数指针数组的声明如下,所谓函数指针数组就是在之前的函数指针的基础上增加了[],由于[]的优先级高于*,故 pf先与[]结合,说明它是一个数组,再与*结合说明数组中的元素的...

    一、函数指针数组

    1.1函数指针数组的声明

          函数指针数组的声明如下,所谓函数指针数组就是在之前的函数指针的基础上增加了[],由于[]的优先级高于*,故 pf先与[]结合,说明它是一个数组,再与*结合说明数组中的元素的类型是指针,再看后面的参数列表,说明每一个指针都指向一个函数的入口地址,并且指向的函数的返回类型为int。

    int (*pf[])(int, int);

    1.2函数指针的使用

          以下代码展示了函数指针数组的一个简单的应用。

    #include <stdio.h>
    
    int Add(int x, int y)
    {
    	return x + y;
    }
    
    int Sub(int x, int y)
    {
    	return x - y;
    }
    
    int main()
    {
    	int a = 10;
    	int b = 20;
    
            //定义一个有2个指针的数组,指针指向一个函数,该函数有两个整型参数并返回一个整型数
    	int(*p[2])(int, int);
    	p[0] = Add; //函数指针数组的第一个元素指向Add函数
    	p[1] = Sub;
    
    	printf("%d, %d\n", p[0](a, b), p[1](a, b));
    
    	system("pause");
    	return 0;
    }

    二、指向函数指针数组的指针

          在此,仅作介绍,它也叫函数指针数组的指针。下面的定义怎么理解呢?首先,p和*结合说明是一个指针,之后与[]结合,说明是一个数组指针,再与*结合说明用一个指针指向了数组指针,之后又指向了一个函数的入口地址,该函数有两个int类型参数,返回值是int。

    int (*(*p)[])(int, int);

         总而言之,指向函数指针数组的指针就是在函数指针数组的基础上,再加一个*表示一个指针去指向它。当然,既然有函数指针数组的指针,则必然还有函数指针数组的指针数组,只不过一般的编程用到的情况很少,如果读者有兴趣的话,可以去研究一下。

    展开全文
  • C语言:理解函数指针数组定义

    千次阅读 2018-10-20 12:09:54
    函数指针数组定义 数组是一个存放相同类型数据的存储空间,那我们已经学习了指针数组,比如: int *arr[10];//数组的每个元素是int* 那要把函数的地址存到一个数组中,那这个数组就叫函数指针数组,那函数...
  • 函数指针函数指针是指向可执行代码段或调用可执行代码段的信息块的指针,而不是指向某种数据的指针。函数指针是将函数当做普通数据那样存储和管理。函数指针有一种固定的形式,就是包含一个确定的返回值类型和若干...
  • 功能:探究函数指针和函数指针数组定义及用法 输入示例: Input 2 numbers & 1 operator(0-max, 1-min, 2-sum): 1 9 2 输出示例: 10 -------------------------------------------...
  • 函数指针、函数指针数组函数指针数组的指针

    千次阅读 多人点赞 2017-11-27 11:39:51
    数组指针 概念:数组指针指针,只要是指针他就占4个字节; 例如: 整形指针:int *p;能够指向整形数据的指针  浮点型指针:float *p;能够指向浮点型的数据的指针 那么数组指针,同样的理解就是指向数组指针...
  • 函数指针(指向函数的指针) 与数据项类似,函数也有自己的地址。函数的地址是存储其机器代码的内存的开始地址。例如,可以编写将另一个函数的地址作为参数的函数,这样第一个函数将能够找到第二个函数,并运行它。...
  • 本篇主要介绍一下数组指针、指针数组、函数指针数组和指向函数指针数组的指针。希望能和大家一起学习,互相交流。(所讲内容的操作均在32位系统下进行) 指针数组:形如:int *p1[5];(p1为数组名) 首先我们要知道...
  • 四、函数指针数组 五、指向函数指针数组的指针 目录 1.指针数组 2.数组指针 3.函数指针 4.函数指针数组 5.函数指针数组的指针 一、指针数组 1.是一个存放指针的数组 2.举一个栗子 int *...
  • 怎样定义函数指针数组

    千次阅读 2018-11-22 20:25:33
    那么,怎样定义函数指针数组呢? 一、什么是函数指针 在定义函数指针数组之前,需要首先知道什么是函数指针。函数指针的定义形象点来说,就是用一个指针变量代替原函数中的函数名位置。 原函数 int Add(...
  • 函数指针: 在c语言中,一般函数都是占用一段连续的内存区,而函数名就是这段连续内存区的首地址,而且指针也代表着地址。所以,我们可以吧函数名(函数首)赋值给指针变量,用指针来调用这个函数。 格式:int (*p...
  • 不比多说上一个代码,就懂了! 代码一: #include &lt;stdio.h&gt; int func(int i) {  printf("%d\n",i);  return i*i;...//定义  s[1] = func;//赋值  printf("m...
  • 编译环境:GCC 示例说明:定义三个参数为void返回值为void的函数;(函数) 定义三个指向void型参数返回值为void的函数指针;(指针) 定义一个保存指向void型参数... 给函数指针赋值、给函数指针数组赋值; ...
  • 数组:一组数据的集合称为数组,它所包含的每一个数据叫做数组元素,例如 int a[4]; 它定义了一个长度为4的整型...指针数组指针数组的元素全为指针。它的声明方法是:数据类型 * 数组名[数组长度];例如int arr[5];
  • 理解函数指针定义 先看一下一段代码: #define _CRT_SECURE_NO_WARNINGS 1 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; void test() { printf("hehe\n"); } int main...
  • 总结指针数组部分的相关知识自己写的一遍博客: 指针是变量单元的地址,地址指向该变量单元,因此地址形象的称为“指针”,通过指针(地址)可以找到内存单元。  (总结)1.指针是存放地址才出现的,地址是为了...
  • 使用函数指针数组建立一套bpm工作流框架。这套框架在各种oa以及某几个大型通信公司应用的很广泛 适应场景 多分枝(类似Swtich)条件下、处理函数的形参列表和返回类型相同。如: int func1(const char *...
  • 直接定义函数指针数组以及赋值。 在c++中可以如下写法(参考: 代码链接 ): .h文件 class Test { private : typedef void ( * func ) ( void ) ; func funcPtr [ 2 ] ; public : Test...
  • 函数指针数组定义

    千次阅读 2014-04-21 09:09:35
    函数指针数组定义方法,有两种:一种是标准的方法;一种是蒙骗法。 第一种,标准方法: { 分析:函数指针数组是一个其元素是函数指针的数组。那么也就是说,此数据结构是是一个数组,且其元素是一个指向...
  • Qt类中使用函数指针数组

    千次阅读 2019-05-13 13:38:18
    声明函数指针类型 typedef void (MainWindow::*pFuns)(void); 函数声明 void test1(); void test2(); 数组定义并赋值 pFuns testFuns[2] = {...通过函数指针数组调用函数 (this->*funs[0])(); 注意:一...
  • QT中函数指针数组

    2020-08-14 17:21:49
    QT中函数指针数组自定义类函数定义函数指针数组使用 自定义类 class myclass{ typedef void (myclass::*Funs)(QJsonObject *jsonObject,void *para); /函数声明/ void fun1(QJsonObject *jsonObject,void *para); ...
  • 函数指针数组:存放函数指针的数组 2、是什么样子 指针函数: 数据类型 * 函数名 (参数); 例: 返回值为int型指针的函数,函数名是fun,参数是x,y; int *fun(int x, int y); 函数指针: 数据类型 (*函数名)...
  •   C语言是一门面向过程的语言,而面向过程最大的利器就是函数,今天我们就来研究一下函数指针相关的话题。 1. 函数指针   首先看一个例子。 #include &lt;stdio.h&gt; #include &lt;stdlib...
  • 前述:C语言的奥秘,博大精深,今天来回忆的分析函数指针,函数指针数组的用法。具体请见下面一个注册程序的实现。 1 #include &lt;stdio.h&gt; 2 #include &lt;string.h&gt; 3 5 6 typedef ...
  • 函数指针 指针我们知道实际上是一个变量或者数组等的地址。如我们定义: void *Ptr; 该指针变量可以指向我们希望指向的地址,如我们有数组为a[2] = {0,1},那么我们可以通过给指针变量赋值,使其指向该数组Ptr = a...
  • C语言的函数指针数组

    千次阅读 2016-12-29 23:22:30
    函数指针数组概念: 数组元素是指针函数的数组叫做指针函数数组,通常我们也叫做转移表 定义个初始化: 返回类型说明符 (*函数指针数组名[])(参数列表) = {函数指针/函数名,…}; 如下: int (*fun_array[])...
  • 一.函数指针 1.定义理解 函数指针:是一个指针,存放函数地址的指针。 函数的地址可以通过取地址函数名拿到,也可以通过函数名直接拿到。... //函数指针定义方式  void (*p)(char *str) = test...
  • 函数名可以通过函数指针加以保存,那们也一定能定义一个数组保存若干个函数名,这就是函数指针数组。正确使用函数指针数组的前提条件是,这若干个需要通过函数指针数组保存的函数必须有相同的输入、输出值。 int(*...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 439,776
精华内容 175,910
关键字:

函数指针数组定义