c语言——二维指针数组

最新推荐文章于 2024-08-08 19:54:07 发布
最新推荐文章于 2024-08-08 19:54:07 发布
阅读量7.7k 收藏 54
点赞数 13
分类专栏： C语言编程知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangyayayaya/article/details/113066592
版权

1 一维度数组与指针

1.1一维数组元素在内存分布

  • #include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define ARRAY_SIZE 8

void main()
{
   int data[ARRAY_SIZE]={0,1,2,3,4,5,6,7};
   int i;
   printf("data address:0x%-8x\r\n",data);
   for(i=0; i<ARRAY_SIZE; i++)
   {
   	  printf("data[%-3d]:value %-3d,address:0x%-10x\r\n",i,data[i],&data[i]);
   }	
}

data address:0xbc4100d0
data[0  ]:value 0  ,address:0xbc4100d0  
data[1  ]:value 1  ,address:0xbc4100d4  
data[2  ]:value 2  ,address:0xbc4100d8  
data[3  ]:value 3  ,address:0xbc4100dc  
data[4  ]:value 4  ,address:0xbc4100e0  
data[5  ]:value 5  ,address:0xbc4100e4  
data[6  ]:value 6  ,address:0xbc4100e8  
data[7  ]:value 7  ,address:0xbc4100ec

结论为:
1 数组元素的地址是线性的、连续的，这也是可以通过数组地址找到所有元素的原因。
2  数组名代表数组指针，同时与首元素的地址相同

1.2一维数组的指针

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define ARRAY_SIZE 8

void main()
{
   int data[ARRAY_SIZE]={0,1,2,3,4,5,6,7};
   int *pointer=data;
   int i;
   printf("data address:0x%-8x\r\n",data);
   for(i=0; i<ARRAY_SIZE; i++)
   {
   	  printf("data[%d]:value %-3d,address:0x%-10x\r\n",i,data[i],&data[i]);
   }	

	for(i=0; i<ARRAY_SIZE; i++)
	{
	   printf("[%d]:value %-3d,address:0x%-10x\r\n",i,*(pointer+i),pointer+i);
	}	 
}

data address:0x13bca160
data[0]:value 0  ,address:0x13bca160  
data[1]:value 1  ,address:0x13bca164  
data[2]:value 2  ,address:0x13bca168  
data[3]:value 3  ,address:0x13bca16c  
data[4]:value 4  ,address:0x13bca170  
data[5]:value 5  ,address:0x13bca174  
data[6]:value 6  ,address:0x13bca178  
data[7]:value 7  ,address:0x13bca17c  
[0]:value 0  ,address:0x13bca160  
[1]:value 1  ,address:0x13bca164  
[2]:value 2  ,address:0x13bca168  
[3]:value 3  ,address:0x13bca16c  
[4]:value 4  ,address:0x13bca170  
[5]:value 5  ,address:0x13bca174  
[6]:value 6  ,address:0x13bca178  
[7]:value 7  ,address:0x13bca17c

结论为:
         1 指向数组的指针加一表示加上每个元素的字节数
          2 指针可以引用一个数组

2 二维度数组与指针

2.1 二维数组元素在内存分布

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define ARRAY_X 7
#define ARRAY_Y 5


void main()
{
   int data[ARRAY_X][ARRAY_Y]={0};
   int *pointer=data;
   int i,j,k,num=0;;
   for(i=0; i<ARRAY_X; i++)
   {
	for(j=0;j<ARRAY_Y;j++)
	{
		data[i][j]=num;
	}   
   } 	 

	for(i=0; i<ARRAY_X;i++)
	{
	 printf("\r\n");
	 for(j=0;j<ARRAY_Y;j++)
	 {
		 data[i][j]=num;
		 
		 printf("data[%d][%d]:%d,(address:0x%-10x)\r\n",i,j,data[i][j],&data[i][j]);
	 }	 
	}	     
}


