更多课程 选择中心

C/C++培训
达内IT学院

400-111-8989

C/C++数组知识,C/C++数组问题知识总结

  • 发布:C++培训
  • 来源:学习笔记
  • 时间:2017-09-25 15:32

char *s 和 char s[] 的区别小结

char *s1 ="hello";

char s2[] = "hello";

【区别所在】

char *s1 的s1,而指针是指向一块内存区域,它指向的内存区域的大小可以随时改变,而且当指针指向常量字符串时,它的内容是不可以被修改的,否则在运行时会报错。

char s2[]的s2 是数组对应着一块内存区域,其地址和容量在生命期里不会改变,只有数组的内容可以改变

【内存模型】

+-----+ +---+---+---+---+---+---+

s1: | *======> | h | e | l | l | o |\0 |

+-----+ +---+---+---+---+---+---+

+---+---+---+---+---+---+

s2: | h | e | l | l | o |\0 |

+---+---+---+---+---+---+

场景一)

char *s1 = "hello";

char s2[] = "hello";

s2=s1; //编译ERROR

s1=s2; //OK

分析:s2其地址和容量在生命期里不能改变

场景二)

char s2[] = "hello";

char *s1 = s2; //编译器做了隐式的转换实际为&s2

char *s1 = &s2;

分析:以上两个指针复值完全等价,由于编译器会做这个隐式转换也容易导致初学者误认为char *s 与char s[]是一回事。

另用第二种在一些编译器甚至会报警告信息。

/* 变量名只是相当于一个标签,他所表示的内容是否能够修改不取决于这个标签而取决于存放内容的内存属性*/

场景三)

char *s1 = "hello";

char s2[] = "hello";

s1[0]='a'; //×运行ERROR(这一句好像在一些的编译器不会出错,原因待查)

s2[0]='a'; //OK

分析:运行时会报错,原因在于企图改变s1的内容,由于s1指向的是常量字符串,其内容是不可修改的,因此在运行时不会通过。而s2指向的是变量区字符串,可以修改。

场景四)

让我们来给一个指针的指针赋值,在使用某些含char**参数的函数时会用到,场景二的增强版。

char *s1="hello";

char s2[]="hello";

char *s3=s2; //★注意这句必须要★

char **s4=&s3; //s2(char[])要用两步才能完成赋值

char **s5=&s1; //s1(char*)只需一步

printf("s4=[%s]\n",*s4);//打印结果:s4=[hello]

printf("s5=[%s]\n",*s5);//打印结果:s5=[hello]

分析:这个例子应当说最能反映出char *与char []的差异,但是由于使用场合不多,新人尤其需要注意。

下面是一些char *s1 和 char s2[]相同的地方(同样编译器对char[]做了隐式变化):

1)作为形参完全相同

如:

void function(char *s1);

void function(char s1[]);

2)只读取不修改的时候

如:

char *s1="hello";

char s2[]="hello";

printf("s1[1]=[%c]\n",s1[1]); //s1[1]=[e]

printf("s2[1]=[%c]\n",s2[1]); //s2[1]=[e]

printf("s1=[%s]\n",s1); //s1=[hello]

printf("s2=[%s]\n",s2); //s2=[hello]

1. 问题介绍

问题引入:

在实习过程中发现了一个以前一直默认的错误,同样char *c ="abc"和charc[]="abc",前者改变其内

容程序是会崩溃的,而后者完全正确。

程序演示:

测试环境Devc++

代码

#include <iostream>

using namespace std;

main()

{

char *c1 = "abc";

char c2[] = "abc";

char *c3 = ( char* )malloc(3);

c3 = "abc";

printf("%d %d %s\n",&c1,c1,c1);

printf("%d %d %s\n",&c2,c2,c2);

printf("%d %d %s\n",&c3,c3,c3);

getchar();

}

运行结果

2293628 4199056 abc

2293624 2293624 abc

2293620 4199056 abc

参考资料:

首先要搞清楚编译程序占用的内存的分区形式:

一、预备知识—程序的内存分配

一个由c/C++编译的程序占用的内存分为以下几个部分

