指针Word文档下载推荐.docx
《指针Word文档下载推荐.docx》由会员分享,可在线阅读,更多相关《指针Word文档下载推荐.docx(9页珍藏版)》请在冰豆网上搜索。
![指针Word文档下载推荐.docx](https://file1.bdocx.com/fileroot1/2022-12/16/1f223cc2-f62f-4ae3-8fe4-8908755af5dd/1f223cc2-f62f-4ae3-8fe4-8908755af5dd1.gif)
//指针所指向的类型是
//指针所指向的的类型是
int()[3]
int*()[4]
③指针的值,或者叫指针所指向的内存区或地址。
指针的值是指针本身存储的数值,这个值将被编译器当作一个地址,而不是一个一般的数值。
在32位程序里,所有类型的指针的值都是一个32位整数,因为32位程序里内存地址全都是32位长。
指针所指向的内存区就是从指针的值所代表的那个内存地址开始,长度为sizeof(指针所指向的类型)的一片内存区。
以后,我们说一个指针的值是XX,就相当于说该指针指向了以XX为首地址的一片内存区域;
我们说一个指针指向了某块内存区域,就相当于说该指针的值是这块内存区域的首地址。
④指针本身所占据的内存区。
用函数sizeof(指针的类型)。
在32位平台里,指针本身占据了4个字节的长度。
<
!
--[if!
supportEmptyParas]-->
--[endif]-->
2.指针的算术运算
指针可以加上或减去一个整数。
指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。
例如:
a[20];
*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号单元开始的四个字节。
总结一下,一个指针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所指向的类型)个字节。
3.运算符&
(取地址运算符)和*(间接运算符)
&
a的运算结果是一个指针,指针的类型是a的类型加个*,指针所指向的类型是a的类型,指针所指向的地址嘛,那就是a的地址。
*p的运算结果就五花八门了。
总之*p的结果是p所指向的东西,这个东西有这些特点:
它的类型是p指向的类型,它所占用的地址是p所指向的地址。
例:
a=12;
b;
*p;
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类型的变量。
4.指针表达式:
一个表达式的最后结果如果是一个指针,那么这个表达式就叫指针表达式。
由于指针表达式的结果是一个指针,所以指针表达式也具有指针所具有的四个要素:
指针的类型,指针所指向的类型,指针指向的内存区,指针自身占据的内存。
标签:
C语言
.
5.数组和指针的关系
数组的数组名其实可以看作一个指针。
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。
其它依此类推。
*str[3]={"
Hello,thisisasample!
"
,"
Hi,goodmorning."
Helloworld"
};
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
sample!
的第一个字符的地址,即'
H'
的地址。
str+1也是一个指针,它指向数组的第1号单元,它的类型是char**,它指向的类型是char
*。
*(str+1)也是一个指针,它的类型是char*,它所指向的类型是char,它指向"
Hi,good
morning."
的第一个字符'
,等等。
总结:
声明了一个数组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(对象)测出的都是对象自身的类型的大小。
6.指针和结构类型的关系
指向结构类型对象的指针。
struct
MyStruct
{
a;
c;
}
ss={20,30,40};
//声明了结构对象ss,并把ss的三个成员初始化为20,30和40。
*ptr=&
ss
//声明了一个指向结构对象ss的指针。
它的类型是MyStruct*,它指向的类型是MyStruct。
*pstr=(int*)&
但是它的类型和它指向的类型和ptr是不同的。
通过指针ptr来访问ss的三个成员变量:
ptr->
通过指针pstr来访问ss的三个成员变量:
*pstr;
//访问了ss的成员a。
*(pstr+1);
//访问了ss的成员b
*(pstr+2)//访问了ss的成员c。
这样使用pstr来访问结构成员是不正规的,为了说明为什么不正规,让我们看看怎样通过指针来访问数组的各个单元。
array[3]={35,56,37};
*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的方法。
7.指针和函数的关系
可以把一个指针声明成为一个指向函数的指针。
fun1(char*,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.
void*(*c)(char,int(*)());
//cisapointertoafunctionthattakes
//twoparameters:
//acharandapointertoa
//functionthattakesno
//parametersandreturns
//anint
//andreturnsapointertovoid.
void**(*d)(int&
char**(*)(char*,char**));
//disapointertoafunctionthattakes
//areferencetoanintandapointer
//toafunctionthattakestwoparameters:
//apointertoacharandapointer
//toapointertoachar
//andreturnsapointertoapointer
//toachar
//andreturnsapointertoapointertovoid
float(*(*e[10]),(int&
))[5];
//eisanarrayof10pointersto
//functionsthattakeasingle
//referencetoanintasanargument
//andreturnpointersto
//anarrayof5floats.