二维数组 二级指针 指针数组 数组指针 的区别和联系

最新推荐文章于 2024-07-24 20:25:39 发布
置顶 最新推荐文章于 2024-07-24 20:25:39 发布
阅读量1.4k 收藏 45
点赞数 23
分类专栏： C语言 文章标签： c语言 指针 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LMY171205/article/details/113742095
版权

注：为了方便解释，二维数组都按2行3列计算；下面的例子都是亲测有效

一、写法及含义

1、int a[2][3] = { {2,4,6}, {20,40,60} };：定义了一个行为2，列为3的二维数组，所以sizeof(c)为3*2*4=24字节

2、int(*b)[3];:数组指针，指向列有3个的二维数组,因为是指针所以sizeof(b)为4字节（一个指针的大小）

3、int*c[2];:指针数组，是一个数组，里面是两个int*类型的指针，所以sizeof(c)为2*4=8字节

4、int** d;:二级指针，可以指向二维数组，因为是指针所以sizeof(b)为4字节（一个指针的大小）

①其中前两个int a[2][3]和int(*b)[3]意思相近，一般都是b = a;把分配好内存的a给b指针，内存存储是连续的,跟内存分配一起理解

int a [2][3] = { {2,4,6}, {20,40,60} };
int(*b)[3];
b=a;
for (int i = 0; i < 2; i++) {
	for(int j = 0; j < 3; j++) {
		printf("b[%d][%d]=%d\r\n", i, j, *(*(b + i) + j));
	}
}

②其中后两个int*c[2];和int** d;意思相近，内存存储方式一样（内存可能是非连续的），跟内存分配一起理解

int p[3] = { 2,4,6 };
int q[3] = { 1,3,5 };
int* c[2] = { p, q };
int** d = NULL;
d = c;	// c可能是非连续的
for (int i = 0; i < 2; i++) {
	for(int j = 0; j < 3; j++) {
		printf("d[%d][%d]=%d\r\n", i, j, *(d[i] + j));
	}
}

二、内存分配

1、int a[2][3] = { {2,4,6}, {20,40,60} };：内存已经分配好，而且内存连续；

2、int(*b)[3];:数组指针

// i代表行，j代表列
b = (int(*)[3])malloc(sizeof(int) * 3 * 2);	// 内存分配是连续的
for (int i = 0; i < 2; i++) {
	for (int j = 0; j < 3; j++) {
		b[i][j] = i + j * 2;	// 赋初值
	}
}

3、 int*c[2];:指针数组，里面的指针内存是连续的，但是指针指向的数组，也就是每行之间的内存可能是不连续的

// i代表行，j代表列
for (int i = 0; i < 2; i++) {
	c[i] = (int*)malloc(sizeof(int) * 3);	// 为每个数组里面的指针分配内存，这就可能造成每行指针之间的内存是不连续的
	for (int j = 0; j < 3; j++) {
		c[i][j] = i + j * 2;	// 赋初值
	}
}

4、int** d;:二级指针

// i代表行，j代表列
d = (int**)malloc(sizeof(int*) * 2);
// 下面和指针数组是一样的，也就是在int** d分配了两个指针指向数组的指针之后和指针数组就是一样的了
for (int i = 0; i < 2; i++) {
	d[i] = (int*)malloc(sizeof(int) * 3);
	for (int j = 0; j < 3; j++) {
		d[i][j] = i + j * 2;	// 赋初值
	}
}

三、函数调用的形参和实参

我们需要注意以下几点：

1、内存存储方式不同的不要互为形参和实参，比如上面说的连续存储内存和非连续存储内存，例int a[2][3]不要和int** d互为形参和实参

2、以下是比较常用的实参和形参搭配方式

实参      

所匹配的形参

数组的数组char c[8][10];   

数组指针char (*)[10];

指针数组char *c[10];  

指针的指针char **c;     

指针数组char *c[10];  

不改变char (*c)[10];

指针的指针char **c;  

不改变char **c;

3、函数返回只能是二级指针

4、以下是我自己实验所的，下面在函数里面打印结果如果是对的，那么用相同的方法就可以更改二维数组里面的值

说明：下面例子里面的打印都是打印的第一行第一列的数据

①当实参是非连续内存时：

  • int array[][3]和int(*array)[3]作为形参不能使用；
  • int** array和int *array[2]全能访问；
