信息发布软件,b2b软件,广告发布软件

标题: 您也会有不知道用C++指针的时候吧快来补补这个用法吧 [打印本页]

作者: 群发软件    时间: 2017-6-11 21:39
标题: 您也会有不知道用C++指针的时候吧快来补补这个用法吧
指针是一个特殊的变量,它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四方面的内容:指针的类型,指针所指向的类型,指针的值或者叫指针所指向的内存区,还有指针本身所占据的内存区。让我们分别说明。

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

例一:  

int *ptr;  
char *ptr;  
int **ptr;  
int (*ptr)[3];  
int *(*ptr)[4];  
指针的类型
从语法的角度看,你只要把指针声明语句里的指针名字去掉,剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型:  
int *ptr; //指针的类型是int *  
char *ptr; //指针的类型是char *  
int **ptr; //指针的类型是 int **  
int (*ptr)[3]; //指针的类型是 int(*)[3]  
int *(*ptr)[4]; //指针的类型是 int *(*)[4]  
怎么样?找出指针的类型的方法是不是很简单?  
指针所指向的类型
当你通过指针来访问指针所指向的内存区时,指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。

从语法上看,你只须把指针声明语句中的指针名字和名字左边的指针声明符*去掉,剩下的就是指针所指向的类型。例如:  
int *ptr; //指针所指向的类型是int  
char *ptr; //指针所指向的的类型是char  
int **ptr; //指针所指向的的类型是 int *  
int (*ptr)[3]; //指针所指向的的类型是 int()[3]  
int *(*ptr)[4]; //指针所指向的的类型是 int *()[4]  
在指针的算术运算中,指针所指向的类型有很大的作用。  

指针的类型(即指针本身的类型)和指针所指向的类型是两个概念。当你对C越来越熟悉时,你会发现,把与指针搅和在一起的“类型”这个概念分成“指针的类型”和“指针所指向的类型”两个概念,是精通指针的关键点之一。我看了不少书,发现有些写得差的书中,就把指针的这两个概念搅在一起了,所以看起书来前后矛盾,越看越糊涂。
指针的值

指针的值是指针本身存储的数值,这个值将被编译器当作一个地址,而不是一个一般的数值。在32位程序里,所有类型的指针的值都是一个32位整数,因为32位程序里内存地址全都是32位长。

指针所指向的内存区就是从指针的值所代表的那个内存地址开始,长度为sizeof(指针所指向的类型)的一片内存区。以后,我们说一个指针的值是XX,就相当于说该指针指向了以XX为首地址的一片内存区域;我们说一个指针指向了某块内存区域,就相当于说该指针的值是这块内存区域的首地址。

指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中,指针所指向的类型已经有了,但由于指针还未初始化,所以它所指向的内存区是不存在的,或者说是无意义的。

以后,每遇到一个指针,都应该问问:这个指针的类型是什么?指针指向的类型是什么?该指针指向了哪里?  
指针本身所占据的内存区
指针本身占了多大的内存?你只要用函数sizeof(指针的类型)测一下就知道了。在32位平台里,指针本身占据了4个字节的长度。

指针本身占据的内存这个概念在判断一个指针表达式是否是左值时很有用。  
指针的算术运算
指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。例如:  
例二:  
char a[20];  
int *ptr=a;  
...  
...  
ptr++;  

在上例中,指针ptr的类型是int*,它指向的类型是int,它被初始化为指向整形变量a。接下来的第3句中,指针ptr被加了1,编译器是这样处理的:它把指针ptr的值加上了sizeof(int),在32位程序中,是被加上了4。由于地址是用字节做单位的,故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。
由于char类型的长度是一个字节,所以,原来ptr是指向数组a的第0号单元开始的四个字节,此时指向了数组a中从第4号单元开始的四个字节。
我们可以用一个指针和一个循环来遍历一个数组,看例子:  
例三:  
[url=] 您也会有不知道用C++指针的时候吧快来补补这个用法吧 b2b软件 [/url]
int array[20];  
int *ptr=array;  
...  
//此处略去为整型数组赋值的代码。  
...  
for(i=0;i<20;i++)  
{  
    (*ptr)++;  
    ptr++;  
}  [url=] 您也会有不知道用C++指针的时候吧快来补补这个用法吧 b2b软件 [/url]