data[0][0]:0,(address:0xfe8a3a10  )
data[0][1]:0,(address:0xfe8a3a14  )
data[0][2]:0,(address:0xfe8a3a18  )
data[0][3]:0,(address:0xfe8a3a1c  )

data[1][0]:0,(address:0xfe8a3a20  )
data[1][1]:0,(address:0xfe8a3a24  )
data[1][2]:0,(address:0xfe8a3a28  )
data[1][3]:0,(address:0xfe8a3a2c  )

data[2][0]:0,(address:0xfe8a3a30  )
data[2][1]:0,(address:0xfe8a3a34  )
data[2][2]:0,(address:0xfe8a3a38  )
data[2][3]:0,(address:0xfe8a3a3c  )
root@ubuntu:Array#


 通过实际的地址信息，可以知道：二维数组在内存中是连续发布的，第0行的第一个元素->第0行的最后一个元素->第1行的第1个元素->第1行的最后一个元素，以次类推，地址增长

 

2.2二维数组的指针

2.2.1指针的使用方法

声明一个二维数组 ：int data[3][4]
 1 根据”数组名同时是数组首元素的地址“的原则，data是首元素的地址，二维数组data[3][4]的首元素是一维数组，所以data是一维数组data[0]的地址
 2 根据”数组名同时是数组首元素的地址“的原则，因此data的值等于&data[0],data[0]表示数组data[3][4]的首元素，这个首元素也是数组。根据“数组名同时是数组首元素的地址”的原则，data[0] 等于&data[0][0]
 3 根据“指针加1等于加上指针所指向的元素的大小“的原则，data+1并不等于data[0]+1，前者是4个单位，后者是1个单位“
 4 对一个指针取值得到的是该指针所指向对象的数值。data[0]表示一维数组data[0]的首元素即data[0][0]的地址，则*(data[0])表示元素data[0][0]的值

2.2.2 指针、指针的指针、变量

声明一个二维数组 ：int data[3][4]

本例中，哪些是一维数组指针，哪些是二维数组指针，哪些是元素值?
  二维数组指针：data
  一维数组指针：data[0]、data[1]、data[2]
  元素值：data[0][0]、data[0][1]、data[0][2]、data[0][3]

  c语言中，*号表示取值，&号表示取地址，按照原则，可以知道:
    data 是二维数组指针,*data是二维数组的元素即一维数组data[0]；data[0]表示一维数组的地址，data[0]就表示一位数组data[0]首元素data[0][0]的地址。所以 **data的值就是data[0][0]，data的值就是&&data[0][0]

 

注意：比较简单的方法是，将指针转化为数组来理解，例如*(*(pointer+i)+j)的代码写成pointer[i][j]，减少出错的概率，[]表示偏移后取值

 

2.2.3 使用二维数组指针去访问元素

声明一个二维数组 ：int data[3][4],data代表这个二维数组的指针

