指针，指针数组，数组指针，函数指针

################################

# #

# 基本知识 #

# #

################################

当然我们一切都是从最简单的内建类型开始，最后我会做一些推广。

先看一下基本的形式,我们从这里起步!

--------------指针----------------

int a=10;

int *p=&a;

-------------指针的指针-----------

int b=20;

int *p=&b;

int **p2p=&p;

-------------简单数组-----------------

int c[10];//整数数组，含有10个整数元素

//也就是说每一个元素都是整数

--------------指针数组--------------------

int *p[10];//指针数组，含有10个指针元素

//也就是说每一个元素都是指针

--------------数组指针--------------------

int (*p)[10];//数组指针，这个指针可以用来指向

//含有10个元素的整数数组

上面这些简单的形式是我们必须要首先理解，这个是基本的知识。

同时我们从上面也要得出一个很重要的知识提示：c++语言层面上

关于变量声明的部分，后缀结合变量的优先级比前缀要高的。

看我们上面的例子的最后两个就明白了，我们为了实现数组指针的

声明我们不得不变通一下。我们采用()来实现优先级的改变，实现了

数组指针的声明。

注：在C语言中[ ]的优先级为1，*的优先级为2，这样[ ]的优先级比*的要高，这样就是先p[10]结合声明一个数组名为p的数组，后再与*结合后为*p[10]，其数组元数为 int类型指针，这样就可以知道int *p[10]就定义了一个指针数组,用来存放unsigned char类型地址，编译器为该一维数组分配了10个sizeof(int
*)的空间.；

对于int (*p)[10]，( )的优先级[ ]相等，这样就是从左到右结合.就是先(*p)结合声明一个p的指针，后再与[10]结合声明一个数组指针后(*p)[10]，其p指向10个数组元素，这样就可以知道int (*p)[10]就定义了一个数组指针，编译器为p分配了一个指针空间,因为其不是一个数组只是指向数组元素,所以编译器不为其分得一个数组空间。

################################

# #

# 进一步提高知识 #

# #

################################

数组，数组的指针，指针的数组，概念太多了。我接受概念一多的

时候，我就想把这些复杂的东西简单一下。因为我太懒了，概念简化

一下，记住更容易一点。所以我们这里要认识一下上面这些概念本质。

这样可以简化概念，减少记忆的难度。

先看一段程序。

#include <iostream>

#include <typeinfo>

using namespace std;

int main()

{

int vInt=10;

int arr[2]={10,20};

int *p=&vInt;

int **p2p=&p;

int *parr[2]={&vInt,&vInt};

int (*p2arr)[2]=&arr;

cout<<"Declaration [int vInt=10] type=="<<typeid(vInt).name()<<endl;

cout<<"Declaration [arr[2]={10,20}] type=="<<typeid(arr).name()<<endl;

cout<<"Declaration [int *p=&vInt] type=="<<typeid(p).name()<<endl;

cout<<"Declaration [int **p2p=&p] type=="<<typeid(p2p).name()<<endl;

cout<<"Declaration [int *parr[2]={&vInt,&vInt}] type=="<<typeid(parr).name()<<endl;

cout<<"Declaration [int (*p2arr)[2]=&arr] type=="<<typeid(p2arr).name()<<endl;

return 0;

}

