指针的指针，数组指针，指针数组 转载

指针的指针

void FindCredit(int **);

main() { int vals[]={7,6,5,-4,3,2,1,0}; int *fp=vals; FindCredit(&fp); printf("%d\n",*fp); }

void FindCredit(int ** fpp){while(**fpp!=0)if(**fpp<0) break;else (*fpp)++;}

首先用一个数组的地址初始化指针fp，然后把该指针的地址作为实参传递给函数FindCredit()。FindCredit()函数通过表达式 **fpp 间接地得到数组中的数据。为遍历数组以找到一个负值，FindCredit()函数进行自增运算的对象是调用者的指向数组的指针，而不是它自己的指向调用者指针的指针。语句(*fpp)++就是对形参指针指向的指针 进行自增运算的。但是因为*运算符高于++运算符，所以圆括号在这里是必须的，如果没有圆括号，那么++运算符将作用于二重指针fpp上。

指向指针数组的指针 指针的指针另一用法处理指针数组。有些程序员喜欢用指针数组来代替多维数组，一个常见的用法就是处理字符串。

char *Names[]={"Bill","Sam","Jim","Paul","Charles",0};

          main(){char **nm=Names;while(*nm!=0) printf("%s\n",*nm++);}

先用 字符型指针数组Names的地址来初始化指针nm。每次printf()的调用都首先传递指针nm指向的字符型指针，然后对nm进行自增运算使其指向数组的下一个元素(还是指针)。注意完成上述认为的语法为*nm++，它首先取得指针指向的内容，然后使指针自增。 注意数组中的最后一个元素被初始化为0，while循环以次来判断是否到了数组末尾。具有零值的指针常常被用做循环数组的终止符。程序员称零值指针为空指针(NULL)。采用空指针作为终止符，在树种增删元素时，就不必改动遍历数组的代码，因为此时数组仍然以空指针作为结束

指向指针的指针，很早以前在说指针的时候说过，但后来发现很多人还是比较难以理解，这一次我们再次仔细说一说指向指针的指针。先看下面的代码，注意看代码中的注解：

#include <iostream>  

#include <string>  

using namespace std;  

void print_char(char* array[]，int len);  

//函数原形声明 void main(void) {  

//-----------------------------段1----------  

char *a[]={"abc"，"cde"，"fgh"};//字符指针数组  

char* *b=a;  

//定义一个指向指针的指针，  

并赋予指针数组首地址所指向的第一个字符串的地址也就是abc\0字符串的首地址  

cout<<*b<<"|"<<*(b+1)<<"|"<<*(b+2)<<endl;  

　　//-----------------------------段2----------  

　　char* test[]={"abc"，"cde"，"fgh"};  

//注意这里是引号，表示是字符串，以后的地址每加1就是加4位(在32位系统上)  

　　int num=sizeof(test)/sizeof(char*);  

//计算字符串个数  

　　print_char(test，num);  

　　cin.get();  

　 　　}  

void print_char(char* array[]，int len)  

//当调用的时候传递进来的不是数组， 而是字符指针他每加1也就是加上sizeof(char*)的长度  

　　{  

　　for(int i=0;i<len;i++)  

　　{  

　　cout<<*array++<<endl;  

　　} 　　} 　　下面我们来仔细说明一下字符指针数组和指向指针的指针，段1中的程序是下面的样子：  

　　char *a[]={"abc"，"cde"，"fgh"};  

　　char* *b=a;  

　　cout<<*b<<"|"<<*(b+1)<<"|"<<*(b+2)<<endl;  

　　char *a[]定义了一个指针数组，注意不是char[]，char[]是不能同时初始化为三个字符的，定义以后的a[]其实内部有三个内存位置，分别存储了abc\0，cde\0，fgh\0，三个字符串的起始地址，而这三个位置的内存地址却不是这三个字符串的起始地址，在这个例子中a[]是存储在栈空间内的，而三个字符串却是存储在静态内存空间内的const区域中的，接下去我们看到了char* *b=a;这里定义了一个指向指针的指针， 如果你写成char *b=a;那么是错误的，因为编译器会返回一个无法将char* *[3]转换给char *的错误，b=a的赋值，实际上是把a的首地址赋给了b，由于b是一个指向指针的指针， 程序的输出  

cout<<*b<<"|"<<*(b+1)<<"|"<<*(b+2)<<endl;  

结果是

 

abc cde fgh  

可以看出每一次内存地址的+1操作事实上是一次加sizeof(char*)的操作，我们在32位的系统中sizeof(char*)的长度是4，所以每加1也就是+4，实际上是*a[]内部三个位置的+1，所以*(b+1)的结果自然就是cde了，我们这时候可能会问，为什么输出是cde而不是c一个呢?答案是这样的，在c++中，输出字符指针就是输出字符串，程序会自动在遇到\0后停止。