#include <stdio.h>
#include <stdlib.h>
/* 下面没有说明的就是打印正确的 */
int** array_two_1(int** array, int n) {	
	printf("array[1][1]-1=%d\r\n", *((int*)array + 1 * n + 1));  // 错误，内存不连续的不能用这个
	printf("array[1][1]-1=%d\r\n", *(array[1] + 1));// 正确，一般用这个
	printf("array[1][1]-1=%d\r\n", array[1][1]); //正确，这里的a[1][1]和二维数组的a[1]a[1]是不一样的，和*(*(array + 1) + 1))意思相同
	printf("array[1][1]-1=%d\r\n", *(*(array + 1) + 1)); //正确
	return array;
}
int** array_two_2(int array[][3]) {	// 和int**不匹配，无法打印
	printf("array[1][1]-2=%d\r\n", array[1][1]);
	printf("array[1][1]-2=%d\r\n", *(*(array + 1) + 1));
	printf("array[1][1]-2=%d\r\n", *(array[1] + 1));
	printf("array[1][1]-2=%d\r\n", *((int*)array + 1 * 3 + 1));
	return (int**)array;
}
int** array_two_3(int(*array)[3]) {	// 和int**不匹配，以下打印全部错误
	printf("array[1][1]-3=%d\r\n", array[1][1]);	
	printf("array[1][1]-3=%d\r\n", *(*(array + 1) + 1));
	printf("array[1][1]-3=%d\r\n", *(array[1] + 1));
	printf("array[1][1]-3=%d\r\n", *((int*)array + 1 * 3 + 1));
	return (int**)array;
}
int** array_two_4(int* array[2]) {
	printf("array[1][1]-4=%d\r\n", *(array[1]+1));  // 正确
	printf("array[1][1]-4=%d\r\n", *((int*)array + 1 * 3 + 1));// 错误，非连续内存不能用这个
	printf("array[1][1]-4=%d\r\n", array[1][1]); // 正确
	printf("array[1][1]-4=%d\r\n", *(*(array + 1) + 1)); // 正确
	return array;
}

int main() {
    int a[3] = { 1,3,5 };
    int c[3] = { 2,4,6 };
    int* d[2] = { a, c };
    int** g = NULL; // 可能为非连续内存，分配完之后{{0, 2, 4}, {1, 3, 5}}
    g = (int**)malloc(sizeof(int*)*2);
    for (int i = 0; i < 2; i++) {
        g[i] = (int*)malloc(sizeof(int)*3);
        for (int j = 0; j < 3; j++) {
            g[i][j] = i+j*2;
            int t = 9;
        }
    }
    int** res1 = NULL;
    int** res2 = NULL;
    int(*res3)[3] = NULL;	
    int** res4 = NULL;
    
    res1 = array_two_1((int**)g, 3);	// res1 = array_two_1(b, 3); 错误的
    //res2 = array_two_2(g);	// 编译错误用不了
    res3 = (int(*)[3])array_two_3((int(*)[3])g);
    res4 = array_two_4(d);
    return 0;
}

②当实参是连续内存时：

  • int** array和int *array[2]只有*((int*)array + 1 * n + 1)能访问；
  • int array[][3]和int (*array)[3]全能访问
#include <stdio.h>
#include <stdlib.h>

int** array_two_1(int** array,int n) {	// 形参没有建立二维数组，所以不能array[1][1]和 *(*(array+1)+1)访问
	printf("array[1][1]-1=%d\r\n", *((int*)array + 1 * n + 1));  // 正确的
	//printf("array[1][1]-1=%d\r\n", *(array[1] + 1));	// 错误
	//printf("array[1][1]-1=%d\r\n", array[1][1]); // 错误的 
	//printf("array[1][1]-1=%d\r\n", *(*(array + 1) + 1)); // 错误的
	//*((int*)array + 1 * n + 1) = 30;	// 正确
	return array;
}
int** array_two_2(int array[][3]) {	// 符合理论
	printf("array[1][1]-2=%d\r\n", array[1][1]);	// 正确，一般写法
	printf("array[1][1]-2=%d\r\n", *(*(array+1)+1)); // 正确
	printf("array[1][1]-2=%d\r\n", *(array[1] + 1)); // 正确
	printf("array[1][1]-2=%d\r\n", *((int*)array + 1 * 3 + 1)); // 正确
	//array[1][1] = 35;	// 正确
	//*(*(array + 1) + 1) = 35;	// 正确
	return (int**)array;
}
int** array_two_3(int (*array)[3]) {	// 符合理论
	printf("array[1][1]-3=%d\r\n", array[1][1]); // 正确
	printf("array[1][1]-3=%d\r\n", *(*(array + 1) + 1));	// 正确，一般写法
	printf("array[1][1]-3=%d\r\n", *(array[1] + 1));  // 正确
	printf("array[1][1]-3=%d\r\n", *((int*)array + 1 * 3 + 1));  // 正确
	//array[1][1] = 36;		// 正确
	return (int**)array;
}

