打印
[牛人杂谈]

函数指针

[复制链接]
762|16
手机看帖
扫描二维码
随时随地手机跟帖
跳转到指定楼层
楼主
wahahaheihei|  楼主 | 2016-4-30 21:51 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  在C语言中,函数名也是指针变量,比如创建了一个add(int n,int m)的函数的同时也创建了一个名为add的指针变量,因此我们可以把函数指针当作一种类型为它赋值、当作参数传递等操作

C语言创建函数指针的公式:
    返回类型 (*指针变量)(参数类型)


#include <stdio.h>

int add(int n,int m){
    return n+m;
}

int sub(int n,int m){
    return n-m;
}

int main(){
    int n=10;
    int m=5;
    int (*calculate)(int,int);//创建一个名为calculate的变量
    calculate=add;
    int result=calculate(n,m);//相当于add(n,m);
    printf("%i\n",result);
    calculate=sub;
    result=calculate(n,m);//相当于sub(n,m);
    printf("%i\n",result);
    return 0;
}


  虽然函数指针是指针,但是在使用的时候我们可以省略"*"的写法比如上面的calculate(n,m),我们不必写成(*calculate)(n,m);需要注意的是函数指针只接受和它的返回值和参数都相同的函数地址

沙发
wahahaheihei|  楼主 | 2016-4-30 22:04 | 只看该作者
函数指针数组
#include <stdio.h>

enum response_type{DUMP,SECOND_CHANCE,MARRIAGE};
typedef struct{
    char *name;
    enum response_type type;
} response;

void dump(response r){
    printf("dump %s\n",r.name);
}

void second_chance(response r){
    printf("second_chance %s\n",r.name);
}

void marriage(response r){
    printf("marriage %s\n",r.name);
}

int main(){
    response r[]={{"Mike",DUMP},{"Luis",SECOND_CHANCE},{"Matt",SECOND_CHANCE},{"William",MARRIAGE}};
    void (*replies[])(response)={dump,second_chance,marriage};//创建函数指针数组
    int i;
    for(i=0;i<4;i++){
        replies[r[i].type](r[i]);
    }
    return 0;
}



使用特权

评论回复
板凳
huangcunxiake| | 2016-4-30 22:27 | 只看该作者
函数指针是指针,但是比较难以理解,通过函数 地址调用函数的功能。

使用特权

评论回复
地板
wahahaheihei|  楼主 | 2016-5-21 12:38 | 只看该作者
函数指针应该是存放函数内存位置的地址,且该变量被标记为一个函数。

使用特权

评论回复
5
killer2014| | 2016-5-25 10:39 | 只看该作者
楼主分析得有道理, 赞一个

使用特权

评论回复
6
orangebanana| | 2016-5-25 14:36 | 只看该作者
函数名也是指针变量?我头一次听说,能否详细讲解一下

使用特权

评论回复
7
Thethree| | 2016-5-26 21:05 | 只看该作者
函数指针和指针函数是有区别的吧

使用特权

评论回复
8
wahahaheihei|  楼主 | 2016-5-27 20:17 | 只看该作者