这个例子将整型数组中各个单元的值加1。由于每次循环都将指针ptr加1,所以每次循环都能访问数组的下一个单元。再看例子:  

例四:  

char a[20];  
int *ptr = a;  
...  
...  
ptr += 5;  

在这个例子中,ptr被加上了5,编译器是这样处理的:将指针ptr的值加上5乘sizeof(int),在32位程序中就是加上了5乘4=20。由于地址的单位是字节,故现在的ptr所指向的地址比起加5后的ptr所指向的地址来说,向高地址方向移动了20个字节。在这个例子中,没加5前的ptr指向数组a的第0号单元开始的四个字节,加5后,ptr已经指向了数组a的合法范围之外了。虽然这种情况在应用上会出问题,但在语法上却是可以的。这也体现出了指针的灵活性。

如果上例中,ptr是被减去5,那么处理过程大同小异,只不过ptr的值是被减去5乘sizeof(int),新的ptr指向的地址将比原来的ptr所指向的地址向低地址方向移动了20个字节。

总结一下,一个指针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所指向的类型)个字节。
运算符&和*
这里&是取地址运算符,*是...书上叫做“间接运算符”。&a的运算结果是一个指针,指针的类型是a的类型加个*,指针所指向的类型是a的类型,指针所指向的地址嘛,那就是a的地址。*p的运算结果就五花八门了。总之*p的结果是p所指向的东西,这个东西有这些特点:它的类型是p指向的类型,它所占用的地址是p所指向的地址。

例五:  

[url=] 您也会有不知道用C++指针的时候吧快来补补这个用法吧 b2b软件 [/url]
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=&b;//*ptr是个指针,&b的结果也是个指针,且这两个指针的类型和所指向的类型是一样的,所以?amp;b来给*ptr赋值就是毫无问题的了。
**ptr=34;//*ptr的结果是ptr所指向的东西,在这里是一个指针,对这个指针再做一次*运算,结果就是一个int类型的变量。[url=] 您也会有不知道用C++指针的时候吧快来补补这个用法吧 b2b软件 [/url]


指针表达式
一个表达式的最后结果如果是一个指针,那么这个表达式就叫指针表达式。下面是一些指针表达式的例子:  

例六:  
[url=] 您也会有不知道用C++指针的时候吧快来补补这个用法吧 b2b软件 [/url]
int a,b;  
int array[10];  
int *pa;  
pa=&a;//&a是一个指针表达式。  
int **ptr=&pa;//&pa也是一个指针表达式。  
*ptr=&b;//*ptr和&b都是指针表达式。  
pa=array;  
pa++;//这也是指针表达式。[url=] 您也会有不知道用C++指针的时候吧快来补补这个用法吧 b2b软件 [/url]


例七:  
char *arr[20];  
char **parr=arr;//如果把arr看作指针的话,arr也是指针表达式  
char *str;  
str=*parr;//*parr是指针表达式  
str=*(parr+1);//*(parr+1)是指针表达式  
str=*(parr+2);//*(parr+2)是指针表达式  

由于指针表达式的结果是一个指针,所以指针表达式也具有指针所具有的四个要素:指针的类型,指针所指向的类型,指针指向的内存区,指针自身占据的内存。

好了,当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存的话,这个指针表达式就是一个左值,否则就不是一个左值。 在例七中,&a不是一个左值,因为它还没有占据明确的内存。*ptr是一个左值,因为*ptr这个指针已经占据了内存,其实*ptr就是指针pa,既然pa已经在内存中有了自己的位置,那么*ptr当然也有了自己的位置。
数组和指针的关系
如果对声明数组的语句不太明白的话,请参阅我前段时间贴出的文章<<如何理解c和c++的复杂类型声明>>。 数组的数组名其实可以看作一个指针。看下例:  