1、栈区(stack)—由编译器自动分配释放,存放函数的参数值,局部变量的值等。其操作方式类似于

数据结构中的栈。

2、堆区(heap)—一般由程序员分配释放,若程序员不释放,程序结束时可能由OS回收。注意它与数据

结构中的堆是两回事,分配方式倒是类似于链表,呵呵。

3、全局区(静态区)(static)—全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态

变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统

释放。

4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放。

5、程序代码区

这是一个前辈写的,非常详细

//main.cpp

int a=0; //全局初始化区

char *p1; //全局未初始化区

main()

{

int b;栈

char s[]="abc"; //栈

char *p2; //栈

char *p3="123456"; //123456\0在常量区,p3在栈上。

static int c=0; //全局(静态)初始化区

p1 = (char*)malloc(10);

p2 = (char*)malloc(20); //分配得来得10和20字节的区域就在堆区。

strcpy(p1,"123456"); //123456\0放在常量区,编译器可能会将它与p3所向"123456"优化成一个

地方。

}

二、堆和栈的理论知识

2.1申请方式

stack:

由系统自动分配。例如,声明在函数中一个局部变量int b;系统自动在栈中为b开辟空间

heap:

需要程序员自己申请,并指明大小,在c中malloc函数

如p1=(char*)malloc(10);

在C++中用new运算符

如p2=(char*)malloc(10);

但是注意p1、p2本身是在栈中的。

2.2

申请后系统的响应

栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。

堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,

会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将

该结点的空间分配给程序,另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大

小,这样,代码中的delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正

好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。

2.3申请大小的限制

栈:在Windows下,栈是向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地

址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译

时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间

较小。

堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地

址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的

虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。

2.4申请效率的比较:

栈:由系统自动分配,速度较快。但程序员是无法控制的。

堆:是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便.

另外,在WINDOWS下,最好的方式是用Virtual Alloc分配内存,他不是在堆,也不是在栈,而是直接在进

程的地址空间中保留一块内存,虽然用起来最不方便。但是速度快,也最灵活。

2.5堆和栈中的存储内容

栈:在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的

地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变

量。注意静态变量是不入栈的。

当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主

函数中的下一条指令,程序由该点继续运行。

堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

2.6存取效率的比较

char s1[]="aaaaaaaaaaaaaaa";

char *s2="bbbbbbbbbbbbbbbbb";

aaaaaaaaaaa是在运行时刻赋值的;

而bbbbbbbbbbb是在编译时就确定的;

但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。

比如:

#include

voidmain()

{

char a=1;

char c[]="1234567890";

char *p="1234567890";

a = c[1];

a = p[1];

return;

}

对应的汇编代码

10:a=c[1];

004010678A4DF1movcl,byteptr[ebp-0Fh]

0040106A884DFCmovbyteptr[ebp-4],cl

11:a=p[1];

0040106D8B55ECmovedx,dwordptr[ebp-14h]

004010708A4201moval,byteptr[edx+1]

004010738845FCmovbyteptr[ebp-4],al

第一种在读取时直接就把字符串中的元素读到寄存器cl中,而第二种则要先把指针值读到edx中,在根据

edx读取字符,显然慢了。

2.7小结:

堆和栈的区别可以用如下的比喻来看出:

使用栈就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会

切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。

使用堆就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大。

自我总结:

char *c1 = "abc";实际上先是在文字常量区分配了一块内存放"abc",然后在栈上分配一地址给c1并指向

这块地址,然后改变常量"abc"自然会崩溃

然而char c2[] = "abc",实际上abc分配内存的地方和上者并不一样,可以从

4199056

2293624 看出,完全是两块地方,推断4199056处于常量区,而2293624处于栈区

2293628

2293624

2293620 这段输出看出三个指针分配的区域为栈区,而且是从高地址到低地址

2293620 4199056abc 看出编译器将c3优化指向常量区的"abc"

继续思考:

代码:

#include <iostream>

using namespace std;

main()

