超强的指针学习笔记.docx

超强的指针学习笔记.docx

《超强的指针学习笔记.docx》由会员分享，可在线阅读，更多相关《超强的指针学习笔记.docx（15页珍藏版）》请在冰豆网上搜索。

超强的指针学习笔记

超强的指针学习笔记

C语言所有复杂的指针声明，都是由各种声明嵌套构成的。

如何解读复杂指针声明呢？

右左法则是一个既著名又常用的方法。

不过，右左法则其实并不是C标准里面的内容，它是从C标准的声明规定中归纳出来的方法。

C标准的声明规则，是用来解决如何创建声明的，而右左法则是用来解决如何辩识一个声明的，两者可以说是相反的。

右左法则的英文原文是这样说的：

Theright-leftrule:

Startreadingthedeclarationfromtheinnermostparentheses,goright,andthengoleft.Whenyouencounterparentheses,thedirectionshouldbereversed.Onceeverythingintheparentheseshasbeenparsed,jumpoutofit.Continuetillthewholedeclarationhasbeenparsed.

这段英文的翻译如下：

右左法则：

首先从最里面的圆括号看起，然后往右看，再往左看。

每当遇到圆括号时，就应该掉转阅读方向。

一旦解析完圆括号里面所有的东西，就跳出圆括号。

重复这个过程直到整个声明解析完毕。

        笔者要对这个法则进行一个小小的修正，应该是从未定义的标识符开始阅读，而不是从括号读起，之所以是未定义的标识符，是因为一个声明里面可能有多个标识符，但未定义的标识符只会有一个。

        现在通过一些例子来讨论右左法则的应用，先从最简单的开始，逐步加深：

int（*func）（int*p）;

首先找到那个未定义的标识符，就是func，它的外面有一对圆括号，而且左边是一个*号，这说明func是一个指针，然后跳出这个圆括号，先看右边，也是一个圆括号，这说明（*func）是一个函数，而func是一个指向这类函数的指针，就是一个函数指针，这类函数具有int*类型的形参，返回值类型是int。

int（*func）（int*p,int（*f）（int*））;

func被一对括号包含，且左边有一个*号，说明func是一个指针，跳出括号，右边也有个括号，那么func是一个指向函数的指针，这类函数具有int*和int（*）（int*）这样的形参，返回值为int类型。

再来看一看func的形参int（*f）（int*），类似前面的解释，f也是一个函数指针，指向的函数具有int*类型的形参，返回值为int。

int（*func[5]）（int*p）;

func右边是一个[]运算符，说明func是一个具有5个元素的数组，func的左边有一个*，说明func的元素是指针，要注意这里的*不是修饰func的，而是修饰func[5]的，原因是[]运算符优先级比*高，func先跟[]结合，因此*修饰的是func[5]。

跳出这个括号，看右边，也是一对圆括号，说明func数组的元素是函数类型的指针，它所指向的函数具有int*类型的形参，返回值类型为int。

int（*（*func）[5]）（int*p）;

func被一个圆括号包含，左边又有一个*，那么func是一个指针，跳出括号，右边是一个[]运算符号，说明func是一个指向数组的指针，现在往左看，左边有一个*号，说明这个数组的元素是指针，再跳出括号，右边又有一个括号，说明这个数组的元素是指向函数的指针。

总结一下，就是：

func是一个指向数组的指针，这个数组的元素是函数指针，这些指针指向具有int*形参，返回值为int类型的函数。

int（*（*func）（int*p））[5];

func是一个函数指针，这类函数具有int*类型的形参，返回值是指向数组的指针，所指向的数组的元素是具有5个int元素的数组。

要注意有些复杂指针声明是非法的，例如：

intfunc（void）[5];

func是一个返回值为具有5个int元素的数组的函数。

但C语言的函数返回值不能为数组，这是因为如果允许函数返回值为数组，那么接收这个数组的内容的东西，也必须是一个数组，但C语言的数组名是一个右值，它不能作为左值来接收另一个数组，因此函数返回值不能为数组。

intfunc[5]（void）;

func是一个具有5个元素的数组，这个数组的元素都是函数。

这也是非法的，因为数组的元素除了类型必须一样外，每个元素所占用的内存空间也必须相同，显然函数是无法达到这个要求的，即使函数的类型一样，但函数所占用的空间通常是不相同的。

作为练习，下面列几个复杂指针声明给读者自己来解析，答案放在第十章里。

int（*（*func）[5][6]）[7][8];

int（*（*（*func）（int*））[5]）（int*）;

int（*（*func[7][8][9]）（int*））[5];

        实际当中，需要声明一个复杂指针时，如果把整个声明写成上面所示的形式，对程序可读性是一大损害。

应该用typedef来对声明逐层分解，增强可读性，例如对于声明：

int（*（*func）（int*p））[5];

可以这样分解：

