精华内容
下载资源
问答
  • 函数指针数组示例

    2014-10-11 13:33:05
    C语言中对函数指针数组不是很了解,老师最近布置了一个作业,就搜集资料写了一个,希望能给大家启发,如果对C语言复杂指针的分析不是很懂得话,可以网上搜索“右左法则”
  • 指针数组 首先从名字就可以知道这是一个数组,是存放指针的数组。 先看几种指针数组: 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.定义理解 函数指针:是一个指针,存放函数地址的指针。 函数的地址可以通过取地址函数名拿到,也可以通过函数名直接拿到。2.函数指针 (1)定义一个函数test void test(char *str) {  printf("%...

    一.函数指针

    1.定义理解
    函数指针:是一个指针,存放函数地址的指针。
    函数的地址可以通过取地址函数名拿到,也可以通过函数名直接拿到。
    2.函数指针
    (1)定义一个函数test

    void test(char *str)
    {
        printf("%s\n",str);
    }
    int main()
    {
        //函数指针的定义方式
        void (*p)(char *str) = test;
        return 0;
    }

    (2)函数指针的使用

    //调用函数test,传参:zhangsan
    (*p)("zhangshan");

    这里的*没有起作用,它是让我们知道这是一个指针然后解引用了一下。所以可以简化一下:(下面的写法也正确)

    p("zhangsan");

    (3)一些函数指针举例

    //add函数
    int (*p)(int x,int y)=add;
    //调用
    p(2,3);
    //sub函数
    int (*p)(int x,int y)=sub;
    //调用
    p(2,3);

    这些函数指针类型都相同,因此我们考虑能不能把这些函数指针放到一个数组中呢?接下来我们引入一个函数指针数组。

    二.函数指针数组

    1.定义理解
    存放相同类型函数指针的数组。
    2.函数指针数组
    定义一个函数指针数组

    int (*p[4])(int,int)={add,sub,mul,div};
    //该函数指针数组包含四个函数指针
    //分别指向add函数,sub函数,mul函数,div函数
    //每一个函数的参数都是两个int型的参数

    调用函数

    //调用add函数
    P[1](8,4);--->输出12
    //调用sub函数
    P[2](8,4);--->输出4
    //调用mul函数
    P[3](8,4);--->输出32
    //调用div函数
    P[4](8,4);--->输出2

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

    1.定义理解
    针对刚刚上面存放了add,sub,mul,div四个函数的地址的指针数组p,既然p是一个数组,那么我们可以对p进行取地址,取出来的是数组的地址,要将这个地址存放起来我们需要一个指针,我们称作指向函数指针数组的指针。
    2.函数指针数组的指针
    那么函数指针数组的指针该如何书写呢? 
    我们还是以上面的函数指针数组p为例。

    int (*(*pp)[4])(int x,int y)=&p;
    //这里的pp就是存放了函数指针数组p的指针

    小总结

    到这里为止大家可能对这些比较绕,我们来总结一下。 
    ①函数指针int (*p)(int , int); 
    (这是一个指针,指向一个函数) 
    ②函数指针数组int (*p[4])(int ,int) 
    (这是一个数组,数组有四个元素,每个元素是一个指向函数的指针) 
    ③指向函数指针数组的指针int (*(*p)[4])(int ,int) 
    (这是一个指针,指向一个数组,这个数组有四个元素,每个元素是一个指向函数的指针
     

    展开全文
  • 本文介绍的函数指针以及函数指针数组解决了实际程序编写过程中遇到的当在多种情况情况下调研多个函数的问题。
  • 详解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(* )( )表示函数指针,两者结合起来就是指向函数指针数组的指针。

    展开全文
  • 函数指针、函数指针数组函数指针数组的指针

    千次阅读 多人点赞 2017-11-27 11:39:51
    数组指针 概念:数组指针指针,只要是指针他就占4个字节; 例如: 整形指针:int *p;能够指向整形数据的指针  浮点型指针:float *p;能够指向浮点型的数据的指针 那么数组指针,同样的理解就是指向数组指针...

    数组指针

    概念:数组指针是指针,只要是指针他就占4个字节;

    例如: 整形指针:int *p;能够指向整形数据的指针

       浮点型指针:float *p;能够指向浮点型的数据的指针

    那么数组指针,同样的理解就是指向数组的指针。

    Eg:  int (*p)[10]

    解释:这里的p由于小括号的原因和*先结合,所以他就是指针,然后指向的是一个大小为10的整形数组,所以p首先是一个指针,然后指向一个整形数组,即p的名字叫做数组指针。

    使用:

    Int arr[10] = {0};

    此时:arr表示:数组首元素的地址

      &arr 表示:数组的地址

    我们运行下面一段代码,得到结果如图:


    arr代表数组的第一个元素,所以打印出数组第一个元素的地址

      arr+1代表数组第一个元素向后加一个,得到了的第二个元素,因为是整形数组,所以,地址加了一个4

     &arr+1:因为&arr代表的是整个数组的地址,所以在+1之后,代表的是下一个数组的地址。

     

    指针数组

    根据数组指针是指针的理解,我们可以得到,指针数组就是数组,其数组的元素都是指针。

    Eg:一个以为指针数组的定义:int *p[10];

    因为[]的结合优先级比较高,所以p先和[]结合

    指针数组常用来指向字符串,方便字符串的处理

    数组参数  指针参数

    一维数组的传参:


    没有报错,说明图中的传参方式都可以作为一维数组的传参方式

    二维数组的传参:

     

    当运行这段代码的时候,会出现第一个函数的报错,提示缺少下标,当我们在一个函数的参数的第二个中加上二维数组的列数:5,则编译通过,说明二维数组在传参的过程中是必须要传列数的。

    一级指针传参

    当一个函数的参数部分是一级指针的 时候,那么此时我们可以给参数传进去一个地址,因为指针里面就是地址,也可以传进去一个指针,此时编译都可以通过,所以,我们在一定的程度上就可以把:地址=指针

    二级指针传参


    在运行如图代码之后,test函数的参数就是接收一个二级指针,在调用的时候,第一次直接传进去一个二级指针:调用成功。因为二级指针里面存放的是一个一级指针的地址,所以我们在第二次调用的时候,传进去一个一级指针的地址&p,显示调用成功,所以:函数的参数是二级指针的时候,可以接收一个二级指针或者一级指针的地址作为参数。

     

    函数指针

    首先运行一段代码:


    可以看到test &test的值是一样的,所以此时,我们就可以把test看作是函数的地址,

     

    阅读一下代码帮助理解:

    Void  test(){

    Printf(“hehe\n”);

    }

    //void (*p1)()

    //void *p2()

    此时只有p1可以存放函数test的地址,p1先和*结合,说明p1是指针,指针的指向是一个函数,指向的这个函数没有参数,返回值的类型是void

     

    函数指针数组:

    首先它是一个数组,存放的元素是指针,这些指针都指向某个函数。

    则其定义为:

    例如:int (*parr1[10])()

    首先parr1先和[]结合,他就是数组,那么数组的内容就是int (*)()类型的函数指针

    错误实例: int *parr1[10]()×

             int (*)()parr3[10] ×

    函数指针数组的用途:转移表

     在我们设计一个计算器的时候:

     

    我们用函数指针数组,将加减乘除四个函数存放起来,

    调用时,我们可以:*pcal[1](3,2),此时我们将调用add函数进行32 加运算

     

    函数指针数组的指针

    既然数组可以用指针指,叫做数组指针,那么函数指针数组也可用指针指起来,叫做:函数指针数组的指针,顾名思义,这个指针指向了一个数组,这个数组叫做函数指针数组,数组里面的元素存放的是函数的指针,这些函数的指针,分别的指向了特定的函数。

    如何定义:

    Void test (const char *str){}

    Int main(){

    //定义函数指针pfun

    Void (*pfun)(const char *) = test;

    //函数指针的数组pfunarr

    Void (*pfunarr[5])(const char *str)

    //函数指针数组的指针

    //void (*(*pfunarr[5]) )(const char *) = &pfunarr;

    Return 0;

    }

    函数指针的应用:回调函数

    例如:

    Int test(void *str1,void *str2){}

    void fun(int x,const char* str,int(*funname)(void *,void*)){

    //函数体内部会调用第三个参数传进来的函数,返回值是int,有两个参数,都是void

    }

    Int main(){

    Fun(a,str,test);//此时test函数就当做参数传递到fun函数里面

    Return 0

    }

    展开全文
  • 函数指针函数指针是指向可执行代码段或调用可执行代码段的信息块的指针,而不是指向某种数据的指针。函数指针是将函数当做普通数据那样存储和管理。函数指针有一种固定的形式,就是包含一个确定的返回值类型和若干...
  • 函数指针数组

    2012-06-27 13:14:33
    函数指针数组
  • 一、函数指针数组1.1函数指针数组的声明 函数指针数组的声明如下,所谓函数指针数组就是在之前的函数指针的基础上增加了[],由于[]的优先级高于*,故 pf先与[]结合,说明它是一个数组,再与*结合说明数组中的元素的...
  • 函数指针: 在c语言中,一般函数都是占用一段连续的内存区,而函数名就是这段连续内存区的首地址,而且指针也代表着地址。所以,我们可以吧函数名(函数首)赋值给指针变量,用指针来调用这个函数。 格式:int (*p...
  • 今天在看C++prime plus的时候无意间看到了函数指针,这是个我很少涉及的地方。打算写一个小程序来熟悉一下。
  • 编译环境:GCC 示例说明:定义三个参数为void返回值为void的函数;(函数) 定义三个指向void型参数返回值为void的函数指针;(指针) 定义一个保存指向void型参数... 给函数指针赋值、给函数指针数组赋值; ...
  • 总结指针数组部分的相关知识自己写的一遍博客: 指针是变量单元的地址,地址指向该变量单元,因此地址形象的称为“指针”,通过指针(地址)可以找到内存单元。  (总结)1.指针是存放地址才出现的,地址是为了...
  • 理解函数指针和定义 先看一下一段代码: #define _CRT_SECURE_NO_WARNINGS 1 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; void test() { printf("hehe\n"); } int main...
  • 函数指针数组:存放函数指针的数组 2、是什么样子 指针函数: 数据类型 * 函数名 (参数); 例: 返回值为int型指针的函数,函数名是fun,参数是x,y; int *fun(int x, int y); 函数指针: 数据类型 (*函数名)...
  • 最近复习C++,突然看到函数指针,由于自己上学期C++学习的比较水,所以在这里专门总结一下。 与普通的指针相似,指向函数的指针包含内存中该函数的地址。对比数组数组名实际是数组的第一个元素在内存中的地址。...
  • 使用函数指针数组建立一套bpm工作流框架。这套框架在各种oa以及某几个大型通信公司应用的很广泛 适应场景 多分枝(类似Swtich)条件下、处理函数的形参列表和返回类型相同。如: int func1(const char *...
  • /指针数组 示例:char *a[4] 理解:定义了一个数组,而它的每个元素的类型是一个指向字符/字符串的指针。 元素表示:char *a[i] char *(a[i])是一样的,因为[]优先级高于* 思考:是否可以这样理解 (char*)arr...
  • 功能:探究函数指针和函数指针数组的定义及用法 输入示例: Input 2 numbers & 1 operator(0-max, 1-min, 2-sum): 1 9 2 输出示例: 10 -------------------------------------------...
  • QT中函数指针数组

    2020-08-14 17:21:49
    QT中函数指针数组自定义类函数定义函数指针数组使用 自定义类 class myclass{ typedef void (myclass::*Funs)(QJsonObject *jsonObject,void *para); /函数声明/ void fun1(QJsonObject *jsonObject,void *para); ...
  •   C语言是一门面向过程的语言,而面向过程最大的利器就是函数,今天我们就来研究一下函数指针相关的话题。 1. 函数指针   首先看一个例子。 #include &lt;stdio.h&gt; #include &lt;stdlib...
  • 函数指针(指向函数的指针) 与数据项类似,函数也有自己的地址。函数的地址是存储其机器代码的内存的开始地址。例如,可以编写将另一个函数的地址作为参数的函数,这样第一个函数将能够找到第二个函数,并运行它。...
  • 数组:一组数据的集合称为数组,它所包含的每一个数据叫做数组元素,例如 int a[4]; 它定义了一个长度为4的整型...指针数组指针数组的元素全为指针。它的声明方法是:数据类型 * 数组名[数组长度];例如int arr[5];
  • 有时候我们如果需要在一个循环中,每次调用不同的函数(这些函数的返回值和参数相同,函数名不同,实现不同),那么就可以使用函数指针数组来使代码更加简练和易读。那么,怎样定义函数指针数组呢? 一、什么是函数...
  • Qt类中使用函数指针数组

    千次阅读 2019-05-13 13:38:18
    声明函数指针类型 typedef void (MainWindow::*pFuns)(void); 函数声明 void test1(); void test2(); 数组定义并赋值 pFuns testFuns[2] = {...通过函数指针数组调用函数 (this->*funs[0])(); 注意:一...
  • 上一篇博客最后的两个例子的答案分别是:函数指针数组函数指针数组的指针。 函数指针数组指针和前面的数组指针其实没有太大区别。然后今天主要理一下函数指针数组和二级指针。 函数指针数组 函数指针数组中,...
  • 前述: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语言:理解函数指针数组和定义

    千次阅读 2018-10-20 12:09:54
    函数指针数组和定义 数组是一个存放相同类型数据的存储空间,那我们已经学习了指针数组,比如: int *arr[10];//数组的每个元素是int* 那要把函数的地址存到一个数组中,那这个数组就叫函数指针数组,那函数...
  • 什么是指针? 在计算机科学中,指针(Pointer)是编程语言中的一个对象,利用地址,它的值直接指向(points to)存在电脑存储器中另一个地方的值。... 指针数组:它是一个数组,数组里面每个元素都是指针,数组的

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 591,409
精华内容 236,563
关键字:

函数指针数组