{

char *c1 = "abc";

char c2[] = "abc";

char *c3 = ( char* )malloc(3);

// *c3 = "abc" //error

strcpy(c3,"abc");

c3[0] = 'g';

printf("%d %d %s\n",&c1,c1,c1);

printf("%d %d %s\n",&c2,c2,c2);

printf("%d %d %s\n",&c3,c3,c3);

getchar();

}

输出:

2293628 4199056 abc

2293624 2293624 abc

2293620 4012976 gbc

写成注释那样,后面改动就会崩溃

可见strcpy(c3,"abc");abc是另一块地方分配的,而且可以改变,和上面的参考文档说法有些不一定,

而且我不能断定4012976是哪个区的,可能要通过算区的长度,希望高人继续深入解释,谢谢

2. 一个实例

1. int *ip = new int;

2. char s[] = "abcd";

3. char* p = "abcd";

4.

5. cout<<ip<<endl;

6. cout<<*ip<<endl;

7. cout<<&ip<<endl;

8. // s = p; //error C2440: '=' : cannot convert from 'char *' to 'char'

9. //难道s不是指向第一个字符的指针吗?

10. cout << s <<endl;//果然这句话输出的是abcd!

11. cout << *s <<endl;//但这句输出的是a!

12. cout << &s <<endl;

13. cout << (s+1) <<endl;

14.// cout << &(s+1) <<endl;//error C2102: '&' requires l-value

15. cout << *(s+1) <<endl;

16. cout << &s[1] <<endl;

17.

18. cout << p <<endl;

19. cout << *p <<endl;

20. cout << &p <<endl;

21. cout << (p+1) <<endl;

22.// cout << &(p+1) <<endl;//error C2102: '&' requires l-value

23. cout << *(p+1) <<endl;

24. cout << &p[1] <<endl;

输出:

相关解释:

char[]是一个数组定义,char*是指针定义,你可以看下他们的区别,对你会有帮助。

1 指针和数组的区别

(1)指针和数组的分配

数组是开辟一块连续的内存空间,数组本身的标识符(也就是通常所说的数组名)代表整个数组,可以使用sizeof来获得数组所占据内存空间的大小(注意,不是数组元素的个数,而是数组占据内存空间的大小,这是以字节为单位的)。举例如下:

#include <stdio.h>

int main(void)

{

char a[] = "hello";

int b[] = {1, 2, 3, 4, 5};

printf("a: %d\n", sizeof(a));

printf("b memory size: %d bytes\n", sizeof(b));

printf("b elements: %d\n", sizeof(b)/sizeof(int));

return 0;

}

数组a为字符型,后面的字符串实际上占据6个字节空间(注意最后有一个\0标识字符串的结束)。从后面sizeof(b)就可以看出如何获得数组占据的内存空间,如何获得数组的元素数目。至于int数据类型分配内存空间的多少,则是编译器相关的。gcc默认为int类型分配4个字节的内存空间。

(2)空间的分配

这里又分为两种情况。

第一,如果是全局的和静态的

char *p = “hello”;

这是定义了一个指针,指向rodata section里面的“hello”,可以被编译器放到字符串池。在汇编里面的关键字为.ltorg。意思就是在字符串池里的字符串是可以共享的,这也是编译器优化的一个措施。

char a[] = “hello”;

这是定义了一个数组,分配在可写数据块,不会被放到字符串池。

第二,如果是局部的

char *p = “hello”;

这是定义了一个指针,指向rodata section里面的“hello”,可以被编译器放到字符串池。在汇编里面的关键字为.ltorg。意思就是在字符串池里的字符串是可以共享的,这也是编译器优化的一个措施。另外,在函数中可以返回它的地址,也就是说,指针是局部变量,但是它指向的内容是全局的。

char a[] = “hello”;

这是定义了一个数组,分配在堆栈上,初始化由编译器进行。(短的时候直接用指令填充,长的时候就从全局字符串表拷贝),不会被放到字符串池(同样如前,可能会从字符串池中拷贝过来)。注意不应该返回它的地址。

cout经研究得出以下结论:

1、对于数字指针如int *p=new int; 那么cout<<p只会输出这个指针的值,而不会输出这个指针指向的内容。