往往,我们一提到指针函数和函数指针的时候,就有很多人弄不懂。下面就由南宁达内小编详细为大家介绍C语言中指针函数和函数指针。

  • 一、指针函数
    当一个函数声明其返回值为一个指针时,实际上就是返回一个地址给调用函数,以用于需要指针或地址的表达式中。
    格式:
    类型说明符 * 函数名(参数)
    当然了,由于返回的是一个地址,所以类型说明符一般都是int。
    例如:
    int *GetDate();  int * aaa(int,int);
    函数返回的是一个地址值,经常使用在返回数组的某一元素地址上。
    int * GetDate(int wk,int dy);  main()
    {  int wk,dy;
    do {  printf("Enter week(1-5)day(1-7)\n");  scanf("%d%d",&wk,&dy);
    }  while(wk<1||wk>5||dy<1||dy>7);
    printf("%d\n",*GetDate(wk,dy));  }
    int * GetDate(int wk,int dy)  {
    static int calendar[5][7]=  {
    {1,2,3,4,5,6,7},  {8,9,10,11,12,13,14},
    {15,16,17,18,19,20,21},  {22,23,24,25,26,27,28},
    {29,30,31,-1}  };
    return &calendar[wk-1][dy-1];  }
    程序应该是很好理解的,子函数返回的是数组某元素的地址。输出的是这个地址里的值。
  • 二、函数指针
    指向函数的指针包含了函数的地址,可以通过它来调用函数。声明格式如下:
    类型说明符 (*函数名)(参数)
    其实这里不能称为函数名,应该叫做指针的变量名。这个特殊的指针指向一个返回整型值的函数。指针的声明笔削和它指向函数的声明保持一致。
    指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号,就变成了一个返回整型指针的函数的原型声明。
    例如:
    void (*fptr)();
    把函数的地址赋值给函数指针,可以采用下面两种形式:
    fptr=&Function;  fptr=Function;
    取地址运算符&不是必需的,因为单单一个函数标识符就标号表示了它的地址,如果是函数调用,还必须包含一个圆括号括起来的参数表。可以采用如下两种方式来通过指针调用函数:
    x=(*fptr)();  x=fptr();
    第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式,因为它明确指出是通过指针而非函数名来调用函数的。下面举一个例子:
    void (*funcp)();  void FileFunc(),EditFunc();
    main()  {
    funcp=FileFunc;  (*funcp)();
    funcp=EditFunc;  (*funcp)();
    }  void FileFunc()
    {   printf("FileFunc\n");
    }  void EditFunc()
    {  printf("EditFunc\n");  }
    程序输出为:
    FileFunc  EditFunc
  • 三、指针的指针
    指针的指针看上去有些令人费解。它们的声明有两个星号。例如:
    char ** cp;
    如果有三个星号,那就是指针的指针的指针,四个星号就是指针的指针的指针的指针,依次类推。当你熟悉了简单的例子以后,就可以应付复杂的情况了。当然,实际程序中,一般也只用到二级指针,三个星号不常见,更别说四个星号了。
    指针的指针需要用到指针的地址。
    char c='A';  char *p=&c;  char **cp=&p;
    通过指针的指针,不仅可以访问它指向的指针,还可以访问它指向的指针所指向的数据。
    下面就是几个这样的例子:
    char *p1=*cp;  char c1=**cp;
    你可能想知道这样的结构有什么用。利用指针的指针可以允许被调用函数修改局部指针变量和处理指针数组。
    void FindCredit(int **);  main()
    {  int vals[]={7,6,5,-4,3,2,1,0};
    int *fp=vals;  FindCredit(&fp);
    printf("%d\n",*fp);  }
    void FindCredit(int ** fpp)  {
    while(**fpp!=0)  if(**fpp<0) break;
    else (*fpp)++;  }
    首先用一个数组的地址初始化指针fp,然后把该指针的地址作为实参传递给函数FindCredit()。FindCredit()函数通过表达式**fpp间接地得到数组中的数据。为遍历数组以找到一个负值,FindCredit()函数进行自增运算的对象是调用者的指向数组的指针,而不是它自己的指向调用者指针的指针。语句(*fpp)++就是对形参指针指向的指针进行自增运算的。但是因为*运算符高于++运算符,所以圆括号在这里是必须的,如果没有圆括号,那么++运算符将作用于二重指针fpp上。
  • 四、指向指针数组的指针
    指针的指针另一用法旧处理指针数组。有些程序员喜欢用指针数组来代替多维数组,一个常见的用法就是处理字符串。
    char *Names[]=  {
    "Bill",  "Sam",
    "Jim",  "Paul",
    "Charles",  0
    };  
    main()  {  char **nm=Names;  while(*nm!=0) printf("%s\n",*nm++);
    }
    先用字符型指针数组Names的地址来初始化指针nm。每次printf()的调用都首先传递指针nm指向的字符型指针,然后对nm进行自增运算使其指向数组的下一个元素(还是指针)。注意完成上述认为的语法为*nm++,它首先取得指针指向的内容,然后使指针自增。


使用特权

评论回复
9
wahahaheihei|  楼主 | 2016-5-27 20:18 | 只看该作者
指针函数与函数指针的区别

一、
在学习arm过程中发现这“指针函数”与“函数指针”容易搞错,所以今天,我自己想一次把它搞清楚,找了一些资料,首先它们之间的定义:
1、指针函数是指带指针的函数,即本质是一个函数。函数返回类型是某一类型的指针
     类型标识符    *函数名(参数表)
      int *f(x,y);
