精华内容
下载资源
问答
  • C 二维数组动态分配和释放 (1)已知第二维 Code-1 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char *) * m); printf("%d\n", sizeof(a));//4,指针 printf("%d\n", sizeof(a[0]));//N,一维数组 ...
    C 二维数组动态分配和释放
    (1)已知第二维
    Code-1
    char (*a)[N];//指向数组的指针
    a = (char (*)[N])malloc(sizeof(char *) * m);
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//N,一维数组
    free(a); 
    (2)已知第一维
    Code-2
    char* a[M];//指针的数组
    int i;
    for(i=0; i<M; i++)
    a[i] = (char *)malloc(sizeof(char) * n);
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<M; i++)
       free(a[i]); 
    (3)已知第一维,一次分配内存(保证内存的连续性)
    Code-3
    char* a[M];//指针的数组
    int i;
    a[0] = (char *)malloc(sizeof(char) * M * n);
    for(i=1; i<M; i++)
    a[i] = a[i-1] + n;
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    free(a[0]); 
    (4)两维都未知
    Code-4
    char **a;
    int i;
    a = (char **)malloc(sizeof(char *) * m);//分配指针数组
    for(i=0; i<m; i++)
    {
    a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<m; i++)
    {
    free(a[i]);
    }
    free(a); 
    (5)两维都未知,一次分配内存(保证内存的连续性)
    Code-5
    char **a;
    int i;
    a = (char **)malloc(sizeof(char *) * m);//分配指针数组
    a[0] = (char *)malloc(sizeof(char) * m * n);//一次性分配所有空间
    for(i=1; i<m; i++)
    {
    a[i] = a[i-1] + n;
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    free(a[0]);
    free(a); 
    2.C++动态分配二维数组
    (1)已知第二维
    Code-6
    char (*a)[N];//指向数组的指针
    a = new char[m][N];
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//N,一维数组
    delete[] a; 
    (2)已知第一维
    Code-7
    char* a[M];//指针的数组
    for(int i=0; i<M; i++)
       a[i] = new char[n];  //以a[0],a[1]……为首地址的数组内存不一定连在一起
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<M; i++)
       delete[] a[i]; 
    (3)已知第一维,一次分配内存(保证内存的连续性)
    Code-8
    char* a[M];//指针的数组
    a[0] = new char[M*n];
    for(int i=1; i<M; i++)
    a[i] = a[i-1] + n;
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    delete[] a[0]; 
    (4)两维都未知
    Code-9
    char **a;
    a = new char* [m];//分配指针数组
    for(int i=0; i<m; i++)
    {
    a[i] = new char[n];//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<m; i++)
    delete[] a[i];
    delete[] a; 
    (5)两维都未知,一次分配内存(保证内存的连续性)
    Code-10
    char **a;
    a = new char* [m];
    a[0] = new char[m * n];//一次性分配所有空间
    for(int i=1; i<m; i++)
    {
    a[i] = a[i-1] + n;//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    delete[] a[0];
    delete[] a; 
    多说一句:new和delete要注意配对使用,即有多少个new就有多少个delete,这样才可以避免内存泄漏!
    3.静态二维数组作为函数参数传递
    如果采用上述几种方法动态分配二维数组,那么将对应的数据类型作为函数参数就可以了。这里讨论静态二维数组作为函数参数传递,即按照以下的调用方式:
    int a[2][3];
    func(a);
    C语言中将静态二维数组作为参数传递比较麻烦,一般需要指明第二维的长度,如果不给定第二维长度,则只能先将其作为一维指针传递,然后利用二维数组的线性存储特性,在函数体内转化为对指定元素的访问。
    首先写好测试代码,以验证参数传递的正确性:
    (1)给定第二维长度
    Code-11
    void func(int a[][N])
    {
    printf("%d\n", a[1][2]);
    } 
    (2)不给定第二维长度
    Code-12
    void func(int* a)
    {
    printf("%d\n", a[1 * N + 2]);//计算元素位置
    } 
    注意:使用该函数时需要将二维数组首地址强制转换为一维指针,即func((int*)a);
    展开全文
  • 二维数组动态分配存储空间二维数组为ans[numRows][numRows] ans = (int **)malloc( numRows*sizeof(int *) ); for ( i = 0; i < numRows; i++ ) ans[i] = (int *)malloc( numRows*sizeof(int) ); ...

    二维数组动态分配存储空间及二维vector的初始化

    C语言:
    设二维数组为ans[numRows][numRows]

    ans = (int **)malloc( numRows*sizeof(int *) );
    for ( i = 0; i < numRows; i++ )
    	ans[i] = (int *)malloc( numRows*sizeof(int) );
    

    C++使用new并初始化:

    int *(*matrix) = new int*[n];
    for (int i = 0; i < n; ++i)
    {
        matrix[i] = new int[n];
        for (int j = 0; j < n; ++j)
        {
            matrix[i][j] = 1;
        }
    }
    

    C++:
    使用vector:

    vector<vector<int>> ans;
    for( int i=0;i<n;i++ )			//n为行数
    {
    	ans.push_back( vector<int>() );
    }
    i=0;
    ans[i].push_back(int x)			//赋值操作
    

    ans.size()和 ans[0].size()来分别获取行数和列数

    二维vector的初始化:

    vector<vector<int>> ans( m,vector<int> (n) );    //m为行数,n为列数
    
    展开全文
  • C语言中二维数组动态分配内存

    万次阅读 2013-09-01 13:01:49
    最近《数据结构》看到哈夫曼树的构造一部分的...这就涉及到二维数组内存的动态分配问题,先来看如何给一个普通的4行5列二维数组分配内存。 [code=c] int **p; int i; if( NULL == (p = (int **)malloc(4 * sizeof(in

    最近在看《数据结构》构造哈夫曼树,构造程序使用到锯齿状数组——即一种特殊二维数组,每行的长度可能是不同的,需根据每行存放的元素个数分配。这就涉及到二维数组内存的动态分配问题,先来看个例子,给一个4行5列的二维数组分配内存。

    int **p;
    int i;
    
    
    if( NULL == (p = (int **)malloc(4 * sizeof(int *))) )
         return -1;
    
    
    for(i = 0; i < 4; i++)
    {
         if( NULL == (p[i] = (int *)malloc(5 * sizeof(int))) )
             return -1;
    }
            
    for(i = 0; i < 4; i++)
    {
         free(p[i]);
    }
    free(p);
    


    在C语言中二维数组其实是数组的数组。第5行给p分配了4个都为指向int的指针大小的内存空间(对应着二维数组的行),然后第11行分别给每行都分配5个int大小的内存空间,这些内存空间在内存中都是线性排列的。
    编译器在处理如上代码时,并不是真的就给每行分配5个int大小的内存空间,在gcc 4.7.2-2中,通常会多分配一个int大小的内存空间(如下图所示)。而在VC6.0中会多分配14个。

    gcc为如上代码中二维数组的内存分配情况如下图:

    后来不小心在程序中写了类似与p[2][50] = 7;的代码,这段代码明显数组越界了,但编译器没有报错。一直在纠结为啥会这样,如果你看了上面那副图你就知道了,其实这时p[2][50]虽然从你分配的内存空间中"越界",此时它用的是图中最后的空白区域的某一块内存,而C语言对数组不会进行越界检查,所以编译器并没有报错。


    欢迎扫码关注我的公众号,第一时间获取最新文章

     

    展开全文
  • 二维数组动态分配内存

    千次阅读 2018-08-20 21:58:52
    二维数组分配动态空间 1.已知二维数组的行(第一维) #include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include &amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; /* 已知数组的行数 ...

    #对二维数组分配动态空间


    ###1.已知二维数组的行(第一维)

    #include <stdio.h>
    #include <stdlib.h>
    
    /*	已知数组的行数
    	列数由终端输入
    */
    int main(void)
    {
    	int i,j,num;
    	int *a[3];//已知数组有3行
    	printf("请输入二位数组的列数:\n");
    	scanf("%d",&num);//列数由终端输入
    	for(i=0;i<3;i++)
    	a[i] = (int *)malloc(sizeof(int)*num);//分配每一行中列的空间
    	for(i=0;i<3;i++)
    	{
    		for(j=0;j<num;j++)
    		{
    			scanf("%d",&a[i][j]);
    		}
    	}
    	for(i=0;i<3;i++)
    	{
    		for(j=0;j<num;j++)
    		{
    			printf("%4d",a[i][j]);
    		}
    		printf("\n");
    	}
    	for(i=0;i<3;i++)
    	free(a[i]);
    	return 0;
    }
    

    ###2.已知二维数组的列(第二维)

    #include <stdio.h>
    #include <stdlib.h>
    
    /*	已知数组的列数
    	行数由终端输入
    */
    int main(void)
    {
    	int i,j,num;
    	int (*a)[3];//已知数组有3列
    	printf("请输入二位数组的行数:\n");
    	scanf("%d",&num);//行数由终端输入
    	a = (int (*)[3])malloc(sizeof(int *)*num);//分配行的空间
    	for(i=0;i<num;i++)
    	{
    		for(j=0;j<3;j++)
    		{
    			scanf("%d",&a[i][j]);
    		}
    	}
    	for(i=0;i<num;i++)
    	{
    		for(j=0;j<3;j++)
    		{
    			printf("%4d",a[i][j]);
    		}
    		printf("\n");
    	}
    	free(a);
    	return 0;
    }
    

    ###3.已知数组的行数,一次分配所有空间

    #include <stdio.h>
    #include <stdlib.h>
    
    /*	已知数组的行数
    	一次分配所有空间
    */
    int main(void)
    {
    	int i,j,num;
    	int *a[3];//已知数组有3行
    	printf("请输入二位数组列数:\n");
    	scanf("%d",&num);//行数由终端输入
    	a[0] = (int *)malloc(sizeof(int)*num*3);//分配总的空间,以a[0]为起始地址
    	for(i=0;i<num*3;i++)
    	{
    		scanf("%d",a[0]+i);
    	}
    	for(i=0;i<num*3;i++)
    	{
    		printf("%4d",*(a[0]+i));
    		if((i+1)%num==0) printf("\n");//为了行列显示
    	}
    	free(a[0]);
    	return 0;
    }
    

    ###4.行列都未知

    #include <stdio.h>
    #include <stdlib.h>
    
    /*
    	行列都未知
    */
    int main(void)
    {
    	int i,j,num,n;
    	int **a;
    	printf("请输入二位数组的行数:\n");
    	scanf("%d",&num);//行数由终端输入
    	printf("请输入二位数组的列数:\n");
    	scanf("%d",&n);//列数由终端输入
    	a = (int **)malloc(sizeof(int *) * num);//分配指针数组
    	for(i=0;i<num;i++)
    	{
    		a[i] = (int *)malloc(sizeof(int) * n);//分配每个指针所指向的数组
    	}
    	
    	for(i=0;i<num;i++)
    	{
    		for(j=0;j<n;j++)
    		{
    			scanf("%d",&a[i][j]);
    		}
    	}
    	for(i=0;i<num;i++)
    	{
    		for(j=0;j<n;j++)
    		{
    			printf("%4d",a[i][j]);
    		}
    		printf("\n");
    	}
    	free(a);
    	return 0;
    }
    

    ###5.行列都未知,一次分配所有空间

    #include <stdio.h>
    #include <stdlib.h>
    
    /*	行列都未知
    	一次分配所有空间
    */
    int main(void)
    {
    	int i,j,num,n;
    	int **a;
    	printf("请输入二位数组行数:\n");
    	scanf("%d",&num);//行数由终端输入
    	printf("请输入二位数组列数:\n");
    	scanf("%d",&n);//列数由终端输入
    	a = (int **)malloc(sizeof(int *) * num);//分配指针数组
    	a[0] = (int *)malloc(sizeof(int) * num * n);//分配总的空间,以a[0]为起始地址
    	for(i=0;i<num*n;i++)
    	{
    		scanf("%d",a[0]+i);
    	}
    	for(i=0;i<num*n;i++)
    	{
    		printf("%4d",*(a[0]+i));
    		if((i+1)%n==0) printf("\n");//为了行列显示
    	}
    	free(a[0]);
    	free(a);
    	return 0;
    }
    

    无需说明的说明:这次不再运行了!!

    展开全文
  • C语言为二维数组动态分配内存的问题

    万次阅读 多人点赞 2013-09-07 22:57:22
    C语言中动态分配一位数组是...假设要为一个n*m的二维数组分配动态内存   首先需要注意的是,不要这样一次性分配为数组内存空间: int **arr = (int**)malloc(n * m * sizeof(int)); 正确的做法是先分配行,再分配列。
  • 最近遇到了一个螺旋矩阵的问题,需要用到二维数组,由此研究下二维数组动态分配。在这之前首先要了解二维指针。原文参见二维数组指针 引用块内容 三种二维指针的表示方法 (1)、int **Ptr; (2)、int *Ptr[ 5...
  • 指针数组、数组指针、二维数组动态分配内存 2016-03-22 22:59 838人阅读 评论(0) 收藏 举报  分类: C(7) C++(12)  目录(?)[+] 1. 二维数组动态分配和释放 1. 已知第...
  • C 二维数组动态分配和释放 (1)已知第二维 Code-1 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char *) * m); printf("%d\n", sizeof(a));//4,指针 ...
  • 今天最算法project时遇到需要使用一个动态数组,并且这个数组在编译时还是不知道大小的,到底能不能给二维数组动态分配空间,我还真没试过。是不是跟一维数组一样?用int *ar = new int[n][m],试了一下不行。 后来...
  • C 二维数组动态分配和释放

    千次阅读 2015-02-11 10:18:25
    转载自:... C 二维数组动态分配和释放 (1)已知第二维 Code-1 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char *) * m); printf("%d\n", sizeof(a));//4,指针 prin
  • //动态分配 char **a; a = new char* [m];//分配指针数组 for(int i=0; i<m; i++) a[i] = new char[n];//分配每个指针所指向的数组 //删除内存 for(i=0; i<m; i++) delete[] a[i]; delete[] a; ...
  • 准备遍历SD卡目录下的文件,并且在LCD上显示...//一个二维数组指针 u8 **p; //假设有10个文件 u8 file_count=10; //假设最长文件名10个字符 u8 maxname=10; p=(u8**)malloc(sizeof(u8*)*file_count);//申
  • C++动态二维数组分配空间的问题 含程序和方法
  • 首先,我们一般需要用到数组的时候,都是直接声明,比如: 1 int array[3][3];  但是,在某些情况下,数组的维数我们是不知道的,可能是等待用户输入维数,这时候需要用变量来...我们一步一步来,申请一维数组
  • 二维数组动态分配

    千次阅读 2014-09-28 15:48:56
    下面给出几种二维数组分配方式。 注:二维数组行坐标、列坐标都是通过m,n来传递的。 1. 利用一维数组分配方式,模拟二维数组 其实栈上二维数组仍然是个连续的内存空间,只不过在访问时做了相应的处理。那么...
  • 今天我们来聊聊二维数组及其二维数组动态内存分配关知识。 1.数组的基本定义 我们都知道,数组是典型的线性存储,是一种最基本的存储表示方法, 把逻辑上相邻的元素存储在物理位置相邻的存储单元中,由此得到的...
  • c语言二维数组定义域动态分配空间  在定义数组时,会经常涉及到二维数组的定义。而当数组初始大小为动态时,我们就需要动态的为数组分配空间分配空间的函数为malloc()或者calloc()。calloc()跟malloc()的区别...
  •  下面三种定义形式怎么理解?怎么动态分配空间? (1)、int **Ptr; (2)、int *Ptr[ 5 ]; 我更喜欢写成 int* Prt[5];...多维数组一向很难,一般都采用一维...闲话少说,这里我就以三个二维数组的比较来展开讨论:  
  • C++ 二维数组 在连续的空间分配二维数组
  • 对于二维数组和二维指针的内存的分配 这里首选说一下一维指针和一维数组的内存分配情况。 一维: 数组:形如int a[5];这里定义了一个一维数组a,并且数组的元素个数是5,这里的a是这五个元素的整体表示,也就是...
  • //二维数组动态数组分配和释放 //数组指针的内存分配和释放 //方法一 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char [N]) * m); free(a); //方法二 char **a; int i;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,976
精华内容 24,790
关键字:

二维数组动态分配空间