精华内容
下载资源
问答
  • int *p[n]; for(int i=0;i<n;i++){ p[i]=&a[i][0]; } 重新定义一个指针p,将p传递过去 二级指针**是指向指针指针二维数组a是……?指针
        int *p[n];
        for(int i=0;i<n;i++){
            p[i]=&a[i][0];
        }
     

    重新定义一个指针p,将p传递过去

    二级指针**是指向指针的指针

    而二维数组a是……?指针

    展开全文
  • 1:第一种方法:直接传递,只是把二维数组的首地址传递进去,在函数内部访问的时候,需要组合重新组成计算行和列 void printArrayInFunction(int** arr,int arrSize,int colSize) { printf("testarray = %p\n]", ...

    1:第一种方法:直接传递,只是把二维数组的首地址传递进去,在函数内部访问的时候,需要组合重新组成计算行和列

    void printArrayInFunction(int** arr,int arrSize,int colSize)
    {
        printf("testarray = %p\n]", arr);
        printf("testarray +1 = %p\n]", arr+1);
        printf("testarray[0][2] = %d\n]", *(arr +2));
        printf("testarray[1][1] = %d\n]", *((arr +1* colSize) + 1));
    }
    

    上面重新进行和列的计算
    第二种方位方式:直接传递指针数组,一个指针,指向二维数组的首行,数组包含两列。在函数内部可以直接以二维数组的形式访问

    void printArrayInFunction_Sec(int (*arr)[2], int arrSize)
    {
        printf("testarray[0][2] = %d\n]", arr[0][1]);
        printf("testarray[1][1] = %d\n]", arr[1][1]);
        return;
    }
    

    第三种方式:直接传递二级指针,然后再内部把二级指针强行转化为指针数组 指针类型为整型,这样也可以再内部直接以二维数组的形式访问

    void printArrayInFunction_third(int** arr, int arrSize, int colSize)
    {
        int(*arrTest)[2] =(int*)arr;
        //printf("testarray = %p\n]", arr);
        //printf("testarray +1 = %p\n]", arr + 1);
        printf("testarray[0][1] = %d\n]", arrTest[0][1]);
        printf("testarray[1][1] = %d\n]", arrTest[1][1]);
    }
    
    void printArray()
    {
        
        int testArray[][2] = { {1,2},{4,5},{6,7}};//init  
    
        printArrayInFunction(testArray, 3, 2);
        printArrayInFunction_Sec(testArray, 3);
        printArrayInFunction_third(testArray, 3, 2);
        return;
    }
    

    打印结果:
    在这里插入图片描述

    展开全文
  • 区分一下指针数组和数组指针二维数组做参数该怎么传递。。 指针数组和数组指针区分 在中间加个“的”即可理解,指针的数组 数组的指针 一、指针数组 指针数组,指针的数组。表示一个数组里面装的全是指针。 定义:...

    前言

    区分一下指针数组和数组指针和二维数组做参数该怎么传递。。

    指针数组和数组指针区分 在中间加个“的”即可理解,指针的数组 数组的指针

    一、指针数组

    指针数组,指针的数组。表示一个数组里面装的全是指针。
    定义:int *p[5]; // []的优先级高于 **,先和p结合为数组,再由int *指明为指针
    不能进行p++操作,因为p是数组头,是一个地址 而不是指针!!

    例子:

    #include <iostream>
    using namespace std;
    int main()
    {
    	int a[][3] = { {1,12,3},{4,5,6},{7,8},{9,10},{11} };//3*5*4
    	int *p1[5];
    
    	for (int i = 0; i < 5; i++)
    	{
    		p1[i] = a[i];//单独给数组里面的每个指针赋值
    	}
    
    	for (int i = 0; i < 5; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			//以下三种形式都可以!
    			//cout << p1[i][j] << " ";
    			//cout << *(p1[i] + j)<< " ";
    			cout << *(*(p1 + i) + j) << " ";
    		}
    		cout << endl;
    	}
    }
    

    结果:
    在这里插入图片描述

    二、数组指针

    数组指针,数组的指针。即为只想数组的指针,又称为行指针,只想一行数组的指针。
    定义:int (*p)[3];//()的优先级最高,先指明p是一个指针,再指向一个大小为3的一维数组。
    p++ 的意思是指向下一行数组。

    例子:

    #include <iostream>
    using namespace std;
    int main()
    {
    	int a[][3] = { {1,12,3},{4,5,6},{7,8},{9,10},{11} };//3*5*4
    	int(*p2)[3];
    	
    	p2 = a;
    	for (int i = 0; i < 5; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			cout << (*p2)[j] << " ";
    		}
    		p2++;
    		cout << endl;
    	}
    }
    

    结果:
    在这里插入图片描述

    三、二维数组做参数传递

    1.就用二维数组但是要表明行或者列

    #include <iostream>
    using namespace std;
    void test(int aaa[][3])
    {
    	for (int i = 0; i < 5; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			cout << aaa[i][j] << " ";
    		}
    		cout << endl;
    	}
    }
    int main()
    {
    	int a[][3] = { {1,12,3},{4,5,6},{7,8},{9,10},{11} };//3*5*4
    	test(a);
    }
    

    2. 用数组指针 (行指针)

    #include <iostream>
    using namespace std;
    void test(int (*aaa)[3],int m)
    {
    	for (int i = 0; i < m; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			cout << (*aaa)[j] << " ";
    		}
    		aaa++;
    		cout << endl;
    	}
    }
    
    int main()
    {
    	int a[][3] = { {1,12,3},{4,5,6},{7,8},{9,10},{11} };//3*5*4
    	test(a,5);
    }
    

    3. 用指针数组

    #include <iostream>
    using namespace std;
    void test(int *aaa[5])
    {
    	for (int i = 0; i < 5; i++)
    	{
    		for (int j = 0; j < 3; j++)
    		{
    			cout << aaa[i][j] << " ";
    			//cout << *(aaa[i]+j) << " ";
    			//cout << *(*(aaa+i) + j) << " ";
    		}
    		cout << endl;
    	}
    }
    
    int main()
    {
    	int a[][3] = { {1,12,3},{4,5,6},{7,8},{9,10},{11} };//3*5*4
    	int* aa[5];
    	for (int i = 0; i < 5; i++)
    	{
    		aa[i] = a[i];
    	}
    	test(aa);
    }
    

    4.用二维指针

    #include <iostream>
    using namespace std;
    void test(int** aaa, int m, int n)//二维指针
    {
    	for (int i = 0; i < m; i++)
    	{
    		for (int j = 0; j < n; j++)
    		{
    			//强制转换二维指针为一维,因为数组他的内存本身就是连续的!
    			cout << *((int*)aaa + i * n + j) << " ";
    			//cout << *(*(aaa+i) + j) << " ";//是错误的!因为aaa这个时候已经由数组退化为指针了,不知道数组的大小啦!
    		}
    		cout << endl;
    	}
    }
    
    int main()
    {
    	int a[][3] = { {1,12,3},{4,5,6},{7,8},{9,10},{11} };//3*5*4
    	test((int**)a,5,3);
    }
    
    展开全文
  • 二级指针二维数组函数参数传递

    千次阅读 2018-05-14 12:05:55
    二维数组作为函数形参时,能作为函数实参的是二维数组,数组指针指针数组作为函数形参时,能作为函数实参的是指针数组,二级指针,一级指针的地址 2、实例验证: #include &lt;stdio.h&gt; #...

    1、传参规则

    • 当二级指针作为函数形参时,能作为函数实参的是二级指针,指针数组,一级指针的地址
    • 当数组指针作为函数形参时,能作为函数实参的是二维数组,数组指针
    • 当二维数组作为函数形参时,能作为函数实参的是二维数组,数组指针
    • 当指针数组作为函数形参时,能作为函数实参的是指针数组,二级指针,一级指针的地址

    2、实例验证:

    #include <stdio.h>
    #include <stdlib.h>
    
    void fun1(int **pp)
    {
        printf("fun1\n");
    }
    void fun2(int(*a_p)[5])
    {
        printf("fun2\n");
    }
    void fun3(int t_d_a[][5])
    {
        printf("fun3\n");
    }
    void fun4(int *p_a[5])
    {
        printf("fun4\n");
    }
    
    int main()
    {
        int *p_a[5];          //指针数组
        int **pp = NULL;      //二级指针
        int *p = NULL;        //一级指针
        int t_d_a[5][5];      //二维数组
        int a[5];             //一维数组
        int(*a_p)[5] = &a;    //数组指针
    
        fun1(p_a);
        fun1(pp);
        fun1(&p);
        //fun1(t_d_a);
        //fun1(a_p);
        printf("\n");
    
        //fun2(p_a);
        //fun2(pp);
        //fun2(&p);
        fun2(t_d_a);
        fun2(a_p);
        printf("\n");
    
        //fun3(p_a);
        //fun3(pp);
        //fun3(&p);
        fun3(t_d_a);
        fun3(a_p);
        printf("\n");
    
        fun4(p_a);
        fun4(pp);
        fun4(&p);
        //fun4(t_d_a);
        //fun4(a_p);
        printf("\n");
    
        return 0;
    }
    展开全文
  • C语言指针重点难点整理(详解)(包括一维数组,二维数组的元素指针二维数组的行指针做函数参数,指针数组,行指针数组) 笔者学指针之前: 呵呵,听闻指针是C语言的难点,我倒要见识一下,到底有多难 笔者学完...
  • 文章目录指针数组,数组指针二维数组,二级指针答案答案的论证必备知识存储结构:不同操作的输出结果: 指针数组,数组指针二维数组,二级指针 答案 无需纠结C语言是如何定义的,因为这样太花时间了。当然有时间...
  • #include #include void input(int *pa,int n) {  int i;  for(i=0;i  scanf("%d",pa); } void output(int *pa,int n) {  int i;  for(i=0;i  {  printf("%d ",*pa);
  • int arr[3][3] 的本质是指向数组的指针即 int (*p)[3],所以二维数组名可以传递给foo( int (*arr)[3]) ,或者foo(int [][3]),但是不能传递给foo(int **arr)  传给函数foo(int **arr) 可以是动态二维数组
  • C语言中的二级指针二维数组问题

    千次阅读 2016-11-17 16:13:20
    关于二级指针和二维数组两者差别很大,不可以直接二级指针传递二维数组 首先来看看二维数组在内存中是如何组织的呢? 一维数组 T arr1 = new T[9] 二维数组T arr2 = new T[3][3] 实际上,不管是一维...
  • 二维数组作为形参,传递二维数组的值 void trfind(int (*Array)[3]); void trfind(int (*Array)[3]) { int a[][3] = {1, 2, 3, 4, 5, 6}; int i, j; for (i=; i<2; i++) for (j=0; j<3; j++) ...
  • 举例子: int data[3][4] ={ {1,2,3,4} , {5,6,7,8} , {9,10,11,12} };...data 是一个数组名,该数组有3个元素,第一个元素本身又是一个数组,有4个int 值组成。 因此,data的类型是指向4个int组成的数...
  • ①实参做二维数组传递首地址时,形参定义为指向数组的指针,int (*p)[n] #include "stdio.h" void main() { void reverse(int (*p)[3]); int a[3][3]; int i,j; printf("input array:\n"); for(i=0;i<3;i++)...
  • 数组指针,指向一个一维数组的指针,又称行指针,被二维数组赋值后可当作二维数组操作。 例: int a[2][3]; a[1][2]=5; int (*b)[3]=a; cout<<a[1][2]; cout<<(*(b+1))[2]; cout<<b[1][2]; ...
  •  C语言中的数组名是一个特殊的存在, 从本质上来讲, 数组名是一个地址, 我们可以打印一个指针的值,和打印一个数组的值来观察出这个本质:int nArray[10] ={ 0 }; int *p = nArray; printf("nArray:%p , p = %p\n", ...
  • 二维数组作为函数形参时,能作为函数实参的是二维数组,数组指针 d.当指针数组作为函数形参时,能作为函数实参的是指针数组,二级指针,一级指针的地址2、实例验证:#include #include <stdl
  • 指针:C语言二级指针二维数组

    千次阅读 2019-04-09 21:25:59
      最近用C语言写LeetCode 有的题目给的函数把二维数组用二级指针传进来 并传入行数和列数 引起一些疑惑 本来以为C语言学得海星,查了一些资料后,觉得自己还是个弟弟 : ( 按一维数组的思路处理二维数组,将二维...
  • 早上朋友问的问题,开始以为是一维数组 A* array[10] ...然后他说还不对,发了截图过来,才发现是二维数组 A* array[10][10] 很自然的以为传 A*** 然而编译不过 正确的应该是参数设为 A* array[][10] 传 f(array)
  • 指针数组、数组指针二维数组动态分配内存 2016-03-22 22:59 838人阅读 评论(0) 收藏 举报  分类: C(7) C++(12)  目录(?)[+] 1. 二维数组动态分配和释放 1. 已知第...
  • 怎样用指针访问二维数组呢? 先来回忆一下怎样用指针访问一维数组。在访问一位数组时,我们实际上声明的是一个和数组元素类型相同的指针变量,指向了数组第一个元素的地址,然后在这个指针访问数组。 比如访问 ...
  • 参数传递二维数组 数组名作为实参 void func1(int iArray[][10]) { } int main() { int array[10][10]; func1(array); } 一维数组指针(也称行指针)作为形参 void func2(int (*pArray)[10]) { } void func2_...
  • 指针二维数组

    2017-05-24 20:34:52
    指针二维数组 输入一个三行四列的数组,并输出元素值 用二维数组做函数形参 *************************/ #include #define N 4 //此处N应与主函数二维数组第二列长度一致,否则报“数组下标不一致...
  • c语言使用指针做函数的形参传递二维数组

    千次阅读 多人点赞 2018-06-14 21:29:23
    C语言中,我们经常会使用到二维数组作为函数的形参,常用的就是用指针做函数参数传递二维数组,有两种基本方法,如下: 1、传递“数组指针” #include &amp;lt;stdio.h&amp;gt; void output( int (*pa)...
  • 1、指针数组数组指针 详细:http://c.biancheng.net/view/335.html 1.1指针数组 int *p1[5]; 指针数组 首先,因为"[ ]" 的优先级要比" * "的优先级要高,所以所以p1[5]首先是一个数组,然后其元素类型为整型指针...
  • 今天编写程序时,传递参数是一个二维数组碰到了
  • *p[3]这个是一个指针数组,它所代表的意思是数组中的每一个元素都是一个指针变量,而(*p)[3],p是一个指针变量,表示指向一个含有3个整型元素的一维数组。 复制代码代码如下: int i,j;  int a[2][3]={3,4,5,6,7...
  • C语言二维数组指针(指向二维数组指针)详解

    千次阅读 多人点赞 2020-05-27 17:43:22
    如有需要,请访问C语言二维数组指针(指向二维数组指针)详解 二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例: int a[3][4] = { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,623
精华内容 14,649
关键字:

如何用指针传递二维数组