typedef  int（*PARA）[5];

typedefPARA（*func）（int*）;

这样就容易看得多了。

===============================================================

转载述：

这是一篇比较老的关于指针的文章，作者站在初学者的角度对指针作了深入的剖析。

如果你在学习指针的时候有什么问题，看一看这篇文章定有收获。

一。

指针的概念

    1。

指针的类型

    2。

指针所指向的类型

    3。

指针的值

二。

指针的算术运算

三。

运算符&和*

四。

指针表达式

五。

数组和指针的关系  

一。

指针的概念

    指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。

    要搞清一个指针需要搞清指针的四方面的内容：

指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针本身所占据的内存区。

让我们分别说明。

    先声明几个指针放着做例子：

例一：

（1）int*ptr;

（2）char*ptr;

（3）int**ptr;

（4）int（*ptr）[3];

（5）int*（*ptr）[4];

如果看不懂后几个例子的话，请参阅我前段时间贴出的文章<<如何理解c和c++的复杂类型声明>>。

1。

指针的类型

    从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。

这是指针本身所具有的类型。

让我们看看例一中各个指针的类型：

（1）int*ptr;//指针的类型是int*

（2）char*ptr;//指针的类型是char*

（3）int**ptr;//指针的类型是int**

（4）int（*ptr）[3];//指针的类型是int（*）[3]

（5）int*（*ptr）[4];//指针的类型是int*（*）[4]

怎么样？

找出指针的类型的方法是不是很简单？

2。

指针所指向的类型

    当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。

    从语法上看，你只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉，剩下的就是指针所指向的类型。

例如：

（1）int*ptr;//指针所指向的类型是int

（2）char*ptr;//指针所指向的的类型是char

（3）int**ptr;//指针所指向的的类型是int*

（4）int（*ptr）[3];//指针所指向的的类型是int（）[3]

（5）int*（*ptr）[4];//指针所指向的的类型是int*（）[4]

    在指针的算术运算中，指针所指向的类型有很大的作用。

    指针的类型（即指针本身的类型）和指针所指向的类型是两个概念。

当你对C越来越熟悉时，你会发现，把与指针搅和在一起的“类型”这个概念分成“指针的类型”和“指针所指向的类型”两个概念，是精通指针的关键点之一。

我看了不少书，发现有些写得差的书中，就把指针的这两个概念搅在一起了，所以看起书来前后矛盾，越看越糊涂。

3。

指针的值

    指针的值，或者叫指针所指向的内存区或地址。

指针的值是指针本身存储的数值，这个值将被编译器当作一个地址，而不是一个一般的数值。

在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序里内存地址全都是32位长。

    指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为sizeof（指针所指向的类型）的一片内存区。

以后，我们说一个指针的值是XX，就相当于说该指针指向了以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内存区域的首地址。

    指针所指向的内存区和指针所指向的类型是两个完全不同的概念。

在例一中，指针所指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的。

    以后，每遇到一个指针，都应该问问：

这个指针的类型是什么？

指针指向的类型是什么？

该指针指向了哪里？

4。

指针本身所占据的内存区。

    指针本身占了多大的内存？

你只要用函数sizeof（指针的类型）测一下就知道了。

在32位平台里，指针本身占据了4个字节的长度。

    指针本身占据的内存这个概念在判断一个指针表达式是否是左值时很有用。

二。

指针的算术运算

    指针可以加上或减去一个整数。

指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。

例如：

例二：

1。

chara[20];

2。

int*ptr=a;

...

...

3。

ptr++;

    在上例中，指针ptr的类型是int*,它指向的类型是int，它被初始化为指向整形变量a。

接下来的第3句中，指针ptr被加了1，编译器是这样处理的：

它把指针ptr的值加上了sizeof（int），在32位程序中，是被加上了4。

由于地址是用字节做单位的，故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。

由于char类型的长度是一个字节，所以，原来ptr是指向数组a的第0号单元开始的四个字节，此时指向了数组a中从第4号单元开始的四个字节。

    我们可以用一个指针和一个循环来遍历一个数组，看例子：

例三：

intarray[20];

int*ptr=array;

...

//此处略去为整型数组赋值的代码。

...

for（i=0;i<20;i++）

{

（*ptr）++;

ptr++；

}

这个例子将整型数组中各个单元的值加1。

由于每次循环都将指针ptr加1，所以每次循环都能访问数组的下一个单元。

再看例子：

例四：

1。

chara[20];

2。

int*ptr=a;

...

...

3。

ptr+=5;

    在这个例子中，ptr被加上了5，编译器是这样处理的：

将指针ptr的值加上5乘sizeof（int），在32位程序中就是加上了5乘4=20。

由于地址的单位是字节，故现在的ptr所指向的地址比起加5后的ptr所指向的地址来说，向高地址方向移动了20个字节。

在这个例子中，