2、对于字符指针入char *p="sdff";那么cout<<p就会输出指针指向的数据,即sdf f

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

如果还不是很理解,水木上也有高人对此进行解释:

这里的charch[]="abc";

表示ch是一个足以存放字符串初值和空字符'/0'的一维数组,可以更改数组中的字符,但是char本身是不可改变的常量。

char *pch ="abc";

那么pch是一个指针,其初值指向一个字符串常量,之后它可以指向其他位置,但如果试图修改字符串的内容,结果将不确定。

______ ______ ______

ch: |abc\0 | pch: | ◎-----> |abc\0 |

______ ______ ______

char chArray[100];

chArray[i] 等价于 *(chArray+i)

和指针的不同在于 chArray不是变量 无法对之赋值

另 事实上 i[chArray] 也等价于 *(chArray+i)

因此,总结如下:

1. char[] p表示p是一个数组指针,相当于const pointer,不允许对该指针进行修改。但该指针所指向的数组内容,是分配在栈上面的,是可以修改的。

2. char * pp表示pp是一个可变指针,允许对其进行修改,即可以指向其他地方,如pp = p也是可以的。对于*pp ="abc";这样的情况,由于编译器优化,一般都会将abc存放在常量区域内,然后pp指针是局部变量,存放在栈中,因此,在函数返回中,允许返回该地址(实际上指向一个常量地址,字符串常量区);而,char[] p是局部变量,当函数结束,存在栈中的数组内容均被销毁,因此返回p地址是不允许的。

同时,从上面的例子可以看出,cout确实存在一些规律:

1、对于数字指针如int *p=new int; 那么cout<<p只会输出这个指针的值,而不会输出这个指针指向的内容。

2、对于字符指针入char *p="sdff";那么cout<<p就会输出指针指向的数据,即sdf f

那么,像&(p+1),由于p+1指向的是一个地址,不是一个指针,无法进行取址操作。

&p[1] = &p+ 1,这样取到的实际上是从p+1开始的字符串内容。

分析上面的程序:

*pp ="abc";

p[] ="abc";

*pp指向的是字符串中的第一个字符。

cout << pp;// 返回pp地址开始的字符串:abc

cout << p;// 返回p地址开始的字符串:abc

cout << *p;// 返回第一个字符:a

cout <<*(p+1); // 返回第二个字符:b

cout << &p[1];// 返回从第二个字符开始的字符串:bc

Machine Learning

分类: C++

1.如果相同,那么将&数组名赋值或者传递给数组参数的时候,会提示:&数组名类型是 int (*)[],而数组类型是int [],他们不能赋值。 2.如果不同,那么为什么,sizeof(&数组名)==sizeof(数组名)?? 3.同样,&函数名和函数名的区别 请尽量详尽地回答,最...展开

原来是这样的,&数组名和数组名是不同的,根据其数据类型就知道了。问题的关键在于为什么sizeof(数组名)==sizeof(&数组名)呢,原因如下:

1,数组名本质上是个地址,但不能说是指针,它能给指针赋值,是因为,指针本身的数据结构和数组名(地址)是一样的 都是32位的int,所以这里能通过指针来对数组进行操作

2,sizeof(数组名)为什么等于sizeof(元素类型)*元素个数呢?这个问题就好比 int i;然后sizeof(i)是一样的道理,因为i实际上代表了一块内存为4byte的大小,同理,a这个数组的“名字”也代表了一块数组整体大小的内存块,所以 sizeof(数组名)==sizeof(元素类型)*元素个数

3,&数组名 只是个指向数组名的指针,大小为4byte(32位),所以,它和数组名不能等同

4,vc6下sizeof(&数组名)==sizeof(数组名),我认为是错的,因为我在linux 下用gcc测试inta[10]的结果是:sizeof(a)==40,sizeof(&a)==4,这也论证了第3点是正确的

5,因为个人觉得gcc对ansi c支持得比较好,所以我认为vc6的编译器在此处的处理是错误的

6,以上观点在陈正冲写的《c语言深度解剖》等到了论证,详见此书的第四章 指针和数组