我们最后分析一下段2中的代码，段2中我们调用了print_array()这个函数，这个函数中形式参数是char *array[]和代码中的char *test[]一样，同为字符指针，当你把参数传递过来的时候，事实上不是把数组内容传递过来，test的首地址传递了进来，由于array是指针，所以在内存中它在栈区，具有变量一样的性质，可以为左值，所以我们输出写成了:

 

cout<<*array++<<endl;  

当然我们也可以改写为:

 

cout<<array[i]<<endl  

这里在循环中的每次加1操作和段1代码总的道理是一样的，注意看下面的图!

到这里这两个非常重要的知识点我们都说完了，说归说，要想透彻理解希望读者多动手，多观察，熟能生巧。下面是内存结构示意图：

 

最近好像是跟指针卯上了，发现以前真的学得不好，太多的东西是模模糊糊的。可能是因为S现在做的项目有太多地方使用到指针，而且有的时候用到复杂的指针，所以才觉得有必要好好的研究下，这样可以减轻S的负担，也为我以后做准备吧。

要搞清一个指针首先必须搞清指针的四方面的内容：

指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区（这里只对int型进行说明，其他的类推）。

 

指针的类型：从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型，这是指针本身所具有的类型。例如： (1)int *ptr; //指针的类型是 int *　 整型指针 (2)int **ptr; //指针的类型是 int **　 指针的指针 (3)int (*ptr)[3]; //指针的类型是 int(*)[3] 数组指针 (4)int *ptr[3]; //指针的类型是 int*[3] 指针数组

 

指针所指向的类型： (1)int *ptr; //指针所指向的类型是 int 指向整型 (3)int **ptr; //指针所指向的的类型是 int * 指向整型指针 (4)int (*ptr)[3]; //指针所指向的的类型是 int()[3] 指向整型数组 (5)int *ptr[3];//指针所指向的类型是 int[] 指向指针数组的第一个单元

 

指针的值(又称指针所指向的内存区或地址)： 指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长。指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为sizeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说该指针指向了以为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。

 

指针本身所占据的内存区：指针类型本身占据的内存空间，在32位平台中，指针本身占据4个字节的长度，可以使用sizeof(指针类型)来测试下指针占据的存储空间。

以上是预备知识，接下来言归正传。

 

指针的指针：这个比较简单，如下代码1：指针pni指向整型变量ni，pni的值为ni所在内存中的地址，指针的指针ppni指向一个整型指针，ppni的值为指针pni所在的存储单元的地址。

int ni=10; int* pni=&ni; int** ppni=&pni;

数组指针：顾名思义，指向数组的指针，这里一定要区分指向数组首单元的指针和数组指针的区别。

如下代码2： int narr[3]; int *p=narr;

在以上代码中，narr只是一个指代数组首地址的指针，而不是一个指向数组的指针。所以p只是一个指向数组首地址的指针。这个例子在《指针和数组名的区别》文章有详细介绍。

数组指针的使用见下代码3：

void main(){

          int array[2][3] = {{1,2,3},{4,5,6}};//二维数组看作是两个一维数组           int (*pa)[3]; //申明一个数组指针，若(*pa)[3]中不为3则出错                         //array[0]指代二维数组中{1,2,3}的首地址，那么&array[0]是数组指针型

                     //第三行定义的pa是指向一个3维数组的数组指针

          pa = &array[0];   //即（*pa）相当于array[0]。           cout<<pa[0]<<"|"<<pa[1]<<"|"<<pa[2]<<endl;           cout<<pa<<endl;           cout<<*pa<<endl;

          cout<<(*pa)[0]<<"|"<<(*pa)[1]<<"|"<<(*pa)[2]<<endl;           cout<<**pa<<endl;           cout<<*(*pa+2)<<endl;

          pa++;           cout<<pa[0]<<"|"<<pa[1]<<"|"<<pa[2]<<endl;           cout<<pa<<endl;           cout<<*pa<<endl;

          cout<<(*pa)[0]<<"|"<<(*pa)[1]<<"|"<<(*pa)[2]<<endl;           cout<<**pa<<endl;           cout<<*(*pa+2)<<endl;

} 输出为：

0012FF68|0012FF74|0012FF80

0012FF68

0012FF68

 

1|2|3

1

3

 

0012FF74|0012FF80|0012FF8C

0012FF74

0012FF74

 

4|5|6

4

6

 

以上代码中第三行定义的pa是指向一个3维数组的数组指针。*pa就是一维数组的指针，自然可以使用

(*pa)[i]的方式访问数组,而*pa+1则是(*pa)[1]这个元素的地址，所以自然得到第5，6，7行所注释的输出。经过pa++语句，由于pa是数组指针，后来pa中存放的地址应该是*pa+sizeof(array[0])，所以现在*pa就是一维数组{4,5,6}对应的首地址，同理得到第9，10，11行所注释的输出结果。

 

指针数组：也就是指针的数组，存放指针的数组，数组中的元素是指针。 例如：

int n1=10; int n2=20; int* np[2]={&n1,&n2}; cout<<*(np[0])<<endl; cout<<*(np[1]);//输出20 上述代码的第三行定义了一个指针数组，数组中含有两个元素，分别是n1、n2的地址，np[0],np[1]就是对应的这两个地址，所以*np[0],*np[1]分别是10，20

 

