指针.docx
《指针.docx》由会员分享,可在线阅读,更多相关《指针.docx(9页珍藏版)》请在冰豆网上搜索。
指针
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]
②指针所指向的类型:
把指针声明语句中的指针名字和名字左边的指针声明符*去掉,剩下的就是指针所指向的类型。
(1)int *ptr; //指针所指向的类型是 int
(2)char *ptr; //指针所指向的的类型是 char
(3)int **ptr; //指针所指向的的类型是 int *
(4)int (*ptr)[3]; //指针所指向的的类型是 int()[3]
(5)int *(*ptr)[4]; //指针所指向的的类型是 int*()[4]
③指针的值,或者叫指针所指向的内存区或地址。
指针的值是指针本身存储的数值,这个值将被编译器当作一个地址,而不是一个一般的数值。
在32位程序里,所有类型的指针的值都是一个32位整数,因为32位程序里内存地址全都是32位长。
指针所指向的内存区就是从指针的值所代表的那个内存地址开始,长度为sizeof(指针所指向的类型)的一片内存区。
以后,我们说一个指针的值是XX,就相当于说该指针指向了以XX为首地址的一片内存区域;我们说一个指针指向了某块内存区域,就相当于说该指针的值是这块内存区域的首地址。
④指针本身所占据的内存区。
用函数sizeof(指针的类型)。
在32位平台里,指针本身占据了4个字节的长度。
--[if!
supportEmptyParas]-->
--[endif]-->
2.指针的算术运算
指针可以加上或减去一个整数。
指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。
例如:
char a[20];
int *ptr=a;
ptr++;
在上例中,指针ptr的类型是int*,它指向的类型是int,它被初始化为指向char数组a。
接下来的第3句中,指针ptr被加了1,编译器是这样处理的:
它把指针ptr的值加上了sizeof(int),在32位程序中,是被加上了4。
由于地址是用字节做单位的,故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。
由于char类型的长度是一个字节,所以,原来ptr是指向数组a的第0号单元开始的四个字节,此时指向了数组a中从第4号单元开始的四个字节。
--[if!
supportEmptyParas]-->
--[endif]-->
总结一下,一个指针ptrold加上一个整数n后,结果是一个新的指针ptrnew,ptrnew的类型和ptrold的类型相同,ptrnew所指向的类型和ptrold所指向的类型也相同。
ptrnew的值将比ptrold的值增加了n乘sizeof(ptrold所指向的类型)个字节。
就是说,ptrnew所指向的内存区将比ptrold所指向的内存区向高地址方向移动了n乘sizeof(ptrold所指向的类型)个字节。
一个指针ptrold减去一个整数n后,结果是一个新的指针ptrnew,ptrnew的类型和ptrold的类型相同,ptrnew所指向的类型和ptrold所指向的类型也相同。
ptrnew的值将比ptrold的值减少了n乘sizeof(ptrold所指向的类型)个字节,就是说,ptrnew所指向的内存区将比ptrold所指向的内存区向低地址方向移动了n乘sizeof(ptrold所指向的类型)个字节。
--[if!
supportEmptyParas]-->
--[endif]-->
3.运算符&(取地址运算符)和*(间接运算符)
&a的运算结果是一个指针,指针的类型是a的类型加个*,指针所指向的类型是a的类型,指针所指向的地址嘛,那就是a的地址。
*p的运算结果就五花八门了。
总之*p的结果是p所指向的东西,这个东西有这些特点:
它的类型是p指向的类型,它所占用的地址是p所指向的地址。
例:
int a=12;
int b;
int *p;
int **ptr;
p=&a //&a的结果是一个指针,类型是int*,指向的类型是int,指向的地址是a的地址。
*p=24;//*p的结果,在这里它的类型是int,它所占用的地址是p所指向的地址,显然,*p就是变量a。
ptr=&p//&p的结果是个指针,该指针的类型是p的类型加个*,在这里是int**。
该指针所指向的类型是p的类型,这里是int*。
该指针所指向的地址就是指针p自己的地址。
*ptr=&(*ptr)//*ptr是个指针,&b的结果也是个指针,且这两个指针的类型和所指向的类型是一样的,所以用&b来给*ptr赋值就是毫无问题的了。
**ptr=34;//*ptr的结果是ptr所指向的东西,在这里是一个指针,对这个指针再做一次*运算,结果就是一个int类型的变量。
--[if!
supportEmptyParas]-->
--[endif]-->
4.指针表达式:
一个表达式的最后结果如果是一个指针,那么这个表达式就叫指针表达式。
由于指针表达式的结果是一个指针,所以指针表达式也具有指针所具有的四个要素:
指针的类型,指针所指向的类型,指针指向的内存区,指针自身占据的内存。
标签:
C语言
.
5.数组和指针的关系
数组的数组名其实可以看作一个指针。
例:
int array[10]={0,1,2,3,4,5,6,7,8,9},value;
value=array[0];//也可写成:
value=*array;
value=array[3];//也可写成:
value=*(array+3);
value=array[4];//也可写成:
value=*(array+4);
一般而言数组名array代表数组本身,类型是int[10],但如果把array看做指针的话,它指向数组的第0个单元,类型是int*,所指向的类型是数组单元的类型即int。
因此*array等于0就一点也不奇怪了。
同理,array+3是一个指向数组第3个单元的指针,所以*(array+3)等于3。
其它依此类推。
例:
char *str[3]={"Hello,thisisasample!
","Hi,goodmorning.","Helloworld"};
char s[80];
strcpy(s,str[0]);//也可写成strcpy(s,*str);
strcpy(s,str[1]);//也可写成strcpy(s,*(str+1));
strcpy(s,str[2]);//也可写成strcpy(s,*(str+2));
str是一个三单元的数组,该数组的每个单元都是一个指针,这些指针各指向一个字符串。
把指针数组名str当作一个指针的话,它指向数组的第0号单元,它的类型是char**,它指向的类型是char*。
*str也是一个指针,它的类型是char*,它所指向的类型是char,它指向的地址是字符串"Hello,this is a sample!
"的第一个字符的地址,即'H'的地址。
str+1也是一个指针,它指向数组的第1号单元,它的类型是char**,它指向的类型是char *。
*(str+1)也是一个指针,它的类型是char*,它所指向的类型是char,它指向"Hi,good morning."的第一个字符'H',等等。
总结:
声明了一个数组TYPE array[n],则数组名称array就有了两重含义:
第一,它代表整个数组,它的类型是TYPE[n];第二,它是一个指针,该指针的类型是TYPE*,该指针指向的类型是TYPE,也就是数组单元的类型,该指针指向的内存区就是数组第0号单元,该指针自己占有单独的内存区,注意它和数组第0号单元占据的内存区是不同的。
该指针的值是不能修改的,即类似array++的表达式是错误的。
在不同的表达式中数组名array可以扮演不同的角色。
在表达式sizeof(array)中,数组名array代表数组本身,故这时sizeof函数测出的是整个数组的大小。
在表达式*array中,array扮演的是指针,因此这个表达式的结果就是数组第0号单元的值。
sizeof(*array)测出的是数组单元的大小。
表达式array+n(其中n=0,1,2,....。
)中,array扮演的是指针,故array+n的结果是一个指针,它的类型是TYPE*,它指向的类型是TYPE,它指向数组第n号单元。
故sizeof(array+n)测出的是指针类型的大小。
sizeof(对象)测出的都是对象自身的类型的大小。
--[if!
supportEmptyParas]-->
--[endif]-->
6.指针和结构类型的关系
指向结构类型对象的指针。
例:
struct MyStruct
{
int a;
int b;
int c;
}
MyStruct ss={20,30,40};//声明了结构对象ss,并把ss的三个成员初始化为20,30和40。
MyStruct *ptr=&ss //声明了一个指向结构对象ss的指针。
它的类型是MyStruct*,它指向的类型是MyStruct。
int *pstr=(int*)&ss //声明了一个指向结构对象ss的指针。
但是它的类型和它指向的类型和ptr是不同的。
通过指针ptr来访问ss的三个成员变量:
ptr->a;
ptr->b;
ptr->c;
通过指针pstr来访问ss的三个成员变量:
*pstr;//访问了ss的成员a。
*(pstr+1);//访问了ss的成员b
*(pstr+2)//访问了ss的成员c。
这样使用pstr来访问结构成员是不正规的,为了说明为什么不正规,让我们看看怎样通过指针来访问数组的各个单元。
例:
int array[3]={35,56,37};
int *pa=array;
通过指针pa访问数组array的三个单元的方法是:
*pa;//访问了第0号单元
*(pa+1);//访问了第1号单元
*(pa+2);//访问了第2号单元
从格式上看倒是与通过指针访问结构成员的不正规方法的格式一样。
所有的C/C++编译器在排列数组的单元时,总是把各个数组单元存放在连续的存储区里,单元和单元之间没有空隙。
但在存放结构对象的各个成员时,在某种编译环境下,可能会需要字对齐或双字对齐或者是别的什么对齐,需要在相邻两个成员之间加若干"填充字节",这就导致各个成员之间可能会有若干个字节的空隙。
所以,即使*pstr访问到了结构对象ss的第一个成员变量a,也不能保证*(pstr+1)就一定能访问到结构成员b。
因为成员a和成员b之间可能会有若干填充字节,说不定*(pstr+1)就正好访问到了这些填充字节呢。
这也证明了指针的灵活性。
要是你的目的就是想看看各个结构成员之间到底有没有填充字节,嘿,这倒是个不错的方法。
通过指针访问结构成员的正确方法应该是象使用指针ptr的方法。
--[if!
supportEmptyParas]-->
--[endif]-->
7.指针和函数的关系
可以把一个指针声明成为一个指向函数的指针。
int fun1(char*,int);
int (*pfun1)(char*,int);
pfun1= fun1;
....
....
inta = (*pfun1)("abcdefg",7); //通过函数指针调用函数。
可以把指针作为函数的形参。
在函数调用语句中,可以用指针表达式来作为实参。
例:
intfun(char*);
inta;
charstr[]="abcdefghijklmn";
a=fun(str);
...
...
intfun(char*s)
{
intnum=0;
for(intI=0;i{
num+=*s;s++;
}
returnnum;
}
这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之和。
前面说了,数组的名字也是一个指针。
在函数调用中,当把str作为实参传递给形参s后,实际是把str的值传递给了s,s所指向的地址就和str所指向的地址一致,但是str和s各自占用各自的存储空间。
在函数体内对s进行自加1运算,并不意味着同时对str进行了自加1运算。
函数指针
函数指针可能是最容易引起理解上的困惑的声明。
函数指针在DOS时代写TSR程序时用得最多;在Win32和X-Windows时代,他们被用在需要回调函数的场合。
当然,还有其它很多地方需要用到函数指针:
虚函数表,STL中的一些模板,WinNT/2K/XP系统服务等。
让我们来看一个函数指针的简单例子:
int(*p)(char);
这里p被声明为一个函数指针,这个函数带一个char类型的参数,并且有一个int类型的返回值。
另外,带有两个float类型参数、返回值是char类型的指针的指针的函数指针可以声明如下:
char**(*p)(float,float);
那么,带两个char类型的const指针参数、无返回值的函数指针又该如何声明呢?
参考如下:
void*(*a[5])(char*const,char*const);
“右左法则”是一个简单的法则,但能让你准确理解所有的声明。
这个法则运用如下:
从最内部的括号开始阅读声明,向右看,然后向左看。
当你碰到一个括号时就调转阅读的方向。
括号内的所有内容都分析完毕就跳出括号的范围。
这样继续,直到整个声明都被分析完毕。
对上述“右左法则”做一个小小的修正:
当你第一次开始阅读声明的时候,你必须从变量名开始,而不是从最内部的括号。
下面结合例子来演示一下“右左法则”的使用。
int*(*(*fp1)(int))[10];
阅读步骤:
1.从变量名开始——fp1
2.往右看,什么也没有,碰到了),因此往左看,碰到一个*——一个指针
3.跳出括号,碰到了(int)——一个带一个int参数的函数
4.向左看,发现一个*——(函数)返回一个指针
5.跳出括号,向右看,碰到[10]——一个10元素的数组
6.向左看,发现一个*——指针
7.向左看,发现int——int类型
总结:
fp1被声明成为一个函数的指针,该函数返回指向指针数组的指针.
再来看一个例子:
int*(*(*arr[5])())();
阅读步骤:
1.从变量名开始——arr
2.往右看,发现是一个数组——一个5元素的数组
3.向左看,发现一个*——指针
4.跳出括号,向右看,发现()——不带参数的函数
5.向左看,碰到*——(函数)返回一个指针
6.跳出括号,向右发现()——不带参数的函数
7.向左,发现*——(函数)返回一个指针
8.继续向左,发现int——int类型
还有更多的例子:
float(*(*b())[])();
//bisafunctionthatreturnsa
//pointertoanarrayofpointers
//tofunctionsreturningfloats.
--[if!
supportEmptyParas]-->
--[endif]-->
void*(*c)(char,int(*)());
//cisapointertoafunctionthattakes
//twoparameters:
//acharandapointertoa
//functionthattakesno
//parametersandreturns
//anint
//andreturnsapointertovoid.
--[if!
supportEmptyParas]-->
--[endif]-->
void**(*d)(int&,
char**(*)(char*,char**));
//disapointertoafunctionthattakes
//twoparameters:
//areferencetoanintandapointer
//toafunctionthattakestwoparameters:
//apointertoacharandapointer
//toapointertoachar
//andreturnsapointertoapointer
//toachar
//andreturnsapointertoapointertovoid
--[if!
supportEmptyParas]-->
--[endif]-->
float(*(*e[10]),(int&))[5];
//eisanarrayof10pointersto
//functionsthattakeasingle
//referencetoanintasanargument
//andreturnpointersto
//anarrayof5floats.