自定义指向函数的指针的数据类型在理解上比其它类型较难以理解.
比如,自定义一个指向int (int,int);的函数的指针数据类型,
是这样做,typedef int (*PointType)(int,int) ;
这样看起来是不是很难理解.我们可以先看一看,定义一个指向函数的指针变量的
方法:int (*p)(int,int); .我们可以把它这样理解为:
int (*)(int,int) p;这样看待是不是有点像定义变量一样.
然后,我们把typedef int (*PointType)(int,int) ;
把它看成 typedef int (*)(int,int) PointType;就是更容易理解.
所以:
PointType p;
相当于int (*p)(int,int);了.
(注意在上面提到的 int (*p)(int,int); 看作int (*)(int,int) p;
不是真的可以这样做,只是对你理解问题容易一点. 同理typedef int
(*)(int,int) PointType
)
说了这么多就举一个例子吧:
#include<stdio.h>
#include<conio.h>
typedef int (*PointType)(int,int);
int function(int,int);
int main()
{
 PointType p;
 p=function;
 clrscr();
 p(1,2);
 getch();
}
int function(int d1,int d2)
{
 printf(“%d %dn”,d1,d2);
}
希望大家能通过此次的讲解,对自定义指向函数的指针的数据类型有更多地了解.

typedef作用简介

C函数指针简单用例,函数指针用例

(1)函数指针:
可以指向 一类 固定形参类型和返回值类型 的函数 的指针
声明:
int fun(int, int)
    ||
    /
int (*pfun)(int, int)

pfun就是函数指针(变量)

调用:

    d = pfun(a, b);
    e = (*pfun)(a, b);

#####指针函数
int *fun(int, int);
int *(fun(int, int));
#####

 

/*ex01.c*/
#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 argc, char *argv[]) {
    int (*pfun)(int, int);
    pfun = max;
    int a = 0, b = 0, c = 0, d = 0, e = 0;
    fscanf(stdin, “%d%d”, &a, &b);

    c = max(a, b);
    d = pfun(a, b);
    e = (*pfun)(a, b);
    fprintf(stdout, “%dn”, c);
    fprintf(stdout, “%dn”, d);
    fprintf(stdout, “%dn”, e);
    return 0;
}

(2)定义函数指针的类型 可以声明函数指针变量
typedef int (*Pfun)(int, int);

Pfun就是自定义函数指针类型

Pfun pfun = min;

创建Pfun类型变量pfun并将min函数赋值它

 

/*ex02.c*/
#include <stdio.h>

typedef int (*Pfun)(int, int);

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 argc, char *argv[]) {
    Pfun pfun = min;
    int a = 0, b = 0, c = 0, d = 0, e = 0;
    fscanf(stdin, “%d%d”, &a, &b);

    c = min(a, b);
    d = pfun(a, b);
    e = (*pfun)(a, b);
    fprintf(stdout, “%dn”, c);
    fprintf(stdout, “%dn”, d);
    fprintf(stdout, “%dn”, e);
    return 0;
    return 0;
}

(3)可以将函数作为参数传入另一函数
#include <stdio.h>

typedef int (*Pfun)(int, int);

int max(int a, int b) {
    return (a > b ? a : b);
}
int min(int a, int b) {
    return (a < b ? a : b);
}

int dofun(Pfun pfun, int a, int b)
{  //用Pfun类型的函数指针变量pfun接收传入的函数
    return pfun(a, b);
}

int main(int argc, char *argv[]) {
    Pfun pfun = min;
    int a = 0, b = 0, c = 0, d = 0, e = 0, f = 0;
    fscanf(stdin, “%d%d”, &a, &b);

    c = min(a, b);
    d = pfun(a, b);
    e = (*pfun)(a, b);
    f = dofun(min, a,
b);      //将min函数作为参数传入dofun,dofun用相应类型的函数指针接收
    fprintf(stdout, “%dn”, c);
    fprintf(stdout, “%dn”, d);
    fprintf(stdout, “%dn”, e);
    fprintf(stdout, “%dn”, e);
    return 0;
    return 0;
}

 

c语言的函数指针举个例子

mxl033 回答是对的。
void*
func(void)这种不是函数指针,而只是一个返回一个指针的函数。是函数,而不是指针。

typedef void (*pFunc)(); //
函数指针类型声明,指向的是无返回无参数的函数.
typedef int (*pFunc1)(int,int); //
函数指针类型声明,指向的是返回int型,参数有两个int型的函数。

void func1()
{
printf(“This is func1n”);
}

int add(int a, int b)
{
return a + b;

}
int main(void)
{
pFunc p = func1; // 函数指针复制
p();

// p = add; 错误,返回类型,和参数都不符合

pFunc1 p1 = add;

p1(1,2) // 返回3

return 0;
}

楼主可以慢慢体会,不懂再问吧
 

•我们可以使用typedef关键字为各种数据类型定义一个新名字(别名)。

C语言 函数指针 的调用问题?函数指针 怎使用?最好有例子

有函数: int fun(int a,int b);
要定义指向该函数的指针
对比指向 int a; 的指针
int *p; p = &a;
p的定义是怎么来的?
首先要保证p是一个指针类型
写下(*p),
然后,考虑下p的基类型,
p的基类型就是变量a的类型int
将int 放在(*p)前面就行了
int (*p);
括号可以省略,就成了 int *p;

同理
想要实现 pf = &fun;
(*pf) 将pf定义为一个指针,
将fun的类型作为pf的基类型
fun相当于一个 int (int a,int b)类型的量
int (int a,int b) (*pf);
基类型中有圆括号和中括号要后移
int (*pf)(int a,int b) ;//括号不能省略
pf = &fun;
调用时
(*pf)(3,4); pf(3,4)都可以
 

