二维数组与指针全面理解

于 2019-10-02 11:59:25 发布
阅读量633 收藏 4
点赞数
原文链接：https://blog.csdn.net/usstmiracle/article/details/79525951
版权

指向二维数组的指针学习笔记
2018-03-12 13:59:50 aFakeProgramer 阅读数 1169更多
分类专栏： c语言基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/usstmiracle/article/details/79525951
二维数组与一维数组的关系
二维数组的指针指向一维数组的指针
一维数组的情况下：数组名代表数组首地址*(a+i)=a[i]
二维数组与指针

int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
a[0] a[1] a[2]

说明：
二维数组的行指针指向一维数组 a,a+1,a+2 行指针的移动单位是以数组为单位进行移动
列指针指向数组的元素a[0]、a[1]、a[2]列指针的移动单位是以数组元素为单位进行移动
A:二维数组是一个特殊的一维数组。
B:对于int a[3][4]而言3表示二维数组中有三个一维数组，每个一维数组里面又含有4个元素。
C:定义了一个一维数组为a，它里面含有三个元素a[0]a[1]a[2],而每个元素，又是一个含有4个元素的一维数组
D:对于一维数组，a[i]就代表一个数
对于二维数组而言，a[i]本身还是一个数组，a[i]是数组名
所以a[i]它依然是一个地址（指针）
E:对于二维数组里面a,a+1,a+i而言，a+i是指向a[i]的而a[i]它本身也是一个数组，所以a+i是指向一维数组的指针
也被称为行指针，而且行指针的移动单位是以数组为单位进行移动
F:对于二维数组里面的a[i]而言，a[i]是指向元素a[i][0]，换句话说，a[i]是指向一维数组元素的指针（列指针），而且列指针是以元素为单位来移动的
G:二维数组中的列指针a[i]这个指针可以越界
H:二维数组中的a,a+1,a+2 虽然是行指针，但是他们都是常量，不能自加，为了让行指针能够实现移动，就要定义一个行指针变量。所以需要定义一个指向一维数组指针变量。
I:以后只能把a,a+1…a+i的值赋给该指针，因为它们都是行指针
k:如果把指向一维数组的指针，赋给二维数组的数组名，那么这个指针，就可以当成二维数组来使用
int a[3][4]，(p)[4]=a;
a[i][j]=p[i][j]=((a+i)+j))=(*(p+i)+j))
格式：
int (*p)[数组长度];
int (*p)[4]; 定义了一个指针为p 这个指针，是一个行指针，那么以后这个指针只能够指向一个一维整型数组的，
并且它所指向的一维整型数组，里面要含有4个元素

int a[3][4]
a–> a[0]—>a[0][0] **a=*a[0]=a[0][0]
a[0][1]
a[0][2]
a[0][3]
a移动一个是移动了一行，是指向一维数组的指针
a[0]是指向一维数组元素的指针（列指针，移动一个元素）
a+1–> a[1]—>a[1][0] **(a+1)=*a[1]=a[1][0]
a[1][1]
a[1][2]
a[1][3]

a+2–> a[2]—>a[2][0]
a[2][1]
a[2][2]
a[2][3]

*a=a[0]
*a[0]=a[0][0]
**a=a[0][0]

**(a+1)=a[1]=a[1][0]
((a+1)+2)=(a[1]+2)=a[1][2]

((a+i)+j)=*(a[i]+j)=a[i][j] //这个结论很重要

例子：