首先它是一个函数,只不过这个函数的返回值是一个地址值。函数返回值必须用同类型的指针变量来接受,也就是说,指针函数一定有函数返回值,而且,在主调函数中,函数返回值必须赋给同类型的指针变量。
表示:
float *fun();
float *p;
p = fun(a);
注意指针函数与函数指针表示方法的不同,千万不要混淆。最简单的辨别方式就是看函数名前面的指针*号有没有被括号()包含,如果被包含就是函数指针,反之则是指针函数。
来讲详细一些吧!请看下面
指针函数:
    当一个函数声明其返回值为一个指针时,实际上就是返回一个地址给调用函数,以用于需要指针或地址的表达式中。
    格式:
         类型说明符 * 函数名(参数)
    当然了,由于返回的是一个地址,所以类型说明符一般都是int。

    例如:int *GetDate();
          int * aaa(int,int);
    函数返回的是一个地址值,经常使用在返回数组的某一元素地址上。


        int * GetDate(int wk,int dy);

        main()
        {
            int wk,dy;
            do
            {
                printf(Enter week(1-5)day(1-7)\n);
                scanf(%d%d,&wk,&dy);
            }
            while(wk<1||wk>5||dy<1||dy>7);
            printf(%d\n,*GetDate(wk,dy));
        }

        int * GetDate(int wk,int dy)
        {
            static int calendar[5][7]=
            {
               {1,2,3,4,5,6,7},
               {8,9,10,11,12,13,14},
               {15,16,17,18,19,20,21},
               {22,23,24,25,26,27,28},
               {29,30,31,-1}
            };
            return &calendar[wk-1][dy-1];
        }
        
程序应该是很好理解的,子函数返回的是数组某元素的地址。输出的是这个地址里的值。
2、函数指针是指向函数的指针变量,即本质是一个指针变量。
 int (*f) (int x); /* 声明一个函数指针 */
 f=func; /* 将func函数的首地址赋给指针f */
指向函数的指针包含了函数的地址,可以通过它来调用函数。声明格式如下:
        类型说明符 (*函数名)(参数)
    其实这里不能称为函数名,应该叫做指针的变量名。这个特殊的指针指向一个返回整型值的函数。指针的声明笔削和它指向函数的声明保持一致。

        指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号,就变成了一个返回整型指针的函数的原型声明。
    例如:
        void (*fptr)();
   
把函数的地址赋值给函数指针,可以采用下面两种形式:
        fptr=&Function;
        fptr=Function;
   
取地址运算符&不是必需的,因为单单一个函数标识符就标号表示了它的地址,如果是函数调用,还必须包含一个圆括号括起来的参数表。
    可以采用如下两种方式来通过指针调用函数:
        x=(*fptr)();
        x=fptr();
   
第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式,因为它明确指出是通过指针而非函数名来调用函数的。下面举一个例子:

        void (*funcp)();
        void FileFunc(),EditFunc();

        main()
        {
            funcp=FileFunc;
            (*funcp)();
            funcp=EditFunc;
            (*funcp)();
        }

        void FileFunc()
        {
            printf(FileFunc\n);
        }

        void EditFunc()
        {
            printf(EditFunc\n);
        }

        
程序输出为:
            FileFunc
            EditFunc
  
主要的区别是一个是指针变量,一个是函数。在使用是必要要搞清楚才能正确使用
二、指针的指针
    指针的指针看上去有些令人费解。它们的声明有两个星号。例如:
        char ** cp;
   
如果有三个星号,那就是指针的指针的指针,四个星号就是指针的指针的指针的指针,依次类推。当你熟悉了简单的例子以后,就可以应付复杂的情况了。当然,实际程序中,一般也只用到  二级指针,三个星号不常见,更别说四个星号了。
    指针的指针需要用到指针的地址。
        char c='A';
        char *p=&c;
        char **cp=&p;
   
通过指针的指针,不仅可以访问它指向的指针,还可以访问它指向的指针所指向的数据。下面就是几个这样的例子:
        char *p1=*cp;
        char c1=**cp;
   
你可能想知道这样的结构有什么用。利用指针的指针可以允许被调用函数修改局部指针变量和处理指针数组。

        void FindCredit(int **);

        main()
        {
            int vals[]={7,6,5,-4,3,2,1,0};
            int *fp=vals;
            FindCredit(&fp);
            printf(%d\n,*fp);
        }

        void FindCredit(int ** fpp)
        {
            while(**fpp!=0)
            if(**fpp<0) break;
            else (*fpp)++;
        }

   
首先用一个数组的地址初始化指针fp,然后把该指针的地址作为实参传递给函数FindCredit()。FindCredit()函数通过表达式**fpp间接地得到数组中的数据。为遍历数组以找到一个负值,FindCredit()函数进行自增运算的对象是调用者的指向数组的指针,而不是它自己的指向调用者指针的指针。语句(*fpp)++就是对形参指针指向的指针进行自增运算的。但是因为*运算符高于++运算符,所以圆括号在这里是必须的,如果没有圆括号,那么++运算符将作用于二重指针fpp上。

