函数与指针
指针函数 和 指针形参详解
指针函数和指针形参详解
指针函数（pointer function）是一个返回指针的函数，它的返
回值是一个指向特定类型数据的指针。
这意味着指针函数返回的是一
个地址，可以用于访问指定类型的数据。
指针函数的定义形式类似于普通函数的定义，只不过返回类型是
指针类型。
例如，如果要定义一个指针函数来返回整数数组的首地址，可以使用如下的语法：
```c
int* function_name(parameters){
// 函数体
return pointer_to_array;
}
```
在函数体内部，可以通过运算或者其他方式获得一个指向指定类型数
据的指针，并将它返回。
指针形参（pointer parameter）是一个函数参数，其类型为指针。
指针形参允许函数访问和修改指针所指向的数据。
指针形参的定义形式与其他形参类似，只不过类型是指针类型。
例如，如果要将一个整型指针作为参数传递给函数，可以使用如下的
语法：
```c
void function_name(int* pointer_name){
// 函数体
// 通过指针访问或修改数据
}
```
在函数体内部，可以通过指针形参访问或修改指针指向的数据。
可以使用*操作符来获取指针所指向的值，使用赋值运算符来修改指针所指向的值。
指针函数和指针形参在C语言中可以用于处理复杂数据结构、动态内存分配等问题。
它们可以提供灵活的数据访问和操作方式，让程序员能够更加高效地处理数据。
函数指针的用法
函数指针的用法函数指针是一种指向函数的指针变量，它可以用来间接调用函数。
在C语言中，函数指针通常用于回调函数、动态函数调用等领域。
以下是函数指针的用法：1. 声明函数指针函数指针的声明格式为：返回类型 (*指针变量名)(参数类型列表)。
例如，int (*p)(int, int) 表示 p 是一个指向返回类型为 int，参数类型为 int, int 的函数指针。
2. 定义函数指针定义函数指针时，需要将其指向具体的函数。
例如：int add(int a, int b) {return a + b;}int (*p)(int, int) = add;上述代码定义了一个指针变量 p，它指向函数 add。
这样，我们就可以通过 p 间接调用 add 函数，例如 p(1, 2)。
3. 函数指针作为参数函数指针还可以作为函数的参数。
这种用法通常用于回调函数。
例如：void forEach(int* arr, int length, int (*callback)(int)) {for (int i = 0; i < length; i++) {arr[i] = callback(arr[i]);}}上述代码定义了一个函数 forEach，它接受一个 int 类型的数组和一个函数指针 callback，用于对数组中的每个元素进行操作。
其中，callback 函数的返回值是 int。
这样，我们就可以通过forEach 函数调用不同的 callback 函数，实现不同的操作。
4. 函数指针数组函数指针还可以放在数组中，形成函数指针数组。
例如：int add(int a, int b) {return a + b;}int sub(int a, int b) {return a - b;}int (*funcs[2])(int, int) = {add, sub};上述代码定义了一个名为 funcs 的函数指针数组，它包含两个元素，分别指向 add 函数和 sub 函数。
指向函数的指针定义
指向函数的指针定义指针是一种特殊的变量，它是一种指向内存地址的指针，用于存储和操作内存中的值。
在C/C++中，指针用于指向变量，函数，数组等。
在本文中，我将详细讨论指向函数的指针的定义，声明及其用法。
I.针定义的概念A.针的定义针是一种特殊的变量，定义方式如下：据类型 *指针名 = &变量名；这里，“*”代表指针符号，“&”代表取地址符号，指针名可以自定义，变量名是指针变量指向的内存地址，这里关键的概念是，一个指针变量只能指向一个定义好的变量。
B.针的用法针可以用于访问一个变量的地址，或者可以用它来访问变量中存储的值。
还可以用指针来间接访问和修改变量中存储的值。
II.数指针定义A.数指针的定义数指针是一种特殊的指针，它可以指向一个函数。
函数指针的定义方式如下：据类型 (*指针名)(参数表) = &函数名这里，“*”代表指针符号，“&”代表取地址符号，指针名可以自定义，函数名是指针变量指向的函数，这里关键的概念是，一个函数指针只能指向一个拥有相同参数表的函数。
B.数指针的声明数指针和普通指针一样，在使用之前需要先声明，声明方式如下：据类型 (*指针名)(参数表);C.数指针的用法数指针的用法和普通指针一样，可以用它来调用函数。
函数指针也可以用于函数回调。
D. 使用函数指针的例子下面是一个使用函数指针的例子：#include <stdio.h>//明函数指针int (*pf)(int, int);//义两个函数int add(int x, int y){return x + y;}int sub(int x, int y){return x - y;}int main(){int a = 5, b = 3;// 使用函数指针pf = add;printf(%d + %d = %da, b, pf(a, b));pf = sub;printf(%d - %d = %da, b, pf(a, b));return 0;}III.向函数的指针定义A. 什么是指向函数的指针向函数的指针是一种指向函数的特殊指针，它可以指向一个拥有相同参数表的函数。
函数指针和指针函数用法和区别
函数指针和指针函数用法和区别函数指针和指针函数（pointerfunction）是C语言编程中常用的技术，在一些高级编程技术（例如设计模式）中也有广泛的应用。
它们的概念比较复杂，有时候会让初学者有点晕头，但是一旦理解了它们的用法和区别，大家就会发现它们对于结构化编程的设计有着重要的意义。
本文尝试以最简单的方式阐述函数指针和指针函数的用法和区别。
首先，在我们讨论函数指针和指针函数之前，我们最好以一个函数为例来介绍它们：void foo (int a, int b){int c = a + b;printf(%dc);}foo函数接收两个整数参数a和b，并将它们相加后输出结果。
接下来我们来看看函数指针是什么：函数指针（function pointer）是一种指向函数的指针，它可以把函数的地址保存在指针变量中，这样你就可以通过指针调用函数。
句话说，它实际上指向一个函数，通过调用它，你可以调用函数。
函数指针的声明可以形式如下：void (*fooPtr)(int, int);其中，fooPtr是函数指针变量，函数指针变量fooPtr可以指向函数foo()。
函数指针可以赋值，例如：fooPtr=foo;此外，你可以使用函数指针调用函数，例如：(*fooPtr)(1,2);这里，可以说fooPtr指向函数foo(),并且调用函数foo()。
现在，让我们来看看指针函数是什么：指针函数（pointer function）是一种特殊的函数，其返回值类型是指针，即它是一种不接受参数并返回指针的函数。
指针函数的声明可以形式如下：int *fooPtr(void);其中，fooPtr()是指针函数，它返回一个int类型的指针。
指针函数可以调用，例如：int *p = fooPtr();这里，fooPtr()调用了指针函数，并将返回的指针赋值给*p。
了解了函数指针和指针函数的基本概念及其用法后，那么函数指针和指针函数有什么区别？函数指针和指针函数的主要区别在于，函数指针可以指向任何函数，而指针函数必须返回指针类型的变量，并且不接受任何参数。
c语言函数指针
c语言函数指针
c语言函数指针是一种非常常用的概念，它可以在编程中发挥效用。
它可以为程序设计师提供灵活性，以便他可以更好地完成他的任务。
这篇文章将介绍什么是函数指针，函数指针的基本原理，函数指针的应用以及如何在c语言中实现函数指针。
什么是函数指针？函数指针是一个指针，指向一个函数。
它是一种指针类型，可以指向任何函数，无论该函数的返回类型或参数类型如何。
函数指针可以被认为是一个特殊的变量，它是指向函数的指针，而不是指向其他类型的普通指针。
函数指针的基本原理是，函数指针可以指向一个函数，以便您可以在不宣布函数的情况下使用它。
换句话说，它将指向一个函数的地址，以便您可以调用它。
例如，您可以使用函数指针来指向一个预先声明的函数，即使您不知道它的签名如何。
通过这种方式，函数指针可以用于抽象函数的调用，以及简化编程任务。
函数指针的应用很广泛，它可以用于实现多态、回调函数和事件处理程序等技术。
它也可以用于处理复杂的函数，如自定义排序算法，以及实现动态链接库。
在c语言中实现函数指针非常容易，只需定义函数指针即可。
首先，定义一个函数指针变量，并且为它分配存储空间。
接下来，使用指针语法来定义函数指针。
最后，使用指针变量来引用函数，即以指针的形式调用函数。
总而言之，函数指针是一种及其强大的概念，它可以在c语言编
程中发挥重要作用。
它可以被用于实现多态、回调函数和事件处理程序等功能，这些功能给程序设计师提供了函数抽象和灵活性，以便更加轻松地完成编程任务。
理解C语言（一）数组、函数与指针
理解C语⾔（⼀）数组、函数与指针1 指针⼀般地，计算机内存的每个位置都由⼀个地址标识，在C语⾔中我们⽤指针表⽰内存地址。
指针变量的值实际上就是内存地址，⽽指针变量所指向的内容则是该内存地址存储的内容，这是通过解引⽤指针获得。
声明⼀个指针变量并不会⾃动分配任何内存。
在对指针进⾏间接访问前，指针必须初始化: 要么指向它现有的内存，要么给它分配动态内存。
对未初始化的指针变量执⾏解引⽤操作是⾮法的，⽽且这种错误常常难以检测，其结果往往是⼀个不相关的值被修改，并且这种错误很难调试，因⽽我们需要明确强调: 未初始化的指针是⽆效的，直到该指针赋值后，才可使⽤它。
int *a;*a=12; //只是声明了变量a,但从未对它初始化，因⽽我们没办法预测值12将存储在什么地⽅int *d=0; //这是可以的，0可以视作为零值int b=12;int *c=&b;另外C标准定义了NULL指针，它作为⼀个特殊的指针常量，表⽰不指向任何位置，因⽽对⼀个NULL指针进⾏解引⽤操作同样也是⾮法的。
因⽽在对指针进⾏解引⽤操作的所有情形前，如常规赋值、指针作为函数的参数，⾸先必须检查指针的合法性- ⾮NULL指针。
解引⽤NULL指针操作的后果因编译器⽽异，两个常见的后果分别是返回置0的值及终⽌程序。
总结下来，不论你的机器对解引⽤NULL指针这种⾏为作何反应，对所有的指针变量进⾏显式的初始化是种好做法。
如果知道指针被初始化为什么地址，就该把它初始化为该地址，否则初始化为NULL在所有指针解引⽤操作前都要对其进⾏合法性检查，判断是否为NULL指针，这是⼀种良好安全的编程风格1.1 指针运算基础在指针值上可以进⾏有限的算术运算和关系运算。
合法的运算具体包括以下⼏种: 指针与整数的加减(包括指针的⾃增和⾃减)、同类型指针间的⽐较、同类型的指针相减。
例如⼀个指针加上或减去⼀个整型值，⽐较两指针是否相等或不相等，但是这两种运算只有作⽤于同⼀个数组中才可以预测。
函数指针的定义
函数指针的定义函数指针，又称为函数引用，是指向函数的指针，它可以用来引用函数，从而使用函数指针来调用函数。
它们可以指向任何返回类型的函数，包括内联函数和扩展函数。
由于函数指针可以指向任何返回类型的函数，因此可以将它们用作动态链接，即当函数指针指向给定的函数时，调用函数指针就会调用该函数。
函数指针的一个主要用途是函数的封装，可以将函数指针作为函数参数传递。
C语言中的函数指针声明是一个比较复杂的知识点，它的声明格式如下：void (*ptr) (data type);其中，ptr函数指针的名称，data type函数指针所指向的函数的参数类型。
另外，函数指针也可以声明多个参数，它的声明格式如下：void(*ptr) (data type1, data type2, ...);其中，ptr函数指针的名称，data type1，data type2，...代表函数指针指向的函数参数类型。
当有了函数指针的声明后，接下来就可以初始化函数指针，初始化函数指针的常用格式如下：ptr = &functionName;该语句意思是将函数名称 functionName地址赋值给指针 ptr。
这样就可以通过指针 ptr用函数 functionName 了。
除了使用函数指针来调用函数外，C/C++言还有一种叫做函数指针数组的东西，它是一种特殊的数组，它存储的元素是函数指针，常见的声明格式如下：void (*arrPtr[n])(data type1, data type2, ...);其中，arrPtr函数指针数组的名称，n函数指针数组的元素的个数，data type1，data type2，... 代表函数指针指向的函数的参数类型。
函数指针数组的一个优点是它可以把多个函数名称存储到一个数组中，从而一次调用数组中的所有函数指针，从而实现代码的复用。
函数指针的另一个强大特性就是它可以实现回调函数，回调函数是指由调用程序自定义的一个函数，在某些情况下，调用程序可以使用函数指针传递给另一个函数，当函数处理完成后，被调用函数会调用另一个函数，也就是传递给它的函数指针指向的函数，这样就实现了回调函数的功能。
C语言中的函数与指针
配存储空间 ，而ｓ ｐ ｗａ 函数 中的ａ 由ｓ ｐ ， ｗａ 函数分 配存储 ｂ
空间 。ｍａｎ ｉ函数执行 ￣ｓ ａ 函数时 ，调用ｓ ａ 函数 ， Ｕｗ ｐ ｗｐ
ｓ ａ／ ｗｐ ￣数为其变量分配存储空间 ，然后实现 了ｓ ａ 函数 ｗｐ
模块用来完成一个特定 的程序功能 。引用一个函数 时， 需要包括对函数 的定义 、声明 ，继而调用 。在掌握 函数 相关概念的同时 ，有以下几点需要注意：
一
ｍａ （ ｉ ） ｎ
｛
建 匙 ｂ；
ｖｉ ｗ ｐｉ ａｉｔ ） ｏ ｓ ａ（ ｔ ， ｄ ｎ ｎｂ
｛
ｉ￡ ； ＆ ￡
ｓ ａ （ ｂ； ｗ ｐａ ） ，
ｐｉｔ ％ｄ％ｄ ，ｂ ； ｒ ｆ ｎ （“ ， ” ａ ） ， ） ）
｛
§ 致
；
Ｐ ｒ ｉｎ ｔｆ（ “ ％ ｄ ，％ ｄ ” ，ａ，ｂ ）；
显然 ，函数ｍ ｉ ａ 是调用函数 （ ｎ 调用函数ｓ ａ ｗ ｐ），函
、
函数 的有 关概 念
数 ｓ ａ 是被调用函数。ｍａｎ ｗｐ ｉ函数 中的ａ 由ｍａ 函数分 ， ｂ ｉ ｎ
为 了使程序 的编写更加清晰 、直观且易于修改 ，Ｃ
语 言中 引用 了函数 。所 谓 函数 ，就 是 一 个程 序模 块 ，该
（） 用 函 数 和 被 调 用 函 数 １调
中变量ａ 的值交换 ，执行完毕后 即释放其 分配变量的 ， ｂ
存储 空间。继而 ，ｍａ 函数继续 执行 ，但其变量ａ 没 ｉ ｎ ， ｂ
有 做 任 何 改 变 ，ｉ ｍａ 函数 不 能 实 现 ａ 的交 换 。 由上 ｌ １ ｉ ］ ｎ ， ｂ
电 出版社 ， ０ ２ ２ ０
函数指针和指针函数的区别
函数指针和指针函数的区别函数指针和指针函数的区别函数指针和指针函数的区别，这两个概念其实是相同的，因为它们都使用了指针这一操作符。
但是指针并不是操作符，而是一种运算符，在某些时候我们可以把它理解成是一个名字，只要有它就能实现我们想要做的事情，指针可以进行变量间的相互赋值、取地址、相互之间的数学计算等操作，这就跟一般的运算符没什么太大的差异了。
下面简单介绍一下这两者的区别。
首先是定义方式上的不同：指针和函数是不同的，函数只要定义出来就会被赋予一个名称，当然也就拥有名字；而指针则需要定义指针变量，然后在程序中通过调用来改变其值，指针变量还具有动态性质，也就是说我们在进行运算或者赋值的时候会根据情况的不同而随着产生不同的结果。
如下图所示：函数和指针的定义都不难，不管是谁，基本上都可以明白它的意思。
另外指针是没有类型的，但是有指针的类型，例如 void* p，它是一个指针，它在类型上和一般的指针完全一样。
函数是有类型的，它和一般的变量很像，也分成静态和动态，静态的指针叫做原指针，动态的指针叫做伪指针。
在调用时，是必须使用原指针来传递参数的，即使是动态指针也是一样的道理。
函数与指针在概念上的区别还体现在指向一个对象的指针，指针函数是不能这样写的，因为如果你这样写的话，那么在运行时将会抛出巨大的错误。
另外在变量名字上，函数和指针是有区别的。
函数和指针虽然看起来非常相似，但是却有天壤之别。
一句话，函数就是运算符，指针是操作符。
如果你已经知道函数是怎么使用的，那么也许指针就好理解多了。
但是请记住，函数不代表就是代码。
函数不仅仅包括“带参”函数，还包括不带参数的函数。
也许你刚开始觉得指针就是一个符号而已，不用多少技巧就可以记住，可真正到了实际应用的时候就发现指针并不是一件容易的事情。
其实这个问题还比较好解决，学习函数的时候最重要的就是先弄清楚这些函数都有哪些特点，如何调用，然后再去慢慢熟悉这些函数的具体使用方法。
函数与指针编程题
1.编一程序,将字符串computer赋给一个字符数组,然后从第一个字母开始间隔地输出该串。
请用指针完成。
答案：#include "stdio.h"main(){ static char x[]="computer":char *p;for(p=x;p<x+7;p+=2)putchar(*p);printf("\n");}2. 写一函数，求一个字符串的长度。
在main函数中输入字符串,并输出其长度。
#include<stdio.h>void main(){char a[100],*p;int n=0;p=a;gets(p);for(;*p!='\0';p++){n++;}printf("%d",n);}3.下面findmax函数将计算数组中的最大元素及其下标值和地址值,请编写*findmax()函数。
并将程序调试运行#include<stdio.h>*findmax(int *s,int t,int *k){ }main(){ int a[10]={12,23,34,45,56,67,78,89,11,22},k,*add;add=findmax(a,10,&k);printf("%d,%d,%o\n",a[k],k,add);}答案：#include<stdio.h>int *findmax(int *s,int t,int *k){int max;max=s[0];for(int i=0;i<t;i++){if(max<s[i]){ max=s[i];*k=i;}}return k;}void main(){ int a[10]={12,23,34,45,56,67,78,89,11,22},k,*add;add=findmax(a,10,&k);printf("%d,%d,%o\n",a[k],k,add);}4. 用指针方法处理。
函数和指针程序设计实验总结与反思
函数和指针程序设计实验总结与反思通过函数和指针程序设计实验还是反映出比较多的问题，我感觉第八章的指针比较难理解，与前面数组部分联系起来了，上理论课时有一些地方不太明白。
通过此次老师重点讲解函数和指针程序设计实验，加深了我对字符指针和指针数组的掌握，理解会好很多，思路也更清晰很多，但还是要多去理解，也有些东西需要去记忆。
比如一个字符串在内存中是连续存储的，它的开始地址为指向字符串的指针值。
当使用指针作为形参时，实参必须是地址，也应是数组名。
一开始写完这个程序的时候运行出来的输出结果数字与数字之间没有间隔，就是一长串的数字，但是顺序是对的，通过对代码的再次检查，在输出后面加上空格，就得到了正确的格式，这种小问题发现比较难，在打代码的时候就要留心。
我从函数和指针程序设计实验中学习到很多。
我们写代码的时候一定要仔细，定义的函数与调用时的要一致，不要犯一些低级的错误。
总之还是要多去理解代码，多从错误中学习。
有10个指针的数组,该指针指向函数
有10个指针的数组,该指针指向函数函数指针是C语言中的一个重要概念，它可以指向程序中的函数，从而使得我们可以在程序运行过程中动态地调用不同的函数。
在本文中，我们将介绍10个不同类型的函数指针，并分别讨论它们的用途和特点。
1. 指针参数函数指针参数函数是一种常见的函数类型，它接受一个指针作为参数，并对指针所指向的数据进行操作。
例如，我们可以定义一个指针参数函数来交换两个变量的值：```cvoid swap(int* a, int* b) {int temp = *a;*a = *b;*b = temp;}```2. 返回指针的函数返回指针的函数是指该函数返回一个指针作为结果。
这种函数通常用于动态分配内存或返回数组的地址。
例如，我们可以定义一个返回动态分配内存的函数：```cint* createIntArray(int size) {int* arr = (int*)malloc(size * sizeof(int));return arr;}```3. 函数指针数组函数指针数组是一个数组，每个元素都是一个函数指针。
我们可以通过函数指针数组来实现函数的动态调用。
例如，我们可以定义一个函数指针数组，其中包含不同的排序算法函数：```cvoid bubbleSort(int* arr, int size) { ... }void selectionSort(int* arr, int size) { ... }void insertionSort(int* arr, int size) { ... }void (*sortAlgorithms[3])(int*, int) = { bubbleSort, selectionSort, insertionSort };```4. 函数指针作为回调函数函数指针作为回调函数是指将一个函数指针作为参数传递给另一个函数，使得后者可以在适当的时候调用前者。
这种机制常用于事件驱动编程中。
函数指针与指针函数
指针变量可以指向变量地址、数组、字符串、 指针变量可以指向变量地址、数组、字符串、动 态分配地址，同时也可指向函数， 态分配地址，同时也可指向函数，每一个函数在编译 系统会分配给该函数一个人口地址， 时，系统会分配给该函数一个人口地址，函数名表示 这个人口地址，那么， 这个人口地址，那么，指向函数的指针变量称之函数 指针变量. 指针变量
[例7．23]下列程序的可执行文件名为test．exe。 23]下列程序的可执行文件名为test exe。 test． argc， main(int argc，char *argv[]) { int i; printf(“argc＝ argc)； printf(“argc＝％d＼n”，argc)； for(i＝ i<argc； for(i＝1；i<argc；i++) printf(” argv[i])； printf(”％s＼n”，argv[i])； } 在操作系统提示符下，输入如下命令行： 在操作系统提示符下，输入如下命令行：
│2x - 1.76 │ fun1(x)=───────── (x-0.3)(10.5 -x) (x-
Cos(x-1.3) Cos(x-
例如：fun1( 例如：fun1( 1.66 ) = -0.806 ****************************************************** *******************/
*********************************************************/
fun( char str1[], char str2[]) { /*================================================*/ int i,j,k,len,len1; char ch; i<len len=strlen(str1); strcpy(str2,""); k=0; for (i=0;i<len-1;i++) { ch=str1[i]; ; if (ch>='A' && ch<='Z') ch=ch+32 else if ( ch>='a' && ch<='z' ) ch=ch-32; str2[k]=ch; k++; } str2[k]='\0'; /*-------------------------------------------------------*/ }
用指针调用函数
用指针调用函数用指针调用函数是C语言中的一种非常重要的编程技巧，其作用是提高程序的效率，减小程序的内存占用，并且可以更加灵活地操纵数据。
本文将分步骤阐述如何用指针调用函数，以便读者更好地理解和掌握这一编程技巧。
步骤一：定义函数和指针在使用指针调用函数之前，我们需要先定义一个函数和一个指针。
通常情况下，函数定义的格式如下：```返回类型函数名称(参数列表){函数体}```对于指针的定义，可以使用如下的格式：```数据类型 *指针名称;```其中，数据类型表示指针所指向的内存单元的数据类型，指针名称则是我们给指针起的别名。
步骤二：传递指针作为函数参数接下来，我们需要将指针作为函数的参数进行传递。
假设我们定义了如下的函数：```void swap(int *a, int *b){int temp;temp = *a;*a = *b;*b = temp;}```在这个函数中，我们使用了指针来传递两个整数变量的内存地址。
首先，我们将指针*a和指针*b所指向的内存单元的值进行交换，然后再通过指针逐一更改实际的变量值，从而实现了交换变量的效果。
在函数中，指针a和指针b都被声明为int类型的指针。
步骤三：通过指针调用函数现在，我们已经定义好了函数和指针，并将指针传递给函数作为参数。
接下来，我们需要通过指针来调用函数，从而实现我们的目的。
在C语言中，可以通过如下的语句来调用函数：```函数名称(参数列表);```如果函数需要传递指针作为参数，那么我们需要使用指针运算符“&”来获取变量的内存地址，并将地址传递给指针参数。
例如，我们可以通过如下的语句来调用上文中定义的swap函数：```int x = 10, y = 20;swap(&x, &y);```在这个例子中，我们定义了两个整型变量x和y，并将它们的初始值分别设为10和20。
接下来，我们调用了swap函数，并将变量x和y的内存地址分别传递给了指针参数*a和*b。
深入解析C语言中函数指针的定义与使用
深⼊解析C语⾔中函数指针的定义与使⽤1.函数指针的定义函数是由执⾏语句组成的指令序列或者代码，这些代码的有序集合根据其⼤⼩被分配到⼀定的内存空间中，这⼀⽚内存空间的起始地址就成为函数的地址，不同的函数有不同的函数地址，编译器通过函数名来索引函数的⼊⼝地址，为了⽅便操作类型属性相同的函数，c/c++引⼊了函数指针，函数指针就是指向代码⼊⼝地址的指针，是指向函数的指针变量。
因⽽“函数指针”本⾝⾸先应该是指针变量，只不过该指针变量指向函数。
这正如⽤指针变量可指向整形变量、字符型、数组⼀样，这⾥是指向函数。
C在编译时，每⼀个函数都有⼀个⼊⼝地址，该⼊⼝地址就是函数指针所指向的地址。
有了指向函数的指针变量后，可⽤该指针变量调⽤函数，就如同⽤指针变量可引⽤其他类型变量⼀样，在这些概念上是⼀致的。
函数指针有两个⽤途：调⽤函数和做函数的参数。
函数指针的声明⽅法为：数据类型标志符 (指针变量名) (形参列表);“函数类型”说明函数的返回类型，由于“()”的优先级⾼于“*”,所以指针变量名外的括号必不可少，后⾯的“形参列表”表⽰指针变量指向的函数所带的参数列表。
例如： int function(int x，int y); /* 声明⼀个函数 */ int (*f) (int x，int y); /* 声明⼀个函数指针 */ f=function; /* 将function函数的⾸地址赋给指针f */ 赋值时函数function不带括号，也不带参数，由于function代表函数的⾸地址，因此经过赋值以后，指针f就指向函数function(int x，int y);的代码的⾸地址。
2.函数指针使⽤的例⼦ 知道了如何定义⼀个函数指针，但如何来使⽤它呢？先看如下例⼦：#include <stdio.h>#include <string.h>char * fun(char * p1,char * p2){ int i = 0; i = strcmp(p1,p2); if (0 == i) { return p1; } else { return p2; }}int main(){ char * (*pf)(char * p1,char * p2); pf = &fun; (*pf) ("aa","bb"); return 0;} 我们使⽤指针的时候，需要通过钥匙（“*”）来取其指向的内存⾥⾯的值，函数指针使⽤也如此。
C语言基础知识函数指针指针函数(定义格式作用及用法说明)
C语言基础知识函数指针指针函数（定义格式作用及用法说明）函数指针（Function Pointers）是C语言中一种特殊的指针，它可以指向一个函数。
不同于普通指针，函数指针表示指向一个函数的入口地址，而且可以在运行时动态改变。
函数指针可以用来实现函数的参数传递、函数的地址调用、函数的回调机制以及多态等功能。
一、定义格式函数指针可以像普通指针一样进行定义，只不过指针的指向类型不是普通的数据类型，而是函数，它的定义格式如下：（1）一般的函数指针：<return_type> (*ptr)(param_list);（2）函数指针数组：<return_type> (*ptr)(param_list)[size];（3）函数指针数组指针：<return_type> (*ptr[size])(param_list);（4）带参数的函数指针：<return_type> (*ptr)(type param);（5）可变参数的函数指针：<return_type> (*ptr)(param_type, ...)；（6）函数指针的指针：<return_type> (**ptr)(param_list);二、作用（1）函数指针可以在函数内外传递，从而可以实现函数参数的传递，实现函数的“回调”机制；（2）函数指针可以用来实现回调函数，比如设计回调函数时，可以将函数指针作为参数，当一些事件发生时，函数指针被调用，来执行特定的操作；（3）函数指针可以实现函数的多态，函数指针可以用来指向不同参数类型的函数，从而实现函数的多态。
三、用法。
C语言指针函数和函数指针详解
C语言指针函数和函数指针详解C语言指针函数和函数指针详解往往，我们一提到指针函数和函数指针的时候，就有很多人弄不懂。
以下是店铺为大家带来的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) ");scanf("%d%d",&wk,&dy);}while(wk<1||wk>5||dy<1||dy>7);printf("%d ",*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];}程序应该是很好理解的，子函数返回的是数组某元素的地址。
输出的是这个地址里的值。
二、函数指针指向函数的指针包含了函数的地址，可以通过它来调用函数。
声明格式如下：类型说明符 (*函数名)(参数)其实这里不能称为函数名，应该叫做指针的变量名。
这个特殊的指针指向一个返回整型值的函数。
指针的声明笔削和它指向函数的声明保持一致。
指针函数和函数指针有什么区别
指针函数和函数指针有什么区别1、指针函数，这两个概念都是简称，指针函数是指带指针的函数，即本质 是一个函数。
我们知道函数都有返回类型（如果不返回值，则为无值型），只不 过指针函数返回类型是某一类型的指针。
其定义格式如下所示： 返回类型标识符 *返回名称（形式参数表）{ 函数体 }返回类型可以是任何基本类型和复合类型。
返回指针的函数的用途十分广 泛。
事实上，每一个函数，即使它不带有返回某种类型的指针，它本身都有一 个入口地址，该地址相当于一个指针。
比如函数返回一个整型值，实际上也相 当于返回一个指针变量的值，不过这时的变量是函数本身而已，而整个函数相 当于一个“变量” 。
例如下面一个返回指针函数的例子：＃i nclude <stdio.h>float *find();main(){static float score[][4] = {{60,70,80,90},{56,89,34,45},{34,23,56,45}};float *p;int i,m;printf("Enter the number to be found:");scanf("%d",&m);printf("the score of NO.%d are:\n",m);p = find(score,m);for(i= 0;i<4;i++)printf("%5.2f\t",*(p+i));}float *find(float (*pionter)[4], int n)/*定义指针函数*/{float *pt;pt = *(pionter+n);return(pt);}学生学号从 0 号算起，函数 find( )被定义为指针函数，形参 pointer 是指针 指向包含 4 个元素的一维数组的指针变量。
pointer+1 指向 score 的第一行。