黑马程序员------[C]关于指针
2015-03-02 15:11
183 查看
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
指针的概念
指针是一个特殊的变量,它里面存储的数值被解释成为内存里的一个地址。
要搞清一个指针需要搞清指针的四方面的内容:指针的类型,指针所指向的
类型,指针的值或者叫指针所指向的内存区,还有指针本身所占据的内存区。让
我们分别说明。
先声明几个指针放着做例子:
指针的类型
从语法的角度看,你只要把指针声明语句里的指针名字去掉,剩下的部分就
是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的
类型:
(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位长。
指针所指向的内存区就是从指针的值所代表的那个内存地址开始,长度为si
zeof(指针所指向的类型)的一片内存区。以后,我们说一个指针的值是XX,就相
当于说该指针指向了以XX为首地址的一片内存区域;我们说一个指针指向了某块
内存区域,就相当于说该指针的值是这块内存区域的首地址。
指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中
,指针所指向的类型已经有了,但由于指针还未初始化,所以它所指向的内存区
是不存在的,或者说是无意义的。
以后,每遇到一个指针,都应该问问:这个指针的类型是什么?指针指向的
类型是什么?该指针指向了哪里?
指针的算术运算
指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减
运算的意义是不一样的。
在上例中,指针ptr的类型是int*,它指向的类型是int,它被初始化为指向整
形变量a。接下来的第3句中,指针ptr被加了1,编译器是这样处理的:它把指针
ptr的值加上了sizeof(int),在32位程序中,是被加上了4。由于地址是用字节做
单位的,故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。
由于char类型的长度是一个字节,所以,原来ptr是指向数组a的第0号单元开始的
四个字节,此时指向了数组a中从第4号单元开始的四个字节。
我们可以用一个指针和一个循环来遍历一个数组,
这个例子将整型数组中各个单元的值加1。由于每次循环都将指针ptr加1,所
以每次循环都能访问数组的下一个单元。
在这个例子中,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所指向的类型也相同。pt
rnew的值将比ptrold的值减少了n乘sizeof(ptrold所指向的类型)个字节,就是说
,ptrnew所指向的内存区将比ptrold所指向的内存区向低地址方向移动了n乘siz
eof(ptrold所指向的类型)个字节。
运算符号&和*
这里&是取地址运算符,*是...书上叫做"间接运算符"。
&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=&b;//*ptr是个指针,&b的结果也是个指针,且这两个指针的类型和所
指向的类型是一样的,所以用&b来给*ptr赋值就是毫无问题的了。
**ptr=34;//*ptr的结果是ptr所指向的东西,在这里是一个指针,对这个指
针再做一次*运算,结果就是一个int类型的变量。
指针表达式
一个表达式的最后结果如果是一个指针,那么这个表达式就叫指针表达式。
由于指针表达式的结果是一个指针,所以指针表达式也具有指针所具有的四
个要素:指针的类型,指针所指向的类型,指针指向的内存区,指针自身占据的
内存。
好了,当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存
的话,这个指针表达式就是一个左值,否则就不是一个左值。
在例七中,&a不是一个左值,因为它还没有占据明确的内存。*ptr是一个左
值,因为*ptr这个指针已经占据了内存,其实*ptr就是指针pa,既然pa已经在内
存中有了自己的位置,那么*ptr当然也有了自己的位置。
第五章 数组和指针的关系
如果对声明数组的语句不太明白的话,请参阅我前段时间贴出的文?lt;<如何
理解c和c
b3c4
++的复杂类型声明>>。
数组的数组名其实可以看作一个指针。
上例中,一般而言数组名array代表数组本身,类型是int [10],但如果把a
rray看做指针的话,它指向数组的第0个单元,类型是int *,所指向的类型是数
组单元的类型即int。因此*array等于0就一点也不奇怪了。同理,array+3是一个
指向数组第3个单元的指针,所以*(array+3)等于3。其它依此类推。
上例中,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’,等等。
指针和函数的关系
可以把一个指针声明成为一个指向函数的指针。
可以把指针作为函数的形参。在函数调用语句中,可以用指针表达式来作为
实参。
这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之和。前面说
了,数组的名字也是一个指针。在函数调用中,当把str作为实参传递给形参s后
,实际是把str的值传递给了s,s所指向的地址就和str所指向的地址一致,但是
str和s各自占用各自的存储空间。在函数体内对s进行自加1运算,并不意味着同
时对str进行了自加1运算。
指针类型转换
当我们初始化一个指针或给一个指针赋值时,赋值号的左边是一个指针,赋
值号的右边是一个指针表达式。在我们前面所举的例子中,绝大多数情况下,指
针的类型和指针表达式的类型是一样的,指针所指向的类型和指针表达式所指向
的类型是一样的。
1.float f=12.3;
2. float *fptr=&f;
3. int *p;
在上面的例子中,假如我们想让指针p指向实数f,应该怎么搞?是用下面的
语句吗?
p=&f;
不对。因为指针p的类型是int*,它指向的类型是int。表达式&f的结果是一
个指针,指针的类型是float*,它指向的类型是float。两者不一致,直接赋值的
方法是不行的。至少在我的MSVC++6.0上,对指针的赋值语句要求赋值号两边的类
型一致,所指向的类型也一致,其它的编译器上我没试过,大家可以试试。为了
实现我们的目的,需要进行"强制类型转换":
p=(int*)&f;
如果有一个指针p,我们需要把它的类型和所指向的类型改为TYEP*和TYPE,
那么语法格式是:
(TYPE*)p;
这样强制类型转换的结果是一个新指针,该新指针的类型是TYPE*,它指向的
类型是TYPE,它指向的地址就是原指针指向的地址。而原来的指针p的一切属性都
没有被修改。
一个函数如果使用了指针作为形参,那么在函数调用语句的实参和形参的结
合过程中,也会发生指针类型的转换。
注意这是一个32位程序,故int类型占了四个字节,char类型占一个字节。函
数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗?在函数调用
语句中,实参&a的结果是一个指针,它的类型是int *,它指向的类型是int。形
参这个指针的类型是char*,它指向的类型是char。这样,在实参和形参的结合过
程中,我们必须进行一次从int*类型到char*类型的转换。结合这个例子,我们可
以这样来想象编译器进行转换的过程:编译器先构造一个临时指针 char*temp,
然后执行temp=(char*)&a,最后再把temp的值传递给s。所以最后的结果是:s的
类型是char*,它指向的类型是char,它指向的地址就是a的首地址。
我们已经知道,指针的值就是指针指向的地址,在32位程序中,指针的值其
实是一个32位整数。那可不可以把一个整数当作指针的值直接赋给指针呢?就象
下面的语句:
[align=center]------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------[/align]
指针的概念
指针是一个特殊的变量,它里面存储的数值被解释成为内存里的一个地址。
要搞清一个指针需要搞清指针的四方面的内容:指针的类型,指针所指向的
类型,指针的值或者叫指针所指向的内存区,还有指针本身所占据的内存区。让
我们分别说明。
先声明几个指针放着做例子:
(1)int *ptr; (2)char *ptr; (3)int **ptr; (4)int (*ptr)[3]; (5)int *(*ptr)[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]
指针所指向的类型。
当你通过指针来访问指针所指向的内存区时,指针所指向的类型决定了编译
器将把那片内存区里的内容当做什么来看待。
从语法上看,你只须把指针声明语句中的指针名字和名字左边的指针声明符
*去掉,剩下的就是指针所指向的类型。例如:
(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位长。
指针所指向的内存区就是从指针的值所代表的那个内存地址开始,长度为si
zeof(指针所指向的类型)的一片内存区。以后,我们说一个指针的值是XX,就相
当于说该指针指向了以XX为首地址的一片内存区域;我们说一个指针指向了某块
内存区域,就相当于说该指针的值是这块内存区域的首地址。
指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中
,指针所指向的类型已经有了,但由于指针还未初始化,所以它所指向的内存区
是不存在的,或者说是无意义的。
以后,每遇到一个指针,都应该问问:这个指针的类型是什么?指针指向的
类型是什么?该指针指向了哪里?
指针的算术运算
指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减
运算的意义是不一样的。
1. char a[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号单元开始的四个字节。
我们可以用一个指针和一个循环来遍历一个数组,
int array[20]; int *ptr=array; ... //此处略去为整型数组赋值的代码。 ... for(i=0;i<20;i++) { (*ptr)++; ptr++; }
这个例子将整型数组中各个单元的值加1。由于每次循环都将指针ptr加1,所
以每次循环都能访问数组的下一个单元。
1. char a[20]; 2. int *ptr=a; ... ... 3. 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所指向的类型也相同。pt
rnew的值将比ptrold的值减少了n乘sizeof(ptrold所指向的类型)个字节,就是说
,ptrnew所指向的内存区将比ptrold所指向的内存区向低地址方向移动了n乘siz
eof(ptrold所指向的类型)个字节。
运算符号&和*
这里&是取地址运算符,*是...书上叫做"间接运算符"。
&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=&b;//*ptr是个指针,&b的结果也是个指针,且这两个指针的类型和所
指向的类型是一样的,所以用&b来给*ptr赋值就是毫无问题的了。
**ptr=34;//*ptr的结果是ptr所指向的东西,在这里是一个指针,对这个指
针再做一次*运算,结果就是一个int类型的变量。
指针表达式
一个表达式的最后结果如果是一个指针,那么这个表达式就叫指针表达式。
int a,b; int array[10]; int *pa; pa=&a;//&a是一个指针表达式。 int **ptr=&pa;//&pa也是一个指针表达式。 *ptr=&b;//*ptr和&b都是指针表达式。 pa=array; pa++;//这也是指针表达式。
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当然也有了自己的位置。
第五章 数组和指针的关系
如果对声明数组的语句不太明白的话,请参阅我前段时间贴出的文?lt;<如何
理解c和c
b3c4
++的复杂类型声明>>。
数组的数组名其实可以看作一个指针。
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],但如果把a
rray看做指针的话,它指向数组的第0个单元,类型是int *,所指向的类型是数
组单元的类型即int。因此*array等于0就一点也不奇怪了。同理,array+3是一个
指向数组第3个单元的指针,所以*(array+3)等于3。其它依此类推。
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));
上例中,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’,等等。
指针和函数的关系
可以把一个指针声明成为一个指向函数的指针。
int fun1(char*,int); int (*pfun1)(char*,int); pfun1=fun1; .... .... int a=(*pfun1)("abcdefg",7);//通过函数指针调用函数。
可以把指针作为函数的形参。在函数调用语句中,可以用指针表达式来作为
实参。
int fun(char*); int a; char str[]="abcdefghijklmn"; a=fun(str); ... ... int fun(char*s) { int num=0; for(int i=0;i { num+=*s;s++; } return num; )
这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之和。前面说
了,数组的名字也是一个指针。在函数调用中,当把str作为实参传递给形参s后
,实际是把str的值传递给了s,s所指向的地址就和str所指向的地址一致,但是
str和s各自占用各自的存储空间。在函数体内对s进行自加1运算,并不意味着同
时对str进行了自加1运算。
指针类型转换
当我们初始化一个指针或给一个指针赋值时,赋值号的左边是一个指针,赋
值号的右边是一个指针表达式。在我们前面所举的例子中,绝大多数情况下,指
针的类型和指针表达式的类型是一样的,指针所指向的类型和指针表达式所指向
的类型是一样的。
1.float f=12.3;
2. float *fptr=&f;
3. int *p;
在上面的例子中,假如我们想让指针p指向实数f,应该怎么搞?是用下面的
语句吗?
p=&f;
不对。因为指针p的类型是int*,它指向的类型是int。表达式&f的结果是一
个指针,指针的类型是float*,它指向的类型是float。两者不一致,直接赋值的
方法是不行的。至少在我的MSVC++6.0上,对指针的赋值语句要求赋值号两边的类
型一致,所指向的类型也一致,其它的编译器上我没试过,大家可以试试。为了
实现我们的目的,需要进行"强制类型转换":
p=(int*)&f;
如果有一个指针p,我们需要把它的类型和所指向的类型改为TYEP*和TYPE,
那么语法格式是:
(TYPE*)p;
这样强制类型转换的结果是一个新指针,该新指针的类型是TYPE*,它指向的
类型是TYPE,它指向的地址就是原指针指向的地址。而原来的指针p的一切属性都
没有被修改。
一个函数如果使用了指针作为形参,那么在函数调用语句的实参和形参的结
合过程中,也会发生指针类型的转换。
void fun(char*); int a=125,b; fun((char*)&a); ... ... void fun(char*s) { char c; c=*(s+3);*(s+3)=*(s+0);*(s+0)=c; c=*(s+2);*(s+2)=*(s+1);*(s+1)=c; } }
注意这是一个32位程序,故int类型占了四个字节,char类型占一个字节。函
数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗?在函数调用
语句中,实参&a的结果是一个指针,它的类型是int *,它指向的类型是int。形
参这个指针的类型是char*,它指向的类型是char。这样,在实参和形参的结合过
程中,我们必须进行一次从int*类型到char*类型的转换。结合这个例子,我们可
以这样来想象编译器进行转换的过程:编译器先构造一个临时指针 char*temp,
然后执行temp=(char*)&a,最后再把temp的值传递给s。所以最后的结果是:s的
类型是char*,它指向的类型是char,它指向的地址就是a的首地址。
我们已经知道,指针的值就是指针指向的地址,在32位程序中,指针的值其
实是一个32位整数。那可不可以把一个整数当作指针的值直接赋给指针呢?就象
下面的语句:
unsigned int a; TYPE *ptr;//TYPE是int,char或结构类型等等类型。 ... ... a=20345686; ptr=20345686;//我们的目的是要使指针ptr指向地址20345686(十进制 )
[align=center]------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------[/align]
相关文章推荐
- 关于指针泄漏
- 关于COM中智能指针的一些建议.
- 关于ABAP指针
- 关于各种字符类型的指针的转换
- 关于C++异常抛出指针问题的探讨
- 关于指针操作问题
- [原创] 一劳永逸:关于C/C++中指针、数组与函数复合定义形式的直观解释
- 关于指针
- 关于指针的一些知识
- 批判,再批判!关于“探究:如何判断Delphi中的对象指针是否可用”!
- 关于指针——二维数组讨论
- 关于C++中函数指针的使用(包含对typedef用法的讨论)
- boost 智能指针 --- 关于性能的少数派报告
- 关于指针和内存的几个问题
- 关于DELPHI的指针
- 关于指针
- 关于boost和loki的智能指针
- 关于C++指针
- 关于指针--二维数组讨论(容易混淆)
- 关于C函数指针的一个解答