深入理解 C/C++ 数组和指针

本文转载自 CSDN @WalkingInTheWind，原文链接：https://blog.csdn.net/luckyxiaoqiang/article/details/7044380

C 语言中数组和指针是一种很特别的关系，首先本质上肯定是不同的，本文从各个角度来论述数组和指针。

1. 数组与指针的关系#

数组和指针是两种不同的类型，数组具有确定数量的元素，而指针只是一个标量值。数组可以在某些情况下转换为指针，当数组名在表达式中使用时，编译器会把数组名转换为一个指针常量，是数组中的第一个元素的地址，类型就是数组元素的地址类型，如int a[5] = {0, 1, 2, 3, 4};，数组名a若出现在表达式中，如int *p = a;，那么它就转换为第一个元素的地址，等价于int *p = &a[0];。再比如int aa[2][5] = { {0,1,2,3,4}, {5,6,7,8,9} };，数组名aa若出现在表达式中，如int (*p)[5] = aa;，那么它就转换为第一个元素的地址，即等价于int (*p)[5] = &aa[0];。但是int (*p)[5] = aa[0];这个就不对了，根据规则我们推一下就明白了，aa[0]的类型是int [5]，是一个元素数量为 5 的整型数组，就算转化，那么转化成的是数组（int [5]）中第一个元素的地址，即&aa[0][0]，类型是int *。所以，要么是int (*p)[5] = aa;，要么是int (*p)[5] = &aa[0];。

只有在两种场合下，数组名并不用指针常量来表示：就是当数组名作为sizeof操作符或单目操作符&的操作数时。sizeof返回整个数组的长度，使用的是它的类型信息，而不是地址信息，不是指向数组的指针的长度；取一个数组名的地址所产生的是一个指向数组的指针，而不是指向某个指针常量值的指针。如上述数组int a[5]，&a表示的是指向数组a的指针，类型是int (*)[5]，所以int *p = &a;是不对的，因为右边是一个整型数组的指针int (*)[5]，而p是一个整型指针int *。关于数组的sizeof问题会在下文中仔细讨论。

2. 数组与指针的下标引用#

int a[5] = {0, 1, 2, 3, 4};，如a[3]，用下标来访问数组a中的第三个元素，那么下标的本质是什么呢？本质就是这样的一个表达式：*(a+3)，当然表达式中必须含有有效的数组名或指针变量。其实a[3]和3[a]是等价的，因为他们被翻译成相同的表达式（顶多顺序不同而已），都是访问的数组a中的元素3。指针当然也能用下标的形式了，如int *p = a;，那么p[3]就是*(p+3)，等同于3[p]，同样访问数组a中的元素3。根据这一规则，我们还能写出更奇怪的表达式，如int aa[2][5] = { {0,1,2,3,4}, {5,6,7,8,9} };，则有1[aa][2]，这个看起来很别扭，首先1[aa]，就是*(1+aa)，那么1[aa][2]就是*(*(1+aa)+2)，也就是aa[1][2]。但是1[2][aa]，这个就不对了，因为前半部分1[2]是不符合要求的。当然在实际中使用这样的表达式是没有意义的，除非就是不想让人很容易的看懂你的代码。

3. 数组与指针的定义和声明#

数组和指针的定义与声明必须保持一致，不能一个地方定义的是数组，然后在另一个地方声明为指针。

首先我们解释一下数组名的下标引用和指针的下标引用，它们是不完全相同的。从访问的方式来讲，对于int a[5] = {0, 1, 2, 3, 4};，有int *p = a;，虽然a[3]和p[3]都会分别被解析成*(a+3)和*(p+3)，但是实质是不一样的。

• 对于a[3]，也就是*(a+3)
  1. 把数组名a代表的数组首元素地址和3相加，得到要访问数据的地址（这里注意，数组名a直接被编译成数组的首元素地址）；
  2. 访问这个地址，取出数据。
• 对于p[3]，也就是*(p+3)
  1. 从指针变量p所代表的地址单元里取出内容（指针变量存储地址数据），也就是数组首元素的地址（这里注意，指针名p代表的是指针变量的存储地址，而指针变量p所存储的地址数据才是数组的首元素地址）【注解：正如int n = 5，变量名n代表的是变量n的存储地址，而地址里为变量n所存储的整型数据5，指针也是普通的变量，只不过指针变量存储的是地址数据，所以这一步就是取指针变量的数据而已】；
  2. 把取出的变量p的数据（即数组首元素的地址）和3相加，得到要访问的数据的地址；
  3. 访问这个地址，取出数据。

