精华内容
下载资源
问答
  • 动态分配数组

    2014-10-10 15:37:00
    动态分配数组 动态数组的声明让我们运行程序时选择自己的大小。动态分配数组,我们使用新的和删除数组形式(通常称为新的[ ]和[ ]删除): 1 2 3 4 int nSize = 12; int *pnArray = new int[nSize]; // note: ...

    注意,删除操作不会删除该指针-它删除指针所指向的内存

    动态分配数组

    动态数组的声明让我们运行程序时选择自己的大小。动态分配数组我们使用新的和删除数组形式(通常称为新的[ ][ ]删除

    1
    2
    3
    4
    int nSize = 12;
    int *pnArray = new int[nSize]; // note: nSize does not need to be constant!
    pnArray[4] = 7;
    delete[] pnArray;

    因为我们是分配一个阵列,C++知道应使用新的而不是新的标量版阵列版。从本质上讲,新的运营商称为[ ][ ]即使放在旁边的新关键字

    当删除动态分配的数组,我们不得不使用阵列版本删除,并删除[ ]。这会告诉CPU需要清理的多变量而不是一个单一的变量

    值得注意的是,数组的访问做同样的方式与动态分配的数组与普通数组。虽然这看起来有点滑稽因为pnarray显式声明为指针记住阵列是真的只是在C++中指针

    最常见的一个错误就是新的程序员在处理动态内存分配是使用删除而不是删除[ ]当删除动态分配的数组。不这样做!使用标量版本的阵列上的删除会导致数据损坏或其它问题

    内存泄漏

    动态分配的内存实际上没有范围。那是,它保持分配直到显式释放或直到程序结束。然而,指针用于访问动态内存分配遵循正态变量的作用域规则。这种不匹配可以创造出有趣的问题

    考虑下面的函数


    展开全文
  • 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语言静态分配数组和动态分配数组

    千次阅读 2016-08-04 12:56:26
    C语言静态分配数组和动态分配数组: 1.静态分配数组: 指定数组的维数值: const unsigned array_size = 3; int ia[array_size] = {0,1,2}; 或: int ia[array_size] = {0}; ...
    C语言静态分配数组和动态分配数组:


    1.静态分配数组:


    指定数组的维数值:

    const unsigned array_size = 3;


    int ia[array_size] = {0,1,2};


    或:


    int ia[array_size] = {0};


    不指定数组的维数值:


    int ia[] = {0,1,2};


    字符串数组初始化:

    char ca1[] = {'C','+','+'};     //数组维数 = 3,没有'\0'


    char ca2[] = {'C','+','+','\0'};  //数组维数 = 4,显示'\0'


    char ca3[] = "C++";      //数组维数 = 4 ,字符串后面有'\0'




    2.动态分配数组:

    一维:


    int *array = (int *)malloc(sizeof(int)*n);

    int *p = array;


    二维:


    int **array = (int **)malloc(sizeof(int)*row);


    for(i = 0; i < row; ++i){


    array[i] = (int *)malloc(sizeof(int)*col);


    }


    int **p = array;


    展开全文
  • vc++动态分配数组

    2021-04-02 11:42:59
    vc++动态分配数组 vc++不允许数组名为变量,如double a[b];否则会报错。 可采用动态数组来改正:double *a=new double[b]; 动态指针数组 double *a[b]; 可改为 double **a=new double *[b];

    vc++动态分配数组
    vc++不允许数组名为变量,如double a[b];否则会报错。
    可采用动态数组来改正:double *a=new double[b];
    最后释放内存: delete[] a;a=NULL;

    动态指针数组
    double *a[b];
    可改为 double **a=new double *[b];

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

    2019-07-30 15:30:34
    我们最常用的数组分配方式就是使用 int array[] ={1,2,3,4}来分配固定长度的数组,但是当需要动态分配数组长度的时候怎么办呢?最近在使用的时候就遇到了,然后自己搜了搜相关的使用方法。 1.先介绍基本数据类型的...
  • C语言中动态分配数组(一维)当初学Pascal的时候就想过这个问题:如何动态的定义及使用数组呢?记得一般用数组的时候都是先指定大小的。当时问老师,老师说是不可以的。后来又问了一位教C++的老师,他告诉我在C++里用...
  • C++中使用关键字new动态分配数组

    千次阅读 2018-07-02 10:16:44
    1 动态分配的格式使用new动态分配数组的格式为new 类型[数组大小]此时,返回值是指定类型的指针。以下代码动态分配了一个整形数组,该数组包含10个元素,其首地址保存在指针pia中。int* pia = new int[10];需要注意...
  • 3. 动态分配数组

    2014-05-12 13:32:00
    3. 动态分配数组 3.1 当编程时很难为数组估计大小,可以在运行程序时,动态为程序分配大小。3.2 动态分配数组大小和分配字符串大小相似,可以使用sizeof来计算数据类型占用的字节数,再来分配,例如:int *a = ...
  • 数组的大小是固定的, 不变的,一旦确定就不能改变。 但此程序的技巧就在于突破了数组大小的固定,实现了动态分配数组。 谢谢支持!
  • 关于c++的动态分配数组

    千次阅读 2019-03-18 16:05:56
    通常我们借助指针来给动态分配数组 一维数组 int n; cin &amp;gt;&amp;gt; n; int *a = new int[n] 二维数组 int n; cin &amp;gt;&amp;gt; n; int **a = new int*[n]; for(int i = 0 ;i &amp;...
  • c++ 动态分配数组

    2020-08-30 16:04:02
    动态分配一维数组 int n=5; int *array=new int[n];//!!!!!!1 //删除数组指针 delete[]array;//不要忘了括号,否则只会删除第一个单元 动态分配二维数组 //!!!动态分配二维数组!!! int n=10; int **memo = new int*...
  • 动态分配数组 动态分配一维或多维数组的方法是由指针管理数组,二维以上的数组按一维数组方式来处理,步骤: 1、定义指针 p ; 2、分配数组的空间,用来存储数组的元素,空间大小暗元素个数计算 3、按一维数组方式...
  • c++动态分配数组空间

    2020-07-19 09:53:39
    c++动态创建数组 malloc 创建一维数组 int *p=(int*)malloc(n*sizeof(int)); 创建二维数组 int **p; cin>>n; p=(int**)malloc(n*sizeof...n表示要创建数组的大小 ...动态分配一维数组: int n=3; vector<
  • 动态分配数组内存赋值后,怎样得到数组的行数和列数 在做项目的时候遇到了动态分配数组内存赋值后,怎样得到数组的行数和列数的问题,下面给大家分享一下我解决这个问题的过程。 1. 首先按普通的数组,我们是怎么...
  • 今天做项目遇到一个这样的问题,我要把查询出来...其实也很简单,我们也经常用的,就是把ArrayList当作动态数组来用就可以了,DEMO:ArrayList array = new ArrayList();下面是从网上检索到的具体用法:Java动态数组...
  • 在java数组中,长度是固定的。可以使用列表保存值并调用toArray方法如果需要,请参见以下示例:importjava.util.List;importjava.util.ArrayList;importjava.util.Random;publicclassA{publicstaticvoidmain(String...
  • 以下是在堆上创建2D数组(或动态分配2D数组)的不同方法。在以下示例中,我们将“r”视为行数,将“c”视为列数,并创建了一个二维数组,其中r = 3,c = 4,并遵循以下值 1 2 3 4 5 6 7 8 9 10 11 121.使用单个指针:...
  • 环境:Win10 x64,VS2015 问题:最近项目用到C++ 调用 Fortran,传参是多维数组...分析:查阅资料才知道,数组动态分配内存有两种方式: 方法1: void malloc2D_1(int **&a) { a = new int*[xDim]; for(int i.
  • 动态分配数组C++模板

    2017-06-02 14:36:42
    通过动态分配的方法实现了动态数组的创建,其中包括多种运算符重载。
  • 对于二维数组:一般来说,当给两个数分别表示行列,但两个数的范围过大,就需要动态分配。 int i,j,m,n; scanf("%d%d",&amp;m,&amp;n); int **a; a=(int**)malloc(sizeof(int*)*m); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,988
精华内容 4,395
关键字:

动态分配数组