int** array_two_4(int *array[2]) {	// 和int**是一样的，只有*((int*)array + 1 * 3 + 1)能用
	//printf("array[1][1]-3=%d\r\n", array[1][1]);	// 错误
	//printf("array[1][1]-3=%d\r\n", *(*(array + 1) + 1));	// 错误
	//printf("array[1][1]-3=%d\r\n", *(array[1] + 1));	// 错误
	printf("array[1][1]-3=%d\r\n", *((int*)array + 1 * 3 + 1));	// 正确
	//*((int*)array + 1 * 3 + 1) = 37;	// 正确
	return array;
}

int main()
{
	int b[2][3] = { {2,4,6}, {20,40,60} };
	int **res1 = NULL;
	int **res2 = NULL;	//int res2[2][3]; 错误
	int(*res3)[3] = NULL;
	int** res4 = NULL;

	res1 = array_two_1((int**)b, 3);// res1 = array_two_1(b, 3); 错误的
	res2 = array_two_2(b);
	res3 = (int(*)[3])array_two_3(b);
	res4 = array_two_4((int**)b);
	return 0;
}

四、打印方式

说明：这里都按打印第一行第一列说明，行列都是从0开始

注意：前三个适用于连续内存和非连续内存的打印，第四个只适用于连续内存打印

1、a[1][1]:一般用于int a[2][3]，这个是按照下标索引读取的

2、*(*(b + 1) + 1)：一般用于数组指针int(*b)[3]；

  • b为指向列有3个的二维数组的指针；
  • b+1指针就指向了第一行首地址的地址，*(b+1)指向了第一行的首地址；
  • *(b+1)+1指向了第一行第一列的地址；*(*(b+1)+1)：取到了里面的内容；

3、*(c[1] + 1)：一般用于指针数组，如果int** d也指向了指针数组，那么也用于int** d打印；

  • c[1]为第一行的首地址；
  • c[1]+1：指向了第一行第一列的地址；
  • *(c[1]+1)取到了里面的内容；

4、*((int*)d + 1 * 3 + 1)：

  • (int*)d:指向int类型的指针，这里加1就是往前走了4个字节；
  • 后面加上1 * 3 + 1，就到了第一行第一列的地址；
  • 再*就取到了第一行第一列里面的内容；
  • 注意这个不适用于非连续的内存如int*c[2]和int** d

附录一、打印的测试程序