下面给出一个例子来说明若定义和声明不一致带来的问题：设 test1.cpp 中有如下定义：char s[] = "abcdefg";，test2.cpp 中有如下声明：extern char *s;，显然编译是没有问题的。那么在 test2.cpp 中引用s[i]结果会怎样呢？如s[3]，结果会是d吗？下面我们对 test2.cpp 中的s[3]进行分析：s的地址当然是由 test1.cpp 中的定义决定了，因为在定义时就分配了内存空间。我们根据上面所给出的下标引用的示例规则来进行分析，如下所示：

1. 从s所代表的地址单元取出内容（4 个字节的地址数据），这里实际上是数组s中的前 4 个元素，这个值是abcd，也就是十六进制的64636261h【注解：由于s声明为指针，s[3]即*(s+3)，则需要先取出指针变量s所存储的地址数据。而若要得到变量s的数据，需要知道变量s的地址，而变量s在其定义时地址就确定了，并且分配了存储空间，存储了"abcdefg"，由此可以得到指针变量s的内容为abcd。换言之，定义为数组而声明为指针时，多了一次寻址操作】；
2. 然后把取到的地址数据和3相加，得到要访问的数据的地址，即64636261h + 3，这个地址是未分配未定义的；
3. 取地址64636261h + 3的内容，由于这个地址单元是未定义的，访问就会出错。

下面给出分析的代码（可以只观察有注释的部分）:

#include <iostream>
using namespace std;
extern void test();
char s[] = "abcdefg";
int main(void)
{
002E13A0  push        ebp
002E13A1  mov         ebp,esp
002E13A3  sub         esp,0D8h
002E13A9  push        ebx
002E13AA  push        esi
002E13AB  push        edi
002E13AC  lea         edi,[ebp+FFFFFF28h]
002E13B2  mov         ecx,36h
002E13B7  mov         eax,0CCCCCCCCh
002E13BC  rep stos    dword ptr es:[edi]
          char ch;
          int i = 3;
002E13BE  mov         dword ptr [ebp-14h],3
          ch = s[i];
002E13C5  mov         eax,dword ptr [ebp-14h]
/* s 直接被翻译成数组首元素的地址和 i(eax) 相加，得到操作数地址，然后作为 byte ptr 类型取内容，传给 cl */
002E13C8  mov         cl,byte ptr [eax+011F7000h]
002E13CE  mov         byte ptr [ebp-5],cl  /* cl 的内容传给 ch(ebp-5) */
          test();
002E13D1  call        002E1073
          return 0;
002E13D6  xor         eax,eax
}
002E13D8  pop         edi
002E13D9  pop         esi
002E13DA  pop         ebx
002E13DB  add         esp,0D8h
002E13E1  cmp         ebp,esp
002E13E3  call        002E113B
002E13E8  mov         esp,ebp
002E13EA  pop         ebp
002E13EB  ret

以下为 test2.cpp，则运行错误：

extern char *s;
void test()
{
011F1470  push        ebp
011F1471  mov         ebp,esp
011F1473  sub         esp,0D8h
011F1479  push        ebx
011F147A  push        esi
011F147B  push        edi
011F147C  lea         edi,[ebp+FFFFFF28h]
011F1482  mov         ecx,36h
011F1487  mov         eax,0CCCCCCCCh
011F148C  rep stos    dword ptr es:[edi]
          char ch;
          int i = 3;
011F148E  mov         dword ptr [ebp-14h],3
          ch = s[i];
/* ds 没有影响，因为 windows 中所有的段基址都为 0，取 011F7000h 单元的内容，
   这里是数组中的前四个字节（指针是四个字节）组成的整数，也就是 64636261h，
   也就是这里，把 s 所指的单元计算成了 64636261h */
011F1495  mov         eax,dword ptr ds:[011F7000h]
/* 然后把地址和 i 相加，也就是 64636261h + 3，这个地址是未分配未定义的，访问当然会出错 */
011F149A  add         eax,dword ptr [ebp-14h]
011F149D  mov         cl,byte ptr [eax]        /* 访问错误 */
011F149F  mov         byte ptr [ebp-5],cl
          return;
}
011F14A2  pop         edi
011F14A3  pop         esi
011F14A4  pop         ebx
011F14A5  mov         esp,ebp
011F14A7  pop         ebp
011F14A8  ret

若 test2.cpp 中这样声明：extern char s[];，这样就正确了，因为声明和定义一致，访问就没问题了。所以千万不要简单的认为数组名与指针是一样的，否则会吃大亏，数组的定义和声明千万要保持一致性。

4. 数组和指针的sizeof问题#

数组的sizeof就是：数组的元素个数 × 元素大小，而指针的sizeof全都是一样，都是地址类型，32 位机器是 4 个字节。下面给出一些例子：

