认识指针

        

定义	含义
int i;	定义整型变量i
int *p;	p为指向整型数据的指针变量
int a[n];	定义整型数组a，它有n个元素
int *p[n];	定义指针数组p，它由n个指向整型数据的指针元素组成
int (*p)[n];	p为指向含n个元素的一维数组的指针变量
int f();	f为返回整型函数值的函数
int *p();	p为返回一个指针的函数，该指针指向整型数据
int (*p)();	p为指向函数的指针，该函数返回一个整型值
int **p;	p为一个指针变量，它指向一个指向整型数据的指针变量

 

先看个简单的：
    char *p 这定义了一个指针，指针指向的数据类型是字符型，char *（p）定义了一个指针P。

    char *p[4] 为指针数组，由于[]的优先级高于*，所以p先和 []结合，p[]是一个数组，暂时把p[]看成是q，也就是char *（q），定义了一个指针q，只不过q是一个数组罢了，故定义了一个数组，数组里面的数据是char *的，所以数组里面的数据为指针类型。所以char *p[4]是四个指针，这四个指针组成了一个数组，称为指针数组，既有多个指针组成的数组。

    char(*p)[4] 为数组指针，强制改变优先级，*先与p结合，使p成为一个指针，这个指针指向了一个具有4个char型数据的数组。故p中存放了这个char型数组的首地址，可用数组指针动态内存申请：

                                          char (*p)[10];

                                     p=(char*)malloc(sizeof(char[x])*N);

    char *f(char，char）为指针函数,（）的优先级高于*，故f先与（）结合，成为函数f（），函数的返回值是char *类型的，故返回值是一个指针。

    char （*f)(char，char）为函数指针，*与f结合成为一 个指针，这个指针指向函数的入口地址。函数名就是函数的首地址。函数指针是指向函数的指针变量。 因而“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。C在编译时，每 一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变 量一样，在这些概念上是一致的。函数指针有两个用途：调用函数和做函数的参数。

　                                    int func(int x); /* 声明一个函数 */ 
　                                    int (*f) (int x); /* 声明一个函数指针 */ 
                                      f=func; /* 将func函数的首地址赋给指针f */

以后如果要调用函数func（），也就可以这样调用：（*f）（）；

 

/****************************************************二级指针**************************************************/

二级指针简单来说就是指向指针的指针。

char a=200；

char *p；

char **q；//q是一个二级指针

p=&a；

q=&p；  //q指向指针p

假设变量a在内存中的地址为2000H，则它们的关系就如下面的示意图：

指针p指向a，p的值是2000H，*p就是取地址2000H中的值即a为200，而p本身的地址是4000H，q指向指针p，*q就是取地址4000H中的值即p的值为2000H，而**q就是取地址2000H中的值即200。

所以：

*p==200；

*q=2000H；

**q=200；

以上的q是一个指针指针的二级指针，然而还有指向数组的二级指针。

 

  当一个指针变量指向另一个指针变量时，则形成二级指针。使用二级指针可以在建立复杂的数据结构时提供较大的灵活性，能够实现其他语言所难以实现的一些功能。定义二级指针的形式是：

  类型标识符**二级指针变量名

  定义指针的同时可以对其赋值，然后就可以使用了。

  如果定义一个指针数组，则指针数组名就是一个二级指针。用指针数组元素值指向长度同的字符串，操作时可以节省内存空间，而对地址进行操作，提高了运行效率。

    char s[3][5]={ "abc ", "uio ", "qwe "}; 
    可以看成是三个指向字符串的一级指针（s[0],s[1],s[2]）,由s[3]得。 而s[3]本身又是一个一维数组存储s[0],s[1],s[2]三个一级指针，则s就可以看作是一个二级指针，即指向指针的指针。 这时定义一个二级指针char**p；就能通过p访问二维数组了。

    也可以这样char *p[] = {“ab“, “cd“, “ef“};定义了一个指针数组.

    char **sp = p;

    就可以使用sp[i]来访问字符串了。

大家都知道，要想在函数中改变形参的值，形参用指针传递就行了。

比如:

void f(char *p1,char *p2)

{

    *p1=10;

    *p2=20;

}

void main()

{

      char a,b;

      char *p，*q；

      p=&a；

      q=&b；

      f(p，q);

}

 执行后此时a=10，b=20；

原理如下：

当调用函数f后，p1指向a，p2指向b；

 接着*p1=10; *p2=20;使p1指向的地址空间的值赋为10，p2指向的地址空间的值赋为20；

 然后函数调用结束，这时a=10，b=20；

如果要在函数中改变指针的值，比如改变p，q的值就需要用到二级指针。

void GetMemory(char **p, int num)
{
       *p = (char *)malloc(sizeof(char) * num);
}

以上函数，就实现了在函数中改变指针的值，使指针指向新申请的空间。

指针是C语言的一大特色，它就像一把双刃剑：使用得当能够给程序带来极大的灵活性和高效性；反之，程序就会变得难以调试，漏洞百出！

众所周知，指针实质就是地址！一个变量的地址即称为此变量的“指针”。如果有这样一种变量：它的存储单元里存放的是其它变量的地址！我们就称之为“指针变量”。(请注意两者之间的区别：两个完全不同的概念！)

我们都知道，数组名和函数名就是它们的入口地址。同理，一个变量名其实也是此变量的所在地 址！C语言中有一种运算符为“&”:取址运算符。因为数组名与函数名本身代表的就是地址，通常不会对并且也不能对它们进行取址操作或其它运算操作 (其实对于函数名的直接引用与对它取址是等价的)。这也是它们被称为“常量”的原因！但对于一个变量来讲，情况就不一样了。要想获得它的地址，就必须进行 “&”运算，尽管它本身表示的也是地址值!而对变量直接进行引用得到却是它所在的内存单元的数据内容！“指针变量”作为一种变量当然也不能例外！ 只不过它与其它普通变量的差别是，它的内容是其它变量(包括“指针变量”)的地址，在WIN32上，它的大小恒为32位，4BYTE。而普通变量则不会有 大小上的限制！对指针变量所指向的地址的数据内容的获取则是通过操作符“*”。在理解上我们将“提领操作符*”视为类型的一部分，并且这种数据类型是一种 变量地址类型(均对每一个“*”而言)！

只要明白了以上常识，“指针”将不会再是程序设计中的“拦路虎”!

从内存的存储映象的角度来讲，C的规则数组(不包括通过数据结构设计的多维数组)不存在多维， 也就是说所有的数组本质上都是一维的，而一级指针就等价于一维数组！关键的不同在于多维数组与一维数组语义上的差别！而我们理解多维数组通常将之形象地描 述成“矩阵”形式。更为精确的理解是多维数组的每个元素就是一个数组，如此递归下去直至最后每个元素是一个简单的变量类型，最终得到的就是一个特殊的一维 数组！

#include
    void main()
    {
        int a[2][3];
        int**p=a;
    }

请问为什么是错误的？？（请不要说数组名是一个指针这个我知道，我想知道为什么不能用二级指针指向二维数组）

    首先数组和指针的概念你没分清楚，数组的本质没搞清楚。这是导致问题出现的根源。 
int x[5]; 这个定义里面，我们说定义了一个数组x，此数组有5个数组元素，元素的类型为int类型。首先要问的是，x到底为什么东西? 我知道，在谭浩 强的书
上面说x是数组名，x代表了数组第一个元素的首地址。没错，x确实是数组的名字，x的值也确实是第一个数组元素的地址值。注意这里我们说x代 表的值与数组第
一个元素的地址值相等，但是并不是说他们的类型是一样的。那么x的类型到底是什么呢? 有人说就是int * 类型。有如下语句可以做证： 
int *p=x; //这句话是正确的。 
x的类型真是int *吗，我们说不是，因为下面的语句是不正确的： 
int a=10; 
x=&a; // int *类型的变量时可以接受值的。所以x不是int* 
那么我们可以猜测x的类型是不是 int *const呢。也就是说x是一个地址值不可以改变的指针。这句话貌似有点正确。但是请大家看看下面的例子： 
int x[5]={0}; 
int a=sizeof(x); // a的值到底是多少?实际上这里a的值是5*4=20 
我这里使用的编译器是VC++ 6.0 int类型数据占用4个字节空间，所以这里的道的是整个数组占用的字节数。 我们不是说x的类型是iint * const类型的 吗，
也就是x应该是一个指针类型，应该是4个字节的啊，为什么sizeof出来时整个数组占用的字节数呢。例如 
sizeof(int *)这个的结果就是4。所以有此可以看出，x的类型并不是int*,也不是int * const。 
int x[5];中的x到底是什么呢，我们说x是数组，此数组有5个元素，并且每个元素都是int类型。 我们有一个识别数据类型的规律例如： 
int x; //x类型为int 
int *x;//x类型为int * 
int **x;//x类型为int ** 
int (*x)[10];//x类型为int(*)[10]实际上是指向数组的指针 
int (*x)(int ,int);//x的类型为int(*)(int,int)实际上是指向函数的指针 
由此可以看出，一个符号是什么数据类型，我们只要在其定义的表达式中去掉符号本身，剩下的就是符号的类型了。照此推断，int x[5];中x的类型应该 是  int [5]这个类型，可以看出此类型并不是int *类型。 
那么int x[5];中的x可以这样赋值: int *p=x; 为什么呢，只能说这里面将x的类型隐式转换为了int *类型。所以这里是可以赋值的，因为进行了类型转 换。 
再请看下面的例子： 
void function(int x[5]) 
{ 
cout<这里输出4 
} 
为什么会输出4，而不是4*5呢，可以看出上面的函数形参实际上类型是int*，并不是数组类型，所以我们在定义函数的时候，下面的都是与上面等价的： 
void function(int x[])//元素个数是多少可以省略 
{ 
cout<这里输出4 
} 
void function(int *x) //直接写成指针变量也没错 
{ 
cout<这里输出4 
} 
他们都是等价的。 
那么我们看一个类似的问题： 
int x[5]; 
int **p=&x; //为什么会报错？ 因为类型不匹配。 
p的类型是int **,而&x的类型却不是int **。 &x的类型实际上是int(*)[5]，因为去的是x的地址，也就是说这个地址是数组的地址，并不是指向数组第 一个元
素的指针的指针(也就是二维指针)，而是整个数组的地址。所以我们可以改成下面的： 
int (*p)[5]=&x;//这就对了。 
指向数组的指针，和指向数组元素的指针有什么不同？ 
我们说对于一个指针变量，要几点是我们必须注意的，例如int *p;我们要注意的是，p的类型是int*，p占用的空间4个字节，p指向的数据类型是int。 p指向的数
据类型占用4个字节。所以对于指针变量，我们要明白指针变量本身是占用空间的，本身是有类型的，其次指针变量所指向的空间是有类型的， 是有空间的。 
那么int *p; char *p1; 对于指针变量来说p,p1里面都放的是地址值，说白了就是一个数值，他们都占用4个字节的空间，但是他们的类型不一样，p里 面的地址
指向的是int类型的数据，p1指向的是char类型的数据，这主要体现在p++与p1++中他们在内存中移动的字节数是不一样的，我们假设int占4个字 节，char占1个
字节。那么对于p来说向前移动了4个字节，p1来说移动了一个字节。这就是他们的类型不同，导致运算过程中的不同。 
int x[5]; 
int (*p3)[5]; 此时p3指向数组x，那么p3++实际上向前移动了多少呢，可以算出移动了4*5个字节。也就是p3指向的是一个数组，是整个数组，所以p3移 动的时
候是将一个数组当做一个整体来看待的。所以向前移动了一整个数组的距离。 
再看你的问题之前，我们来看一个类似的问题： 
int a[2][3]; 
int**p=&a; //这里我用&a来赋值行不行呢。是不行的。 
这里为什么是错误的，原因就是因为&a的类型不是int**类型。所以类型不兼容，导致不能赋值，同时这两种类型是不可以相互转换的。 那么&a到底是一 个什么
样的类型呢。 我们说&a去的是整个数组的地址，那么&a自然就是指向整个数组的指针了。 int (*p)[2][3]=&a; 此时这样赋值才是正确的。如果 我们要用a直
接赋值，那该定义一个什么样的变量来接受它呢，首先要明白，数组名代表的地址类型是指向数组的第一个元素的指针，例如： 
int a[10]; 
int *p=a; 实际上这里与 int *p=&a[0];是等价的。因为指向a[0]的指针类型就是int*类型。  那么&a的是去数组的地址，其类型是指向数组的指针，而 不是
指向数组第一个元素的指针，整个是要区别的，他们的类型就不一样。 int(*p)[10]=&a; 
所以说这里的a和&a绝对不是同一个东西，虽然本质上他们的地址值是一样的，但是他们的类型不一样。就决定他们代表不同的意义。 
那么刚刚说了对于下面的例子： 
int a[2][3]; 
int (*p)[2][3]=&a;//我们可以定义这样的一个变量p来接受&a的值。 
那么我们要接受a应该定义一个什么样的变量呢。a[2][3]是一个二维数组，可以看成是这样的a是一个数组，具有两个元素，分别为a[0],a[1]其中这两个 元素的
值 a[0],a[1]他们的值又是一个具有3个元素的数组。此时我们可以将a[0],a[1]看成是数组名，那么a[0][0]就是数组a[0]的第0个元素了。对应关系 如下： 
a[0] ---->  a[0][0],a[0][1],a[0][2] 
a[1] ---->  a[1][0],a[1][1],a[1][2] 
那么a到底是什么，其实a数组有两个元素，a[0],a[1]，那么a的值自然就是其第一个元素的地址了，也就是&a[0]了。这是一个什么类型？  我们知道如 果我们
将 a[0]看成一个整体，例如我们用A来代替a[0],那么A[0],A[1]就相当于a[0][0],a[0][1] 。 此时A就是一个int类型的数组，&A，的类型实际上就 是  int(*p)[3] 这个类型。 
所以下面的代码也是正确的： 
int a[2][3]; 
int(*p)[3]=a; //所以对于你的问题，可以这样子。。

	  

.pdf