C++ 语法之函数和函数指针

在上一章中 C++ 语法之 指针的一些应用说明-CSDN博客

我们了解了指针变量，int *p;取变量a的地址这些。

那么函数同样也有个地址，直接输出函数名就可以得到地址，如下：

#include<iostream>
using namespace std;
void fun()
{int a = 5;}
int main()
{cout << "fun函数地址:" << fun;
}

返回函数地址：

这个就是系统为这个函数代码分配的内存空间的首地址。

既然有这个内存地址，那相对的，跟变量指针一样，也有函数指针，我们要怎么定义函数指针变量呢？

像int *p; char *cptr; 可以看到，定义指针变量需要提前进行类型区分。

所以函数指针，也是如此，必须说明这个函数的返回值，以及参数类型，几个参数。

如下定义：

void (*pFun)();

如果fun函数是这样

void fun(int a);

则对应的函数指针:

void (*pFun)(int);

你们可以在编译器尝试一下，是必须对应一致的，函数指针不能指向定义不一样的函数。

就像int *p指针不能指向char变量地址一样，只能是int类型的。

现在我们来一个例子学习一下：
 

#include<iostream>
using namespace std;
void (*pFun)();
void fun1()
{cout << "我是fun2";
}void fun()
{cout << "我是fun\n";pFun = fun1; //在这里 函数指针 指向另一个函数 pFun;
}int main()
{pFun = &fun; //为了便于阅读用&fun, 事实上直接pFun=fun也可以，下面加*号同理  可省略(*pFun)();(*pFun)();
}

结果： 

上面的例子说明了，pFun指针指向fun,就是fun函数，指向fun1就是fun1函数。 

其实跟变量指针一个道理。

函数的生命周期 

我们知道在函数内正常定义的变量叫局部变量，函数执行完了，这些变量的内存空间就被释放了。

也就是函数每执行一次，比如有个int a=5;就会给a分配内存空间，执行完了，就会释放。

这种由系统分配，系统释放的内存空间，就是内存中的栈空间。

也就是说，这种变量在栈中申请空间。由系统管理释放。

而堆中，是由程序员自己申请的内存空间:

比如C的malloc函数(需free释放)

C++的new 

例: int* ptr = new int; (需delete释放)

像这些，申请的空间，系统不会帮你自动释放，所以就需要你自己手动释放，否则，这块空间即使不使用了，也会被程序一直占用。它并没有栈中内存空间的功能，自动释放。

这个内存堆栈空间是系统定义的，而物理上内存并没有此种划分，需要明白。

下面我们用一些例子来证明：

#include <iostream>using namespace std;
int i = 0;  
void fun() {int a = 5;cout << "第" << i << "次地址:" << &a << endl;
}int main() {for (; i < 4; i++) {fun();}return 0;
}

每次调用fun函数，输出局部变量a的地址，理论上应该是不同的地址，因为每次函数调用完之后a变量在栈中的空间会被释放。

但是结果：

地址是一样的，这是系统优化分配的原因，因为这个地址被释放了，下次分配还可以找同样的地址。这是合法的，就像在磁盘删掉一个文件，然后再存储，还是原来的位置。

所以由于这种现象，上面这个代码并不能证明变量被重新分配内存空间。

我们要怎么做，在函数执行期间，调用其它函数干扰栈空间分配，就像磁盘删除文件，然后复制大量其它文件，这样再粘贴的文件位置就会不一样？

比如下面这个：