例八:  
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。其它依此类推。

例九:  
[url=] 您也会有不知道用C++指针的时候吧快来补补这个用法吧 b2b软件 [/url]
char *str[3]={  
"Hello,this is a sample!",  
"Hi,good morning.",  
"Hello world"  
};  
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));  [url=] 您也会有不知道用C++指针的时候吧快来补补这个用法吧 b2b软件 [/url]


上例中,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)测出的是指针类型的大小。

例十:  
int array[10];  
int (*ptr)[10];  
ptr=&array;  

上例中ptr是一个指针,它的类型是int (*)[10],他指向的类型是int [10],我们用整个数组的首地址来初始化它。在语句ptr=&array中,array代表数组本身。

本节中提到了函数sizeof(),那么我来问一问,sizeof(指针名称)测出的究竟是指针自身类型的大小呢还是指针所指向的类型的大小?答案是前者。例如:
int (*ptr)[10];  

则在32位程序中,有:  
sizeof(int(*)[10])==4  
sizeof(int [10])==40  
sizeof(ptr)==4  
实际上,sizeof(对象)测出的都是对象自身的类型的大小,而不是别的什么类型的大小。  
指针和结构类型的关系
可以声明一个指向结构类型对象的指针。  

例十一:  
[url=] 您也会有不知道用C++指针的时候吧快来补补这个用法吧 b2b软件 [/url]
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是不同的。[url=] 您也会有不知道用C++指针的时候吧快来补补这个用法吧 b2b软件 [/url]

请问怎样通过指针ptr来访问ss的三个成员变量?  

答案:  
ptr->a;  
ptr->b;  
ptr->c;  

又请问怎样通过指针pstr来访问ss的三个成员变量?  
答案:  
*pstr;//访问了ss的成员a。  
*(pstr+1);//访问了ss的成员b。  
*(pstr+2)//访问了ss的成员c。

