本文使用运行环境如下： 操作系统：Ubuntu Linux 18.04 64 bit 编译环境：gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04)
C是最好的语言！咳咳……just for fun。在C语言中，很多时候指针（通常说的指针即指针变量）可以当成数组来用，数组也可以当成指针来用。需要明确的是：指针和数组是不一样的，本质上是两种不同的东西。
先来看个例子：
ptr_arr.c:
#include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int i; int arr[3] = {1,2,3}; int *aptr = calloc(3, sizeof(int)); int CALLOC_SIZE = 3 * sizeof(int); if(NULL == aptr) { printf("aptr alloc failed!\n"); } /* 给aptr指向的内存空间赋值 */ aptr[0] = 4; aptr[1] = 5; aptr[2] = 6; /* 分别用数组访问方式和指针访问方式，打印arr数组元素 */ for(i=0; i<3; i++) { printf("array access: arr[%d] = %d, pointer access: *(arr+%d) = %d\n", i, arr[i], i, *(arr+i)); } printf("============================================================\n"); /* 分别用数组访问方式和指针访问方式，打印aptr指向内存空间int元素 */ for(i=0; i<3; i++) { printf("array access: aptr[%d] = %d, pointer access: *(aptr+%d)= %d\n", i, aptr[i], i, *(aptr+i)); } printf("============================================================\n"); /* 分别打印arr数组占用内存空间大小和aptr指针占用内存空间大小以及aptr指针指向空间大小 */ printf("sizeof(arr) = %2lu Byte\n", sizeof(arr)); printf("sizeof(aptr) = %2lu Byte\n", sizeof(aptr)); printf("CALLOC_SIZE = - Byte\n", CALLOC_SIZE); return 0; }以上代码大致做了以下操作：
main函数中定义了一个有3个int型数组成员的arr数组（并将其依次初始化为1、2、3）、定义了一个aptr指针指向一段大小为3个int型变量大小的内存空间（并将其依次赋值为4、5、6）；
随后分别用数组访问方式和指针访问方式打印arr数组成员和aptr指针指向的内存成员；
最后分别打印arr数组占用的内存空间大小和aptr指针占用的内存空间大小以及aptr指针引用空间的大小。
程序执行结果：
$ gcc ptr_arr.c $ ./a.out array access: arr[0] = 1, pointer access: *(arr+0) = 1 array access: arr[1] = 2, pointer access: *(arr+1) = 2 array access: arr[2] = 3, pointer access: *(arr+2) = 3 ============================================================ array access: aptr[0] = 4, pointer access: *(aptr+0)= 4 array access: aptr[1] = 5, pointer access: *(aptr+1)= 5 array access: aptr[2] = 6, pointer access: *(aptr+2)= 6 ============================================================ sizeof(arr) = 12 Byte sizeof(aptr) = 8 Byte CALLOC_SIZE = 12 Byte从程序执行结果来看:
对arr数组，访问数组成员正常使用[]操作符的方式访问，也可以通过指针偏移*(arr+i)的方式正常访问；对aptr指针，访问指向的内存成员正常使用指针偏移*(arr+i)的方式访问，也可以通过[]操作符正常访问；事实上，以arr数组为例，arr[i]是*(arr+i)的语法糖（即做了一层包装），arr[i]本质上就是*(arr+i)操作。从以上2条执行结果来看，似乎指针和数组是相同的，可以混为一谈，其实不然，看程序最后的输出：
arr数组占用了12个字节，arr数组有3个int数组成员，每个int数组成员的大小为4字节，3*4刚好是12个字节；aptr指针占用了8个字节，当前运行环境是64位操作系统，64位操作系统的内存寻址范围是64位（8字节），8个字节就可以容纳64位操作系统下任意地址值，此处aptr仅仅占用了指针变量自身的大小，而并不是动态内存分配时分配的CALLOC_SIZE（12字节）大小。以上分析说明，指针和数组是不同的，至少在使用sizeof操作符时，它们返回的对象大小是不一样的：
arr数组定义时自动分配了一段连续的内存空间；而aptr指针定义时只分配了用于容纳指针变量的8字节空间，aptr引用的内存空间是后面动态内存申请得到的。arr是数组名，则sizeof(arr)返回的是整个数组对象的大小；aptr是指针变量，则sizeof(aptr)返回的是指针变量对象的大小，而不是aptr引用内存的大小。我们知道，C语言中数组名等价于数组首元素的地址，在表达式中使用arr就相当于&arr[0]，那么是否可以改变arr的地址呢？显然是不被允许的！试想一下，编译器在arr数组定义时自动为其分配了一段连续的内存空间，arr就是这段内存空间的标签，这段内存空间在arr数组的生命周期结束前一直存在，如果arr的地址被改变了，那么不就造成内存泄漏了吗？但显然arr数组首元素的值是可以被改变的，arr[0]可以作为左值。
因此数组名可以看成一个指向-非-常量-的常量指针（仅仅可以看成），形如int * const arr，其指向不能被改变（即不能作为左值被重新赋值），其指向的数据可以被改变（指向的数据即数组首元素），由于其不能作为左值，因此尝试使用arr++遍历数组时，编译是不能通过的。看示例程序：
#include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int i; int arr[3] = {1,2,3}; int *aptr = arr; for(i=0; i<3; i++) { printf("arr[%d] = %d\n", i, *arr); arr++; /* arr不是指针，因此不能作为左值使用，此处必然报错 */ } return 0; }编译以上程序，编译结果：
$ gcc ptr_arr.c ptr_arr.c: In function ‘main’: ptr_arr.c:13:6: error: lvalue required as increment operand arr++; ^~程序中想通过arr数组名以指针自增的方式遍历数组，但arr是数组名不是指针（仅仅是可以看成指向-非-常量-的常量指针），编译器在第13行报出“需要左值作为增量操作数”的错误。我们将程序稍作修改，使用真正的指针aptr指向arr数组，然后用aptr指针自增的方式遍历数组，看看结果如何。
#include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int i; int arr[3] = {1,2,3}; int *aptr = arr; for(i=0; i<3; i++) { printf("arr[%d] = %d\n", i, *aptr); aptr++; } return 0; }编译运行结果：
$ gcc ptr_arr.c $ ./a.out arr[0] = 1 arr[1] = 2 arr[2] = 3程序编译通过且正常执行，说明指针是可以作为左值的，也说明数组和指针是不同的，数组仅仅是有时候用起来像指针，数组不是指针。
新建2个C源文件arr.c和main.c，文件内容分别如下：
arr.c
#include <stdio.h> /* 定义arr数组，有3个成员 */ int arr[3] = {1,2,3}; void print_arr(void) { /* 输出arr数组首元素地址 */ printf("%s: arr = 0x6lx\n", __FILE__, (long unsigned int)arr); /* 输出数组首地址 */ printf("%s: &arr = 0x6lx\n", __FILE__, (long unsigned int)&arr); }main.c
#include <stdio.h> extern void print_arr(void); /* 将arr.c中定义的数组声明为指针 */ extern int *arr; /* 以十六进制显示一段内存空间 */ void d(char *start, size_t len) { size_t i; printf("0x6lx:", (long unsigned int)start); for(i=0; i<len; i++) printf(" x", start[i]); printf("\n"); } int main(int argc, char *argv[]) { size_t i; /* 输出arr.c中arr和&arr的值 */ print_arr(); /* 输出main.c中arr和&arr的值 */ printf("%s: arr = 0x6lx\n", __FILE__, (long unsigned int)arr); printf("%s: &arr = 0x6lx\n", __FILE__, (long unsigned int)&arr); /* 以十六进制显示mian.c中&arr的内存字节排布 */ d((char *)&arr, 12); for(i=0; i<3; i++) { /* arr在arr.c中被定义为数组，main.c中被声明为指针; 此处仍想用访问数组的方式来访问arr */ printf("arr[%d] = %d\n", i, arr[i]); } return 0； }在arr.c中arr被定义为数组，在mian.c中arr被声明为指针，此后在mian.c中仍想像访问数组一样去访问arr，这会造成什么后果？编译后执行：
$ gcc arr.c main.c $ ./a.out arr.c: arr = 0x00005597a8a06010 arr.c: &arr = 0x00005597a8a06010 main.c: arr = 0x0000000200000001 main.c: &arr = 0x00005597a8a06010 0x00005597a8a06010: 01 00 00 00 02 00 00 00 03 00 00 00 Segmentation fault (core dumped)可以看到在程序执行的最后发生了段错误，访问了非法内存。
main.c中使用的arr是在arr.c中定义的（即main.c中不会为arr分配内存空间），编译的最后阶段必然要将main.c中声明的arr链接到arr.c中定义的arr数组对应的内存空间上去（如果最后没有找到arr的定义，编译器将报错停止）。问题在于main.c中将arr看成了指针，指针也是变量（也要分配内存空间），因此指针变量的地址（存放指针变量的空间）被分配在了arr.c中arr数组的起始地址上（main.c中arr的地址和arr.c中arr数组的起始地址相同）。
因此，指针变量的值（内容）就变成了arr.c中arr数组起始地址开始的8个字节（64位操作系统下64位程序指针长度为8字节），下图中显示顺序不同是因为字节序为小端序，本文暂不讨论。
因此，在main.c中想通过arr访问数组的内容，就相当于从0x0000000200000001这个地址去访问arr数组，而arr数组的起始地址是0x00005597a8a06010。
0x0000000200000001是原来arr数组里保存的值，是个非法地址，现在对这个非法地址解引用访问必然产生段错误。修正这个错误只需将main.c中arr的外部声明改成数组extern int arr[]即可。
从这个例子也能够看出指针不同于数组，数组可以直接通过数组名+下标的方式访问所有成员，而指针需要先访问指针的内容（即指针的值），再对其解引用最终得到结果，指针值非法时将引发异常。
考虑如下代码para.c：
#include <stdio.h> void fun(int arr[3]) { printf("sizeof(arr): %lu\n", sizeof(arr)); } int main(int argc, char *argv[]) { int arr[3] = {1,2,3}; fun(arr); return 0; }fun函数只做了一件事情：打印参数的大小，fun函数的参数是类型为int[3]的数组arr，如果sizeof的操作数是数组名，那么输出的应该是sizeof(int)=4*3=12，结果却并非如此，编译后执行：
$ gcc para.c para.c: In function ‘fun’: para.c:5:37: warning: ‘sizeof’ on array function parameter ‘arr’ will return size of ‘int *’ [-Wsizeof-array-argument] printf("sizeof(arr): %lu\n", sizeof(arr)); ^ para.c:3:14: note: declared here void fun(int arr[3]) ^~~ $ ./a.out sizeof(arr): 8程序输出的结果是8，sizeof(arr)返回的结果是8字节，刚好是64位系统下指针的长度，再看编译器给出的警告信息：sizeof(arr)将返回int *的大小，arr是数组名，此处却返回int *的大小，说明编译器将其看成了指针。将fun函数参数改成指针
void fun(int *arr) { printf("sizeof(arr): %lu\n", sizeof(arr)); }重新编译后执行：
$ gcc para.c $ ./a.out sizeof(arr): 8此时编译器警告没有了，执行结果是相同的，说明编译器的确将数组参数当成了指针。
C语言是为操作系统而生的语言，其操作必须高效，因此C语言中的函数参数只有值拷贝一种方式传递（将实参的值拷贝给形参）。在本例中体现为：fun函数传入arr数组名时，编译器自动将其转化为了指针。如果编译器原样将整个数组都传入函数，那么就要将整个数组都复制一份传给形参，复制的过程必然存在系统开销，同时栈内存是有限的，当数组空间超过了可用栈内存空间时，将发生栈溢出。
因此将数组参数转化为指针，只传入数组首地址必然是高效的选择。鉴于数组参数自动被转化为指针，通常将数组作为参数时，还需要传入数组长度，便于计算数组边界，否则有可能产生越界异常。
将代码稍作修改，用指针参数遍历数组：
#include <stdio.h> void fun(int *arr, size_t size) { size_t i; printf("sizeof(arr): %lu\n", sizeof(arr)); *arr = 6;/* 修改arr指针指向的元素的值，此处为arr[0]=6 */ for(i=0; i<size; i++) { printf("arr[%lu] = %d\n", i, *arr); arr++;/* arr可以自增，说明arr不是数组，是真正的指针 */ } } int main(int argc, char *argv[]) { int arr[3] = {1,2,3}; fun(arr, sizeof(arr)/sizeof(int )); return 0; }编译后执行：
$ gcc para.c $ ./a.out sizeof(arr): 8 arr[0] = 6 arr[1] = 2 arr[2] = 3第12行执行arr++操作（相当于arr = arr + 1，如果arr是数组必将编译报错）编译无警告无错误，运行结果正常，说明数组作为函数参数时，和指针是等价的。
本文通过几个简要的示例，尝试从多个维度说明指针与数组的异同：
指针的用法和数组的用法很很像，因为arr[i]本质是*(arr+i)的语法糖，但指针和数组在占用内存空间大小本质上上不同；数组名可以看成指向-非-常量-的常量指针（形如int * const arr），但数组名不能作为左值（即不能对数组名赋值），指针可以作为左值；数组可以直接通过数组名+下标的方式访问数组成员，而指针需要先访问指针的内容（即指针的值），再对其解引用得到结果；数组一经分配内存是固定的，使用数组名+下标只要不超出索引范围不会访问到非法内存地址，但指针由于其灵活性，存在很大可能会访问到非法内存地址；数组名作函数形参时将自动被转化为指针，此时函数内形参的操作就是指针的操作，此时的数组和指针是等价的。以上几点不难看出，指针和数组在本质上还是不同的，在涉及指针和数组的操作时，需要分清当前的对象是指针还是数组，掌握好指针和数组的特性有助于减少bug。
