对于数组array[]，数组名array表示数组首地址，那么为什么&array仍然表示数组首地址，而不是二级指针？
对于函数指针也有相同的疑问，函数 bool lengthCom( const string &a,    const string &b );,
当函数名作为一个值使用时该函数自动转化为指针，
那么为什么 p = &lengthCom与 p = lengthCom等价

对于数组array[],为什么&array不是二级指针 ----- 数组不是指针，自然&array不可能是二级指针
对于数组array[]，数组名array表示数组首地址 ----- 没这种说法，要看正书
那么为什么 p = &lengthCom与 p = lengthCom等价 ------ 你自己不是说了嘛“当函数名作为一个值使用时该函数自动转化为指针”

数组名问题
设有
int a[5];
如果将数组看成一个整体，则这个整体为a，这个整体的地址为&a;我们可以定义int(*p)[5]=&a;
如果不把数组看成一个整体，则a就是第一个元素的地址，即&a[0]
设有
int b[5][3];
如果将数组看成一个整体，则这个整体为b，这个整体的地址为&b;我们可以定义int(*p)[5][3]=&b;
如果不把数组看成一个整体，则b就是第一个元素的地址，即&b[0]注意不是&b[0][0]我们可以定义int(*p)[3]=b;
要记住：N维数组名可以看做是其N-1维数组名的地址。
看我以前作的笔记吧，语言说的有一点乱，你还是慢慢看吧：

假设定义一个3行4列的二维数组，示例如下：
int a[3][4];
我们将它看成一个整体，这个整体可用a表示，这个整体的地址可用&a表示。
我们将它看成一个一维数组，由数组元素a[0]、a[1]、a[2]组成，它的数组名为a，代表&a[0]。
a[0]、a[1]、a[2]看成一个个单独的数组，数组名a[0]代表&a[0][0]、数组名a[1]代表&a[1][0]、数组名a[2]代表&a[2][0]。
即：
     a[0]    a[0][0],a[0][1], a[0][2],a[0][3]
a    a[1]    a[1][0],a[1][2], a[1][2],a[1][3]
     a[2]    a[2][0],a[2][1], a[2][2],a[2][3]
a就是&a[0]，a[0]就是&a[0][0]，而a[0]和a[0][0]是不同的对象，所以a和a[0]的数值相同，但是表示不同对象的地址。
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a[3][4];
printf("变量a的长度：%d\n",sizeof(a));//整体所占用内存单元数量
    printf("一维数组元素a[0]的长度：%d\n",sizeof(a[0]));
    printf("一维数组元素a[1]的长度：%d\n",sizeof(a[1]));
    printf("一维数组元素a[2]的长度：%d\n",sizeof(a[2]));

printf("变量a的地址：%d\n",&a);   //整体地址

    printf("一维数组a的首地址，也就是数组元素a[0]的地址：%d，%d\n",a, &a[0]);
    printf("一维数组a[0]的首地址，也就是数组元素a[0][0]的地址：%d，%d\n",a[0] , &a[0][0]);
    printf("一维数组元素a[1]的地址：%d\n",&a[1]);
     printf("一维数组a[1]的首地址，也就是数组元素a[1][0]的地址：%d\n",a[1],&a[1][0]);
    printf("一维数组元素a[2]的地址：%d\n",&a[2]);  
    printf("一维数组a[2]的首地址，也就是数组元素a[2][0]的地址：%d\n",a[2],&a[2][0]);

    system("pause");  
    return 0;  
}

对于多维数组，使用指针同样可以灵活访问数组元素。若定义数组T b[K][M][N]，再定义指针T  (*p) [M][N]=b，下式为存取数组元素b[i][j][k]的等效方式：
*(*(*(b+i)+j)+k)、*(*(*(p+i)+j)+k)、p[i][j][k]
#include <iostream>
using namespace std;
void main()
{
    int a[3][4][5],(*p)[4][5]=a;
    for(int k=0;k<3;k++)
        for(int i=0;i<4;i++)
            for(int j=0;j<5;j++)
                a[k][i][j]=k*100+i*10+j;
    for(int k=0;k<3;k++)
    {
        for(int i=0;i<4;i++)
        {
            for(int j=0;j<5;j++)
                printf("%4d",p[k][i][j]);
            printf("\n");
        }
        printf("\n");
    }
}

函数指针
每一个函数在编译时，系统会分配给该函数一个入口地址，函数名表示这个入口地址，函数名是函数指针常量。指向函数的指针变量称之函数指针变量。
函数指针变量的定义
返回值类型 (*函数指针变量名)(参数类型列表);
例如：
如果定义了一个函数，其函数原型为“int fun(int,int,int);”
int(*funP)(int,int,int);
funP=fun;
函数指针变量的引用
返回值类型 (*&引用名)(形参表)=匹配的函数指针变量名;
例如：
int(*funP)(int,int,int)=nullptr;
int(*&rfunP)(int,int,int)=funP;
rfunP与funP是同一对象。
函数名的引用
函数名是函数指针常量，函数名的引用就是函数指针常量的引用。
返回值类型 (*const&引用名)(形参表)=匹配的函数名;
例如：
如果定义了一个函数，其函数原型为“int fun(int,int,int);”
int(*const&rfun)(int,int,int)=fun;
函数指针数组的定义
返回值类型 (*函数指针变量名[长度])(形参表);
例一：定义函数指针数组
int(*pfuns[4])(int,int,int);
pfuns数组中的每个元素只能指向其函数原型为“int 函数名(int,int,int);”的函数。
例二：定义函数指针数组并初始化
double a1(double,double);
double a2(double,double);
double a3(double,double);
double (*pfun[3])(double,double)={a1,a2,a3};
函数指针数组的引用
返回值类型 (*(&引用名)[长度])(形参表)=匹配的函数指针数组名;
例如：
int(*pfuns[4])(int,int,int)={nullptr};
int(*(&rfuns)[4])(int,int,int)=pfuns;//函数指针数组的引用
rfuns与pfuns是同一对象，都是数组。