data第一个元素的地址，该元素是一维数组
data+1第二个元素的地址，该元素是一维数组
*(data+1)数组的地址，也是数组的首元素的地址，该数组是一维数组。*(data+1)的值于data+1相同，但是意义不一样。
(*(data+1）+2)二维数组第1行第2列的元素的地址，也是一位数组data+1的第2个元素的地址。   
*(*(data+1)+2)二维数组第一行第二列元素的值


   

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define ARRAY_X 3
#define ARRAY_Y 4


void main()
{
   int data[ARRAY_X][ARRAY_Y]={0};
   int *pointer=data;
   int i,j,k,num=10;;
   for(i=0; i<ARRAY_X; i++)
   {
	for(j=0;j<ARRAY_Y;j++)
	{
		data[i][j]=num++;
	}   
   } 	 

   for(i=0; i<ARRAY_X;i++)
   {
	printf("\r\n");
	for(j=0;j<ARRAY_Y;j++)
	{		
		printf("data[%d][%d]:%d,(address:0x%-10x)\r\n",i,j,data[i][j],&data[i][j]);
	}	
   }     

   printf("data:0x%x\r\n",data);
   printf("*data:0x%x\r\n",*data);   
   printf("**data:0x%x\r\n",**data);

	printf("data[0][0]:0x%x\r\n",data[0][0]);
	printf("&data[0][0]:0x%x\r\n",&data[0][0]);		
	printf("data[0]:0x%x\r\n",data[0]);	
	printf("&data[0]:0x%x\r\n",&data[0]);
	printf("&data[0][0]:0x%x\r\n",&data[0][0]);

	for(i=0; i<ARRAY_X;i++)
	{
	 printf("\r\n");
	 for(j=0;j<ARRAY_Y;j++)
	 {		 	
		 printf("*(data+%d)):0x%x\r\n",i,*(data+i));	 
		 printf("*(*(data+%d)+%d):%d\r\n",i,j,*(*(data+i)+j));
	 }	 
	}	
	
}


data[0][0]:10,(address:0xf49fe5e0  )
data[0][1]:11,(address:0xf49fe5e4  )
data[0][2]:12,(address:0xf49fe5e8  )
data[0][3]:13,(address:0xf49fe5ec  )

data[1][0]:14,(address:0xf49fe5f0  )
data[1][1]:15,(address:0xf49fe5f4  )
data[1][2]:16,(address:0xf49fe5f8  )
data[1][3]:17,(address:0xf49fe5fc  )

data[2][0]:18,(address:0xf49fe600  )
data[2][1]:19,(address:0xf49fe604  )
data[2][2]:20,(address:0xf49fe608  )
data[2][3]:21,(address:0xf49fe60c  )
data:0xf49fe5e0
*data:0xf49fe5e0
**data:0xa
data[0][0]:0xa
&data[0][0]:0xf49fe5e0
data[0]:0xf49fe5e0
&data[0]:0xf49fe5e0
&data[0][0]:0xf49fe5e0

*(data+0)):0xf49fe5e0
*(*(data+0)+0):10
*(data+0)):0xf49fe5e0
*(*(data+0)+1):11
*(data+0)):0xf49fe5e0
*(*(data+0)+2):12
*(data+0)):0xf49fe5e0
*(*(data+0)+3):13

*(data+1)):0xf49fe5f0
*(*(data+1)+0):14
*(data+1)):0xf49fe5f0
*(*(data+1)+1):15
*(data+1)):0xf49fe5f0
*(*(data+1)+2):16
*(data+1)):0xf49fe5f0
*(*(data+1)+3):17

*(data+2)):0xf49fe600
*(*(data+2)+0):18
*(data+2)):0xf49fe600
*(*(data+2)+1):19
*(data+2)):0xf49fe600
*(*(data+2)+2):20
*(data+2)):0xf49fe600
*(*(data+2)+3):21

2.2.4 指向二维数组的指针

 在编写函数时，入参通常会是一个二维数组的指针，怎样正确访问这个二维数组的指针呢？

声明一个二维数组 ：int data[3][4]。

声明一个指针int (* pointer)[4]，该指针指向一个包含4个元素的数组.

[4]通知编译器，每次pointer+1将会移动4个单位的长度。

错误的声明：int  ** pointer，等价于int (* pointer)[1]，编译器不知道宽度，每次pointer+1只会移动1个单位的长度

错误的声明：int  * pointer[4]，变成了指针数组，指针指向整型数。

