指针与数组的区别



 

一．指针与数组的联系：

指针与数组是C语言中很重要的两个概念，它们之间有着密切的关系，利用这种关系，可以增强处理数组的灵活性，加快运行速度，本文着重讨论指针与数组之间的联系及在编程中的应用。

1．指针与数组的关系

　　当一个指针变量被初始化成数组名时，就说该指针变量指向了数组。如：

　　char str[20], *ptr;

　　ptr=str;

　　ptr被置为数组str的第一个元素的地址，因为数组名就是该数组的首地址，也是数组第一个元素的地址。此时可以认为指针ptr就是数组str（反之不成立），这样原来对数组的处理都可以用指针来实现。如对数组元素的访问，既可以用下标变量访问，也可以用指针访问。

2．指向数组元素的指针

　　若有如下定义：

　　int a[10], *pa;

　　pa=a;

　　则p=&a[0]是将数组第1个元素的地址赋给了指针变量p。

　　实际上，C语言中数组名就是数组的首地址，所以第一个元素的地址可以用两种方法获得：p=&a[0]或p=a。

　　这两种方法在形式上相像，其区别在于：pa是指针变量，a是数组名。值得注意的是：pa是一个可以变化的指针变量，而a是一个常数。因为数组一经被说明，数组的地址也就是固定的，因此a是不能变化的，不允许使用a＋＋、＋＋a或语句a＋=10，而pa＋＋、＋＋pa、pa＋=10则是正确的。由此可见，此时指针与数组融为一体。

3．指针与一维数组

　　理解指针与一维数组的关系，首先要了解在编译系统中，一维数组的存储组织形式和对数组元素的访问方法。

　　一维数组是一个线形表，它被存放在一片连续的内存单元中。C语言对数组的访问是通过数组名（数组的起始地址）加上相对于起始地址的相对量（由下标变量给出），得到要访问的数组元素的单元地址，然后再对计算出的单元地址的内容进行访问。通常把数据类型所占单元的字节个数称为扩大因子。

　　实际上编译系统将数组元素的形式a[i]转换成*(a＋i)，然后才进行运算。对于一般数组元素的形式：<数组名>[<下标表达式>]，编译程序将其转换成：*(<数组名>＋<下标表达式>)，其中下标表达式为：下标表达式*扩大因子。整个式子计算结果是一个内存地址，最后的结果为：*<地址>=<地址所对应单元的地址的内容>。由此可见，C语言对数组的处理，实际上是转换成指针地址的运算。

　　数组与指针暗中结合在一起。因此，任何能由下标完成的操作，都可以用指针来实现，一个不带下标的数组名就是一个指向该数组的指针。

4．指针与多维数组

　　用指针变量可以指向一维数组，也可以指向多维数组。但在概念上和使用上，多维数组的指针比一维数组的指针要复杂一些。

　　例如，在一个三维数组中，引用元素c[i][j][k]的地址计算最终将换成：*(*(*(c＋i)＋j)＋k)。了解了多维数组的存储形式和访问多维数组元素的内部转换公式后，再看当一个指针变量指向多维数组及其元素的情况。

　　1）指向数组元素的指针变量

　　若有如下说明：

　　int a[3][4];

　　int *p;

　　p=a;

　　p是指向整型变量的指针；p=a使p指向整型二维数组a的首地址。

　　*(*(p＋1)＋2)表示取a[1][2]的内容；*p表示取a[0][1]的内容，因为p是指向整型变量的指针；p＋＋表示p的内容加1，即p中存放的地址增加一个整型量的字节数2，从而使p指向下一个整型量a[0][1]。

　　2）指向由j个整数组成的一维数组的指针变量

　　当指针变量p不是指向整型变量，而是指向一个包含j个元素的一维数组。如果p=a[0]，则p＋＋不是指向a[0][1]，而是指向a[1]。这时p的增值以一维数组的长度为单位。

5．指针与字符数组

　　C语言中许多字符串操作都是由指向字符数组的指针及指针的运算来实现的。因为对于字符串来说，一般都是严格的顺序存取方式，使用指针可以打破这种存取方式，更为灵活地处理字符串。

另外由于字符串以′\0′作为结束符，而′\0′的ASCII码是0，它正好是C语言的逻辑假值，所以可以直接用它作为判断字符串结束的条件，而不需要用字符串的长度来判断。C语言中类似的字符串处理函数都是用指针来完成，使程序运行速度更快、效率更高，而且更易于理解。

 

二．指针与数组的区别：

1.把数组作为参数传递的时候，会退化为指针

数组名作为函数形参时，在函数体内，其失去了本身的内涵，仅仅只是一个指针；很遗憾，在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

所以，数组名作为函数形参时，其沦落为一个普通指针！它的贵族身份被剥夺，成了一个地地道道的只拥有4个字节的平民。

典型的情况是

void func(int A[])

{

      //sizeof(A)得到的是4bytes

}

int main()

{

    int a[10]; //sizeof(a) 得到的结果是40bytes

    funct(a);

}

2、数组名可作为指针常量