(1)函数指针:
可以指向 一类 固定形参类型和返回值类型 的函数 的指针 声明: int fun(int,
int) || / int (*p…

 

  1#include <stdio.h>

 2

 3 typedef int Integer;

 4 typedef unsigned int UInterger;

 5

 6 typedef float Float;

 7

 8 int main(int argc, const char * argv[]) {

 9     Integer i = -10;

10     UInterger ui = 11;

11    

12     Float f = 12.39f;

13    

14     printf(“%d  %d  %.2f”, i, ui, f);

15    

16     return 0;

17 }

•也可以在别名的基础上再起一个别名

•typedef int Integer;

•typedef Integer MyInteger;

 

二、typedef与指针

•除开可以给基本数据类型起别名,typedef也可以给指针起别名

 1 #include <stdio.h>

 2

 3 typedef char *String;

 4

 5 int main(int argc, const char * argv[]) {

 6     // 相当于char *str = “This is a string!”;

 7     String str = “This is a string!”;

 8    

 9     printf(“%s”, str);

10    

11     return 0;

12 }

三、typedef与结构体


 1 // 定义一个结构体

 2 struct MyPoint {

 3     float x;

 4     float y;

 5 };

 6

 7 int main(int argc, const char * argv[]) {

 8     // 定义结构体变量

 9     struct MyPoint p;

10     p.x = 10.0f;

11     p.y = 20.0f;

12    

13     return 0;

14 }


2.使用typedef给结构体起别名


 1 // 定义一个结构体

 2 struct MyPoint {

 3     float x;

 4     float y;

 5 };

 6

 7 // 起别名

 8 typedef struct MyPoint Point;

 9

10 int main(int argc, const char * argv[]) {

11     // 定义结构体变量

12     Point p;

13     p.x = 10.0f;

14     p.y = 20.0f;

15    

16     return 0;

17 }



// 定义一个结构体,顺便起别名

typedef struct MyPoint {

    float x;

    float y;

} Point;

甚至可以省略结构体名称:

typedef struct {

    float x;

    float y;

} Point;


三、typedef与指向结构体的指针

 

 1 #include <stdio.h>

 2

 3 // 定义一个结构体并起别名

 4 typedef struct {

 5     float x;

 6     float y;

 7 } Point;

 8

 9 // 起别名

10 typedef Point *PP;

11

12 int main(int argc, const char * argv[]) {

13     // 定义结构体变量

14     Point point = {10, 20};

15    

16     // 定义指针变量

17     PP p = &point;

18    

19     // 利用指针变量访问结构体成员

20     printf(“x=%f,y=%f”, p->x, p->y);

21     return 0;

22 }

五、typedef与指向函数的指针


1 #include <stdio.h>

 2

 3 // 定义一个sum函数,计算a跟b的和

 4 int sum(int a, int b) {

 5     int c = a + b;

 6     printf(“%d + %d = %d”, a, b, c);

 7     return c;

 8 }

 9

10 int main(int argc, const char * argv[]) {

11     // 定义一个指向sum函数的指针变量p

12     int (*p)(int, int) = sum;

13    

14     // 利用指针变量p调用sum函数

15     (*p)(4, 5);

16    

17     return 0;

18 }

 



 1 include <stdio.h>

 2

 3 // 定义一个sum函数,计算a跟b的和

 4 int sum(int a, int b) {

 5     int c = a + b;

 6     printf(“%d + %d = %d”, a, b, c);

 7     return c;

 8 }

 9

10 typedef int (*MySum)(int, int);

11

12 int main(int argc, const char * argv[]) {

13     // 定义一个指向sum函数的指针变量p

14     MySum p = sum;

15    

16     // 利用指针变量p调用sum函数

17     (*p)(4, 5);

18    

19     return 0;

20 }

六、typedef与#define 


1 typedef char *String;

2

3 int main(int argc, const char * argv[]) {

4     String str = “This is a string!”;

5     return 0;

6 }


1 #define String char *

2

3 int main(int argc, const char * argv[]) {

4     String str = “This is a string!”;

5     return 0;

6 }

 ———

 1 typedef char *String1;

 2

 3 #define String2 char *

 4

 5 int main(int argc, const char * argv[]) {

 6     String1 str1, str2;

 7    

 8     String2 str3, str4;

 9     return 0;

10 }

•第一行给char
*起了个别名String1,第2行定义了宏String2。然后在第6、第8行定义了4个变量。

•重点来了,注意:在这种情况下,只有str1、str2、str3才是指向char类型的指针变量,str4只是个char类型的变量。

• 

•下面简单分析一下原因:

•* 如果连续声明两个int类型的变量,我们可以这样写:

•int a, b;

•上面的代码相当于:

•int a;

•int b;

•* 以此类推

•1 typedef char *String1;

•2    

•3 String1 str1, str2;

•经过typedef处理后,String1也算是一种数据类型,所以第3行代码相当于

•1 String1 str1;

•2 String1 str2;

•由于String1就是char *,所以上面的两行代码等于

•char *str1;

•char *str2;

 

•* 再看看宏定义的情况

•1 #define String2 char *

•2

•3 String2 str3, str4;

•因为宏定义纯粹是字符串替换,用char *代替String2,所以第3行代码相当于

•char * str3, str4;

•其实也就相当于:

•char * str3;

•char str4;

•可以看出,只有str4是基本数据类型,str1、str2、str3都是指针类型。

•所以,以后给类型起别名,最好使用typedef,而不是使用#define