C语言回顾——指针与数组

今天萌新博主来给大家介绍C语言指针中指针与数组部分，在这一块也是非常难以理解的，闲言少叙，咱们开始吧！

大家都知道数组与指针有着紧密的联系，数组是由一组若干个元素构成，我们在访问数组的时候，采用的是循环体的方式，就是把数组的下标逐步的循环一次，这样我们就可以读出所有数组元素的值。那么重点来了，数组下标与地址的之间的关系，如果我们掌握好，大家学起来指针与数组就会非常的吃力，萌新博主与大家也是感同身受啊！

【数组的存储方式】

数组的三个特点：
1.数组有若干个元素
2.元素的数据类型必须相同
3.数组中的数据元素是有序排列的

arr1[4]={1,2,3,4}
arr2[4]={4,3,2,1}
//这两个数组不一样

数组元素占用的字节长度都是相等的；
指向数组的指针的初始值就是数组的首地址；

int arr[4]={1,2,3,4}

每个元素占用的字节长度为：sizeof(int)；

若sizeof(int)==2，假设数组的第一个元素a[0]的地址为0x00000001，则数组的第二个元素a[1]的地址为0x00000003，则数组的第三个元素a[2]的地址为0x00000005

所以说数组中的数据元素是有序排列的，那我们在查找数组元素的时候，只需要查找到第一个元素的地址，就能按照顺序找到相应的元素了。

#include <stdio.h>
int main(void)
{
	int arr[4]={1,2,3,4};
	printf("arr[0]=%p\n",&arr[0]);
	printf("arr[1]=%p\n",&arr[1]);
	printf("arr[2]=%p\n",&arr[2]);
	printf("arr[3]=%p\n",&arr[3]);
	return 0;
}

运行结果：

那我们再来看指针的性质：
【指针与整数的运算】

指针加n=指针原来的值+n*sizeof(指针所指变量类型)

指针减n=指针原来的值-n*sizeof(指针所指变量类型)

int *p=NULL
p=&arr[0]
p=0x000001
p+1=0x000001+1×sizeof(int)
p+2=0x000001+2×sizeof(int)
p+3=0x000001+3×sizeof(int)

#include <stdio.h>
int main(void)
{
	int arr[4]={1,2,3,4};
	int *p=NULL;//声明一个指针
	int i=0;
	p=&arr[0];//等价于p=arr;
	printf("sizeof(int)=%d\n",sizeof(int));
	printf("arr[0]=%p\n",&arr[0]);
	printf("arr[1]=%p\n",&arr[1]);
	printf("arr[2]=%p\n",&arr[2]);
	printf("arr[3]=%p\n",&arr[3]);
	for(i=0;i<=3;i++)
	{
		printf("p+%d=%p\n",i,p+i);//循环输出指针的值
	}
}

结果：
sizeof(int)=4
arr[0]=0019FF20
arr[1]=0019FF24
arr[2]=0019FF28
arr[3]=0019FF2C
p+0=0019FF20
p+1=0019FF24
p+2=0019FF28
p+3=0019FF2C

我们不难发现，我们可以通过指针来访问一维数组
注意：以上对应关系的成立，指针p必须指向数组元素的首地址。

【那指针是如何访问数组的呢？】

#include <stdio.h>
int main(void)
{
	int arr[8]={1,2,3,4,5,6,7,8};
	int i=0;
    int *p=NULL;
    p=arr;//指针指向首地址
	printf("arr[i]\n");
    for(i=0;i<8;i++)
	{
	printf("arr[%d]=%d\n",i,arr[i]);
	}

    printf("p+i\n");
	for(i=0;i<8;i++)
	{
	printf("p+%d=%d\n",i,*(p+i));
	}
    return 0;
}

运行结果：

【访问指针的四种方法】
1.直接下标法
有一个数组a[i]
int *p=a等价于int *p=&a[0]

2.首地址自加法*(a+i)
数组名就是首地址：a等价于p

3.指针自加法*(p+i)

4.指针下标法p[i]

通过指针可以修改数组元素

int arr1[8]={省略};
int arr2[8]={省略};
int i=1;
int *p1=arr1;//使指针p指向arr的首地址
int *p2=arr2;
p1=p2;//改变指针指向
p++;//让指针指向下一个元素

注意：指针可以自加，但是数组名不可以自加，如arr1++，同时数组名也不能相互赋值，如arr1=arr2;

【用数组访问与用指针访问的区别】
1.访问方式不同

使用数组名访问时直接访问，使用指针是间接访问;
下标从0开始的原因：因为下标的实质是地址偏移量

2.占用空间不同

系统为arr分配了“sizeof(类型)*元素个数”个字节，给指针分配了“sizeof(类型)”个字节

换句话说使用指针可以降低空间复杂度，我们来看个程序：

#include <stdio.h>
int main(void)
{
	int arr[8]={1,2,3,4,5,6,7,8};
    int *p=NULL;
    p=arr;//指针指向首地址
	printf("sizeof(arr)=%d\n",sizeof(arr));
	printf("sizeof(*p)=%d\n",sizeof(*p));
	return 0;
}

运行结果：

很明显，系统为arr分配了32个字节，给指针分配了4个字节。

【让我们来回顾二维数组】
二维数组a[i][j]，具有两个下标：行下标与列下标。
存储方式：先存储行下标，再存储列下标
即先在一个行下标内把a[0]列存满，再存a[1]列的元素。