　　根据结论2，数组名可以转换为指向其指代实体的指针，所以程序1中的第5行数组名直接赋值给指针，程序2第7行直接将数组名作为指针形参都可成立。

　下面的程序成立吗？

   int intArray[10];

   intArray++;

　　读者可以编译之，发现编译出错。原因在于，虽然数组名可以转换为指向其指代实体的指针，但是它只能被看作一个指针常量，不能被修改。

　　而指针，不管是指向结构体、数组还是基本数据类型的指针，都不包含原始数据结构的内涵，在WIN32平台下，sizeof操作的结果都是4。

顺便纠正一下许多程序员的另一个误解。许多程序员以为sizeof是一个函数，而实际上，它是一个操作符，不过其使用方式看起来的确太像一个函数了。语句sizeof(int)就可以说明sizeof的确不是一个函数，因为函数接纳形参（一个变量），世界上没有一个C/C++函数接纳一个数据类型（如int）为"形参"。

3．对于问题：为什么用strcpy()函数时，

char a[3] = "abc";

strcopy(a,"end");

-------------------没有错。

用-----------------

char *a = "abc";

strcopy(a,"end");

------------------运行时就有错呢？

解释如下：

char *a = "abc";  abc是一个字符串常量，有它自己的存储空间，因为分配在只读数据块，我们无法直接访问。这样赋值后，a只能读，不能写

所以strcpy(a, "end")不行，只有当你为a分配非常量的存储空间后才行

如：

char *a = new char[4];

strcpy(a, "end");  

printf("%s", a);

delete []a;

4//main.cpp

int array[3] = {7, 8, 9}; //全局变量

int main()

{

Test1();

Test2();

return 0;

}

//Test1.cpp

extern int array[3];

void Test1()

{

cout << array[1] << endl;

}

//Test2.cpp

extern int *array; //这个地方是不同的

void Test2()

{

cout << array << endl;

cout << array[1] << endl;

}

Test1()和Test2()的输出结果相同吗？

编译一下再看看，就发现执行Test2会有奇怪的结果，第一条语句的输出是7， 第二条语句会死机。而Test1()却一切正常。

这是为什么？

原因在编译器。在Test1.cpp中，由于使用了extern所以编译的时候要先用占位符将array标志一下，在连接的时候用main.cpp中的array进行替换。当编译器给变量赋值的时候，他认为这个值是该变量的地址。就好比：int i = 5;在编译器中编译后会把5的地址0x8291记录

而不是5，在i需要值的时候去0x8291这个地址去取出值给i（这里的i是全局的或者静态变量，这时候才能在编译阶段确定地址）。

所以在Test1.cpp中，把array的地址给了array,假设这个地址是0x34fe，但是由于数组的特性array == &array，所以这里是正常的。而在Test2.cpp中，array是个指针,所以会去0x34fe中取出值给array，所以array = 0x0007(数组的第一个值,这里要做地址，因为是给指针用)

这就是看到的Test2()的输出结果。显然array[1]会死机，因为0x0007地址是没有被分配的，并且是给操作系统用的而不是给用户用的。

5．数组和指针的分配

数组是开辟一块连续的内存空间,数组本身的标示符代表整个数组,可以用sizeof取得真实的大小；指针则是只分配一个指针大小的内存,并可把它的值指向某个有效的内存空间

[全局的和静态的]

char *p= "hello ";

一个指针,指向只读数据块(section)里的 "hello ",可被编译器放入字符串池(也就是说, 你在写一个char *q= "hello ",可能和p共享数据)

char a[]= "hello ";

一个数组,分配在可写数据块(section),不会被放到字符串池中

[局部]

char *p= "hello ";

一个指针,指向只读数据块(section)里的 "hello ",可被编译器放入字符串池(也就是说, 你在写一个char *q= "hello ",可能和p共享数据),另外,在函数中可以返回它的地址,也就是说,指针是局部变量,他指向的数据却是全局的.

char a[]= "hello ";

一个数组,分配在堆栈上,初始化由编译器进行(短的话直接用指令填充,长的就从全局字符串表拷贝),不会被放到字符串池中(但是却可能从字符串池中拷贝过来),也不应该返回

它的地址.

[代码中的字面字符串]

printf( "%s\n ", "hello ");

这两个字面常量( "%s\n "和 "hello "),都在只读数据块里

[用途]

全局指针

用于不需要修改内容,却可能会修改指针的情况(当然,不修改也没人反对)

全局数组,用于不需要修改地址,却需要修改内容的场合

既需要修改指针,有需要修改内容怎么办呢?定义一个数组,在定义一个指针指向它就可以了

函数中如果不需要修改字符串的内容,应该尽量用char*p= "xxx "这种写法.

初始化的局部字符数组影响效率,一般应该尽量避开(应该使用的情况下则不要犹豫)

 

   

  C++/C程序中，指针和数组在不少地方可以相互替换着用，让人产生一种错觉，以为两者是等价的。

    数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。

指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。

下面以字符串为例比较指针与数组的特性。

