函数指针 订阅
函数指针是指向函数的指针变量。 因此“函数指针”本身首先应是指针变量,只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样,这里是指向函数。如前所述,C在编译时,每一个函数都有一个入口地址,该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后,可用该指针变量调用函数,就如同用指针变量可引用其他类型变量一样,在这些概念上是大体一致的。函数指针有两个用途:调用函数和做函数的参数。 展开全文
函数指针是指向函数的指针变量。 因此“函数指针”本身首先应是指针变量,只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样,这里是指向函数。如前所述,C在编译时,每一个函数都有一个入口地址,该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后,可用该指针变量调用函数,就如同用指针变量可引用其他类型变量一样,在这些概念上是大体一致的。函数指针有两个用途:调用函数和做函数的参数。
信息
解    释
指向函数的指针变量
外文名
Function pointer
行    业
IT
中文名
函数指针
函数指针方法
函数指针的声明方法为:返回值类型 ( * 指针变量名) ([形参列表]);注1:“返回值类型”说明函数的返回类型,“(指针变量名 )”中的括号不能省,括号改变了运算符的优先级。若省略整体则成为一个函数说明,说明了一个返回的数据类型是指针的函数,后面的“形参列表”表示指针变量指向的函数所带的参数列表。例如:int func(int x); /* 声明一个函数 */int (*f) (int x); /* 声明一个函数指针 */f=func; /* 将func函数的首地址赋给指针f */或者使用下面的方法将函数地址赋给函数指针:f = &func;赋值时函数func不带括号,也不带参数,由于func代表函数的首地址,因此经过赋值以后,指针f就指向函数func(x)的代码的首地址。注2:函数括号中的形参可有可无,视情况而定。下面的程序说明了函数指针调用函数的方法:例一、ptr是指向函数的指针变量,所以可把函数max()赋给ptr作为ptr的值,即把max()的入口地址赋给ptr,以后就可以用ptr来调用该函数,实际上ptr和max都指向同一个入口地址,不同就是ptr是一个指针变量,不像函数名称那样是死的,它可以指向任何函数,就看你想怎么做了。在程序中把哪个函数的地址赋给它,它就指向哪个函数。而后用指针变量调用它,因此可以先后指向不同的函数。不过注意,指向函数的指针变量没有++和--运算,用时要小心。不过,在某些编译器中这是不能通过的。这个例子的补充如下。应该是这样的:1.定义函数指针类型:typedef int (*fun_ptr)(int,int);2.声明变量,赋值:fun_ptr max_func=max;也就是说,赋给函数指针的函数应该和函数指针所指的函数原型是一致的。例二、
收起全文
精华内容
下载资源
问答
  • 函数指针和指针函数用法和区别

    万次阅读 多人点赞 2018-05-24 08:11:10
    函数指针和指针函数,在学习 C 语言的时候遇到这两个东西简直头疼,当然还有更头疼的,比如什么函数指针函数、指针函数指针、数组指针、指针数组、函数指针数组等等,描述越长其定义就越复杂,当然理解起来就越难,...

    前言

    函数指针和指针函数,在学习 C 语言的时候遇到这两个东西简直头疼,当然还有更头疼的,比如什么函数指针函数、指针函数指针、数组指针、指针数组、函数指针数组等等,描述越长其定义就越复杂,当然理解起来就越难,特别是刚开始学习这门语言的童鞋,估计碰到这些东西就已经要崩溃了,然后好不容易死记硬背下来应付考试或者面试,然后过了几天发现,又是根本不会用,也不知道该在哪些地方用,这就尴尬了。
    今天这里只讲两个相对简单的,其实上面说那些太复杂的东西也真的很少用,即便是用了理解起来很麻烦,所以莫不如先深刻理解这两个比较容易的,并且项目中比较常用到。

    正文

    先来看看两者的定义以及说明。

    指针函数

    定义

    指针函数,简单的来说,就是一个返回指针的函数,其本质是一个函数,而该函数的返回值是一个指针。
    声明格式为:*类型标识符 函数名(参数表)

    这似乎并不难理解,再进一步描述一下。
    看看下面这个函数声明:

    int fun(int x,int y);
    

    这种函数应该都很熟悉,其实就是一个函数,然后返回值是一个 int 类型,是一个数值。
    接着看下面这个函数声明:

    int *fun(int x,int y);
    

    这和上面那个函数唯一的区别就是在函数名前面多了一个*号,而这个函数就是一个指针函数。其返回值是一个 int 类型的指针,是一个地址。

    这样描述应该很容易理解了,所谓的指针函数也没什么特别的,和普通函数对比不过就是其返回了一个指针(即地址值)而已。

    指针函数的写法

    int *fun(int x,int y);
    int * fun(int x,int y);
    int* fun(int x,int y);
    

    这个写法看个人习惯,其实如果*靠近返回值类型的话可能更容易理解其定义。

    示例

    (由于本人习惯于 Qt 中进行开发,所以这里为了方便,示例是在 Qt 工程中写的,其语法是一样的,只是输出方式不同)
    来看一个非常简单的示例:

    typedef struct _Data{
        int a;
        int b;
    }Data;
    
    //指针函数
    Data* f(int a,int b){
        Data * data = new Data;
        data->a = a;
        data->b = b;
        return data;
    }
    
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        //调用指针函数
        Data * myData = f(4,5);
        qDebug() << "f(4,5) = " << myData->a << myData->b;
    
        return a.exec();
    }
    
    

    输出如下:

    f(4,5) =  4 5
    

    注意:在调用指针函数时,需要一个同类型的指针来接收其函数的返回值。
    不过也可以将其返回值定义为 void*类型,在调用的时候强制转换返回值为自己想要的类型,如下:

    //指针函数
    void* f(int a,int b){
        Data * data = new Data;
        data->a = a;
        data->b = b;
        return data;
    }
    
    调用:
    Data * myData = static_cast<Data*>(f(4,5));
    

    其输出结果是一样的,不过不建议这么使用,因为强制转换可能会带来风险。

    函数指针

    定义

    函数指针,其本质是一个指针变量,该指针指向这个函数。总结来说,函数指针就是指向函数的指针。
    声明格式:类型说明符 (*函数名) (参数)
    如下:

    int (*fun)(int x,int y);
    

    函数指针是需要把一个函数的地址赋值给它,有两种写法:

    fun = &Function;
    fun = Function;
    

    取地址运算符&不是必需的,因为一个函数标识符就表示了它的地址,如果是函数调用,还必须包含一个圆括号括起来的参数表。

    调用函数指针的方式也有两种:

    x = (*fun)();
    x = fun();
    

    两种方式均可,其中第二种看上去和普通的函数调用没啥区别,如果可以的话,建议使用第一种,因为可以清楚的指明这是通过指针的方式来调用函数。当然,也要看个人习惯,如果理解其定义,随便怎么用都行啦。

    示例

    int add(int x,int y){
        return x+y;
    }
    int sub(int x,int y){
        return x-y;
    }
    //函数指针
    int (*fun)(int x,int y);
    
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        //第一种写法
        fun = add;
        qDebug() << "(*fun)(1,2) = " << (*fun)(1,2) ;
    	//第二种写法
        fun = &sub;
        qDebug() << "(*fun)(5,3) = " << (*fun)(5,3)  << fun(5,3);
    
        return a.exec();
    }
    
    

    输出如下:

    (*fun)(1,2) =  3
    (*fun)(5,2) =  2 2
    

    上面说到的几种赋值和调用方式我都分别使用了,其输出结果是一样的。

    二者区别

    通过以上的介绍,应该都能清楚的理解其二者的定义。那么简单的总结下二者的区别:

    定义不同

    指针函数本质是一个函数,其返回值为指针。
    函数指针本质是一个指针,其指向一个函数。

    写法不同

    指针函数:int* fun(int x,int y);
    函数指针:int (*fun)(int x,int y);
    可以简单粗暴的理解为,指针函数的*是属于数据类型的,而函数指针的星号是属于函数名的。
    再简单一点,可以这样辨别两者:函数名带括号的就是函数指针,否则就是指针函数。

    用法不同

    上面已经写了详细示例,这里就不在啰嗦了。

    总而言之,这两个东西很容易搞混淆,一定要深入理解其两者定义和区别,避免犯错。

    另外,本文都是针对普通函数指针进行介绍,如果是C++非静态成员函数指针,其用法会有一些区别,在另外一篇博客中单独介绍,文章在这里

    展开全文
  • 指针函数和函数指针

    万次阅读 多人点赞 2019-03-30 16:21:36
    很多人因为搞不清这两个概念,干脆就避而远之,我刚接触C语言的时候对这两个概念也比较模糊,特别是当指针函数、函数指针函数指针变量、函数指针数组放在一块的时候,能把强迫症的人活活逼疯。 其实如果理解了这些...

    概述

    指针函数和函数指针是C语言里两个比较绕的概念。但是不仅面试题爱考,实际应用中也比较广泛。很多人因为搞不清这两个概念,干脆就避而远之,我刚接触C语言的时候对这两个概念也比较模糊,特别是当指针函数、函数指针、函数指针变量、函数指针数组放在一块的时候,能把强迫症的人活活逼疯。
    其实如果理解了这些概念的本质,是不需要死记硬背的,理解起来也比较容易。

    指针函数

    指针函数: 顾名思义,它的本质是一个函数,不过它的返回值是一个指针。其声明的形式如下所示:

    ret *func(args, ...);
    

    其中,func是一个函数,args是形参列表,ret *作为一个整体,是 func函数的返回值,是一个指针的形式。
    下面举一个具体的实例来做说明:

    文件:pointer_func.c

    # include <stdio.h>
    # include <stdlib.h>
    
    int * func_sum(int n)
    {
        if (n < 0)
        {
            printf("error:n must be > 0\n");
            exit(-1);
        }
        static int sum = 0;
        int *p = &sum;
        for (int i = 0; i < n; i++)
        {
            sum += i;
        }
        return p;
    }
    
    int main(void)
    {
        int num = 0;
        printf("please input one number:");
        scanf("%d", &num);
        int *p = func_sum(num); 
        printf("sum:%d\n", *p);
        return 0;
    }
    

    上例就是一个指针函数的例子,其中,int * func_sum(int n)就是一个指针函数, 其功能十分简单,是根据传入的参数n,来计算从0到n的所有自然数的和,其结果通过指针的形式返回给调用方。
    以上代码的运行结果如下所示:
    运行结果1
    如果上述代码使用普通的局部变量来实现,也是可以的,如下所示:

    文件:pointer_func2.c

    # include <stdio.h>
    # include <stdlib.h>
    
    int func_sum2(int n)
    {   
        if (n < 0)
        {   
            printf("error:n must be > 0\n");
            exit(-1);
        }
        int sum = 0;
        int i = 0;
        for (i = 0; i < n; i++)
        {   
            sum += i;
        }
        return sum;
    }
    
    int main(void)
    {
        int num = 0;
        printf("please input one number:");
        scanf("%d", &num);
        int ret = func_sum2(num);
        printf("sum2:%d\n", ret);
        return 0;
    }
    

    本案例中,func_sum2函数的功能与指针函数所实现的功能完全一样。
    在这里插入图片描述
    不过在使用指针函数时,需要注意一点,相信细心地读者已经发现了,对比func_sumfunc_sum2函数,除了返回值不一样之外,还有一个不同的地方在于,在func_sum中,变量sum使用的是静态局部变量,而func_sum2函数中,变量sum使用的则是普通的变量。
    如果我们把指针函数的sum定义为普通的局部变量,会是什么结果呢?不妨来试验一下:

    文件:pointer_func3.c

    # include <stdio.h>
    # include <stdlib.h>
    
    int * func_sum(int n)
    {
        if (n < 0)
        {
            printf("error:n must be > 0\n");
            exit(-1);
        }
        int sum = 0;
        int *p = &sum;
        for (int i = 0; i < n; i++)
        {
            sum += i;
        }
        return p;
    }
    
    int main(void)
    {
        int num = 0;
        printf("please input one number:");
        scanf("%d", &num);
        int *p = func_sum(num); 
        printf("sum:%d\n", *p);
        return 0;
    }
    

    执行以上程序,发现仍然能得到正确的结果:
    在这里插入图片描述
    可是如果我们把main函数里面稍微改动一下:

    int main(void)
    {
        int num = 0;
        printf("please input one number:");
        scanf("%d", &num);
        int *p = func_sum(num);
        printf("wait for a while...\n");    //此处加一句打印
        printf("sum:%d\n", *p);
        return 0;
    }
    

    我们在输出sum之前打印一句话,这时看到得到的结果完全不是我们预先想象的样子,得到的并不是我们想要的答案。
    在这里插入图片描述
    为什么会出现上面的结果呢?
    其实原因在于,一般的局部变量是存放于栈区的,当函数结束,栈区的变量就会释放掉,如果我们在函数内部定义一个变量,在使用一个指针去指向这个变量,当函数调用结束时,这个变量的空间就已经被释放,这时就算返回了该地址的指针,也不一定会得到正确的值。上面的示例中,在返回该指针后,立即访问,的确是得到了正确的结果,但这只是十分巧合的情况,如果我们等待一会儿再去访问该地址,很有可能该地址已经被其他的变量所占用,这时候得到的就不是我们想要的结果。甚至更严重的是,如果因此访问到了不可访问的内容,很有可能造成段错误等程序崩溃的情况。
    因此,在使用指针函数的时候,一定要避免出现返回局部变量指针的情况。
    那么为什么用了static就可以避免这个问题呢?
    原因是一旦使用了static去修饰变量,那么该变量就变成了静态变量。而静态变量是存放在数据段的,它的生命周期存在于整个程序运行期间,只要程序没有结束,该变量就会一直存在,所以该指针就能一直访问到该变量。
    因此,还有一种解决方案是使用全局变量,因为全局变量也是放在数据段的,但是并不推荐使用全局变量。

    函数指针

    与指针函数不同,函数指针 的本质是一个指针,该指针的地址指向了一个函数,所以它是指向函数的指针。
    我们知道,函数的定义是存在于代码段,因此,每个函数在代码段中,也有着自己的入口地址,函数指针就是指向代码段中函数入口地址的指针。
    其声明形式如下所示:

    ret (*p)(args, ...);
    

    其中,ret为返回值,*p作为一个整体,代表的是指向该函数的指针,args为形参列表。其中p被称为函数指针变量

    关于函数指针的初始化

    与数组类似,在数组中,数组名即代表着该数组的首地址,函数也是一样,函数名即是该数组的入口地址,因此,函数名就是该函数的函数指针。
    因此,我们可以采用如下的初始化方式:

    函数指针变量 =  函数名;
    

    下面还是以一个简单的例子来具体说明一下函数指针的应用:

    文件:func_pointer.c

    #include <stdio.h>
    
    int max(int a, int b)
    {
        return a > b ? a : b;
    }
    
    int main(void)
    {
        int (*p)(int, int); //函数指针的定义
        //int (*p)();       //函数指针的另一种定义方式,不过不建议使用
        //int (*p)(int a, int b);   //也可以使用这种方式定义函数指针
        
        p = max;    //函数指针初始化
    
        int ret = p(10, 15);    //函数指针的调用
        //int ret = (*max)(10,15);
        //int ret = (*p)(10,15);
        //以上两种写法与第一种写法是等价的,不过建议使用第一种方式
        printf("max = %d \n", ret);
        return 0;
    }
    

    上面这个函数的功能也十分简单,就是求两个数中较大的一个数。值得注意的是通过函数指针调用的方式。
    首先代码里提供了3种函数指针定义的方式,这三种方式都是正确的,比较推荐第一种和第三种定义方式。然后对函数指针进行初始化,前面已经提到过了,直接将函数名赋值给函数指针变量名即可。
    上述代码运行的结果如下:
    在这里插入图片描述
    调用的时候,既可以直接使用函数指针调用,也可以通过函数指针所指向的值去调用。(*p)所代表的就是函数指针所指向的值,也就是函数本身,这样调用自然不会有问题。有兴趣的同学可以去试一试。

    为什么要使用函数指针?

    那么,有不少人就觉得,本来很简单的函数调用,搞那么复杂干什么?其实在这样比较简单的代码实现中不容易看出来,当项目比较大,代码变得复杂了以后,函数指针就体现出了其优越性。
    举个例子,如果我们要实现数组的排序,我们知道,常用的数组排序方法有很多种,比如快排,插入排序,冒泡排序,选择排序等,如果不管内部实现,你会发现,除了函数名不一样之外,返回值,包括函数入参都是相同的,这时候如果要调用不同的排序方法,就可以使用指针函数来实现,我们只需要修改函数指针初始化的地方,而不需要去修改每个调用的地方(特别是当调用特别频繁的时候)。

    回调函数

    函数指针的一个非常典型的应用就是回调函数
    什么是回调函数?
    回调函数就是一个通过指针函数调用的函数。其将函数指针作为一个参数,传递给另一个函数。
    回调函数并不是由实现方直接调用,而是在特定的事件或条件发生时由另外一方来调用的。
    同样我们来看一个回调函数的例子:

    文件:callback.c

    #include<stdio.h>
    #include<stdlib.h>
    
    //函数功能:实现累加求和
    int func_sum(int n)
    {
            int sum = 0;
            if (n < 0)
            {
                    printf("n must be > 0\n");
                    exit(-1);
            }
            for (int i = 0; i < n; i++)
            {
                    sum += i;
            }
            return sum;
    }
    
    //这个函数是回调函数,其中第二个参数为一个函数指针,通过该函数指针来调用求和函数,并把结果返回给主调函数
    int callback(int n, int (*p)(int))
    {
            return p(n);
    }
    
    int main(void)
    {
            int n = 0;
            printf("please input number:");
            scanf("%d", &n);
            printf("the sum from 0 to %d is %d\n", n, callback(n, func_sum));       //此处直接调用回调函数,而不是直接调用func_sum函数
            return 0;
    }
    

    上面这个简单的demo就是一个比较典型的回调函数的例子。在这个程序中,回调函数callback无需关心func_sum是怎么实现的,只需要去调用即可。
    这样的好处就是,如果以后对求和函数有优化,比如新写了个func_sum2函数的实现,我们只需要在调用回调函数的地方将函数指针指向func_sum2即可,而无需去修改callback函数内部。
    以上代码的输出结果如下:
    在这里插入图片描述
    回调函数广泛用于开发场景中,比如信号函数、线程函数等,都使用到了回调函数的知识。

    展开全文
  • 指针数组 首先从名字就可以知道这是一个数组,是存放指针的数组。 先看几种指针数组: 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;
    }




    展开全文
  • 详解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(* )( )表示函数指针,两者结合起来就是指向函数指针数组的指针。

    展开全文
  • 函数指针(指向函数的指针) 与数据项类似,函数也有自己的地址。函数的地址是存储其机器代码的内存的开始地址。例如,可以编写将另一个函数的地址作为参数的函数,这样第一个函数将能够找到第二个函数,并运行它。...
  • C++函数指针、指针函数、返回值为函数指针的函数浅谈 引言 函数指针、指针函数是C中重要而容易混淆的概念,博主将通过两个实例来说明这两个截然不同的概念。 而返回值为函数指针的指针函数就更难理解了,放在文章的...
  • c语言函数指针_指针函数_返回值是函数指针

    千次阅读 多人点赞 2019-03-06 17:38:43
    函数指针作为函数的返回值 1.指针函数的定义 顾名思义,指针函数即返回指针的函数。其一般定义形式如下: 类型名 *函数名(函数参数表列); 其中,后缀运算符括号“()”表示这是一个函数,其前缀运算符星号“*”...
  • 详解函数指针和类成员函数指针

    千次阅读 多人点赞 2017-11-12 21:35:56
    我觉得要理解这个问题,以及要理解后面的函数指针和类成员函数指针,没有什么比从计算机原理的角度来理解更容易了。这里就简要回顾一下相关知识。 众所周知,计算机(图灵机)执行程序的基本流程就是:取指令->执行...
  • 函数指针函数指针类型

    千次阅读 2018-09-29 08:48:59
    函数指针 1. 定义 每一个函数都占用一段内存单元,它们有一个起始地址,指向函数入口地址的指针称为函数指针。 注意:函数指针的本质是一个指针变量,且指针指向的函数的入口地址 2. 语法 指向函数的指针变量...
  • 其中,后缀运算符括号"()"表示这是一个函数,其前缀运算符星号"*"表示此函数指针函数,其函数值为指针,即它带回来的值的类型为指针,当调用这个函数后,将得到一个"指向返回值为…的指针(地址),"类型名"表示...
  • C语言中函数指针和回调函数的详解

    万次阅读 多人点赞 2019-05-18 23:10:01
    函数指针:指向函数的指针变量。 因此“函数指针”本身首先应是指针变量,只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样,这里是指向函数。如前所述,C在编译时,每一个函数都有一个...
  • 就像自定义数据类型一样,我们也可以先定义一个函数指针类型,然后再用这个类型来申明函数指针变量。 我先给你一个自定义数据类型的例子。 typedef int* PINT; //为int* 类型定义了一个PINT的别名 int main
  • C语言 函数指针和指针函数用法

    千次阅读 2020-04-03 13:43:36
    函数指针和指针函数,在学习 C 语言的时候遇到这两个东西简直头疼,当然还有更头疼的,比如什么函数指针函数、指针函数指针、数组指针、指针数组、函数指针数组等等,描述越长其定义就越复杂,当然理解起来就越难,...
  • C++类成员函数指针使用介绍

    万次阅读 多人点赞 2019-09-21 16:07:49
    在之前写过的博客中有介绍过函数指针和指针函数的区别和简单用法(文章在这里),当时的Demo非常简单,都是C语言的写法,但是当在C++中直接像C那样使用类成员函数指针时就会报错:reference to non-static member ...
  • 使用 typedef 定义函数指针,更优雅的使用函数指针

    万次阅读 多人点赞 2018-08-24 09:23:56
    关于函数指针的介绍,这里就不做过多说明了,不了解的同学可以看看这篇博客: https://blog.csdn.net/afei__/article/details/80549202   使用 typedef 定义函数指针 通过下面这个例子,我们看看 typedef 是...
  • 函数指针函数指针数组,函数指针数组的指针

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

    千次阅读 2021-01-19 18:04:56
    首先问大家一句,什么是函数指针? 肯定有的人会这样回答,函数指针?不就是指向函数地址的一个指针吗?或者就是一个存放着一个函数首地址的变量? 当然,那些有点底层基础的肯定会这样说,函数就是一堆连续的机器码...
  • 就像自定义数据类型一样,我们也可以先定义一个函数指针类型,然后再用这个类型来申明函数指针变量。 我先给你一个自定义数据类型的例子。 typedef int* PINT; //为int* 类型定义了一个PINT的别名 int main() {...
  • 函数指针

    千次阅读 2019-06-05 17:21:03
    函数指针指向的函数而非对象。与其他指针一样,函数指针也指向特定的类型。函数的类型是由返回值和参数列表决定,与函数名无关。例如: //比较两个字符串的长度 bool lenghtCompare(const string &s1, const ...
  • C++ 类成员函数的函数指针

    万次阅读 多人点赞 2018-08-23 18:40:17
    当我们在 C++ 中直接像 C 那样使用类的成员函数指针时,通常会报错,提示你不能使用非静态的函数指针: reference to non-static member function must be called 两个解决方法: 把非静态的成员方法改成静态的...
  • C++函数指针和回调函数

    千次阅读 2019-03-06 23:44:32
    什么是函数指针 函数指针就是指向函数的指针,指向某种特定的类型。函数的类型由它的返回类型和形参类型共同决定,与函数名无关,例如: bool lengthCompare(const string &amp;amp;, const string &amp;...
  • 如何用函数指针调用函数

    千次阅读 2020-07-10 09:23:48
    先举一个用函数指针调用函数的例子 int Func(int x); /*声明一个函数*/ int (*p) (int x); /*定义一个函数指针*/ p = Func; /*将Func函数的首地址赋给指针变量p*/ int Func(int x); 这一句是声明一个函数,使我们...
  • 一、函数指针的定义 一个函数总是占用一段连续的内存区域,函数名在表达式中有时也会被转换为该函数所在内存区域的首地址,这和数组名非常类似。 我们可以把函数的这个首地址(或称入口地址)赋予一个指针变量,即...
  • 指针数组与数组指针   当我们在学习指针与数组时总会遇到两个令人容易混淆的概念:数组指针指针数组。   在这里数组指针是指向数组的指针,其本质为指针指向的对象是数组。由于数组的形式多样所以数组指针的...
  • C++ 类中函数指针的使用

    千次阅读 2021-04-17 14:33:50
    文章目录函数指针用法类中的成员函数接收函数指针情况1情况2情况3总结 函数指针用法 函数指针可以作为一个函数的参数,传不同的函数指针给这个函数就可以让其实现不能的功能。从而我们可以复用这个函数剩余的大部分...
  • 函数指针函数指针是指向可执行代码段或调用可执行代码段的信息块的指针,而不是指向某种数据的指针。函数指针是将函数当做普通数据那样存储和管理。函数指针有一种固定的形式,就是包含一个确定的返回值类型和若干...
  • 函数指针指向的是函数而非对象。和其他类型一样,函数指针指向某种特定类型。因为函数的类型由它的返回类型和形参类型共同决定,与函数名无关,所以想要声明一个函数指针,只需要用指针替换函数名即可,例如:比较...
  • C语言--函数指针的用法总结

    千次阅读 2018-05-15 21:54:22
    一个函数在编译时被分配一个入口地址,这个入口地址就称为函数的指针。 函数名代表函数的入口地址,这一点和数组一样。我们可以用一个指针变量来存放这...这是通常调用方法,其实我们可以定义一个函数指针,通过指...
  • 指针函数和函数指针的理解与应用

    千次阅读 多人点赞 2019-02-11 13:11:01
    指针函数 指针函数, 即返回值为指针函数, 本质上是一个函数, 我们先看下面实例: #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;time.h&amp;gt; int year; int mon; int day; ...
  • c++ 函数指针

    万次阅读 多人点赞 2019-06-15 21:41:38
    函数指针基础: 1. 获取函数的地址 2. 声明一个函数指针 3.使用函数指针来调用函数 获取函数指针: 函数的地址就是函数名,要将函数作为参数进行传递,必须传递函数名。 声明函数指针 声明指针时,必须指定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,388,378
精华内容 555,351
关键字:

函数指针