main()//这里的每一个main()函数都是一个单独的例子
{

int a[3][4]={{1,2,0,1},{1,1,0,2},{3,2,0,1}},k1,k2,k3;
k1=**a***a+1;                   //**a=a[0][0]=1 *  1+1=   2
k2=**a**(*a+**a+1);             //1* *(*a+1+1)=*(a[0]+2)=a[0][2]=0
k3=**a*(*(*a+*(*(a+1)+2)));     //*(*(a+1)+2)=a[1][2]=0     **a*(*(*a+0))=1*1=1
    printf("k1=%d,k2=%d,k3=%d",k1,k2,k3);

}

	main()//这里的每一个main()函数都是一个单独的例子
	{
	
		int a[3][4]={{1,2,0,1},{1,1,0,2},{3,2,0,1}},k1,k2,k3;
		k1=**a***a+1;                   //**a=a[0][0]=1 *  1+1=   2
		k2=**a**(*a+**a+1);             //1* *(*a+1+1)=*(a[0]+2)=a[0][2]=0
		k3=**a*(*(*a+*(*(a+1)+2)));     //*(*(a+1)+2)=a[1][2]=0     **a*(*(*a+0))=1*1=1
		
		k4=*a[2];//a[2][0]=3
		k5=(*a)[2]//a[0][2]
		k6=*(a[0]+6)//a[1][2]
		二维数组中的a[i]这个指针可以越界（非常重要）
                   printf("k1=%d,k2=%d,k3=%d",k1,k2,k3);			

	}

数组名是常量，不能自加

int a[3][4],*p[4];

定义了一个指针为p 这个指针，是一个行指针，那么以后这个指针只能够指向一个一维整型数组的，
并且它所指向的一维整型数组，里面要含有4个元素
p=a[0];//这是错的
p=a//p 是行指针 a,a+1…a+i

以后只能把a,a+1…a+i的值赋给该指针，因为它们都是行指针,行指针是以数组为单位进行移动的

main()
{

	int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}},*p[4],k1;
	p=a+1;
	k1=**p+*(*p+1)+*(*(p+1)+1)//a[1][0]+a[1][1]+a[2][1]=21
	 printf("k1=%d",k1);
}


main()//这里的每一个main()函数都是一个单独的例子
{
	
	int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}},(*p1)[4]=a,*p2=a[1],k;
	k=*(*p1+1)**p2;     //*(a[0]+1) *  a[1][0]=a[0][1]*a[1][0]=2*5=10
        printf("k1=%d",k1);
}		
	
	main()
	{
	
		int a[3][3]={{2},{4},{6}},i,*p=&a[0][0];//这边的p是列指针
		for(i=0;i<2;i++)
		{
			if(i==0)
			{
				a[i][i+1]=*p+1;
			}
			else
			{
				++p;
				
			}
			printf("%d",*p);
		}
			
	}        key //23
	
	
		
	main()//这里的每一个main()函数都是一个单独的例子
	{
	
		int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
		int (*p)[4]=a,i,j,k=0;
		for(i=0;i<3;i++)
		{
			for(j=0;j<2;j++)
			{
				k+=*(*(p+i)+j);//k+=p[i][j];
			}
			printf("k=%d",k);//把前两列加起来33
		}
	}

如果把指向一维数组的指针，赋给二维数组的数组名，那么这个指针，就可以当成二维数组来使用

int a[3][4]，(p)[4]=a;
a[i][j]=p[i][j]=((a+i)+j))=(*(p+i)+j))
main()
{
int a[][3]={{1,2,3},{4,5,0}},(*pa)[3],i;
pa=a;
for(i=0;i<3;i++)
{
if(i<2)
pa[1][i]=pa[1][i]-1;
else pa[1][i]=1;
}
printf("%d",a[0][1]a[1][1]+a[1][2]);//7
}

指向一维数组的指针，一般会与二维数组配合使用，实际上就是对二维数组进行编程，
实际就是以二维数组作为函数参数。
A:型参用数组，实参也用数组
函数定义 ： fun(int a[][4])
函数调用： fun(a)
B:型参用指针，而实参用数组：
函数定义： fun(int (*p)[4])
函数调用： fun(a)
C:型参用指针，而实参用指针：
函数定义： fun(int (*p)[4])
函数调用： fun(指针a)

//编写一个函数，目的是为了求出二维数组中所有元素的和

int sum(int (*p)[4])
{
int s,i,j;
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
s+=p[i][j];
}
}
return s;
}
int sum(int a[][4])
{
int s,i,j;
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
s+=a[i][j];
}
}
return s;
}

