在上一章中 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.另:还记得我们在文章开头取了一个函数地址吗，那么这个属于什么区域呢？这个是代码区，因为函数的执行代码是存储在程序代码区。
这就是一个函数的内存分布区域，不是所有的内容都是一起的。