#include <iostream>
using namespace std;
int main()
{
    int a[6][8] = {0};
    int (*p)[8];
    p = &a[0];
    int (*pp)[6][8];
    pp = &a;

    cout << sizeof(a) << endl;        // 192
    cout << sizeof(*a) << endl;       // 32
    cout << sizeof(&a) << endl;       // 4
    cout << sizeof(a[0]) << endl;     // 32
    cout << sizeof(*a[0]) << endl;    // 4
    cout << sizeof(&a[0]) << endl;    // 4
    cout << sizeof(a[0][0]) << endl;  // 4
    cout << sizeof(&a[0][0]) << endl; // 4
    cout << sizeof(p) << endl;        // 4
    cout << sizeof(*p) << endl;       // 32
    cout << sizeof(&p) << endl;       // 4
    cout << sizeof(pp) << endl;       // 4
    cout << sizeof(*pp) << endl;      // 192
    cout << sizeof(&pp) << endl;      // 4

    system("pause");
    return 0;
}

VS2010 在 32 位 windows7 下的运行结果如以上代码中的注释部分（VC6.0 不符合标准），下面对程序逐一做简单的解释：

• sizeof(a);，a的定义为int a[6][8]，类型是int [6][8]，即元素个数为6*8的二维int型数组，它的大小就是6*8*sizeof(int)，这里是192；
• sizeof(*a);，*a这个表达式中数组名a被转换为指针，即数组第一个元素a[0]的地址，*得到这个地址所指的对象，也就是a[0]，总的来说*a等价于*(&a[0])，a[0]的类型int [8]，即大小为 8 的一维int型数组，它的大小就是8*sizeof(int)，这里是32；
• sizeof(&a);，&取a的地址，类型是int (*)[6][8]，地址类型，这里大小是4；
• sizeof(a[0]);，a[0]的类型int [8]，即大小为 8 的一维int型数组，它的大小就是8*sizeof(int)，这里是32；
• sizeof(*a[0]);，*a[0]这个表达式中数组名a[0]被转换为指针，即数组的第一个元素a[0][0]的地址，*得到这个地址所指的元素，也就是a[0][0]，总的来说*a[0]等价于*(&a[0][0])，a[0][0]的类型是int，它的大小就是sizeof(int)，这里是4；
• sizeof(&a[0]);，&取a[0]的地址，类型是int (*)[8]，地址类型，这里大小是4；
• sizeof(a[0][0]);，a[0][0]的类型是int，它的大小就是sizeof(int)，这里是4；
• sizeof(&a[0][0]);，&取a[0][0]的地址，类型是int *，地址类型，这里大小是4；
• sizeof(p);，p的类型是int (*)[8]，指向一个元素个数为 8 的int型数组，地址类型，这里大小是4；
• sizeof(*p);，*p取得p所指的元素，类型是int [8]，大小为8*sizeof(int)，这里是32；
• sizeof(&p);，&取p的地址，类型是int (**)[8]，地址类型，这里大小是4；
• sizeof(pp);，pp的类型是int (*)[6][8]，指向一个大小为6*8的二维int型数组，地址类型，这里大小为4；
• sizeof(*pp);，*pp取得pp所指的对象，类型是int [6][8]，即元素个数为6*8的二维int型数组，它的大小就是6*8*sizeof(int)，这里是192；
• sizeof(&pp);，&取pp的地址，类型是int (**)[6][8]，地址类型，这里大小是4；

5. 数组作为函数参数#

当数组作为函数参数传入时，数组退化为指针，类型是第一个元素的地址类型。“数组名被改写成一个指针参数”，这个规则并不是递归定义的。数组的数组会被改写为“数组的指针”，而不是“指针的指针”。下面给出几个例子：

fun1(char s[10])
{
    // s 在函数内部的实际类型是 char *
}

fun2(char s[][10])
{
    // s 在函数内部的实际类型是 char (*)[10]，即 char [10] 数组的指针
}

fun3(char *s[15])
{
    // s 在函数内部的实际类型是 char **，字符型指针的指针
}

fun4(char (*s)[20])
{
    // s 在函数内部的实际类型不变，仍然是 char (*)[20]，即 char [20] 数组的指针
}

以上可以简单的归纳为：数组作为参数被改写为指向数组的第一个元素（这里的元素可以是数组）的指针。数组作为参数必须提供除了最左边一维以外的所有维长度。

另外，我们还要注意：char s[][10]和char **s作为函数参数是不一样的，因为函数内部指针的类型是不一样的（数组指针和二级指针），尤其在进行指针加减运算以及sizeof运算时。

总结：总结了这么多，应该对数组和指针有个较深入的理解了。这些问题的归根原因还是来自于指针问题，这也正是 C 语言的精华所在，不掌握这些根本不算掌握 C 语言，不过掌握了这些也不敢说就等于掌握了 C 语言！！！