三、指向指针数组的指针
    指针的指针另一用法旧处理指针数组。有些程序员喜欢用指针数组来代替多维数组,一个常见的用法就是处理字符串。

        char *Names[]=
        {
             Bill,
             Sam,
             Jim,
             Paul,
             Charles,
             0
        };

        main()
        {
            char **nm=Names;
            while(*nm!=0) printf(%s\n,*nm++);
        }

   
先用字符型指针数组Names的地址来初始化指针nm。每次printf()的调用都首先传递指针nm指向的字符型指针,然后对nm进行自增运算使其指向数组的下一个元素(还是指针)。注意完成上述认为的语法为*nm++,它首先取得指针指向的内容,然后使指针自增。
    注意数组中的最后一个元素被初始化为0,while循环以次来判断是否到了数组末尾。具有零值的指针常常被用做循环数组的终止符。程序员称零值指针为空指针(NULL)。采用空指针作为终止符,在树种增删元素时,就不必改动遍历数组的代码,因为此时数组仍然以空指针作为结束。



使用特权

评论回复
10
keenboyee| | 2016-5-27 21:09 | 只看该作者

使用特权

评论回复
11
稳稳の幸福| | 2016-5-29 18:05 | 只看该作者
*号一多,我就懵了。

使用特权

评论回复
12
734774645| | 2016-5-31 18:51 | 只看该作者
int * aaa(int,int);
这个是函数的指针吗

使用特权

评论回复
13
heisexingqisi| | 2016-5-31 19:33 | 只看该作者
函数指针是指向函数的指针变量。 因而“函数指针”本身首先应是指针变量,只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样,这里是指向函数。

使用特权

评论回复
14
heisexingqisi| | 2016-5-31 19:33 | 只看该作者
在学习arm过程中发现这“指针函数”与“函数指针”容易搞错,所以今天,我自己想一次把它搞清楚,找了一些资料,首先它们之间的定义:
1、指针函数是指带指针的函数,即本质是一个函数。函数返回类型是某一类型的指针
     类型标识符    *函数名(参数表)
      int *f(x,y);

首先它是一个函数,只不过这个函数的返回值是一个地址值。函数返回值必须用同类型的指针变量来接受,也就是说,指针函数一定有函数返回值,而且,在主调函数中,函数返回值必须赋给同类型的指针变量。
表示:
float *fun();
float *p;
p = fun(a);
注意指针函数与函数指针表示方法的不同,千万不要混淆。最简单的辨别方式就是看函数名前面的指针*号有没有被括号()包含,如果被包含就是函数指针,反之则是指针函数。
来讲详细一些吧!请看下面
指针函数:
    当一个函数声明其返回值为一个指针时,实际上就是返回一个地址给调用函数,以用于需要指针或地址的表达式中。
    格式:
         类型说明符 * 函数名(参数)
    当然了,由于返回的是一个地址,所以类型说明符一般都是int。
    例如:int *GetDate();
          int * aaa(int,int);
    函数返回的是一个地址值,经常使用在返回数组的某一元素地址上。

        int * GetDate(int wk,int dy);

        main()
        {
            int wk,dy;
            do
            {
                printf(Enter week(1-5)day(1-7)\n);
                scanf(%d%d,&wk,&dy);
            }
            while(wk<1||wk>5||dy<1||dy>7);
            printf(%d\n,*GetDate(wk,dy));
        }

        int * GetDate(int wk,int dy)
        {
            static int calendar[5][7]=
            {
               {1,2,3,4,5,6,7},
               {8,9,10,11,12,13,14},
               {15,16,17,18,19,20,21},
               {22,23,24,25,26,27,28},
               {29,30,31,-1}
            };
            return &calendar[wk-1][dy-1];
        }
        程序应该是很好理解的,子函数返回的是数组某元素的地址。输出的是这个地址里的值。



2、函数指针是指向函数的指针变量,即本质是一个指针变量。
 int (*f) (int x); /* 声明一个函数指针 */
 f=func; /* 将func函数的首地址赋给指针f */