各位的回答都很好,谢谢各位了

sadman000 | 浏览 1853 次 2011-03-16 23:24

2011-03-17 00:50

#团队夺宝战,快来开启本次夺宝之旅吧!#

最佳答案

的概念

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

要搞清一个指针需要搞清指针的四方面的内容:指针的类型,指针所指向的 类型,指针的值或者叫指针所指向的内存区,还有指针本身所占据的内存区。让 我们分别说明。

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

例一:

(1)int *ptr;

(2)char *ptr;

(3)int **ptr;

(4)int (*ptr)[3];

(5)int *(*ptr)[4];

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。 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所指向的类型也相同。ptrnew的值将比ptrold的值减少了n乘sizeof(ptrold所指向的类型)个字节,就是说,ptrnew所指向的内存区将比ptrold所指向的内存区向低地址方向移动了n乘sizeof(ptrold所指向的类型)个字节。

第三章。运算?amp;和*

这里&是取地址运算符,*是...书上叫做"间接运算符"。

&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++的复杂类型声明>>。

数组的数组名其实可以看作一个指针。看下例:

例八:

int array[10]=,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’,等等。

下面总结一下数组的数组名的问题。声明了一个数组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扮演的是指针,故arr

ay+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(对象)测出的都是对象自身的类型的大小,而不是别的什么类型的大小。

第六章。指针和结构类型的关系

可以声明一个指向结构类型对象的指针。

例十一:

struct MyStruct

{

int a;

int b;

int c;

}

MyStruct ss=;//声明了结构对象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。

呵呵,虽然我在我的MSVC++6.0上调式过上述代码,但是要知道,这样使用p

str来访问结构成员是不正规的,为了说明为什么不正规,让我们看看怎样通过指

针来访问数组的各个单元:

例十二:

int array[3]=;

int *pa=array;

通过指针pa访问数组array的三个单元的方法是:

*pa;//访问了第0号单元

*(pa+1);//访问了第1号单元

*(pa+2);//访问了第2号单元

从格式上看倒是与通过指针访问结构成员的不正规方法的格式一样。

所有的C/C++编译器在排列数组的单元时,总是把各个数组单元存放在连续的存储区里,单元和单元之间没有空隙。但在存放结构对象的各个成员时,在某种编译环境下,可能会需要字对齐或双字对齐或者是别的什么对齐,需要在相邻两个成员之间加若干?quot;填充字节",这就导致各个成员之间可能会有若干个字节的空隙。

所以,在例十二中,即使*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);//通过函数指针调用函数。

可以把指针作为函数的形参。在函数调用语句中,可以用指针表达式来作为

实参。

例十三:

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(十进制

)

ptr=a;//我们的目的是要使指针ptr指向地址20345686(十进制)

编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就不能达到了吗?不,还有办法:

unsigned int a;

TYPE *ptr;//TYPE是int,char或结构类型等等类型。

...

...

a=某个数,这个数必须代表一个合法的地址;

ptr=(TYPE*)a;//呵呵,这就可以了。

严格说来这里的(TYPE*)和指针类型转换中的(TYPE*)还不一样。这里的(TYPE*)的意思是把无符号整数a的值当作一个地址来看待。

上面强调了a的值必须代表一个合法的地址,否则的话,在你使用ptr的时候,就会出现非法操作错误。

想想能不能反过来,把指针指向的地址即指针的值当作一个整数取出来。完全可以。下面的例子演示了把一个指针的值当作一个整数取出来,然后再把这个整数当作一个地址赋给一个指针:

例十六:

int a=123,b;

int *ptr=&a;

char *str;

b=(int)ptr;//把指针ptr的值当作一个整数取出来。

str=(char*)b;//把这个整数的值当作一个地址赋给指针str。

好了,现在我们已经知道了,可以把指针的值当作一个整数取出来,也可以把一个整数值当作地址赋给一个指针。

第九章。指针的安全问题

看下面的例子:

例十七:

char s=’a’;

int *ptr;

ptr=(int*)&s;

*ptr=1298;