main()
{
int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
printf(“sum=%d”,sum(a));
}
例子：
把二维数组的第一行元素与最后一行的元素调换，把第二行与倒数第二行的元素调换，以此类推

1 2 3 4 17 18 19 20
5 6 7 8 13 14 15 16
9 10 11 12 转换成 9 10 11 12
13 14 15 16 5 6 7 8
17 18 19 20 1 2 3 4

a[i][0] > a[j][0]
a[i][1] > a[j][1]
a[i][2] > a[j][2]
a[i][3] > a[j][3]

第0行与第4行的元素交换

void funhuan(int (*p)[4])
{
int i,j,n,t;
for(i=0,j=4;i<j;i++,j–)//实现行的互换
{
for(n=0;n<4;n++)//每行的4个元素
{
t=p[i][n];
p[i][n]=p[j][n];
p[j][n]=t;
}
}
}

main()
{
int a[5][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
int i,j;
for(i=0;i<5;i++)
{
for(j=0;j<4;j++)
{
printf("%5d",a[i][j]);
}
printf("\n");
}
printf("\n");
funhuan(a);
for(i=0;i<5;i++)
{
for(j=0;j<4;j++)
{
printf("%5d",a[i][j]);
}
printf("\n");
}
}

编写一个程序，它的功能是把一个二维数组中周边元素都置为零

void setZero(int (p)[4])
{
int i,j;
for(i=0;i<4;i++)
{
p[0][i]=0;//(*(a)+i)=0;
p[3][i]=0;
p[i][0]=0;
p[i][3]=0;
}
}
main()
{
int a[5][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
setZero(a);
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
printf("%5d",a[i][j]);
}
printf("\n");
}

给一个一维数组，中所有行的元素的值都向右移m个位置，左边置零。

void move0(int *a,int n)
{
for(int i=0;i<n;i++)
{
a[n-i]=a[n-i-1];
}
a[0]=0;
}

main()
{
  int a[4]={1,2,3,4},i,m;
	
	for(i=0;i<4;i++)
   {
	   printf("%5d",a[i]);
	}	
		printf("\n");
		scanf("%d",&m);
	for(i=0;i<m;i++)
	{
		move0(a,4);
	}		
	for(i=0;i<4;i++)
   {
	   printf("%5d",a[i]);
   }
}

编写一个函数，把N*N的一个二维数组，根据给定的M值将这个二维数组中所有行的元素的值都向右移m个位置，左边置零。
1 2 3 4 0 0 1 2
5 6 7 8 5 6 7 8
9 10 11 12 转换成 9 10 11 12
13 14 15 16 13 14 15 16

若m=1

为了方便思考，假设先移动一行，移动第i行

先看第一行， 1 下标为2开始移
，2 下标为1开始移
3 下标为0开始移
i 下标为3-i开始移

m=2时
a[i][3]=a[i][1]
a[i][2]=a[i][0]
下标隔2， 因为m=2
j=3-m//从该位置开始移
for(j=3-m;j>=0;j–)
{
a[i][j+m]=a[i][j];//右移m个位置
}
for(j=0;j<m;j++)//左边置零
{
a[i][j]=0;
}

程序实现：

void fun(int (*a)[4],int m)//m右移多少位
{
int i,j;
//每一行都要移位，假设先移第i行
for(i=0;i<4;i++)
{
for(j=3-m;j>=0;j–)//表示在移动
{
a[i][m+j]=a[i][j];
}
for(j=0;j<m;j++)//把前面剩下的元素设为0
{
a[i][j]=0;
}
}
}

main()
{
int a[5][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16},m;
printf(“输入一个整数给m:”);
scanf("%d",&m);
fun(a,m);
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)//表示在移动
{
printf("%5d",a[i][j]);
}
printf("\n");
}