指向函数的指针包含了函数的地址,可以通过它来调用函数。声明格式如下:
        类型说明符 (*函数名)(参数)
    其实这里不能称为函数名,应该叫做指针的变量名。这个特殊的指针指向一个返回整型值的函数。指针的声明笔削和它指向函数的声明保持一致。
        指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号,就变成了一个返回整型指针的函数的原型声明。
    例如:
        void (*fptr)();
    把函数的地址赋值给函数指针,可以采用下面两种形式:
        fptr=&Function;
        fptr=Function;
    取地址运算符&不是必需的,因为单单一个函数标识符就标号表示了它的地址,如果是函数调用,还必须包含一个圆括号括起来的参数表。
    可以采用如下两种方式来通过指针调用函数:
        x=(*fptr)();
        x=fptr();
    第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式,因为它明确指出是通过指针而非函数名来调用函数的。下面举一个例子:

        void (*funcp)();
        void FileFunc(),EditFunc();

        main()
        {
            funcp=FileFunc;
            (*funcp)();
            funcp=EditFunc;
            (*funcp)();
        }

        void FileFunc()
        {
            printf(FileFunc\n);
        }

        void EditFunc()
        {
            printf(EditFunc\n);
        }

        程序输出为:
            FileFunc
            EditFunc
  
主要的区别是一个是指针变量,一个是函数。在使用是必要要搞清楚才能正确使用

二、指针的指针
    指针的指针看上去有些令人费解。它们的声明有两个星号。例如:
        char ** cp;
    如果有三个星号,那就是指针的指针的指针,四个星号就是指针的指针的指针的指针,依次类推。当你熟悉了简单的例子以后,就可以应付复杂的情况了。当然,实际程序中,一般也只用到  二级指针,三个星号不常见,更别说四个星号了。
    指针的指针需要用到指针的地址。
        char c='A';
        char *p=&c;
        char **cp=&p;
    通过指针的指针,不仅可以访问它指向的指针,还可以访问它指向的指针所指向的数据。下面就是几个这样的例子:
        char *p1=*cp;
        char c1=**cp;
    你可能想知道这样的结构有什么用。利用指针的指针可以允许被调用函数修改局部指针变量和处理指针数组。

        void FindCredit(int **);

        main()
        {
            int vals[]={7,6,5,-4,3,2,1,0};
            int *fp=vals;
            FindCredit(&fp);
            printf(%d\n,*fp);
        }

        void FindCredit(int ** fpp)
        {
            while(**fpp!=0)
            if(**fpp<0) break;
            else (*fpp)++;
        }

    首先用一个数组的地址初始化指针fp,然后把该指针的地址作为实参传递给函数FindCredit()。FindCredit()函数通过表达式**fpp间接地得到数组中的数据。为遍历数组以找到一个负值,FindCredit()函数进行自增运算的对象是调用者的指向数组的指针,而不是它自己的指向调用者指针的指针。语句(*fpp)++就是对形参指针指向的指针进行自增运算的。但是因为*运算符高于++运算符,所以圆括号在这里是必须的,如果没有圆括号,那么++运算符将作用于二重指针fpp上。

三、指向指针数组的指针
    指针的指针另一用法旧处理指针数组。有些程序员喜欢用指针数组来代替多维数组,一个常见的用法就是处理字符串。

        char *Names[]=
        {
             Bill,
             Sam,
             Jim,
             Paul,
             Charles,
             0
        };

        main()
        {
            char **nm=Names;
            while(*nm!=0) printf(%s\n,*nm++);
        }

    先用字符型指针数组Names的地址来初始化指针nm。每次printf()的调用都首先传递指针nm指向的字符型指针,然后对nm进行自增运算使其指向数组的下一个元素(还是指针)。注意完成上述认为的语法为*nm++,它首先取得指针指向的内容,然后使指针自增。
    注意数组中的最后一个元素被初始化为0,while循环以次来判断是否到了数组末尾。具有零值的指针常常被用做循环数组的终止符。程序员称零值指针为空指针(NULL)。采用空指针作为终止符,在树种增删元素时,就不必改动遍历数组的代码,因为此时数组仍然以空指针作为结束。

使用特权

评论回复
15
zhuomuniao110| | 2016-5-31 20:47 | 只看该作者
指向函数的指针包含了函数的地址,可以通过它来调用函数。

使用特权

评论回复
16
zhuotuzi| | 2016-5-31 22:20 | 只看该作者
指针的指针看上去有些令人费解。它们的声明有两个星号。如果有三个星号,那就是指针的指针的指针,四个星号就是指针的指针的指针的指针,依次类推。

使用特权

评论回复
17
wahahaheihei|  楼主 | 2016-5-31 23:04 | 只看该作者
通过指针的指针,不仅可以访问它指向的指针,还可以访问它指向的指针所指向的数据。下面就是几个这样的例子:
        char *p1=*cp;
        char c1=**cp;

好神奇,不懂。

使用特权

评论回复
发新帖 我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则

217

主题

3042

帖子

12

粉丝