对于指针的指针、数组指针、指针数组，我们还可以给出更为直观的定义方法：

指针的指针： typedef int* intP; intP* p;

数组指针： typedef int intArray[2]; intArray* p;

指针数组： typedef int* intPtr; intPtr p[2]; 由于一些运算符优先级不同（*的优先级比[]低），所以在适当的时候使用typedef可以有效的避免迷惑性。

这几天的研究结束了我和S对指针的困惑，所以作此总结，希望对大家都有帮助。

数组指针与指针数组的区别
int (*p)[10]; 定义了一个数组指针，它是个指针 这个指针与一般的指针没有什么区别，仅仅是这个指针指向一个数组。这里我们把数组作为了基本的元素处理。也就是说，将整个数组作为一种类型，而数组名就是这个类型的一个具体变量。例如：

int a[10]; 一个数组类型，形状就是这样：int [10]; a就是新定义的一个变量。 int b[3]; 一个数组类型，形状就是这样：int [3];b就是新定义的一个变量。 因为这两个类型形状不一样，因此是两个不同的类型，因此a,b就是不同类型的变量。这就好比int a和double b ：a和b不一样。不知道大家是否已经对数组类型有了基本的印象？ 那么把数组名作为该数组类型的一个具体变量，我们就可以定义指向这个变量的指针，即数组指针。 对于数组类型：int [10],我们可以定义一个指针，int (*p) [10].注意这里一定要加上小括弧。否则就会变成了指针数组。定义了指针之后，我们可以对该指针赋值，如p=&a;如果定义了一个二维数组，int c[3][10]。我们可以认为定义了一个一维的数组，这个数组有三个int[10]的元素。因此和一般的数组一样，我们可以将该数组名赋给指针，其实也就是第一个元素的地址付给指针。即: p=c;或者p=&c[0]。其余情况以此类推。 --------------------------------------------------------------- 数组指针是指针类型，它指向一个数组，代表数组的首地址。

指针数组首先是一个数组，只不过这个数组的元素是指针而己。

 

数组指针是定义的一个指针，而指针 所指的对象是一个数组，指针 指向该数组的首单元的地址，它对数组的内部元素的属性不了解，只是规定了首单元的地址，通过它可以找到该数组。

指针数组指的是一个数组，它其中的所有元素都是指针类型，这里所有指针都指向不同的地址，而所指地址的数据也不一定相同，但是必须属于同一数据类型。 二者相差很多。 --------------------------------------------------------------- 下面的程序有错误嘛？为什么？ #include<iostream.h> void main(){ int *p=new int [10]; int arr[10]; int (*ptr)[10]; ptr=p;//cannot convert from 'int *' to 'int (*)[10]' ptr=arr;//cannot convert from 'int [10]' to 'int (*)[10]' ptr=&arr;//正确 typedef int (*type)[10];//正确 type pa=&(new int[10]); int* pb; type pc=&(pb=new int[10]); type pd=(type)(new int[10]); }

数组指针是指向数组的， 如: int a[3][3],(*p)[3]; p=a; 这里(*p)[3]用于告诉编译系统，它是一个指针，指向一个长度为3的整型数组。这样在用指针访问其所指向的内存单元的时候就可以用 *（*(p+i)+j) 来表示 a[i][j];

若：int a[3][3],*p; p=a; 就需用：*(p+3*i+j)来表示a[i][j].

指针数组是这样一种特殊的数组：它的每一个数组元素都是一个指针。 如：int *p[3]; p[0],p[1],p[2]都是一个指针。

我看了你所说的有关指针问题的看法,我非常同意你所说的. 其实我也有一点看法:所谓指针数组吗,其实就可以把他看成一个结构体指针,只是他里面的元素都是相同的类型.

例如:int (*p)[10];p就是指向一个由10个整型单元构成的数组的指针.p必须是指向由10个整型单元构成的数组,就如一个结构体指针必须指向与它相同类型的一个结构体一样
前言： 其实数组也就是一个逻辑上的拥有首地址的连续的内存空间。 1。我们常常用改变下标的方式来访问数组，本质上和通过加减某种特定类型的 指针来实现在逻辑内存上的跳跃是相同的，其实数组的越界和程序员通过指针 强行访问逻辑内存是一样的原理，只是指针更加灵活，同时也带来的大量的 安全性问题。 2。而对于诸如 int*(*p)[i] 这样的问题，无非就是一个指针的指针，而后一指针表象上就是那个数组，所以如果我们要想访问数组元素，就必须通过多加一个指针的方式来访问，而且还需要注意的是，后一指针也就是表象上的数组的寻址或者是跳跃方式是按照每一个元素以sizeof(int)的空间来跳跃的，我们也可以让这样的int成为其他的基本类型或者是扩展类型，只不过改变的跳跃的空间的大小或者是方式（这里的方式可以认为是某种具有嵌套关系的扩展类型）。