int main()
{
	int a[3] = { 2,4,6 };
	int c[3] = { 1,3,5 };
	int* d[2] = { a, c };
	int b[2][3] = { {2,4,6}, {20,40,60} };
	int** e = NULL;
	int(*h)[3];
	int(*k)[3];	// 连续内存，分配完之后{{0, 2, 4}, {1, 3, 5}}
	k = (int(*)[3])malloc(sizeof(int) * 3 * 2);
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 3; j++) {
			k[i][j] = i + j * 2;
		}
	}
	int** g = NULL;	// 可能为非连续内存，分配完之后{{0, 2, 4}, {1, 3, 5}}
	g = (int**)malloc(sizeof(int*) * 2);
	for (int i = 0; i < 2; i++) {
		g[i] = (int*)malloc(sizeof(int) * 3);
		for (int j = 0; j < 3; j++) {
			g[i][j] = i + j * 2;
		}
	}
	e = d;	// d可能是非连续的
	h = b;	// b是连续的
	/* 下面除了不正确的，其他打印的都是正确的，打印正确都是3*/
	printf("k = %d\r\n", k[1][1]);	
	printf("k = %d\r\n", *(*(k + 1) + 1));	// 一般这么访问
	printf("k = %d\r\n", *(k[1] + 1));
	printf("k = %d\r\n", *((int*)k + 1 * 3 + 1));

	printf("g = %d\r\n", g[1][1]);	
	printf("g = %d\r\n", *(*(g + 1) + 1));
	printf("g = %d\r\n", *(g[1] + 1));	// 一般这么访问
	printf("g = %d\r\n", *((int*)g + 1 * 3 + 1));	// 不正确，因为g是非连续的

	printf("b = %d\r\n", b[1][1]);	// 一般这么访问
	printf("b = %d\r\n", *(*(b + 1) + 1));
	printf("b = %d\r\n", *(b[1] + 1));
	printf("b = %d\r\n", *((int*)b + 1 * 3 + 1));

	printf("h = %d\r\n", h[1][1]);
	printf("h = %d\r\n", *(*(h + 1) + 1));	// 一般这么访问
	printf("h = %d\r\n", *(h[1] + 1));
	printf("h = %d\r\n", *((int*)h + 1 * 3 + 1));

	printf("e = %d\r\n", e[1][1]);
	printf("e = %d\r\n", *(*(e + 1) + 1));	
	printf("e = %d\r\n", *(e[1] + 1));	// 一般这么访问
	printf("e = %d\r\n", *((int*)e + 1 * 3 + 1));	// 不正确，因为e是非连续的，打印结果为1，应该为3

	printf("d = %d\r\n", d[1][1]);
	printf("d = %d\r\n", *(*(d + 1) + 1));
	printf("d = %d\r\n", *(d[1] + 1));	// 一般这么访问
	printf("d = %d\r\n", *((int*)d + 1 * 3 + 1));   // 不正确，因为d是非连续的，打印结果为1，应该为3

	return 0;
}

【创作不易，如果觉得有用，请多多转发关注，有什么意见也请大家留言！】

 

