精华内容
下载资源
问答
  • 分析两种动态分配二位数组的方法,其原理一致。 0. 动态分配一维数组int a[rows] #include <stdlib.h> int main{void} { ... int *a = (int *)malloc(rows * sizeof(int));//分配一段内存,...

    分析两种动态分配二位数组的方法,其原理一致。

    0. 动态分配一维数组int a[rows]

    #include <stdlib.h>
    
    int main{void}
    {
        ...
    
        int *a = (int *)malloc(rows * sizeof(int));//分配一段内存,存放rows个int型的数据
        
        ...
    }

    1. 动态分配内容不一定连续的二维数组a[rows][columns]

    #include <stdlib.h>
    
    int main{void}
    {
        ...
    
        int **a = (int **)malloc(rows * sizeof(int *));//分配一个指针数组有rows个元素,数组的每一个元素是一个数组指针
        
        for(i = 0;i < rows; i++)
        {
          a[i] = (int *)malloc(columns * sizeof(int));//为每数组指针分配columns个存放int型数据的内存
        }
    
        ...
    }

    2. 分配连续的二维数组a[rows][columns]

    #include <stdlib.h>
    
    int main{void}
    {
        ...
    
        int **a = (int **)malloc(rows * sizeof(int *));//分配一个指针数组有rows个元素,数组的每一个元素是一个数组指针
        
        a[0] = (int *)malloc(rows * columns * sizeof(int));//分配存放rows * columns个int型数据的数组,a[0]加1则移动1个int型数据的空间,此处a[0]表示int型数据的地址
        
        for(i = 1;i < rows; i++)
        {
          a[i] = a[0] + i * columns;//每行有columns个int型元素,所以rows每加1,地址加i * columns 
        }
    
        ...
    }

     

     

    展开全文
  • C语言动态分配数组

    万次阅读 多人点赞 2018-06-21 12:57:42
    很多人在编写C语言代码的时候很少使用动态数组,不管什么情况下通通使用静态数组的方法来解决,在当初学习C语言的时候我就是一个典型的例子,但是现在发现这是一个相当不好的习惯,甚至可能导致编写的程序出现一些...

    很多人在编写C语言代码的时候很少使用动态数组,不管什么情况下通通使用静态数组的方法来解决,在当初学习C语言的时候我就是一个典型的例子,但是现在发现这是一个相当不好的习惯,甚至可能导致编写的程序出现一些致命的错误。尤其对于搞嵌入式的人来所,嵌入式系统的内存是宝贵的,内存是否高效率的使用往往意味着嵌入式设备是否高质量和高性能,所以高效的使用内存对我们来说是很重要的。那么我们在自己编写C语言代码的时候就应该学会使用动态数组,这也就是我这篇博客要给大家讲的,我尽我所能的用一些简单的代码来讲解动态数组,希望我所讲的对你有所帮助。

    那么我们首先来看看什么是动态数组,动态数组是相对于静态数组而言,从“动”字我们也可以看出它的灵活性,静态数组的长度是预先定义好的,在整个程序中,一旦给定大小后就无法改变。而动态数组则不然,它可以随程序需要而重新指定大小。动态数组的内存空间是从堆动态分配的。是通过执行代码而为其分配存储空间。当程序执行到我们编写的分配语句时,才为其分配。对于静态数组,其创建非常方便,使用完也无需释放,要引用也简单,但是创建后无法改变其大小是其致命弱点!对于动态数组,其创建麻烦,使用完必须由程序员自己释放,否则将会引起内存泄露。但其使用非常灵活,能根据程序需要动态分配大小。所以相对于静态数组的来说我们对于使用动态数组有很大的自由度。

    在创建动态数组的过程中我们要遵循一个原则,那就是在创建的时候从外层往里层,逐层创建;而释放的时候从里层往外层,逐层释放。这个话你读了可能理解并不深刻,不过不要急,接下来我们看看两段代码。

    一维动态数组的创建:

    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
    int n1,i;
    int *array;
    printf("请输入所要创建的一维动态数组的长度:");
    scanf("%d",&n1);
    array=(int*)calloc(n1,sizeof(int));
    for(i=0;i<n1;i++)
    {
     printf("%d\t",array[i]);
    }
    printf("\n");
    for(i=0;i<n1;i++)
    {
     array[i]=i+1;
     printf("%d\t",array[i]);
    }
     free(array);//释放第一维指针 
    return 0;
    }

    运行结果为:

     

    二维数组的创建:

    #include <iostream>
    #include <stdlib.h>
    using namespace std;
    
    int main(){
    	int num1,num2;
    	cout<<"请输入动态二维数组的第一个维度:";
    	cin>>num1;
    	cout<<"请输入动态二维数组的第二个维度:";
    	cin>>num2;
    	int **array = (int **)calloc(num1,sizeof(int));
    	for(int i=0;i<num1;i++) {
    		array[i] = (int*)calloc(num2,sizeof(int));
    	}
    	for(int i=0;i<num1;i++){
    		for(int j=0;j<num2;j++){
    			array[i][j] =i*num2+j+1;
    			printf("%d\t",array[i][j]);
    		}
    		cout<<endl;
    	}
    	for(int i=0;i<num1;i++)	free(array[i]);
    	free(array);
    	return 0;
    }

    运行结果为:

     请输入所要创建的动态数组的第一维长度:3
    请输入所要创建的动态数组的第二维长度:3
    1       2       3
    4       5       6
    7       8       9
    Press any key to continue

    有了上面的代码我们再来说动态数组的建立就简单了,以二维为例,先说创建,还记得我们上面说的创建的原则嘛:从外层往里层,逐层创建。

    array=(int**)malloc(n1*sizeof(int*)); //第一维

    以上是我们创建二维动态数组的最外层,创建好了最外层那么我们接下来就是要创建次外层了。这里使用了二级指针。

    array[i]=(int*)malloc(n2* sizeof(int));//第二维

    在创建次外层的过程中我们使用了一个for语句,千万别忘了使用for循环语句,这是绝大多数人的一个易错点。

    创建好了接下来我们该讲到释放了,而释放的时候从里层往外层,逐层释放。刚刚与我们上面的创建相反,在以上代码中我们首先使用了下面一个for循环来释放里层。

    for(i=0;i<n1;i++) 

    free(array[i]);//释放第二维指针 
    }

    在通过以下语句来释放外层。
    free(array);//释放第一维指针

    如果出现多维的情况怎么做呢,我们接下来再来看看一个三维动态数组的创建和释放,以加深下读者的印象。代码如下:

    #include <stdlib.h> 
    #include <stdio.h> 
    int main() 
    { 
    int n1,n2,n3; 
    int ***array; 
    int i,j,k; 
    printf("请输入所要创建的动态数组的第一维长度:");
    scanf("%d",&n1); 
    printf("请输入所要创建的动态数组的第二维长度:");
    scanf("%d",&n2); 
    printf("请输入所要创建的动态数组的第三维长度:");
    scanf("%d",&n3); 
    array=(int***)malloc(n1*sizeof(int**));//第一维 
    for(i=0; i<n1; i++) 
    { 
    array[i]=(int**)malloc(n2*sizeof(int*)); //第二维 
    for(j=0;j<n2;j++) 
    { 
    array[i][j]=(int*)malloc(n3*sizeof(int)); //第三维 
    } 
    } 
    for(i=0;i<n1;i++)
    {
    for(j=0;j<n2;j++)
    {
    for(k=0;k<n3;k++) 
    { 
    array[i][j][k]=i+j+k+1; 
    printf("%d\t",array[i][j][k]); 
    } 
    printf("\n");
    }
    printf("\n");
    }
    for(i=0;i<n1;i++) 
    { 
    for(j=0;j<n2;j++) 
    { 
    free(array[i][j]);//释放第三维指针 
    } 
    } 
    for(i=0;i<n1;i++) 
    { 
    free(array[i]);//释放第二维指针 
    } 
    free(array);//释放第一维指针 
    return 0; 
    }

    运行结果为:

    请输入所要创建的动态数组的第一维长度:3
    请输入所要创建的动态数组的第二维长度:3
    请输入所要创建的动态数组的第三维长度:3
    1       2       3
    2       3       4
    3       4       5

    2       3       4
    3       4       5
    4       5       6

    3       4       5
    4       5       6
    5       6       7

    Press any key to continue

    看了以上三维动态数组的创建和释放代码以后,我想读者这个时候已经可以自己编写任意维的动态数组了。但是细心的读者可能发现了一个问题,那就是我们所讲的动态数组都是一次性创建好的,如果接下来在使用的过程中我们使用的数组需要扩展或者删减一些不再使用元素该怎么办呢?!接下来我们先看一段关于动态数组扩展的代码,在此以一维动态数组的扩展为例,其它的以此类推。

    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
    int*n,*p;
    int i,n1,n2;
    printf("请输入所要创建的动态数组的长度:");
    scanf("%d",&n1); 
    n=(int*)calloc(n1,sizeof(int));
    printf("请输入所要扩展的动态数组的长度:");
    scanf("%d",&n2); 
    p=(int*)realloc(n,(n2)*sizeof(int));//动态扩充数组
    for(i=0;i<n2;i++)
    {
    p[i]=i+1;
    if(i%5==0)
    printf("\n");
    printf("%d\t",p[i]);
    }
    free(p);
    return 0;
    }

    运行结果如下:

    请输入所要创建的动态数组的长度:6
    请输入所要扩展的动态数组的长度:25

    1       2       3       4       5
    6       7       8       9       10
    11      12      13      14      15
    16      17      18      19      20
    21      22      23      24      25      Press any key to continue

     

    接下来如何缩小动态数组。

    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
    int*n,*p;
    int i,n1,n2;
    printf("请输入所要创建的动态数组的长度:");
    scanf("%d",&n1); 
    n=(int*)calloc(n1,sizeof(int));
    for(i=0;i<n1;i++)
    {
    n[i]=i+1;
    if(i%5==0)
    printf("\n");
    printf("%d\t",n[i]);
    }
    printf("\n请输入所要缩小的动态数组的长度:");
    scanf("%d",&n2); 
    p=(int*)realloc(n,(n2)*sizeof(int));
    for(i=0;i<n2;i++)
    {
    if(i%5==0)
    printf("\n");
    printf("%d\t",p[i]);
    }
    printf("\n");
    free(p);
    return 0;
    }

    运行结果为:

    请输入所要创建的动态数组的长度:25

    1       2       3       4       5
    6       7       8       9       10
    11      12      13      14      15
    16      17      18      19      20
    21      22      23      24      25
    请输入所要缩小的动态数组的长度:15

    1       2       3       4       5
    6       7       8       9       10
    11      12      13      14      15
    Press any key to continue

    在这里值得注意的一点就是在缩减动态数组的时候,它是删除了后面的元素,而前面的元素保持不变。在使用realloc()函数的时候要由其注意它的使用规则。

     

    讲到这儿就到了该说结束的时候了,由于本人水平有限,博客中的不妥或错误之处在所难免,殷切希望读者批评指正。同时也欢迎读者共同探讨相关的内容,如果乐意交流的话请留下你宝贵的意见。

    展开全文
  • C语言动态分配数组

    2019-07-30 15:30:34
    我们最常用的数组分配方式就是使用 int array[] ={1,2,3,4}来分配固定长度的数组,但是当需要动态分配数组长度的时候怎么办呢?最近在使用的时候就遇到了,然后自己搜了搜相关的使用方法。 1.先介绍基本数据类型的...

    最近在研究C语言相关的东西,遇到了一些问题,主要是关于数组内存分配的问题。我们最常用的数组分配方式就是使用 int array[] ={1,2,3,4}来分配固定长度的数组,但是当需要动态分配数组长度的时候怎么办呢?最近在使用的时候就遇到了,然后自己搜了搜相关的使用方法。
    1.先介绍基本数据类型的创建方法
    int array;
    printf(“请输入数组的长度:”);
    scanf("%d",&n);
    array=(int
    )calloc(n,sizeof(int));//calloc()表示分配n*sizeof(int)长度的内存
    2.结构体的创建方法
    typedef struct str
    {
    int a;
    char b;
    }str;
    int array;
    printf(“请输入数组的长度:”);
    scanf("%d",&n);
    array=(int
    )calloc(n,sizeof(str));//这里直接使用sizeof(str)就行了。

    展开全文
  • 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语言对数组不会进行越界检查,所以编译器并没有报错。

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

    万次阅读 多人点赞 2013-09-07 22:57:22
    C语言中动态分配一位数组是很简单的,但是没有可以直接对二维数组进行动态分配的函数,因此,要相对二维数组动态分配内存,便要借助于一位数组来实现,具体如下:   假设要为一个n*m的二维数组分配动态内存   首先...
  • c语言动态分配数组

    2012-12-28 14:22:00
    /*c语言动态数组,运行时确定数组元素个数。*/ #include <stdio.h> #include <malloc.h> int main(void) { int *p; int n; /*运行时分配内存*/ scanf("%d", &n); p = (int *)...
  • 1、一维数组动态分配内存:int num[5] 源码: int main(void) { // 使用动态内存分配一个数组为 int num[5] int *num = NULL; int len = 5; num = (int *)malloc(len * sizeof(int)); for (int i = 0; i &...
  • 我们都知道要实现根据程序的需要动态分配存储空间,在C中需要使用到stdlib.h中的两个函数,malloc,free,两个函数的介绍如下: malloc函数的原型为: void *malloc (u igned int size) 其作用是在内存的动态...
  • 通过动态内存分配实现c语言动态指针"数组". 其实这种结构并非是一种数组,只是手动实现的一种类似数组的结构,实现类似数组的功能。应该可以说是一种伪数组结构吧。 #include <stdio.h>#include <...
  • 1、一维数组动态分配内存:int num[5]源码:int ① num = (int *)malloc(len * sizeof(int));在堆区分配了5个int型的内存空间,并将该内存空间的首元素地址返回给指针num,创建了一个数组为int num[5],如下图所示:...
  • 手把手入门C语言动态创建数组首先实现用户输入输出数组使用 realloc 函数扩展数组长度 首先实现用户输入输出数组 #include <stdio.h> #include <stdlib.h> /** 动态创建数组 动态数组的创建 1...
  • 1、一维数组动态分配内存:int num[5]源码:int main(void) { // 使用动态内存分配一个数组为 int num[5] int *num = NULL; int len = 5; num = (int *)malloc(len * sizeof(int)); for (int i = 0; i < ...
  • int **countArr = (int **)malloc(sizeof(int*)*row);...关于memset函数,常用于给一块连续内存空间初始化,虽然传入的第二个参数指明了初始化的值,但实际使用的时候通常只能初始化为0。 因为memset是按字节
  • C语言 动态分配内存

    2021-04-19 08:47:34
    C语言 动态分配内存 动态内存管理 callco free malloc realloc 动态内存的常见问题 重述:指针的用法 1)提供访问存储在数组中的信息的另一种方法 2)提供另一种(更有效的)向函数传递参数的方法 3)启用动态数据...
  • 我们都知道要实现根据程序的需要动态分配存储空间,在C中需要使用到stdlib.h中的两个函数,malloc,free,两个函数的介绍如下: malloc函数的原型为: void *malloc (u igned int size) 其作用是在内存的动态存储区...
  • 输入n,m. n表示n*n数组, m表示相邻m个...动态分配数组内存, 然后计算m个数相乘的最大值. 例如 输入 3 2 21 22 23 20 00 11 17 06 15 得出 506 问下m个数相乘求最大值怎么写啊 只会写两个数相乘..... 谢谢啦
  • 普通的动态内存分配只能分配一维的数组: 例如: #define ARRAY_SIZE 1024 ; unsigned char * pa = NULL ; pa = (unsigned char *)malloc(ARRAY_SIZE) ; 然后就可以pa[1], pa[0] ...当成一维数组操作了。 释放的...
  • #include "stdio.h" #include #include #define NULL 0 void **darray_new(int row, int col, int ...//size是每个分配元素内存的空间 {  void **arr;  arr = (void **) malloc(sizeof(void *) * row + si
  • 查余补漏:在前几次的讲解中,有朋友提出C语言内存分配只是malloc和free,然后还有在缓存章节的有朋友提出的内存四区,所以我在说数组之前,先进行补漏。我们前面在说内存分配的时候,并没有明确的说明内存四区的...
  • 请实现一个简单的动态数组,能够随时改变大小,不会溢出,也不会浪费内存空间。 下面的代码实现了简单的动态数组: #include #include int main() { //从控制台获取初始数组大小 int N; int *a; int i; ...
  • 【C语言】C语言动态分配内存

    千次阅读 多人点赞 2015-06-12 11:39:56
    C语言动态分配内存  一维数组 #include #include #include int main() { int i = 0; int N = 0; int *arr = NULL; scanf("%d",&N); arr = (int *)malloc(N*sizeof(int)); memset(arr,0,N*sizeof(int));...
  • C语言中的动态数组

    2021-03-14 09:47:31
    动态数组内存空间是从堆动态分配的。是通过执行代码而为其分配存储空间。当程序执行到我们编写的分配语句时,才为其分配。对于静态数组,其创建非常方便,使用完也无需释放,要引用也简单,但是创建后无法改变其...
  • C语言动态分配内存

    2016-05-21 14:09:37
    C语言中不允许动态数组类型。 例如: int n; scanf(“%d”,&n); int a[n]; 用变量表示长度,想对数组的大小作动态说明,这是错误的。但是在实际的编程中,往往会发生这种情况,即所需的内存空间取决于实际输入...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,428
精华内容 571
关键字:

c语言动态分配内存数组

c语言 订阅