指针和数组的区别

uxlike

已于 2022-05-06 14:24:38 修改

阅读量2.3k

点赞数 2

分类专栏： C之我见文章标签： c语言

于 2020-10-04 22:00:13 首次发布

本文链接：https://blog.csdn.net/to_free/article/details/108923232

版权

C之我见专栏收录该内容

8 篇文章 0 订阅

订阅专栏

0. 前言

~~C是最好的语言！咳咳……just for fun~~。在C语言中，很多时候指针（通常说的指针即指针变量）可以当成数组来用，数组也可以当成指针来用。需要明确的是：指针和数组是不一样的，本质上是两种不同的东西。

1. 数组的大小和指针的大小

先来看个例子：

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  = %2d 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引用内存的大小。

2. 数组名可以看成“指向-非-常量-的常量指针”

我们知道，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

程序编译通过且正常执行，说明指针是可以作为左值的，也说明数组和指针是不同的，数组仅仅是有时候用起来像指针，数组不是指针。

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   = 0x%016lx\n", __FILE__, (long unsigned int)arr);
	/* 输出数组首地址 */
    printf("%s: &arr  = 0x%016lx\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("0x%016lx:", (long unsigned int)start);
	for(i=0; i<len; i++)
		printf(" %02x", 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  = 0x%016lx\n", __FILE__, (long unsigned int)arr);
	printf("%s: &arr = 0x%016lx\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[]即可。

从这个例子也能够看出指针不同于数组，数组可以直接通过数组名+下标的方式访问所有成员，而指针需要先访问指针的内容（即指针的值），再对其解引用最终得到结果，指针值非法时将引发异常。

4. 数组名作形参时等同指针

考虑如下代码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是数组必将编译报错）编译无警告无错误，运行结果正常，说明数组作为函数参数时，和指针是等价的。

5. 总结

本文通过几个简要的示例，尝试从多个维度说明指针与数组的异同：

指针的用法和数组的用法很很像，因为arr[i]本质是*(arr+i)的语法糖，但指针和数组在占用内存空间大小本质上上不同；
数组名可以看成指向-非-常量-的常量指针（形如int * const arr），但数组名不能作为左值（即不能对数组名赋值），指针可以作为左值；
数组可以直接通过数组名+下标的方式访问数组成员，而指针需要先访问指针的内容（即指针的值），再对其解引用得到结果；数组一经分配内存是固定的，使用数组名+下标只要不超出索引范围不会访问到非法内存地址，但指针由于其灵活性，存在很大可能会访问到非法内存地址；
数组名作函数形参时将自动被转化为指针，此时函数内形参的操作就是指针的操作，此时的数组和指针是等价的。

以上几点不难看出，指针和数组在本质上还是不同的，在涉及指针和数组的操作时，需要分清当前的对象是指针还是数组，掌握好指针和数组的特性有助于减少bug。