void main()
{
   int data[ARRAY_X][ARRAY_Y]={0};
   int (*pointer)[ARRAY_Y]=data;
   int i,j,k,num=10;;
   for(i=0; i<ARRAY_X; i++)
   {
	for(j=0;j<ARRAY_Y;j++)
	{
		data[i][j]=num++;
	}   
   } 	 

   for(i=0; i<ARRAY_X;i++)
   {
	printf("\r\n");
	for(j=0;j<ARRAY_Y;j++)
	{		
		printf("data[%d][%d]:0x%x,(address:0x%-10x)\r\n",i,j,data[i][j],&data[i][j]);
	}	
   }     

   printf("data:0x%x\r\n",data);
   printf("*data:0x%x\r\n",*data);   
   printf("**data:0x%x\r\n",**data);

	printf("data[0][0]:0x%x\r\n",data[0][0]);
	printf("&data[0][0]:0x%x\r\n",&data[0][0]);		
	printf("data[0]:0x%x\r\n",data[0]);	
	printf("&data[0]:0x%x\r\n",&data[0]);
	printf("&data[0][0]:0x%x\r\n",&data[0][0]);

	for(i=0; i<ARRAY_X;i++)
	{
	 printf("\r\n");
	 for(j=0;j<ARRAY_Y;j++)
	 {		 	
		 printf("*(pointer+%d)+%d: 0x%x\r\n",i,j, *(pointer+i)+j);		 
		 printf(" *(*(pointer+%d)+%d): 0x%x\r\n",i,j, *(*(pointer+i)+j));
	 }	 
	}	
	
}




data[0][0]:0xa,(address:0xb8a93be0  )
data[0][1]:0xb,(address:0xb8a93be4  )
data[0][2]:0xc,(address:0xb8a93be8  )
data[0][3]:0xd,(address:0xb8a93bec  )

data[1][0]:0xe,(address:0xb8a93bf0  )
data[1][1]:0xf,(address:0xb8a93bf4  )
data[1][2]:0x10,(address:0xb8a93bf8  )
data[1][3]:0x11,(address:0xb8a93bfc  )

data[2][0]:0x12,(address:0xb8a93c00  )
data[2][1]:0x13,(address:0xb8a93c04  )
data[2][2]:0x14,(address:0xb8a93c08  )
data[2][3]:0x15,(address:0xb8a93c0c  )
data:0xb8a93be0
*data:0xb8a93be0
**data:0xa
data[0][0]:0xa
&data[0][0]:0xb8a93be0
data[0]:0xb8a93be0
&data[0]:0xb8a93be0
&data[0][0]:0xb8a93be0

*(pointer+0)+0: 0xb8a93be0
 *(*(pointer+0)+0): 0xa
*(pointer+0)+1: 0xb8a93be4
 *(*(pointer+0)+1): 0xb
*(pointer+0)+2: 0xb8a93be8
 *(*(pointer+0)+2): 0xc
*(pointer+0)+3: 0xb8a93bec
 *(*(pointer+0)+3): 0xd

*(pointer+1)+0: 0xb8a93bf0
 *(*(pointer+1)+0): 0xe
*(pointer+1)+1: 0xb8a93bf4
 *(*(pointer+1)+1): 0xf
*(pointer+1)+2: 0xb8a93bf8
 *(*(pointer+1)+2): 0x10
*(pointer+1)+3: 0xb8a93bfc
 *(*(pointer+1)+3): 0x11

*(pointer+2)+0: 0xb8a93c00
 *(*(pointer+2)+0): 0x12
*(pointer+2)+1: 0xb8a93c04
 *(*(pointer+2)+1): 0x13
*(pointer+2)+2: 0xb8a93c08
 *(*(pointer+2)+2): 0x14
*(pointer+2)+3: 0xb8a93c0c
 *(*(pointer+2)+3): 0x15

3 指针的指针的指针 

3.1 指向二维数组的指针--元素为基本类型

 声明一个二维指针数组：int * p_data[3][4]

        这是一个二维数组，数组元素中存放的是指针，指针指向一个整型数。

   int *(*pointer)[4]

     这是一个指针，指向一个一维数组，该一维数组长度为4，数组的每个元素是一个指向整型数的指针。

 如何使用   pointer来访问p_data的值呢？

    pointer=p_data;

 p_data[i][j] 等价于pointer[i][j]，等价于*(*(pointer+i)+j)  ; 

