精华内容
下载资源
问答
  • 通过指针访问二维数组的三种方法
    千次阅读 多人点赞
    2019-11-21 17:17:44

    下面总结了一下通过指针访问二维数组的三种方法,里边涉及指针、指针数组、数组指针、指向指针的指针以及二维数组的应用,愿对于大家理解和使用指针有所参考和帮助。

    程序如下:

    #include <stdio.h>
    
    int main()
    {
    	int i, j;
    
    	int score[3][4] = {
        	{65,67,70,60},
        	{80,87,90,81},
        	{90,99,100,98}};
    
    	//第一种方法,二维数组当成一维数组来访问
    	int *p;
    	printf("方法1,二维数组当成一维数组来访问:\n");//换行
    	p = score[0];//或者&score[0][0],都可以。
    	for(i = 0; i < 3 * 4; i++)
    		printf("%4d,", *(p + i));
    	printf("\n");//换行
    
    	//第二种方法,通过数组指针来访问
    	int (*pr)[4];//数组指针
    	printf("\n方法2,通过数组指针来访问:\n");//换行
    	pr = score;
    	for(i = 0; i < 3; i++)
    	{
    		for(j = 0; j < 4; j++)
    			printf("%4d,", *(*(pr + i) + j));
    		printf("\n");//换行
    	}
    
    	//第三种方法,通过指向指针的指针+指针数组来访问
    	int **pt;//指向指针的指针
    	int *ptt[3];//指针数组
    	printf("\n方法3,通过指向指针的指针+指针数组来访问:\n");//换行
    	for(i = 0; i < 3; i++)
    		ptt[i] = score[i];//给指针数组赋值
    	pt = ptt;//需要通过指针数组来转换一下
    	for(i = 0; i < 3; i++)
    	{
    		for(j = 0; j < 4; j++)
    			printf("%4d,", *(*(pt + i) + j));
    		printf("\n");//换行
    	}
    }
    

    具体就不再解释了,注释已经写得比较明白了。程序在Code::Blocks下编译通过,运行结果如下:

    更多相关内容
  • 指针访问二维数组

    热门讨论 2022-04-08 21:30:18
    文章目录 前言 用指针访问二位数组 通过指针访问二维数组的不同形式 ==*a和a 是两个完全不同的概念:== ==为什么不能用*p=a== 二维数组元素的访问的四种方式: 1、通过下标访问数组元素 2、通过数组首地址访问数组...


    前言

    如何理解二维数组?我们以二维的方式理解二维数组,他在存储时却是一维的。


    用指针访问二位数组

    例:int a[3] [4] = {1,3,5,7,9,11,13,15,17,19,21,23};

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

    我们想象的二维数组的存储方式:3行4列

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

    我们认为前四个是一个以a[0]为数组名的一位数组,共有四个int元素

    中间四个是名为a[1]的一维数组

    最后四个是名为a[2]的一维数组

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xvD4uspk-1649424643293)(C:\Users\17273\AppData\Roaming\Typora\typora-user-images\image-20220408195446474.png)]

    通过指针访问二维数组的不同形式

    在这里插入图片描述

    *a和a 是两个完全不同的概念:

    a看待这个数组认为这个数组是一维数组,它自身加一会转向下一个一维数组即a+1

    *a指向的是每个元素都是整数的一维数组所以就认为 *a+0 指向的就是整数,加一就是下一个整数

    为什么不能用*p=a

    int x,*p;
    double y,*q;
    p=&x;
    q=&y;
    p=q;//是错的
    //p是指向四个字节为存储单元的地址
    //q是指向八个字节为存储单元的地址
    //两者不可以等价
    

    二维数组元素的访问的四种方式:

    1、通过下标访问数组元素

    int a[3][4];
    for (int i=0; i<3; i++)
        for (int j=0; j<4; j++)
            a[i][j] = i+j;
    
    int a[3][4];
    for (int i=0; i<3; i++)
        for (int j=0; j<4 ;j++)
            *(*(a+i)+j)=i+j;
    

    2、通过数组首地址访问数组元素

    对于二维数组元素a[i] [j], “【】”实际上是变址运算符,即将元素a[i] [j]的存储地址转换为a[i] + j。

    3、通过指针访问数组元素(以一维数组的角度“看待”二维数组”)

    int a[3][4];
    int *p=&a[0][0];
    for (int i=0; i<3; i++)
        for(int j=0; j<4; j++)
            *(p++) = i+j;		//相当于*p=i+j;p++;
    

    在这里,指针p被定义为:“指向int的指针”,也就是说:p指针“认为”它指向的是一个一维数组,每个元素都是int型的,共有12个元素。

    4、通过指针访问数组(以二维数组的角度“看待”数组)

    int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
    int (*p)[4];		
    /*
    对p指针的理解:
    *p声明了p的指针。
    p是指向什么的指针呢?
    指向了一个包含了4个整数的一维数组
    */
    p=a;
    for(int i=0; i<3;i++)
    	for (int j=0;j < 4;j++)
            *(*(p+i)+j)=i+j;
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kABn2WMW-1649424643295)(C:\Users\17273\AppData\Roaming\Typora\typora-user-images\image-20220408203550957.png)]

    指针这样定义之后,==指针p将以和数组a完全相同的“视角”去看待二维数组。==也就是说,a可以怎么使用,p也可以同样怎么使用

    //例如:此处*(*(p+i)+j)替换为p[i][j],a[i][j],*(*(a+i)+j)都是等价的
    

    指向字符串的二维数组

    char *str[3]={"Red","Green","Blue"};//方括号的优先级要高于"*"优先级
    //意思是str是具有三个元素的数组,数组里面存储的是指向字符的指针
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WhhJAfk3-1649424643296)(C:\Users\17273\AppData\Roaming\Typora\typora-user-images\image-20220408204323760.png)]

    实例:学生成绩

    score数组中存放了3个学生4们功课的成绩

    通过调用average函数计算所有学生所有成绩的平均值

    通过调用search函数显示第n个学生4门功课的成绩。

    思路:

    需要定义一个二维数组score,每行存储一个学生的4们功课的成绩。有3行,则存储了3个学生的成绩。

    65707060
    80879081
    909910098

    当编写函数average计算所有学生成绩平均值的时候,可以用一维数组的角度去看待这个score数组,也就是说,“认为”这个数组有12个成绩,直接求和,在计算平均分就行了

    当编写函数search显示第n个学生的4门功课的时候,则使用二维数组的角度去看待这个score数组,也就是说,“认为”这个数组有3行,每行4个元素

    void average(float *p,int n)
    {
        //以一维数组的方式看待学生成绩
        float *p_end;
    	float sum=0,aver;
        p_end=p+n;
        for ( ; p<p_end;p++)
            sum=sum+(*p);
        aver=sum/n;
        printf("平均成绩为:%5.1f\n",aver);
    }
    
    void search(float (*p)[4],int n)//可以写成 float p[][4]
    {
        //以二维数组的方式看待学生成绩,视角与score相同
        int i;
        printf("第%d个学生的成绩为: ",n);
        for (i=0;i<4;i++)
            printf("%5.1f",*(*(p+n)+i));  //可以替换成p[n][i]
    }
    
    int main()
    {
        float score[3][4]={{65,67,70,60},{80,87,90,81},{90,99,100,98}};
        average(&score[0][0],12);		//可以替换成score[0],*(score+0)
        search(score,2);
        return 0;
    }
    

    思考 (如果看不懂,请回退往前再看)

    (1)同是给函数传递score二维数组,为什么average函数和search函数传参时采用了不同的方式?

    average(&score[0][0],12);		//可以替换成score[0],*(score+0)
    search(score,2);				//显示第二个学生的成绩
    

    二维数组作为函数的参数

    1、以一维数组的角度“看待”二维数组

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P2KFzj6W-1649424643296)(C:\Users\17273\AppData\Roaming\Typora\typora-user-images\image-20220408210509696.png)]

    2、以二维数组的角度“看待”一维数组

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hblYxFbm-1649424643297)(C:\Users\17273\AppData\Roaming\Typora\typora-user-images\image-20220408210627250.png)]


    课后练习

    题目描述:写一个inverse函数,此函数的功能是:将一个 3*4 的二维数组中的值按逆序重新存放。

    程序运行结果范例

    请输入 3*4 的二维数组:

    1 2 3 4

    5 6 7 8

    9 10 11 12

    逆序存放后的结果为:

    12 11 10 9

    8 7 6 5

    4 3 2 1

    提示:

    这个程序有多种实现思路,尝试使用两种方法实现

    答案

    方法一:用二维数组的方式看待程序:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AypqDO38-1649424659790)(C:\Users\17273\AppData\Roaming\Typora\typora-user-images\image-20220408211150882.png)]

    void inverse(int a[][N],int b[][N])
    {
        int i,j;
        for (i=0;i<M;i++)
            for (j=0;j<N;j++)
                b[M-i-1][N-j-1]=a[i][j]
    }
    
    int main()
    {
        int a[M][N],b[M][N];
        int i,j;
        printf("请输入 %d*%d 的二维数组:\n",M,N);
        for (i=0;i<M;i++)
            for (j=0;j<N;j++)
                scanf("%d",&a[i][j]);
        inverse(a,b);
        printf("逆序存放后的结果为:\n");
        for (i=0;i<M;i++)
        {
            for (j=0;j<N;j++)
                printf("%d\t",b[i][j]);
        }
    }
    

    方法二: 用一维数组的方式看待程序:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wbqZDO8I-1649424659791)(C:\Users\17273\AppData\Roaming\Typora\typora-user-images\image-20220408211921472.png)]

    void swap(int *p1,int *p2)
    {
        int tmp = *p1;
        *p1 = *p2;
        *p2 = tmp;
    }
    
    //以 int *a 这样的方式传参,使得在子程序中以一维的方式看待数组,
    //也就是说,把数组看成了一个具有 M*N 个元素的,每个元素都是 int 的数组
    void inverse(int *a,int n)
    {
        int *p,*q;
        for (p=a,q=a+n-1;p<=q;p++,q--)
        {
            swap(p,q);
        }
    }
    
    int main()
    {
        int a[M][N];
        int i,j;
        printf("请输入 %d * %d 的二维数组: \n");
        for (i=0;i<M;i++)
            for (j=0;j<M;j++)
                scanf("%d",&a[i][j]);
        inverse(&a[0][0],M*N);
        printf("逆序存放后的结果为: \n");
        for (i=0;i<M;i++)
        {
            for (j=0;j<N;j++)
                printf("%d\t",a[i][j]);
        	printf("\n");
        }
        return 0;
    }
    

    程序用到了M,N两个常量,这样的程序具有良好的灵活性。

    展开全文
  • #include <stdlib.h> #include <stdio.h> int main(void){ int A[3][4] ={ {81, 32, 33, 44}, ... //定义指针用于遍历二维数组 you = &A[0][0]; //等同于 you = A[0]; p =.

    在这里插入图片描述

    #include <stdlib.h>
    #include <stdio.h>
    
    int main(void){
    	int A[3][4] ={
    		{81, 32, 33, 44},
    		{35, 60, 85, 20},
    		{16, 53, 45, 555}
    	};
    
    	//指针存储值
    	int *p = NULL;
    
    	int *you = NULL;  //定义指针用于遍历二维数组
    
    
    	you = &A[0][0]; //等同于  you = A[0];
    	p = you;
    	//用二维数组遍历全部
    	for(int i=0; i<3*4; i++, p++){
    		if(*p > *you){  //*you 可替换成 A[i/3][i%4]
    			you = p;
    		}
    	}
    	
    	printf("偷窥学生是:%d\n", *you);
    	//printf("偷窥学生是:%d\n", *p);
    	//计算位置
    	int bou = you-A[0];
    	
    	printf("%d\n", bou);  //第几位
    	printf("第%d层\n", bou/3); //楼层
    	printf("第%d位\n", bou%4); //楼层里面第几位
    
    	system("pause");
    	return 0;
    }
    
    
    
    
    
    /*据同学们报告,
    A 栋学生楼有学生用高倍望眼镜偷看别人洗澡,
    宿管办领导决定逐个宿舍排查,
    得到的线报是 A0 到 A3 宿舍的 
    某个子最矮的男生。
    */
    // 使用普通指针访问二维数组
    /**
    // demo 8-18.c 
    #include <stdio.h> 
    #include <stdlib.h> 
    int main() { 
    	/*据同学们报告,A 栋学生楼有学生用高倍望眼镜偷看别人洗澡,
    	宿管办领导决定逐个宿舍排查,得到的线报是 A0 到 A3 宿舍的
    	某个子最矮的男生。  
    	int A[4][3]={{173, 158, 166}, 
    				{168, 155, 171},
    				{163, 164, 165},
    				{163, 164, 172}
    	}; 
    
    	int *boy = NULL;//坏男孩 
    	int *p =NULL; //定义指针,用以遍历二维数组 //p = A[0];
    	p = &A[0][0]; 
    	boy = p;
    	for(int i=1; i<4*3; i++,p++){
            if(*boy > *p){ //*p 可以替换成 A[i/3][i%3] 
    			 boy = p; 
    		}
    	}
    	printf("偷窥的学生是: %d\n", *boy);
    	//2.根据指针计算下标
    	int pos = boy - A[0];
    
    	printf("index: %d\n", pos);
    	printf("位于 A[%d] 宿舍\n", pos/3);
    	printf("是第 %d 个成员\n", pos%3);
    	system("pause"); 
    	return 0;
    }
    **/
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • //先定义一个一维数组 int* pa = arr; //再定义一个指针指向这个数组 //通过指针访问数组和数组通过下标访问 for (int i = 0; i < 5; i++) { printf("%d ", arr[i]); //通过数组下标访问数组里面的...

    对指针和数组是不是还懵懵懂懂,看看这篇文章

    
    #include<stdio.h>
    /*
    	指针和数组的相关练习
    */
    int main()
    {
    	int arr[5] = { 1,2,3,4,5 };			//先定义一个一维数组
    	int* pa = arr;						//再定义一个指针指向这个数组
    	//通过指针访问数组和数组通过下标访问
    	for (int i = 0; i < 5; i++)
    	{
    	printf("%d ", arr[i]);	//通过数组下标访问数组里面的内容
    	}	
    	
    	printf("\n");
    
    	for (int i = 0; i < 5; i++)
    		printf("%d ", *(pa + i));		//通过指针访问数组里面的内容
    
    	printf("\n");
    
    	for (int i = 0; i < 5; i++)
    		printf("%d ", pa[i]);			//两种方法相结合	
    										//因为pa指向的是数组arr的首地址所以可以直接用pa替换掉arr
    	//上面的三种方法都可以访问得到数组中元素
    	printf("\n");
    
    	//下面开始研究二维数组和指针的关系
    
    	int a[2][3] = {						//先定义一个二维数组,并初始化
    		1,2,3,
    		4,5,6
    	};
    	int(*p)[3] = a;						//再定义一个行指针指向这个二位数组的首地址
    	//因为p先被括号起来所以先结合*	所以p首先是一个指针
    	//其次p再与[]结合		说明p是一个数组指针
    	//接着[]里面是三		说明p是一个数组指针指向有三列元素的数组
    	//最后前面是int型     说明p是一个数组指针指向有三列元素是整型的数组
    	// 	   圆括号不能省略 省略了是另外一回事
    	// 
    	//如果是		int* p[3]
    	//那么分析应该是	p先和[]结合		说明p是一个数组
    	// 				接着是[]里面是3	说明p是一个含有三个元素的数组
    	//				最后是int*		说明p是一个含有三个整型指针变量的数组
    	//综上:int (*p)[3]	中 p是指针
    	// 	   int *p[3]	中 p是数组
    	// 
    	//下面开始对二维数组访问	
    	//No.1	数组下面的方式		
    	//No.2	行指针访问
    
    	for (int i = 0; i < 2; i++)
    		for (int j = 0; j < 3; j++)
    			printf("%d ", a[i][j]);		//通过数组下标访问数组元素
    
    	printf("\n");
    
    	for (int i = 0; i < 2; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			printf("%d ", (*p)[j]);		//通过行指针访问数组中的元素
    		}
    		p++;	//指针可以做++运算,数组名不可以
    				//但数组名可以做加整数运算
    	}
    
    	//通过实验发现 :这两种访问方式都可以访问到数组里面的内容
    	return 0;
    }
    

    图片:
    程序最终结果 在这里插入图片描述 Alt

    展开全文
  • C++中指针指向二维数组实例详解 一维指针通常用指针表示,其指向的地址是数组第一元素所在的内存地址,如下 int ary[4][5]; int(*aryp)[5] = ary; 那么ary[4]相当于int(*aryp),以下理解如此,但参数传递需要知道...
  • 问题描述:用行指针访问二维数组 编译环境vc++6.0 代码: #include <stdio.h> int main() { int a[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 }; int(*p)[4]; //行指针 p = a; //指向数组a的第一行 printf...
  • 如下所示,这是一个简单的二维数组指针访问: #include <iostream> #define X 7 using namespace std; int main() { int a[X][X];//定义数组 for(int i=0;i<X;i++) for(int j=0;j<X;j++) { a[i]...
  • 怎样用指针访问二维数组呢? 先来回忆一下怎样用指针访问一维数组。在访问一位数组时,我们实际上声明的是一个和数组元素类型相同的指针变量,指向了数组第一个元素的地址,然后在用这个指针访问数组。 比如访问 ...
  • 通过指针访问二维数组的三种方式

    千次阅读 2019-11-29 20:38:51
    通过指针访问二维数组的三种方式 /* *通过指针访问二维数组的三种方式 *2019-11-29 */ #include <stdio.h> int main(int argc, char *argv[]) { int a[4][4]; int i, j; int *pInt; //普通指针 int (*...
  • 之前对指针的认识并不深入,最近在做图像处理,需要用二维数组存储图像数据,发现用指针访问二维数组的规律,感觉很有意思。 一般,我们定义一个二维数组比如m[2][2]={ 1,2,3,4 },假如想访问第i行,j列的元素,用m...
  • 使用指针访问二维数组中的元素C语言程序设计11200C语言使用指针访问二维数组中的元素数组与指向数组的指针数组按照维度或者说按照下标的个数分为一维数组二维数组数组和变量的使用一样可以归纳为三步第一数组的定义...
  • 如何使用指针访问二维数组

    千次阅读 多人点赞 2016-11-21 16:53:01
    如何使用指针访问二维数组? 先来看看在一维数组中怎样使用指针访问数组: 一维数组中 a[i] 中的 a 代表了本数组的首地址,相当于 &a[0]。 因此 *a 就等于 a[0]。 那么对 a 加 1,就可以访问下一位: ...
  • /**通过指针访问一维数组,二维数组,多维数组*/#includeconst int COLS=3;const int COUNT=4;//通过一级指针,计算偏移量来遍历一维数组void printSingleDimensionalArray(int *data,int data_len);//通过一级...
  • 要求使用指针变量访问数组元素。 输入样例: 10 11 12 13 14 88 15 16 22 33 55 44 输出样例: max=88 row=1 column=1 代码如下: #include<stdio.h> void findmax(int (a)[4],int n) { int i,j,row,column; int...
  • 1.二重指针 (1)二重指针与普通一重指针的区别 ->本质上来说,二重指针和一重指针的本质都是指针变量,指针变量的本质就是变量。 ->一重指针变量和二重指针变量本身都占4字节内存空间。 ...
  • 指针引用二维数组元素 C语言 指针引用二维数组 为什么用指针引用二维数组元素 C语言 指针引用二维数组 为什么相关问题:匿名网友:a 是数组首地址,等于 &a[0][0].*p 声明里是指针。语句里 *p 是 指针指向的值。...
  • 二维数组:逻辑存储: 物理存储: C语言中的多维数组基本的定义是以数组作为元素构成的数组,二维数组的数组元素是- -维数组, 三维数组的数组元素是一个=维数组,依此类推。也就是说,多维数组用的是一个嵌套的...
  • 二级指针二维数组

    2021-04-26 14:48:17
    指针 一级指针指向的是变量的首地址,指针指向的是一级指针的首地址。 整型变量a;一级整型指针变量p;级整型指针变量s。 s本身是p的地址;p本身是a的地址;a本身是数据0。 *s是p本身;*p是a本身。 **s是a...
  • 一级/二级指针访问二维数组看似是个简单的问题,但在实际编程中发现还是有不少值得学习的细节问题,本文总结如下 指针解引用过程 指针解引用过程 声明一个指针类型使用该指针访问数据的解引用过程如上图所示,...
  • 通过数组指针二维数组赋值

    千次阅读 2021-11-12 14:04:48
    在经过长时间的迷惑后,我放弃了使用指针传参 #include<stdio.h> #define N1 3 #define N2 5 void f(double (*a)[N2],double (*p)[N2]); void show(double (*p)[N2]); int main(void) { double a[N1]...
  • 关于指针二维数组的问题是许多和我一样的菜鸟初遇的难题 ,下面的一段代码是阐述在一个以7*7的数组遇到上下左右同时有三个为1的即是障碍就将其赌死,可以适用于迷宫程序。 #include #include #include #...
  • 1:第一种方法:直接传递,只是把二维数组的首地址传递进去,在函数内部访问的时候,需要组合重新组成计算行和列 void printArrayInFunction(int** arr,int arrSize,int colSize) { printf("testarray = %p\n]", ...
  • 指针访问内存比变量名访问速度更快,数组采用指针加减1的方式访问数组,增加了访问内存的灵活性。 指针与一维数组 指针移动方式访问数组元素: int a[5], *p; // a存放了数组的首地址 p=a; // 数组首地址赋给...
  • 分析:int (*p)[4]=a :这行代码是定义一个指向含有4个元素的一维数组的指针p,并且把二维数组a的首地址赋给p。对于二维数组a,可以把其抽象理解成a为一维数组,a的每个元素又是一个一维数组。其中a[0]={1,3,4,7}. ...
  • 一级指针遍历二维数组 前言:本文中出现的有关小数组,进阶的陌生知识点,我将一一解释清楚。 源代码: //一级指针 遍历 二维数组 int c[2][3] = {{1, 2, 3}, {4, 5, 6}}; int *d = c[0]; //输出小数组中的...
  • 数组指针实现方式 #include<iostream> #include<cmath> /** * 数组: * 使用指针创建数组 * 释放指针所占的空间 */ template<class T> void make2dArray(T**& arr, int ...
  • (p+i) 由于p是指向int[4]类型的,所以p+i就向后移动了44个...首先明白二维数组在内存的存放是线性的,先存放第一行的内容,再存放下一行…… 而指针向后移动的字节数是根据自己的指向来决定的在这里插入图片描述 ...
  • 二维数组在内存中存储是线性连续的,可以计算出二维数组的偏移量,进而使用一级指针遍历二维数组/**使用1级指针访问二维数组因为数组本身在地址空间中就是连续排列的,根据行数和列数,计算出访问单元的 地址偏移量 ...
  • C语言指针二维数组

    千次阅读 2021-05-07 20:58:57
    1.二维数组 1.1、二维数组的内存映像 (1)一维数组在内存中是连续分布的多个内存单元组成的,而二维数组在内存中也是连续分布的多个内存单元组成的。 (1)从内存角度来看,一维数组和二维数组没有本质差别。 (2)二维...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 56,533
精华内容 22,613
关键字:

指针访问二维数组