呵呵,虽然我在我的MSVC++6.0上调式过上述代码,但是要知道,这样使用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的方法。
指针和函数的关系
可以把一个指针声明成为一个指向函数的指针。  
int fun1(char*,int);  
int (*pfun1)(char*,int);  
pfun1=fun1;  
....  
....  
int a=(*pfun1)("abcdefg",7);//通过函数指针调用函数。  
可以把指针作为函数的形参。在函数调用语句中,可以用指针表达式来作为实参。  


 在C++中,指针用得比较多,对于里面众多的指针用法,不免弄得有些糊涂,自从我从图书馆里借到一本谭浩强教授主编的《C++面向对象程序设计》后,才帮我理清了思路。现把部分内容展现给大家,希望对大家有所帮助。

  C++程序设计重要基础就是类和对象,对象指针是很重要的一部分,包括指向对象的指针、指向对象成员的指针、this指针、指向对象的常指针、指向常对象的指针等。

  1、指向对象的指针

  定义:对象空间的起始地址就是对象的指针。

  说明:在建立对象时,编译系统就为每个对象分配一定的存储空间以存放其成员,不过注意,在一般情况下不同对象的数据存储单元中存放的数据成员是不相同,而不同对象的函数代码却是相同的,也就是说,它们的函数代码是共享的。这时我们可以定义一个指针变量用来存放对象的指针。

  定义指向类对象的指针变量的一般形式是:

  类名 *对象指针名;

  如对于与个Time类对象,我们可以有:

  Time t;

  Time *p;

  p=&t;

  我们就可以通过对象指针访问对象和对象的成员,假如所定义的类中有数据成员hour、minute、sec,成员函数有gettime(),则

  (*p).hour 即为p指向对象中的hour成员,相当于t.hour

  (*p).gettime() 即为p指向对象中的成员函数gettime(),相当于t.gettime()

  也可以用如下形式:

  p->hour 和 p->gettime()和上面是等价的。

  2、指向对象成员的指针

  (1)指向对象数据成员的指针

  在C中我们学过指向普通变量的指针变量,在C++中定义指向对象数据成员的指针变量的方法和定义指向普通变量的指针变量方法相同,其一般形式为:

  数据类型名 *指针变量名;

  如:

  int *p;

  p=&t.hour; //将对象t的数据成员hour的地址赋给p,p指向t.hour

  (2)指向对象成员函数的指针

  定义指向对象成员函数的指针变量和定义指向普通函数的指针变量不同。

  在定义指向普通函数的指针变量时我们可以这样定义:

  void (*p)();

  p=fun;

  (*p)(); //调用fun函数

  然而编译系统要求在将函数地址赋给指针变量时必须满足三个条件:

  函数参数类型及个数要匹配

  函数返回值的类型要匹配

  所属的类要匹配

  显然在上面的p与类是无关的。为了满足第三条,我们可以为指针指定类,故定义指向对象成员函数的指针变量一般形式为:

  数据类型(类名::*指针变量名)(参数表列);

  可以让指针指向公用的成员函数,如:

  void (Time::*p)(); //定义指向Time类对象成员函数的指针变量p

  p=&Time::gettime; //把Time类的公用成员函数gettime()地址赋给指针变量p

  (t.*p)(); //调用Time类对象t的成员函数gettime()

  注意:因为成员函数不存放在对象空间中,多个同类对象共享此成员函数代码,所以在将成员函数的入口地址赋给指针变量是应写成:

  指向对象成员函数的指针变量=&类名::成员函数名;

  在成员函数名后面没有"()",如果写成p=&Time::gettime()是错误的。[nextp

  3、this指针

  在每个成员函数中都包含了一个特殊的指针,称为this,它是指向本类对象的指针,它的值是当前被调用成员函数所在对象的起始地址。之所以有这个指针,是因为为了保证同类的不同对象的成员函数引用的是指定对象中的数据成员,它是系统自动实现的。

  如定义一个求体积的函数

  int box::vol()

  {return(height*width*length);}

  假如已经定义了对象t,当调用成员函数t.vol()时,编译系统就把对象t的起始地址赋给this指针,于是在成员函数引用数据成员时,根据指针this就可以引用到对象t的数据成员。所以C++把上面的函数处理成

  int box::vol()

  {return(this->height*this->width*this->length);}

  由于this的值是当前被调用成员函数所在对象的起始地址,所以可以写成

  int box::vol()

  {return((*this).height*(*this).width*(*this).length);}

  所以在调用成员函数t.vlo()时,实际的调用方式为t.vol(&t),不过对象t的地址传给this指针是由系统自动完成的,不需人为加上。





作者: linshihu    时间: 2017-6-20 20:13
这家店服务一流,技术专业。不论是售前、技术,都十分耐心。网站已建设成我想象中的样子,特别感谢小笨蛋与三号笨蛋,一级棒!
作者: ekmci    时间: 2017-6-24 02:09
,真心的说
作者: 西充    时间: 2017-6-24 05:59
大家都来看看本公司给我设计的软件真好。。。大家都来使用吧
作者: meili1    时间: 2017-7-1 12:16
感谢店家的细心指导!!谢谢!
作者: mmgg520    时间: 2017-7-3 01:54
在太好用了,制作很精致。卖家服务也好。下次有需要的介绍给朋友。
作者: mmgg520    时间: 2017-7-3 21:36
。服务不
作者: 武器    时间: 2017-7-6 22:49
的,手艺不错
作者: mmgg520    时间: 2017-7-11 20:28
及时做出评价,系统默认好评!




欢迎光临 信息发布软件,b2b软件,广告发布软件 (http://postbbs.com/) Powered by Discuz! X3.2