精华内容
下载资源
问答
  • C++ 二维数组指针遍历

    2021-08-03 17:07:29
    二维数组在内存中存储是线性连续的,可以计算出二维数组的偏移量,进而使用一级指针遍历二维数组 #include<stdio.h> void printMatirx(int *pArray,int rows,int cols) int main() { int array[2][3] ={{1,...

    一、将整个数组看出整体

    二维数组在内存中存储是线性连续的,可以计算出二维数组的偏移量,进而使用一级指针遍历二维数组

    #include<stdio.h>
    
    void printMatirx(int *pArray,int rows,int cols)
    
    int main()
    {
        int array[2][3] ={{1,2,3},{4,5,6}};
        int *pArray = NULL;
        pArray = array;
        printf("array[0][0] = %d\n", *pArray);
        printf("array[1][2] = %d\n", *(pArray + 1 * 3 + 2));//访问1行2列的二维数组
        printMatirx(array,2,3);                             //打印2行3列的数组
        return 0;
    }
    void printMatirx(int *pArray,int rows,int cols){
        int i;
        int j;
        for(i=0;i<rows;i++){
            for(j=0;j< cols;j++){
                printf("%d\t",*(pArray+i*cols+j));//访问i行j列的二维数组元素
            }
            printf("\n");
        }
    }
    

    使用指向数组的指针

    直接使用 [ ] 访问数组,方便。

    #include<stdio.h>
    #define COLS 3
    
    void printMatirx(int (*pArray)[COLS],int rows);
    
    int main()
    {
        int array[2][COLS] ={{1,2,3},
                            {4,5,6}};
    
        int (*pArray)[COLS] = NULL;
        pArray = array;
        printf("array[0][0] = %d\n", pArray[0][0]);
        printf("array[1][2] = %d\n", pArray[1][2]);
        printMatirx(pArray,2);
        return 0;
    }
    
    
    void printMatirx(int (*pArray)[COLS],int rows)
    {
        int i,j;
        for(i=0;i<rows;i++){
            for(j=0;j<COLS;j++){
                printf("%d\t",pArray[i][j]);
            }
            printf("\n");
        }
    }
    
    展开全文
  • C/C++二维数组及一维指针数组内存分配 我们以char 类型的二维数组为例吧;char array[3][5];这个数组的内存空间是怎么样的呢? 可以把它理解成一个矩阵的形式,他所占的字节数==3 * 5 * sizeof(char),就是15个...

    C/C++二维数组及一维指针数组内存分配

    我们以char 类型的二维数组为例吧;char array[3][5];这个数组的内存空间是怎么样的呢?
    可以把它理解成一个矩阵的形式,他所占的字节数==3 * 5 * sizeof(char),就是15个字节,有三行,每行占五个字节;

    下面我们来看下面一种形式:char *array_two[3],建立一个含有三个指向char类型的指针的数组;
    那么他的内存分配就是非常非常连续的,地址是一个接着一个的,我们直接看代码吧:
    在这里插入图片描述


    the adress of array_one[0]==000000000061fdd0
    the adress of array_one[1]==000000000061fdda
    the adress of array_one[2]==000000000061fde4
    the adress of array_one[3]==000000000061fdee
    the adress of array_one[4]==000000000061fdf8
    --------------------------------------------
    the adress of array_two[0]==0000000000409000
    the adress of array_two[1]==0000000000409004
    the adress of array_two[2]==0000000000409008
    the adress of array_two[3]==000000000040900b
    the adress of array_two[4]==000000000040900f
    

    array_one[0]->array_one[1]增加了10个字节,array_one[1]->array_one[2],也增加了10个字节,所以我们会发现,array_one数组每行增加10个字节,内存空间非常的规整并且连续。并且,不管每一行有没有被填满,每行都是固定的10个字节

    那么,我们来看一下array_two数组。**从array_two[0]->array_two[1]增加了4个字节,array_one[1]->array_one[2],增加了四个字节;**从array_two[2]->array_two[3]增加了3个字节,从array_two[3]->array_two[4]增加了4个字节,array_two数组并不是像array_one数组那样以相同的字节数增加的;仔细观察我们对array_two数组的初始化,你会发现什么?red加上末尾的\0刚好占据四个字节,ass加上末尾的\0也刚好占据四个字节,bc加上末尾的\0刚好占据三个字节…
    你发现了什么现象呢?他们的内存空间是连续的,但是并不是规整的。

    展开全文
  • C++中数组与指针有着紧密的联系,用指针对数组进行操作使得程序更加简洁高效,但是二者的衔接中往往会出现许多诸如格式,空间大小等方面不对应的问题,下面我将通过几个实例来简述二维数组指针的关系。...

    在C++中数组与指针有着紧密的联系,用指针对数组进行操作使得程序更加简洁高效,但是二者的衔接中往往会出现许多诸如格式,空间大小等方面不对应的问题,下面我将通过几个实例来简述二维数组与指针的关系。

    首先来看最简单的将指针指向一维数组。

    char a[10];			//先定义一个一维字符型数组a
    char *p[10];		//这种定义得到的是指针数组,即整个数组中全部存放字符型指针
    char (*p)[10];	//这样定义得到指向数组的指针
    *p=a;
    

    上例体现了一个很重要的注意点:运算符的优先级。指针运算符“*”的优先级是低于中括号的,所以如果不用小括号约束,p将会先与“[10]”结合,再去取指针,这样得到的就是指针数组,这一点在许多指向数组的指针定义中都会出现。

    现在让我们来看如何让指针指向二维数组,对指向二维数组的指针的定义,主要有以下几种方式。
    (1)指定行宽的指向方法

    #include <iostream>
    #include <cstdlib>
    
    using namespace std;
    
    int main()
    {
    	int n[][3] = { 10,20,30,40,50,60 };
    	int(*p)[3];
    	p = n;
    	cout << p[0][0] << "," << *(p[0] + 1) << "," << (*p)[2] << "," << p[1][1] << endl;
    
    	return 0;
    }
    

    通过给出与二维数组n列数一致的指向数组的指针p,可以使p指向数组n,之后指针名p可以进行所有与数组名有关的操作。

    这种指向思想是将二维数组视为一维数组操作,我们通过软件给出的对应关系也可以看出,如下图:

    在这里插入图片描述
    我们输入一个错误的指向格式,系统将会告诉我们这个指针希望指向一个什么格式的对象,显然使用这种方式定义的指向二维数组的指针,把列向量值固定为3,而只指向行向量,这样就将二维化为一维,实现了指针指向。

    这样的指针可以像数组名一样,直接用中括号来选取所需元素

    (2)指向元素的指向方法

    #include <iostream>
    #include <cstdlib>
    
    using namespace std;
    
    int main()
    {
    	int n[][3] = { 10,20,30,40,50,60 };
    	int *p=new int[10];
    	p = &n[0][0];
    	cout << *p << "," << *(p + 1) << "," << p[1] << "," << p[5] << endl;
    
    	return 0;
    }
    
    

    这种方式定义的指针指向单个元素,与方法一的一大区别是定义的指针需要在定义时初始化一个容纳数组的空间(new int[10];),定义指针却不指定其空间是一个非常严重的错误。

    这种方法下即使仍能以指针名+中括号的形式提取元素值,但需要注意,这样的指针是一维的,对应二维数组中元素的下标依行从左至右按顺序排列,这是与方法一使用指针提取元素最大的区别。方法一的指针可以使用双下标表示,也可以使用单下标表示,但方法二只能使用单下标。

    展开全文
  • c/c++ 一维数组、二维数组作为函数参数、返回值 一、一维数组作为参数 传入数组 int [] 为了规范,常常需要将数组的size一同传入,这是因为C++/C遇到参数为数组时,不会去一个个拷贝数组内的元素(太过于耗时),...

    c/c++ 一维数组、二维数组作为函数参数、返回值

    一、一维数组作为参数

    传入数组 int []

    为了规范,常常需要将数组的size一同传入,这是因为C++/C遇到参数为数组时,不会去一个个拷贝数组内的元素(太过于耗时),此时数组在函数内退化为数组首地址。 使用sizeof(array)/sizeof(array[0])得到1,可以验证我们前面的说法。
    一般情况下,函数内经常需要使用数组的size,此时就需要我们将size传入函数。

    int sum(int array[], int size)

    #include <stdio.h>
    int sum(int array[],int size)
    {
    	int summ=0,i;
    	for(i=0;i<size;i++)
    	{
    		summ+=array[i];
    	}
    	return summ;
    }
    int main()
    {
    	int arr[3]={1,2,3};
    	int ArrSum;
    	ArrSum=sum(arr,3);//注意这边传入参数是还是写arr,而不能写arr[]或arr[3]
    	printf("%d",ArrSum);
    	return 0;
    }
    
    传入数组首地址 int *

    int sum(int * array, int size)
    与上面一种其实本质上并没什么不同。
    不管哪一种,只要函数内部对传入的数组进行了修改,该数组本身的值也会改变,因为传入的都是地址,可以直接对地址上存储的元素进行修改。

    #include <stdio.h>
    int sum(int *array,int size)
    {
    	int summ=0,i;
    	for(i=0;i<size;i++)
    	{
    		summ+=*(array+i);
    	}
    	return summ;
    }
    int main()
    {
    	int arr[3]={1,2,3};
    	int ArrSum;
    	ArrSum=sum(arr,3);//这边传递的参数还是arr,和函数参数是数组一样
    	printf("%d",ArrSum);//但是这里的arr表示的是指针
    	return 0;
    }
    
    还有一种不推荐使用的传参方法

    int sum(int array[20])
    or
    const int size = 20;
    int sum(int array[size])
    从效果来讲,与前面两种并无本质区别,但是容易出错,(const),而且函数内也get不到size

    一维数组作为参数总结

    三个等价的一维数组传参方式

    int sum(int *)
    int sum(int [])
    int sum(int [10])
    为了避免数组越界,传入size的方法:

    1. 将size作为参数传入
    2. 使用数组的引用避免数组降价
      当参数是一个数组类型的引用时,数组长度成为参数与实参类型一部分,编译器会检查实参数组长度与形参是否匹配

    int sum(int (& array )[10])

    二、二维数组作为参数

    与一维数组一样,比较常用有两种传入方式,但是区别在于必须写出列数。因为数组在调用时同样有数组降价的问题,实际函数得到的是一个指针,指向行向量构成的一维数组,这样每个一维数组的size必须提前定义好,便于分配栈空间。

    1. int sum(int array[][4], int size)
    2. int sum(int (*array)[4], int size)

    这两种方法中size表示的都是行数,然后还有几种比较不常用的方法

    #include <stdio.h>
    int sum(int array[][3],int size)
    {
    	int summ=0,i,j;
    	for(i=0;i<2;i++)
    	{
    		for(j=0;j<3;j++)
    		{
    			summ+=array[i][j];
    		}
    	}
    	return summ;
    }
    int main()
    {
    	int arr[2][3]={1,2,3,4,5,6};
    	int ArrSum;
    	ArrSum=sum(arr,6);//注意只要参数是数组的,调用的时候就写数组名就可以了,不管是一维数组还是二维数组
    	printf("%d",ArrSum);
    	printf("\n%d",arr);
    	printf("\n%d",arr[0]);
    	return 0;
    }
    
    #include <stdio.h>
    int sum(int *array,int size)//这边的参数是一个指向整型的指针
    {
    	int summ=0,i;
    	for(i=0;i<size;i++)
    	{
    		summ+=*(array+i);//因此这边只需要一次间接寻址即可
    	}
    	return summ;
    }
    int main()
    {
    	int arr[2][3]={1,2,3,4,5,6};
    	int ArrSum;
    	ArrSum=sum(arr[0],6);//注意这里传入的参数是arr[0]而不是arr,arr表示的是数组第一行(即arr[0])的地址,而arr[0]表示的是arr[0]]0]的地址,但是有一个奇怪的地方是arr和arr[0]的地址是一样的。
    	printf("%d",ArrSum);
    	printf("\n%d",arr);
    	printf("\n%d",arr[0]);
    	return 0;
    }
    
    #include <stdio.h>
    int sum(int (*array)[3],int size)//这边的参数是一个数组指针,该指针指向的是一个数组(包含了三个int型的数组)
    {
    	int summ=0,i,j;
    	for(i=0;i<2;i++)
    	{
    		for(j=0;j<3;j++)
    		{
    			summ+=*(*(array+i)+j);//深刻理解这个表达式的含义。
    		}
    	}
    	return summ;
    }
    int main()
    {
    	int arr[2][3]={1,2,3,4,5,6};
    	int ArrSum;
    	ArrSum=sum(arr,6);//
    	printf("%d",ArrSum);
    	return 0;
    }
    

    三、函数返回数组

    返回输入数组的指针
    这里有个容易造成错误的点,函数返回的是数组指针(指向数组的指针),但是如果返回之后指针指向的数组被销毁了呢?
    提到这里,再复习一下内存空间的四个区域,栈空间、堆区间、数据区(静态区)、代码区。静态变量、全局变量是放在数据区的,作用范围是全局的,而局部变量通常位于栈空间,随着被调用函数的退出自动释放空间被销毁。

    一维数组,返回数组指针
    	#include <iostream>
    	#include <cstdlib>
    	#include <ctime>
    	using namespace std;
    	// 要生成和返回随机数的函数
    	int * getRandom( )
    	{
    	  static int  r[10];
    	  // 设置种子
    	  srand( (unsigned)time( NULL ) );
    	  for (int i = 0; i < 10; ++i)
    	  {
    	    r[i] = rand();
    	    cout << r[i] << endl;
    	  }
    	  return r;
    	}
    	// 要调用上面定义函数的主函数
    	int main ()
    	{
    	   // 一个指向整数的指针,不是指向数组的指针,只是指向数组第一个元素对的指针。
    	   int *p;
    	   p = getRandom();
    	   for ( int i = 0; i < 10; i++ )
    	   {
    	       cout << "*(p + " << i << ") : ";
    	       cout << *(p + i) << endl;
    	   }
    	   return 0;
    	}
    
    	#include "stdio.h"
    	#include "stdlib.h"
    	int * Max(int *arr,int n)
    	{
    	    int *a=(int *)malloc(2*sizeof(int));
    	    int maxNum=0,maxIndex,i;
    	    for (i=0;i<n;i++)
    	        if (arr[i]>maxNum)
    	            {maxNum=arr[i];maxIndex=i+1;}
    	    a[0]=maxNum;a[1]=maxIndex;
    	    return a;
    	}
    	void main()
    	{
    	    int a[2]={5,2};//a[0]=5,a[1]=2; 
    	    int *b=Max(a,2);
    	    int i;
    	    for(i=0;i<2;i++)
    	        printf("b[%d]=%d\n",i,b[i]);
    	    free(b);
    	}
    
    二维数组指针
    #include "stdio.h"
    #include "stdlib.h"
    int  **Max(int **arr,int n,int m)
    {
        int **data,i,j;
    	data=(int **)malloc(n*sizeof(int *));//强制类型转换,将其转成二维指针。
    	for ( i=0;i<n;i++)
    		data[i]=(int *)malloc(2*sizeof(int));
    	for ( i=0;i<n;++i)
    	{
    		int maxNum=0;
    		for (j=0;j<m;++j)
    		{
    			//printf("arr[%d][%d]=%d ",i,j,*((int *)arr+m*i+j));
    			if (*((int *)arr+m*i+j)>maxNum)
    			{
    				maxNum=*((int *)arr+m*i+j);
    				data[i][0]=maxNum;data[i][1]=j;
    			}
    		}
    		//printf("\n");
    	}
        return data;
    }
    
    void main()
    {
    	int a[2][3]={5,2,4,6,3,9};
        int **b=Max((int **)a,2,3);//同上,强制类型转换,这里为什么要进行类型转换呢,二维数组名是二维指针吗?看起来是,那编译不通过说明二维数组名不是二维指针。
        int i;
    	for (i=0;i<2;i++)
    	{
    		printf("the maximum num for row %d is %d\n",i+1,b[i][0]);
    		printf("the maximum num for row %d is in %d",i+1,b[i][1]+1);
    		printf("\n");
    	}
    	for(i=0;i<2;i++)
    		free(b[i]);
    	free(b);
    }
    
    展开全文
  • 文章目录I. 数组与指针互转I.i. 数组的一个基本性质就是能看成一个指针I... 二维数组指针IV.i. 二维数组内存分布IV.ii 二维数组作形参并遍历IV.ii.a. 固定第二维,第一维是指针或数组IV.ii.b. 一级指针指代二维数组IV
  • 二维数组名是一个指向数组中所有元素的指针,而数组指针是一个行指针。体现在sizeof()上的不同。 #include <iostream> using namespace std; int main() { // a是一个二维数组名,指向一个二维数组 int a[2]...
  • 二维数组array的首地址, 其值为二维数组array的首地址 array -> 表示一个二维数组, 其值为二维数组array的首地址 *array -> 表示二维数组array的第一个元素, 即一个int[3]数组, 的首地址 **array -> ...
  • C/C++从函数返回指针是常规操作,本文针对返回二维数组指针做了一些研究,并给出二维数组指针返回double**类型指针的结论。 常规C/C++函数返回二维数组指针 (1)返回值返回二维数组指针 首先看通过返回值返回...
  • 二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例: int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上...
  • 关于二维数组中数组元素的存储地址,有同学问出了个好问题。在我的课件中,出现了下面的讲解:a[i][j]的地址是p+(i*col+j)*d(d是数组元素所占的字节数)。同学编程序进行验证,出问题了:地球停止转动了也必须先赞...
  • c语言指针的应用 #include <...传递的时候给一个二维数组的名字即可,数组的名字可以被当成是指向第一个元素的指针 void search(int *,int *,int array[24][7],int key); //函数print_row_i的第一个参数.
  • C++指针(三): 指针二维数组 在介绍指针二维数组之前,先介绍二维数组的地址、行地址以及元素地址。
  • 如何在C函数中传递指向二维数组指针参数前几日用C编写DSP程序时,遇到一个问题:如何向C函数中传递指向二维数组指针参数。初接触以为很简单,直接声明一个二维数组,然后把数组名传进去。但是一经编译便报错。...
  • C++二维数组转置

    2021-11-13 21:47:37
    第一种:N*N列矩阵 #include <iostream> #define N 3 using namespace std; void ReverseArray(int a[N][N]){//数组转置 int t; for(int i = 0;...= j){//主对角线上的数组转之后为本身,所以进行交换
  • 二维数组排序数组排序有内置API,一般是一维的,这里分享下二维或者多维的用法1 C++ 二维数组第一列升序,第一列相同第二列降序2 C 二维数组第一列升序,第一列相同第二列降序3 更一般的思路 数组排序有内置API,...
  • 我们要知道为什么不用数组指针来打印一维数组呢? 因为很明显,用平常的方法就可以了。使用数组指针来打印显得麻烦多了 #include<stdio.h> void print(int(*p)[5], int i , int n) { int r = 0; int j = 0...
  • 然后再对所有的第一维分配内存,创建二维指针数组; 第2步,创建临时的char一维数组fileName,用sprintf_s函数对fileName赋值; 第3步,用strcpy函数对bgFrames_path的第一维数组进行拷贝赋值; 第4步,传入参数...
  • 这几天做笔试题,有个变长二维数组的传递。平时核心代码写多了,写完整函数反倒不清晰二维数组的传递了。 1.简单传参 int aa(int a[][2]) { cout<<a[0][0]<<" "<<a[0][1]<<endl; } int ...
  • C++ 二维数组参数传递的实现方法int a[2][2]={ {4, 6}, {9, 11} };我定义了这样一个数组,我想把这个数组作为参数,传递到一个函数中,并要在函数中能引用该二维数组的元素,我该怎么做?第一种方式是直接传递二维...
  • C++维数组定义一维数组定义一维数组的一般格式为:类型标识符 数组名[常量表达式];例如:int a[10];它表示数组名为a,此数组为整型,有10个元素。关于一维数组的几点说明:1) 数组名定名规则和变量名相同,遵循...
  • 指向具有M个元素的一维数组指针 定义格式如下: 类型 (*指针变量)[M]; //M为一整型常量 通常利用该指针变量,指向二维数组的行地址,其中M表示二维数组的列数。 例如:利用行指针变量,按行输出二维数组各元素值 ...
  • 文章目录1 一维数组名1.1 一维数组名称的作用1.2 一维数组名的2种特例情况2 数组指针的定义方式2.1 typedef定义数组类型2.2 typedef定义数组指针类型 1 一维数组名 参考本人博客《C++数组》第2.2节一维数组的数组名...
  • 在经过长时间的迷惑后,我放弃了使用指针传参 #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]...
  • C++ 堆空间变量,包括平时写算法题,常常用的是 new 单一变量,偶然发现自己不会 new 二维数组即 new 指针数组,说实话有点对自己失望,故总结此文,并附上 hash_map demo 实现。 二、new 指针数组 hash_map demo ...
  • 如下所示,这是一个简单的二维数组指针访问: #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]...
  • 数组指针实现方式 #include<iostream> #include<cmath> /** * 数组: * 使用指针创建数组 * 释放指针所占的空间 */ template<class T> void make2dArray(T**& arr, int ...
  • 说明:当我们需要二维数组作为引用参数时,这时就可以用到双指针;因为使用双指针容易出现问题,所以最好用指针数组来代替(单指针); 如图1所示,双指针保存信息是“多个目标,且每个目标包含6个参数”;用指针...
  • 一. 二维数组 二维数组通常也被称为矩阵(matrix)。 六种初始化方式:   (1) int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};   (2) int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};   或: int a[3][4]={  ...
  • 我理解中的二维数组、指针数组、数组指针、二级指针: 二维数组: 人们为了便于理解,主观性认为存在的一个概念,从底层来看,二维数组仍然是一个一维数组,只不过是一位数组的每个元素仍然是一个一位数组,大方向上...
  • /**通过指针来访问一维数组,二维数组,多维数组*/#includeconst int COLS=3;const int COUNT=4;//通过一级指针,计算偏移量来遍历一维数组void printSingleDimensionalArray(int *data,int data_len);//通过一级...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,069
精华内容 17,227
关键字:

c++二维数组指针

c++ 订阅