LMY171205
关注
  • 23
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数组指针与二维数组详解
08-01
理解这些概念对于编写涉及二维数组和指针的C语言程序至关重要，它们在处理表格数据、矩阵运算、图像处理等领域具有广泛的应用。在实际编程中，灵活运用这些知识可以有效地管理和操作数组，提高代码效率。在学习过程...
数组指针与二维数组的寻址
12-22
此文描述了数组指针与二维数组的寻址的相关内容，具体内容请看下面 　引例：已知如下程序 　1 #include 　2 main() 　3 { 　4 int x[3][4] = {1，3，5，7，9，11，2，4，6，8，10，12} ; 　5 int (*p)[4] =...
二维数组与指针(详解)
dddjjjsicnu的博客
04-02 6万+
一.2维数组 1.二维数组的定义 int a[3][3]; 在这我们定义了一个二维数组，拥有3行3列共9个int型存储空间大小。 2.二维数组的行地址和各个元素地址的表示 int a[3][4]; 对于数组a，我们可以将a[3][4]分为两部分理解a[3]和[4]，对于a[3]，我们可以看成是一个一维数组，其元素分别为a[0],a[1],a[2],他们分别表示各行所代表的起始地址，而对于[4]...
C语言 指针+二维数组详解 （应付期末、考研的最强笔记，建议收藏）
青春无问西东 岁月自成芳华
09-03 4万+
本文通过从二维数组的介绍开始，讲解什么是二维数组——>怎么定义和使用二维数组——>怎么引用二维数组的元素——>怎么通过指针来引用二维数组(具体包括多种分式)来逐步说明指针+二维数组的配合使用，相信学完本文内容，读者对于指针和二维数组会有更加深刻的印象和理解。通过学校期末考试和考研C语言内容完全足够！！！
数组指针和指针数组
热门推荐
mick_hu的博客
09-17 14万+
首先，理解一下数组指针和指针数组这两个名词： “数组指针”和“指针数组”，只要在名词中间加上“的”字，就知道中心了—— 数组的指针：是一个指针，什么样的指针呢？指向数组的指针。 指针的数组：是一个数组，什么样的数组呢？装着指针的数组。 然后，需要明确一个优先级顺序：()>[]>*，所以： (*p)[n]：根据优先级，先看括号内，则p是一个指针，这个指针指向一个一维数组，数组长...
【C++】二维数组的行指针和列指针
zzy979481894的博客
05-11 1万+
在C++中，数组与指针有密切的关系。任何通过数组和下标实现的表达式可等价地通过指针和偏移量实现。下面首先介绍一维数组与指针的关系，之后介绍二维数组的行指针和列指针。
二维数组指针表示，C语言指针引用二维数组详解
Salvator_的博客
12-09 7526
指针变量可以指向一维数组中的元素，当然也就可以指向二维数组中的元素。但是在概念和使用方法上，二维数组的指针比一维数组的指针要复杂一些。要理解指针和二维数组的关系首先要记住一句话：二维数组就是一维数组，这句话该怎么理解呢？ 假如有一个二维数组： int a[3][4] = {{1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23}}; 其中，a 是二维数组名...
C语言二维数组及指针引用
weixin_45863060的博客
04-11 8199
文章目录C语言二维数组及指针引用1.二维数组的定义与表示2.用指针引用二维数组元素 C语言二维数组及指针引用 1.二维数组的定义与表示 二维数组是形如： 表示一个int类型，三行四列的数组 int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12} 表示一个char类型，两行三列的数组 char s[2][3]={{'a','b','c'},{'d','e','f'}} 二维数组a的存储形式如下表所示： 行/列行/列行/列 a[i][0] a[i][1] a[i][2] a
浅析一级指针和二级指针、一维数组和二维数组
Soky的博客
12-27 2556
1、说起指针之前，先来看看下面这个例子。 #include <stdio.h> #include <stdlib.h> int malloc_pointer(char *p) { if(p == NULL) { p = (char *)malloc(10); } return 0; } int free_pointer(char *p) { if(p != NULL) { free(p); p = NULL; } return 0; } int m
关于二维数组，二维数组指针
LuHe123_ye的博客
11-12 2809
最近学习指针，一不小心就掉进了二维数组指针的坑里面，在迷惑了接近一个星期后，我有了以下的总结。（希望有大佬看见了能指点指点，我也不知道这么理解到底对不对） 这是我一开始犯的错误，完全忘记了野指针这回事： #include<stdio.h> #define N 3 int main(void) { int (*a)[N]= //不能这么做，这是一个二维数组指针，指针指向的是一个二维数组，定义一个指针需要有地址，这样写有些编译器都通不过 {
【C 语言】二级指针作为输入 ( 二维数组 | 二维数组遍历 | 二维数组排序 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-26 2216
一、二维数组、 1、二维数组声明及初始化、 2、二维数组遍历、 3、二维数组排序、 二、完整代码示例、
二级指针与二维数组
汤小萌的博客
08-10 1165
二级指针与二维数组容易搞混,二级指针做函数参数
c++ 二级指针与二维数组之间值操作
04-18
在C++编程语言中，二级指针（Double ...了解二级指针和二维数组的关系以及如何进行值操作，对于理解和编写涉及动态内存分配和复杂数据结构的C++程序至关重要。熟练掌握这一技巧，将有助于编写更高效、更灵活的代码。
C语言 指针与二维数组详解
12-31
二维数组在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有“缝隙”。以下面的二维数组 a 为例： int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上理解...
C++中用new创建二维数组和指针数组实例代码
12-31
使用new 创建二维数组方法 #include using namespace std; void main() { //用new创建一个二维数组,有两种方法,是等价的 //一: int (*p)[10] = new int[5][10]; //二: int **p = new int* [5]; for(int i=0;i <...
6 C 语言指针的奥秘：理论与实践详解
Thanks_ks的IT探秘之旅
07-24 733
本文详细阐述了 C 语言中指针的相关知识，包括变量访问机制、指针变量及其内存大小、取地址与取值操作符、注意事项、指针的传递与偏移、动态内存申请与释放、栈空间和堆空间的特点，以及野指针、悬垂指针等重要概念，并设置了判断题和 OJ 练习以巩固所学。全面且深入地帮助读者掌握 C 语言中指针的复杂内容。
C语言变量
qixi_ao的博客
07-24 780
变量
学习记录day18——数据结构 算法
最新发布
weixin_64918301的博客
07-24 764
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
（数据结构）二叉树
2401_83526138的博客
07-24 621
树是一种非线性的数据结构，它是由n（n>=0）个有限节点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：有一个特殊的节点，称为根节点，根节点没有前驱节点除根节点外，其余节点被分成M（M > 0）个互不相交的集合T1, T2, ......, Tm，其中每一个集合Ti(1 <= i <= m)又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继树是递归定义的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值