a[0][0],a[0][1],a[0][2],a[0][3]
a[1][0],a[1][1],a[1][2],a[1][3]

【二维数组arr[ ][ ]的首地址有多种表达形式】
1.将二维数组看成元素是一维数组的元素
2.数组中第0行第0列的地址，&arr[0][0]
3.由于二维数组先存储行，所以第一行的第一个元素的地址，即&a[0]也是首地址

二维数组的元素个数：i×j

arr[2][3]={(1,2,3),(4,5,6)}
arr[2][3]={arr1[3],arr2[3]}
二维数组的首地址：&arr[0][0]，&arr[0]
二维数组的数组名，不是首地址

int arr[i][j];
int *p=&arr[0][0];

此时p指向第一行第一个元素，即arr[0][0]，而列指针是arr[i]，指向第(i+1)列的元素。

不允许操作：p=arr或声明的时候使用int *p=arr(arr会指向一整行的地址)

那我们从a[0][0]跳到a[2][2]，如何操作？

#include <stdio.h>
int main(void)
{
	int a[3][3]={1,2,3,4,5,6,7,8,9};
	int i=0;
	int j=0;
	for(i=0;i<3;i++)
	{
	for(j=0;j<3;j++)
	{
	printf("a[%d][%d]=%d\t",i,j,a[i][j]);
	}
	printf("\n");
	}
}

运行结果：

a[0][0]是第一行第一列的元素 ，p=&[0][0]
a[2][2]是第三行第三列的元素

有一个指针p指向二维数组的首地址:&a[0][0]
指针的偏移量为：p+行数×行下标+列下标；

我们来看个例子：

#include <stdio.h>
int main(void)
{
	int a[3][3]={1,2,3,4,5,6,7,8,9};
	int i=0;
	int j=0;

	int *p=NULL;
	p=&a[0][0];
	
	for(i=0;i<3;i++)
	{
	for(j=0;j<3;j++)
	{
	printf("a[%d][%d]=%d\t",i,j,a[i][j]);
	}
	printf("\n");
	}

	for(i=0;i<3;i++)
	{
	for(j=0;j<3;j++)
	{
    printf("p+N*%d+%d\t",i,j,*(p+3*i+j));
	}
	printf("\n");
	}
    printf("p+N*i+j\n");
}

运行结果：

于是我们得到二维数组的四种表现形式，如下图

【二维数组的矩阵转置】

#include <stdio.h>
int main(void)
{
	int a[3][3]={1,2,3,4,5,6,7,8,9};
	int i=0;
	int j=0;
	int *p=NULL;
	p=&a[0][0];//p指向首地址

	printf("转置前：\n");
		for(i=0;i<3;i++)
		{
			for(j=0;j<3;j++)
			{
			printf("a[%d][%d]==%d\t",i,j,*(p+3*i+j));
			}
			printf("\n");
		}

		printf("转置后：\n");
		for(j=0;j<3;j++)
		{
			for(i=0;i<3;i++)
			{
			printf("a[%d][%d]==%d\t",i,j,*(p+3*i+j));
			}
			printf("\n");
		}
}

运行结果：

在for循环中，我们只需要把i换成j，j换成i就可以实现矩阵的转置，而不需要中间变量。

【二维数组形参的形式】
另外当我们用数组作为函数的形式参数，我们需要给函数传递一个数组首地址和一个数组长度

【将数组和数组长度分别作为形参】

void function(int array[],int size)
void function(int *arry,int size)

我们再来一个例子
【在一个升序数组中查找大于3的元素】

#include <stdio.h>
void printarray(int *arr,int n)
{
	int i=0;
	for(i=0;i<n;i++)
	{
	printf("%4d",arr[i]);
	}
	printf("\n");
}


int main(void)
{	
	int arr[9]={1,2,3,4,5,6,7,8,9};
	int *p=NULL;
	p=arr;
	while(*p<3)//while循环对指针p进行取值
	{
	p++;//如果p的值<3,则将地址下移，再继续与3比较
	}
	printarray(p,9-(p-arr));//经过3次自加后，指针由指向元素1到指向元素4
	//那么指针p将以arr[3]为首地址传到函数中,(p-arr)为arr[3]与首地址arr[0]的差值，也就之间的个数
	return 0;
}

运行结果：

【用二维数组形参函数来完成矩阵倒置】

#include <stdio.h>
void function1(int *p,int M,int N)
{
	int i,j;
	for(i=0;i<M;i++)
	{
		for(j=0;j<M;j++)
		{
		printf("%d",*(p+i*N+j));//也可以用*p++:输出当前值，地址下移
		}
		printf("\n");
	}
	
}

void function2(int *p,int M,int N)
{
	int i,j;
	for(j=0;j<M;j++)
	{
		for(i=0;i<M;i++)
		{
		printf("%d",*(p+i*N+j));//*(p+i*N+j)是指针偏移量法
		}
		printf("\n");
	}
		
}
//注意形参M,N是行列长度，不是下标

int main(void)
{	
	int arr[3][3]={1,2,3,4,5,6,7,8,9};
	int *p=NULL;
	p=&arr[0][0];
	function1(p,3,3);
	printf("\n");
	function2(p,3,3);
	return 0;
}

运行结果：

二维数组形参的其他形式

数组首地址表示法