//编写一个函数，可以求出二维数组每一行的最大值，并存放在数组num里面返回
void fun(int (*a)[4],int *num)
{
int i,j,max,k=0;
for(i=0;i<4;i++)
{
max=a[i][0];
for(j=1;j<4;j++)
{
if(max<a[i][j])
max=a[i][j];
}
num[k++]=max;
printf("\n");
}
}
main()
{
int a[4][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16},num[4]={0};

	for(i=0;i<4;i++)
{
	for(j=0;j<4;j++)
	{
		printf("%5d",a[i][j]);
	}
	printf("\n");
}
fun(a,num);
	for(i=0;i<4;i++)
{
	
		printf("%5d",num[i]);
	
	printf("\n");
}
要做一棵树
关注
指向二维数组的指针
04-09
主要介绍指向二维数组的指针，怎样去使用，定义二维数组。赋值。
指向二维数组的指针学习笔记
usstmiracle的博客
03-12 3865
二维数组与一维数组的关系 二维数组的指针指向一维数组的指针 一维数组的情况下：数组名代表数组首地址*(a+i)=a[i] 二维数组与指针 int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; a[0] a[1] a[2] 说明： 二维数组的行指针指向一维数组 a,a+1,a+2 行指...
C++数组（二维数组）与指针 以及 函数传递/返回指针和数组参数
佐井白白的微笑
07-07 5009
概论 指针基础 指针进阶 一维数组的定义与初始化 指针和数组 本文参考资料 C++ Primer, 5e; Coursera北大数据结构与算法课程。 1. 概论 指针在C\C++语言中是很重要的内容，并且和指针有关的内容一向令人头大。在本教程中，我总结了一些关于指针和数组的用法（尤其是指针和二维数组）。 2.指针基础 指针是指向另外一种类型的复合类型。 指针本身
Vector创建二维数组.zip
最新发布
03-24
使用`vector` 创建二维数组提供了一种更灵活、易于理解和维护的方式。它可以动态扩展，简化了内存管理，并提供了对现代C++库的全面支持。然而，对于非常大的二维数组，可能需要考虑内存开销和访问效率，这时可能需要...
数组二维数组PPT学习教案.pptx
10-05
二维数组是编程语言中一种非常基础且重要的数据结构，它被广泛应用于各种计算问题，特别是...这个PPT学习教案提供了一套全面的教程，涵盖了从基础知识到实践应用的多个方面，对于学习和复习二维数组的知识非常有帮助。
c代码-二维数组自动赋值
07-16
在C语言中，二维数组是一种常见的数据结构...通过以上的讲解，你应该对C语言中二维数组的声明、初始化、赋值、访问以及动态分配有了全面的理解。在实际编程中，熟练掌握二维数组的使用能帮助你高效地处理各种复杂问题。
数组与指针的艺术 pdf
05-01
- “一维数组是一级指针”、“二维数组是二级指针”等说法。这些说法忽略了数组名和指针之间的本质区别。 - “数组名是一个常量指针”、“数组名是一个指针常量”的观点。这些表述同样存在误区，因为数组名并非指针...
C语言指针与二维数组
摩尔的博客
05-14 1863
前头话 上次我们说到指针是一个好东西啊，指针极大的缓解了内存小的鸭梨，所以对于我们来说，学号指针就是坚实的第一步，今天我们谈一谈C语言指针和二维数组 转载自C语言中文网二维数组在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有“缝隙”。以下面的二维数组 a 为例： int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9,
如何理解二维数组与指针
rihui1hao的专栏
04-05 997
一维数组 int a[3]={1,2,3} 赋值：int *p=a 我们有  a[0]==*(a+0)==*a 同样的  a[i]==*(a+i) 对于一维数组可以理解为列指针，因为它的移动是发生在列上的 二维数组：int a[2][3]={{1,2,3},{4,5,6}} 赋值：int (*p)[3]=a 而对于二维数组可以把它理解为行指针 a 表示的是该二维数组的首地址
指向二维数组的数组指针
qq_43449554的博客
01-26 319
C语言高级教程：指针与二维数组的内存理解
"《指针高级：on-chip ESD保护在集成电路中的应用》是一篇深入探讨C语言中指针概念及其高级特性的技术文章，特别关注于二维数组的处理和内存地址的理解。文章首先介绍了指针的基础概念，指出数组名本质上是常指针，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值