指针ptr是一个int*类型的指针,它指向的类型是int。它指向的地址就是s的首地址。在32位程序中,s占一个字节,int类型占四个字节。最后一条语句不但改变了s所占的一个字节,还把和s相临的高地址方向的三个字节也改变了。这三个字节是干什么的?只有编译程序知道,而写程序的人是不太可能知道的。也许这三个字节里存储了非常重要的数据,也许这三个字节里正好是程序的一条代码,而由于你对指针的马虎应用,这三个字节的值被改变了!这会造成崩溃性的错误。

让我们再来看一例:

例十八:

1。 char a;

2。 int *ptr=&a;

...

...

3。 ptr++;

4。 *ptr=115;

该例子完全可以通过编译,并能执行。但是看到没有?第3句对指针ptr进行自加1运算后,ptr指向了和整形变量a相邻的高地址方向的一块存储区。这块存储区里是什么?我们不知道。有可能它是一个非常重要的数据,甚至可能是一条代码。而第4句竟然往这片存储区里写入一个数据!这是严重的错误。所以在使用指针时,程序员心里必须非常清楚:我的指针究竟指向了哪里。

在用指针访问数组的时候,也要注意不要超出数组的低端和高端界限,否则也会造成类似的错误。

在指针的强制类型转换:ptr1=(TYPE*)ptr2中,如果sizeof(ptr2的类型)大

于sizeof(ptr1的类型),那么在使用指针ptr1来访问ptr2所指向的存储区时是安全的。如果sizeof(ptr2的类型)小于sizeof(ptr1的类型),那么在使用指针ptr1来访问ptr2所指向的存储区时是不安全的。至于为什么,读者结合例十七来想一想,应该会明白的。

a和&a有什么区别

2012-08-30 09:42 4379人阅读 评论(0) 收藏 举报

分类:

C++(43)

请写出以下代码的打印结果,主要目的是考察a和&a的区别。

#include<stdio.h>

void main( void)

{

inta[5]={1,2,3,4,5};

int*ptr=(int *)(&a+1);

printf("%d,%d",*(a+1),*(ptr-1));

return;

}

输出结果:2,5。

*(a+1)其实很简单就是指a[1],输出为2.

问题关键就在于第二个点,*(ptr-1)输出为多少?

解释如下,&a+1不是首地址+1,系统会认为加了一个整个a数组,偏移了整个数组a的大小(也就是5个int的大小)。所以int *ptr=(int *)(&a+1);其实ptr实际是&(a[5]),也就是a+5.

原因为何呢?

&a是数组指针,其类型为int(*)[5];

而指针加1要根据指针类型加上一定的值,不同类型的指针+1之后增加的大小不同,a是长度为5的int数组指针,所以要加5*sizeof(int),所以ptr实际是a[5],但是ptr与(&a+1)类型是不一样的,这点非常重要,所以ptr-1只会减去sizeof(int*),a,&a的地址是一样的,但意思就不一样了,a是数组首地址,也就是a[0]的地址,&a是对象(数组)首地址,a+1是数组下一元素的地址,即a[1],&a+1是下一个对象的地址,即a[5]。

预约申请免费试听课

填写下面表单即可预约申请免费试听!怕钱不够?可就业挣钱后再付学费! 怕学不会?助教全程陪读,随时解惑!担心就业?一地学习,可全国推荐就业!

上一篇:C++培训教程:C++ 中的智能指针知识点
下一篇:C++基本数据类型盘点和详解

C语言创建windows窗口实例

C++回调函数是什么?

C++ shared_ptr和动态数组

C语言有哪些关键词,C语言44个关键词大全

  • 扫码领取资料

    回复关键字:视频资料

    免费领取 达内课程视频学习资料

  • 搜索抖音号

    搜索抖音号:1821685962

    免费领取达内课程视频学习资料

Copyright © 2021 Tedu.cn All Rights Reserved 京ICP备08000853号-56 京公网安备 11010802029508号 达内时代科技集团有限公司 版权所有

选择城市和中心
黑龙江省

吉林省

河北省

湖南省

贵州省

云南省

广西省

海南省