例子：演示函数指针变量、函数指针变量的引用、函数指针数组和函数指针数组的引用的使用。
#include <iostream>
using namespace std;
int add(int a,int b){return a+b;}
int sub(int a,int b){return a-b;}
int mul(int a,int b){return a*b;}
int divi(int a,int b){if(b)return a/b;else cout<<"出错";}
int main()
{
    int a=100,b=10;
    int(*pfun)(int,int);//函数指针变量
    pfun = add,cout << pfun(a, b) << ends,
    pfun = sub,cout << pfun(a, b) << ends,
    pfun = mul,cout << pfun(a, b) << ends,
    pfun = divi,cout<< pfun(a, b) << endl;

    int(*pfuns[])(int, int)={add, sub, mul, divi}; //函数指针数组
    cout << pfuns[0](a, b) << ends << pfuns[1](a, b) << ends << pfuns[2](a, b) << ends << pfuns[3](a, b) << endl;

    int(*(&rfun0))(int, int)(pfuns[0]);//函数指针的引用
    int(*(&rfun1))(int, int)(pfuns[1]);
    int(*(&rfun2))(int, int)(pfuns[2]);
    int(*&rfun3)(int, int)=pfuns[3];
    cout<<rfun0(a, b)<<ends<<rfun1(a, b)<<ends<<rfun2(a, b)<<ends<<rfun3(a, b)<<endl;
   
    int(*(&rfuns)[4])(int,int)=pfuns;//函数指针数组的引用
    cout<<rfuns[0](a,b)<<ends<<rfuns[1](a,b)<<ends<<rfuns[2](a,b)<<ends<<rfuns[3](a,b)<< endl;
    return 0;
}


例子：存在的现象
#include <iostream>
using namespace std;
int fun(int x,int y,int z)
{
    return (x+y+z);
}
int main()
{
    int a=1,b=2,c=3;
    cout<<fun(a,b,c)<<endl;
    cout<<(&fun)(a,b,c)<<endl;
    cout<<(********fun)(a,b,c)<<endl;

    int(*funP)(int,int,int);
    funP=fun;
    cout<<funP(a,b,c)<<endl;
    cout<<(********funP)(a,b,c)<<endl;

    funP=&fun;
    cout<<funP(a,b,c)<<endl;
    cout<<(***********funP)(a,b,c)<<endl;

    funP=********fun;
    cout<<funP(a,b,c)<<endl;
    cout<<(***********funP)(a,b,c)<<endl;
    return 0;
}
函数指针型的自定义
typedef类型说明符(*用户类型名)(特定形参表);
typedef void (*FunType)(int ); //定义一个函数指针类型
FunType FunP1,FunP2,FunP3;//等价于void (*FunP1)(int ), (*FunP2)(int ) , (*FunP3)(int );
例：
#include <iostream>
using namespace std;
void MyFun(int x)
{
    printf("%d\n",x);
}
typedef void (*FunType)(int ); //定义一个函数指针类型
int main(int argc, char* argv[])
{
    FunType FunP; //定义一个函数指针变量
    MyFun(10);
    FunP=MyFun;
    FunP(20);
    return 0;
}
函数指针作为函数的参数
#include <iostream>
using namespace std;
void MyFun1(int x)
{
    printf("函数MyFun1中输出：%d\n",x);
}
void MyFun2(int x)
{
    printf("函数MyFun2中输出：%d\n",x);
}
void MyFun3(int x)
{
    printf("函数MyFun3中输出：%d\n",x);
}
typedef void (*FunType)(int );
void CallMyFun(FunType fp,int x) //此函数头也可写成void CallMyFun(void(*fp)(int),int x)
{
    fp(x);
}
int main()
{
    CallMyFun(MyFun1,10);
    CallMyFun(MyFun2,20);
    CallMyFun(MyFun3,30);
}

这些东西是我以前花了一个多星期的研究成果。例子通过测试的。

[quote]以下是引用rjsp在2016-8-30 17:41:26的发言：

对于数组array[],为什么&array不是二级指针 ----- 数组不是指针，自然&array不可能是二级指针
对于数组array[]，数组名array表示数组首地址 ----- 没这种说法，要看正书
那么为什么 p = &lengthCom与 p = lengthCom等价 ------ 你自己不是说了嘛“当函数名作为一个值使用时该函数自动转化为指针”[/quote
我一直认为array是array[]的首地址，

若把数组名看作对象,则此对象就是数组中所有元素所组成的一个整体;若将数组名看作是地址值,则此值是其第一个元素的地址。注意，如果是N维数组，要将N维数组看作是一维数组，这第一个元素就是这个一维数组的第一个元素。这个元素是N-1维数组。
我以前认为，数组是地址，就不该说它是指针。指针应该是个变量或const变量，用来存储地址。
但是网上的很多人说地址是指针，指针是地址。我只能随大流，有时也说数组名是指针，函数名是指针。但自己心里清楚就行，数组名，函数名它是常量，其值可以是地址值。
有人说数组不是指针，那么它当然不是二级指针，这个没错。因为他分的很清，指针是指针，地址是地址。
如果他认为指针是地址，地址就是指针的话，他也没错，一维数组名的确不是二级指针。可以动手编个小程序编译一下就知道：
void main()
{
    int a[5];
    int**p;
    p=a;//error
}

上面我少了一个&，重写于此：
void main()
 {
     int a[5];
     int**p;
     p=&a;//error
 }