*(p_data[i][j])等价于*(pointer[i][j]，等价于 **(*(pointer+i)+j)

3.2 指向二维数组的指针--元素为结构体

声明结构体

typedef struct avl{
int name[4];
int age;
}AVL;

定义宏
#define ARRAY_X 3
#define ARRAY_y 6


声明二维结构提指针数组
AVL* pointer[ARRAY_X][ARRAY_y];    

声明指向数组的指针，数组的长度为6，每个元素为存放AVL类型指针
AVL*(*ppp)[ARRAY_y];

ppp=pointer;

引用方法：
ppp[x][y]   
ppp[x][y])->name
ppp[x][y])->age

二维数组指针的关键是数组的宽度，告诉编译器每次移动一个单位需要偏移多少个字节。

ReloadNow
关注
专栏目录
【C】二维数组及其指针
Linloir的博客
12-11 1184
C语言中二维数组与指针二维数组的创建和它们的指针创建一个固定长度的二维数组二维数组的指针操作 二维数组的创建和它们的指针 创建一个固定长度的二维数组 假设我打算建立一个二维数组，并创建一个指针用于保存这个二维数组的地址，对于如下两种方法， int arr[2][3] = {0, 1, 2, 3, 4, 5}; int **ptr = arr; int arr[2][3] = {0, 1, 2, 3, 4, 5}; int (*ptr)[2] = arr; 使用第一种方法时，编译器会报错如下：int (*)[
C语言——二维数组、指针
qq_52911954的博客
07-20 1392
C语言——二维数组、二维数组的访问、二维数组的初始化、指针和指针变量、定义指针变量、取地址运算符和取值运算符
C指针之二维数组
baidu_41388533的博客
06-16 1193
二维数组 二维数组的内存映像 一维数组在内存中是连续分布的多个内存单元组成的，而二维数组在内存中也是连续分布的多个内存单元组成的。 从内存角度来看，一维数组和二维数组没有本质差别。 二维数组int a[2][5]和一维数组int b[10]其实没有任何本质差别。我们可以把两者的同一单元的对应关系写下来。 a[0][0] a[0][1] a[0][4] a[1][0] a[1][1] a[1][4] b[0] b[1] ...
二维数组指针，指针数组，指针函数
最新发布
T66656的博客
08-08 732
定义：//p指向二维数组s练习:输入三个字符串 ，排序输出。
指针数组
DeadKnightLiu的专栏
04-14 602
 概括的说，指针其实就是可变数组的首地址，说是可变数组，是指其包含内容的数量的可变的，并且是可动态申请和释放的，从而充分节约宝贵的内存资源。我一向喜欢一维数组，除非万不得已，我一般是不用二维数组的，多维的则更是很少涉足了。因为一维简单，容易理解，而用指针指向的多维数组就具有相当的复杂性了，也因此更具有讨论的必要。    闲话少说，这里我就以三个二维数组的比较来展开讨论：    (1)、int **
c语言二维数组与指针
yangchang999的专栏
08-05 1万+
很多C++/C初学者对于二维数组与指针的关系总是搞不清楚，对它的误解比比皆是。一下是本人的一些总结，部分内容参考相关资料，希望对大家的理解有所帮助。（本文对于C/C++而言） 首先，我们先从存储的角度对二维数组作一个全面的了解。二维数组在内存中的存储，是按照先行后列依次存放
C语言——二维数组指针
2302_76515999的博客
03-24 104
二维数组指针分为父数组和子数组，可以用for循环来取内容
C语言二维数组指针
L1848506530的博客
08-25 77
二维数组详解
C语言——指针数组、 数组指针、函数指针、无类型&&malloc函数
SCT_CX的博客
01-27 316
指针数组 VS 数组指针
c语言字节数组比较,C语言回顾——指针与数组
weixin_35538148的博客
05-18 756
今天萌新博主来给大家介绍C语言指针中指针与数组部分，在这一块也是非常难以理解的，闲言少叙，咱们开始吧！大家都知道数组与指针有着紧密的联系，数组是由一组若干个元素构成，我们在访问数组的时候，采用的是循环体的方式，就是把数组的下标逐步的循环一次，这样我们就可以读出所有数组元素的值。那么重点来了，数组下标与地址的之间的关系，如果我们掌握好，大家学起来指针与数组就会非常的吃力，萌新博主与大家也是感同身受啊...
零基础C语言入门028——指向二维数组的指针，三个重要公式
alex5153的博客
04-14 577
C 语言没有真正意义上的二维数组 在 C 语言中，二维数组的实现，只是简单地通过“线性扩展”的方式进行。 如图所示，int b[4][5]; 就是定义 4 个元素，每个元素都是一个包含 5 个整型变量的一维数组。它在内存中依然是以线性的形式存储。 弄清楚下边三个问题： 假设我们定义了二维数组 int array[4][5]： 数组指针和二维数组 要用指针来指向二维数组，需要使用数组指针的形式。 见...
二维数组与指针详解
01-20
详细讲述了二维数组与指针之间的联系，对于学习C语言，理解指针数组吗，数组指针，数组与指针之间的关系有重要的帮助。仔细学习完该文档，详细你不会再为指针和数据而困惑。
浅谈C语言指针——二维数组、*pt[i]、(*pt)[i]
qq_44429995的博客
07-08 732
C语言指针辨析
C语言指向二维数组的四种指针以及动态分配二维数组的五种方式
有术无道止于术，有道无术尚有可为。
09-18 8375
本文介绍了可以指向二维数组的四种指针，以及动态分配二维数组的五种方式
C语言学习之二维数组&数组指针
qq_41878292的博客
08-12 1921
地址为int *类型。
C语言二维数组的指针
qq_18671205的博客
09-12 729
以int a[2][3]={}；这个二维数组为例子： a为a[2][3]的数组名，二维数组的指针，指向的是一维数组 而a[0]数组的指针，是单个元素a[0][0];一维数组的指针，指向的是单个元素 虽然a[0]与a的首地址都是a[0][0],但是随着指针的偏移，a每次偏移12B,而a[0]每次偏移4B 为int a[2][3]定义一个指针int *p； 为什么*p=a是错误的呢？因...
C语言 指针+二维数组详解 （应付期末、考研的最强笔记，建议收藏）
热门推荐
青春无问西东 岁月自成芳华
09-03 4万+
本文通过从二维数组的介绍开始，讲解什么是二维数组——>怎么定义和使用二维数组——>怎么引用二维数组的元素——>怎么通过指针来引用二维数组(具体包括多种分式)来逐步说明指针+二维数组的配合使用，相信学完本文内容，读者对于指针和二维数组会有更加深刻的印象和理解。通过学校期末考试和考研C语言内容完全足够！！！
C语言二维数组指针（指向二维数组的指针）详解
罗铠威的博客
05-09 8760
声明！本文转载仅为方便学习使用！ 如有需要，请访问C语言指针数组（数组每个元素都是指针）详解C语言二维数组指针（指向二维数组的指针）详解 二维数组在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有“缝隙”。以下面的二维数组 a 为例： int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上理解，a 的分布像一个矩阵： 0 1 2 3 4 5 6 7 8 9
C语言 二维数组和指针
imxlw00的专栏
06-14 8771
二维数组可以看成是元素为一维数组的数组，假设有一个三行四列的二维数组a，它定义为： int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }; a 是二维数组名。a 数组包含 3 行，即 3 个行元素：a[0]，a[1]，a[2]。每个行元素都可以看成含有 4 个元素的一维数组。而且 C 语言规定，a[0]、a[1]、a[2]分别是这三个一...
C语言教程：二维数组解析
"二维数组-C语言教程——浙大" 在C语言中，二维数组是一种非常重要的数据结构，它被形象地比喻为一个表格或平面矩阵。二维数组可以看作是由一维数组排列组成的，每个一维数组又称为一个行或者列。这种结构允许我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值