1 修改内容

       示例1中，字符数组a的容量是6个字符，其内容为hello\0。a的内容可以改变，如a[0]= ‘X’。指针p指向常量字符串“world”（位于静态存储区，内容为world\0），常量字符串的内容是不可以被修改的。从语法上看，编译器并不觉得语句p[0]= ‘X’有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误。

char a[] = “hello”; a[0] = ‘X’; cout << a << endl; char *p = “world”;     // 注意p指向常量字符串 p[0] = ‘X’;             // 编译器不能发现该错误 cout << p << endl;

示例1 修改数组和指针的内容

2 内容复制与比较

    不能对数组名进行直接复制与比较。示例2中，若想把数组a的内容复制给数组b，不能用语句 b = a ，否则将产生编译错误。应该用标准库函数strcpy进行复制。同理，比较b和a的内容是否相同，不能用if(b==a) 来判断，应该用标准库函数strcmp进行比较。

    语句p = a 并不能把a的内容复制指针p，而是把a的地址赋给了p。要想复制a的内容，可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存，再用strcpy进行字符串复制。同理，语句if(p==a) 比较的不是内容而是地址，应该用库函数strcmp来比较。

// 数组…     char a[] = "hello";     char b[10];     strcpy(b, a);           // 不能用   b = a;     if(strcmp(b, a) == 0)   // 不能用  if (b == a) …

// 指针…     int len = strlen(a);     char *p = (char *)malloc(sizeof(char)*(len+1));     strcpy(p,a);            // 不要用 p = a;     if(strcmp(p, a) == 0)   // 不要用 if (p == a) …

示例2 数组和指针的内容复制与比较

3 计算内存容量

    用运算符sizeof可以计算出数组的容量（字节数）。示例3（a）中，sizeof(a)的值是12（注意别忘了’\0’）。指针p指向a，但是sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数，相当于sizeof(char*)，而不是p所指的内存容量。C++/C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。

注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。示例3（b）中，不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)。

char a[] = "hello world";     char *p  = a;     cout<< sizeof(a) << endl;   // 12字节     cout<< sizeof(p) << endl;   // 4字节

示例3（a） 计算数组和指针的内存容量

void Func(char a[100])     {         cout<< sizeof(a) << endl;   // 4字节而不是100字节 }

 int arr[5];

 

     arr现在就是数组名， arr 代表的是该数组整块内存，即sizeof(arr) == 20 (假设sizeof(int) == 4), arr 里的内容是该块内存的首地址，即 arr == &arr[0]  。 arr可以看做是一个常量，也就不可以使用 arr++ 之类的运算。

 

     int *p;

     p = arr;

 

     p是一个指向int类型的指针，p  = arr,就是把数组的首地址（arr的内容就是数组的首地址，这个前面有分析）赋给p,即 p 现在就是指向数组的首地址，通过 p 就可以访问整个数组，但是 p 这里只是是个指针变量，也就是 p 的本质没有改变，p 不能和 arr 一样代表整个数组的内存， 所以 sizeof(p) == sizeof(int*)  ！= sizeof(arr)。

     把数组的首地址赋给 p，但 p 的本质一个int类型的指针变量，所以也就可以对 p 进行 ++ 之类的运算。

 

     我们可以通过对 p ，arr 的偏移（int类型的指针 +1 或 -1， 是向上或向下偏移 sizeof(int) 个byte）来访问数组里的元素，         *( p + i ) ，*（arr + i），也可以通过传统的 arr[i] 访问数组。 

 

    

 

 

     举个例子（例子来源于老师上课时讲解的）：

 

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

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

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

 

     这里的输出的值应该是？

 

     a 是 代表（不是指向）的是整个数组内存，a 的值是该数组内存的首地址， 对 a 取地址（&a），即......,所以这里的 &a 是指向整个数组的内存块，所以 a 的值与 &a 的值是一样的，都是该数组的首地址，但他们的含义是不一样的。

     这里 &a 的每次偏移是移动整个内存块的大小，这里就是移动 sizeof(a)，即40 byte，所以这里的 &a + 1, 是指针向下移动个40byte（数组内存块的大小），&a+1的指向 是下个 sizeof(a)大小的内存块。

 

 

下面是内存分配图：

 

        &a   ---> ==========  假设这里的地址值是 0x11111111          &a 和 a 的值都是 0x11111111

                      ||        1        ||

                      ==========

                      ||        2        ||

                      ==========

                      ||        3        ||

                      ==========

                      ||        4        ||

                      ========== <-----ptr-1  int类型的指针每偏移是 sizeof（int） 个 字节

                      ||        5        ||

    &a +1 ---> ==========  <-----ptr    上面的题目中 让 int 类型的指针 ptr 也指向了这里

                      ||        ?        ||

                      ==========

                      ||        ?        ||

                      ==========

                      ||        ?        ||

                      ==========

                      ||        ?        ||

                      ==========

                      ||        ?        ||

     &a+2 ---->==========

                      ||        ?        ||

                      ==========

                             """"""

                             """"""

                             """"""

 

 

     所以上面题目的输出结果 是 :

                              

                         2,5