运行的结果如下：(我在前面加了行号#XX)

#01 Declaration [int vInt=10] type==int

#02 Declaration [arr[2]={10,20}] type==int *

#03 Declaration [int *p=&vInt] type==int *

#04 Declaration [int **p2p=&p] type==int * *

#05 Declaration [int *parr[2]={&vInt,&vInt}] type==int **

#06 Declaration [int (*p2arr)[2]=&arr] type==int (*)[2]

现在我们来分析一下结果。因为我们已经具有了第一部分的基本知识，我们现在

可以很明确区别出来我们声明的类型。这里主要有两个很重要的部分，我们不过

是就事讲事情，编译器是如何实现的原理不在这里讨论之列。

--------#02：数组------------

现在看#02,想到了什么没有呀？在编译器看来数组只是相对应类型的指针类型。

当我们把数组传递给函数作为参数的时候，传递的是指针，所以我们可以利用

参数来修改数组元素。这个转化是编译器自动完成的。

void f(int[]);

int a[2]={10,20};

f(a);//这行等价于编译器完成的函数转化f(int *p)

也就是说这里编译器自动完成了int[]类型到int *的转化，

注意是编译器完成的，也可以说是语言本身实现的，我们

对此只有接受的份了。

-------#05：指针数组---------------

指针数组的编译器内部表示也是对应类型的指针。

------#06：数组指针----------------

数组指针的编译器内部表示就是有一点特别了。

编译器(或者说是语言本身)有数组指针这个内部表示。

由于c++语言的类型严格检查的语言（当然还有一些是存在隐式类型转化的）

所以我们下面的写法是不能编译通过的。

{

file://---------编译不能通过--------------

int arr[3]={10,20};//注意是3个元素数组

int (*p2arr)[2]=&arr;//注意是指向2个元素数组的指针

file://---------编译不能通过--------------

}

################################

# #

# 初步小结 #

# #

################################

通过上面两个小节的内容，大家应该基本明白了，

数组，指针，指针数组，数组指针到底是怎么一回事情了吧。

-----------补充开始-----------------------

关于数组和指针的转化，以及我们使用指针(++,--)等来操作数组，

是基于数组在内存中是连续分布的。

但是我们使用“迭代器”的时候，情况是不一样的。

这个问题本文不讨论。

-----------补充结束---------------------

函数指针数组与返回数组指针的函数

int (*a[])(int);

int (*p())[10];
第一种情况为数组里面是函数指针的情况,因为(int (*)(int))是一个强制转换方式, 将里面的a[]这个数组转换成了一个函数指针的数组, 并且该函数是一个带一个整型变量,并且返回一个整型的函数.

第二种情况为函数返回的为指向一个一维数组的指针的情况. 因为(int (*)[10])将其强制转换成了一个指针,而该指针则是一个指向一维数组的指针.

分别举两个例子进行说明:

对于第一种函数指针数组的情况,如下:

#include<stdio.h>

int fun(int a)

{

return a+1;

}

int main()

{

int (*p[10])(int);

int i;

p[0] = fun;

i = (p[0])(10);

printf("i=%d/n", i);

return 0;

}

p[10]为一个指针数组,而该指针数组里面的值为函数指针类型.让p[0]指向fun()函数.然后再进行调用,就可以调用到fun()这个函数了.

对于第二种返回数组指针的函数,如下:

#include<stdio.h>

#include<stdlib.h>

int (*p())[10]

{

int (*m)[10];

int i;

m = (int (*)[10])malloc(10, sizeof(int));

if (m == NULL)

{

printf("calloc error/n");

exit(1);

}

for (i = 0; i < 10; i++)

*(*m+i) = i+1;

return m;

}

int main()

{

int (*a)[10];

int i;

a = p();

for (i = 0; i < 10; i++)

printf("%d ", *(*a+i));

printf("/ndone/n");

return 0;

}

其实int (*m)[10];这种方式一般是用来指向一个二维数组的,例如

int b[4][10];

int (*m)[10] = b;

其指向二维数组中的一维.

使用*(*(m+i)+j);这种方式就可以访问b[i][j]这个元素.而上面的是使用这种方式来指向一个一维数组,同样也是一样的.只是前面的*(m+i)中的i变为0了.因为只有一维大小.即

int a[10];

int (*m)[10] = &a;

就使得m指向了a这个数组了.而平时所用的int *p = a;只是让p指向了a的第一个元素.比前面的指向一维数组的指针少了一维.前面的m+1跳过的是10个整型的长度.而后面的p+1则只是跳过了1个整型的长度.