#include <iostream>using namespace std;
int i = 0;
void fun() {int a = 5;cout << "第" << i << "次地址:" << &a << endl;
}
void other()
{int b = 5;int c = 6;int bc[56] = { 0 };
}
int main() {for (; i < 4; i++) {fun(); other();//调用一下其它函数，里面申请栈空间，打乱分配。}return 0;
}

并没有用，原因是other里的也是局部变量，执行完后，同样变量占用的栈空间也被释放了。所以跟原来的还是一样。 

那我们想个方法，不被释放，看下面的代码：

#include <iostream>using namespace std;
int i = 0;
void fun(int sum) {int a = 5;cout << "第" << sum << "次地址:" << &a << endl;
}int main() {for (; i < 4; i++) {fun(i);int b = 5; //定义 b变量，然后再调用fun(11) 此时b变量和fun(11)同时在for的作用域中fun(11);int c = 6;fun(22);}return 0;
}

很遗憾，还是没有效果，所有的a变量地址都是一样的。

我分析可能是进入for作用域一次性的分配好了(有待验证）。

从这个现象可以看出，虽然每次执行函数时其中的局部变量，都是重新分配，但系统遵循着某一种优化规则，使得每次分配的地址尽可能一样。

由于方向上的问题，这个规则就不深入研究了。

好了，通过直观的查看地址方法已失败，实验起来比较困难。

我们可以从侧面来验证，有两个方法，第一个通过值的变化来验证，如果内存空间被释放了，那么的它的值如果没有保留，那可以证明函数执行完，局部变量已经被释放。

取值验证：

#include <iostream>using namespace std;
int i = 0;
int* ptr;
void fun(int sum) {int a = 5;ptr = &a; //将a变量的地址存到全局指针变量ptr中 以便在函数外访问cout << "\n fun函数内a值:" << *ptr;
}
int main() {for (; i < 2; i++) {fun(i); cout << "\n函数外的a值:" << *ptr;}return 0;
}

结果：

可以看到，同样是取*ptr的值，函数外已经变了，说明系统没有为变量a留有内存空间来保存值了，函数执行完就被释放了。 

第二个通过递归调用函数的方法强制验证，这样的地址绝对不能相同，比如说递归调用4次函数。

局部变量a肯定是不同的地址，如果每一次都重新分配空间的话。

为什么，因为在递归未完成时，所有的局部变量都不会被释放。因为所有的函数都没执行完。

它想复用上一次变量A的地址是不可能的。

这个方法是反向证明，证明每次是重新分配空间的。然后就可以佐证，即然每次执行重新分配空间，那么执行完了也应当是释放空间的。

递归调用验证：

#include <iostream>using namespace std;void fun(int sum) {int a = 5;if (sum == 0) return; //用sum来控制 递归调用fun函数，防止无限循环调用else{cout << "\nsum=" << sum << "时,a的地址:" << &a;sum = sum - 1;fun(sum);//递归调用fun}}
int main() {fun(4);return 0;
}

结果：

可以看到，每次a变量地址是不同的，四个不同的地址。 

说了局部变量，这里有个有趣的点，有没有一种变量，我不想每次函数执行，重新分配和释放，是一直存在的，有，就是在函数内被static修饰的变量，这种变量跟全局变量一样，它的空间不是在堆栈中，而是静态内存空间中，从整个程序开始分配，运行期间一直存在，到程序结束才释放。

 代码示例：

using namespace std;
int g = 5;
void fun() {static int s = 5; //静态变量int b = 10;int c = 10;s++;cout << "\n静态s变量值:" << s << "------地址:" << &s << "-----全局变量g地址:" << &g;cout << "\n局部变量b地址:" << &b << "---局部变量c地址:" << &c;}
int main() {for(int i=0;i<3;i++)fun();return 0;
}

运行结果：

 1.从地址分配来看，可以证明，全局变量g和静态变量s 的地址相近，说明它们在同一块内存区域（静态存储区)。有着相同的特性。

2.而局部变量b,c又是另一块内存区域(动态存储区)，即栈中。所以它们的地址很接近，只是后几位不同。

3.可以看到静态变量s的值在增长，说明并没有被释放，而开头一句static int s=5;静态变量在定义时赋值只会初始化一次。

 4.另:还记得我们在文章开头取了一个函数地址吗，那么这个属于什么区域呢？这个是代码区，因为函数的执行代码是存储在程序代码区。

这就是一个函数的内存分布区域，不是所有的内容都是一起的。