精华内容
下载资源
问答
  • 问:为什么要动态分配内存 答1:因为内存太宝贵。 答2:如果全部是静止内存不能释放,对于小的程序可以运行完毕。但是对于大的程序,还没运行完,内存就要被占用完,此时就要发生内存泄露。 答3:给定一个占用...

    问:为什么要动态分配内存

    答1:因为内存太宝贵。

    答2:如果全部是静止内存不能释放,对于小的程序可以运行完毕。但是对于大的程序,还没运行完,内存就要被占用完,此时就要发生内存泄露。

    答3:给定一个占用内存可变大小的变量(假设是数组的长度len),给该变量通过函数动态分配内存后,分配内存的大小是根据数组的长度len决定的,假定用户输入len的大小是5,系统就会动态的给该数组分配长度为5的内存,该段代码运行结束后,系统调用free()函数释放分配的内存,然后接着运行剩下的程序。换句话说,动态分配内存可以根据需要去申请内存,用完后就还回去,让需要的程序用。

    问:什么时候需要动态分配内存

    答:当程序中有比较大的数据块需要使用内存的时候使用。原因:比较大的数据块如果使用了静态内存,在该数据块运行完毕后不能动态的释放该内存,直到整个程序运行完才能释放,如果整个程序比较大,有可能因为内存不够而发生错误。

    问:难道不可以在该静态分配的内存使用完后,使用free()函数释放吗?

    答:不可以,首先malloc() 函数和free()函数必须是配套使用,其次free()函数不能释放普通变量,只能释放指针。

    问:什么时候需要动态分配内存(网友整理:https://blog.csdn.net/sinat_39085247/article/details/74356820

    答:什么时候我们需要动态分配内存空间呢?举一个例子吧。int *p; 我们定义了一个指向int类型的指针p;p是用来储存一个地址的值的,我们之所以要为p这个变量分配空间是让它有一个明确的指向,打个比方吧!你现在做好了一个指向方向的路标,但是你并没有让这个路标指向一个确切的方位,也就是说现在的这个路标是瞎指向的,这样我们就不能够通过它来明确到底哪里是东,哪里是西,何为北,何为南了。虽然我们在计算机的内存里定义了一个指针变量,但是我们并没有让这个变量指示一个确切int类型变量的地址,所以我们就必须要让它有一个明确的指示方向。这样我们就要通过动态分配内存的方式来认为的规定它的方向!

         计算机内存的四大区域:栈区,常量区,全局区,堆区(动态分配)

    1. 栈   区:在栈里面储存一些我们定义的局部变量以及形参;
    2. 常量区:主要是储存一些字符常量;
    3. 全局区:在全局区里储存一些全局变量和静态变量;
    4. 堆       :堆主要是通过动态分配的储存空间;

    以数组为例子来说明动态分配和释放内存

    #include<stdio.h>
    #include<malloc.h>
    int main()
    {
    	int len;//定义数组的长度
    	int *pArr=(int *)malloc(sizeof(int)*len);
    	for(int i=0;i<len;++i)
    		scanf("%d"\n,&pArr[i]);
    	for(i=0;i<len;++i)
    		printf("%d\n",*(pArr+i));
        free(pArr);  //pArr指向数组的首地址
        pArr = NULL;
        /*...
        剩余代码
        ...*/
    	return 0;
    	
    }

    问:为什么malloc函数前面需要int *的强制转换?

    答:因为程序需要告诉编译器malloc函数返回值的第一个字节是int *类型的还是其他类型的。

    1:代码中的malloch函数分配内存,在该段代码运行完后,通过free()函数释放,被释放的内存空间留着可以被剩余代码接着利用。

    2:同时当我们使用malloc()函数的时候还应该注意当我们释放完空间的时候还要将原先的指针变量赋予一个NULL,也就是赋予一个空指针,留着下次的时候使用它!如果我们不赋予|NULL行不行呢??答案是:不行的!如果我们不赋予一个空指针这样会导致原先的指针变量成为了一个野指针,何谓野指针?野指针就是一个没有明确指向的指针,系统不知道它会指向什么地方,野指针是很危险的,因此当我们每次使用完malloc()函数的时候都必须将指针赋予一个空指针!

    展开全文
  • 程序执行的时候是需要堆和栈,动态分配的空间是在堆中,程序中的局部变量等是在栈中,xilinx的SDK会默认的将堆和栈设置为1024个字节,这对我们需要使用比较大的内存来说是比较小的,毕竟我们已经使用了DDRSDRAM,动辄...
     
    

    xilinx的工具很强大,在XPS中生成硬件环境后直接生成BSP,基于BSP可建立C语言和C++工程,这里我们很容易跑一个Hello World程序,但是,有时执行自己的程序,得不到想要的结果,仔细检查代码,可能发现与hello world不同的地方也就是在于使用了一个较大的数组或是使用new 关键字或是malloc关键字分配了一个较大的内存,但明明在配置硬件时使用的DDR SDRAM,程序应该在SDRAM上执行才对,而DDR一般容量很大,不可能出现这个问题,仔细分析发现SDK在链接代码时使用了一个lscript.ld



    程序执行的时候是需要堆和栈,动态分配的空间是在堆中,程序中的局部变量等是在栈中,xilinx的SDK会默认的将堆和栈设置为1024个字节,这对我们需要使用比较大的内存来说是比较小的,毕竟我们已经使用了DDRSDRAM,动辄几百兆,故我们只需要根据自己需要将堆栈调大点即可



    展开全文
  • 在C中动态分配内存的基本步骤有: 1,用malloc类的函数分配内存; 2,用这些内存支持应用程序 3,用free函数释放内存 二、动态内存分配函数  malloc :从堆上分配内存  realloc : 在之前分配的内存块的基础上,将内存...

    #include<stdio.h>

    /**
    在C中动态分配内存的基本步骤有:
    1,用malloc类的函数分配内存;
    2,用这些内存支持应用程序
    3,用free函数释放内存
    二、动态内存分配函数
        malloc :从堆上分配内存
        realloc : 在之前分配的内存块的基础上,将内存重新分配为更大或者更小的部分
        calloc: 从堆上分配内存并清零
        free:将内存块返回堆
    */
    void mainaa()
    {
        int *pi = (int*) malloc(sizeof(int));
        *pi = 5;
        printf("*pi:%d\n",*pi);
        free(pi);
    }
    //为字符串分配内存,将其初始化,并逐个字符打印字符串,然而每次迭代name都会增加1,最后name会指向字符串结尾的NUL字符,
    //分配内存的起始地址丢失了
    void mainbb()
    {
        //为10个双精度浮点数分配空间,需要80个字节
        //double *pd = (double*)malloc(NUMBER_OF_DOUBLES*sizeof(double));
        //以下程序只分配了10个字节
        const int NUMBER_OF_DOUBLES = 10;
        double *pd = (double*)malloc(NUMBER_OF_DOUBLES);

        //初始化静态或全局变量时不能调用函数,下面的代码声明一个静态变量,并试图用
        //malloc来初始化,这样会产生一个编译时错误消息
        //static int *pi = malloc(sizeof(int));

        char *name = (char*)malloc(strlen("Susan")+1);
        strcpy(name,"Susan");

        while(*name != 0){
            printf("%c",*name);
            name++;
        }
    }
    /**
        使用calloc函数
        calloc会在分配的同时清空内存,该函数的原型如下:void *calloc(size_t numElements,size_t elementSize);
        calloc函数会根据numElements和elementSize两个参数的乘积来分配内存,并返回一个指向内存的第一个字节的指针。如果不能分配内存
        则返回null,此函数最初用来辅助分配数组内存。
        如果numElements或elementSize为0,那么calloc可能返回空指针。如果calloc无法分配内存就会返回空指针,而且全局变量errno会设置为ENOMEM(内存不足),
        这是POSIX错误码,有的系统上可能没有
    **/
    void maincc()
    {
        //下面两端代码都是为pi分配了20字节,全部包含0
        //int *pi = calloc(5,sizeof(int));

        //int *pi = malloc(5*sizeof(int));
        //memset(pi,0,5*sizeof(int));

        /**
            memset函数会用某个值填充内存块,第一个参数是指向要填充的缓冲区的指针,第二个参数是填缓冲区的值,最后一个参数是要填充的字节数。
            如果内存需要清零可以使用calloc,不过执行calloc可能比执行malloc慢。cfree函数已经没用了。
        */
    }
    /**
        realloc函数
        realloc函数会重新分配内存,原型:void *realloc(void *ptr,size_t size);
        realloc函数返回指向内存块的指针。该函数接受两个参数,第一个参数是指向原内存块的指针,第二个是请求的大小。重新分配的块大小和第一个参数
        引用的块大小不同。返回值是指向重新分配的内存的指针。
        请求的大小可以比当前分配的字节数小或者大。如果比当前分配的小,那么多余的内存会还给堆,不能保证多余的内存会被清空。如果比当前分配的大,
        那么可能的话,就在紧挨着当前分配内存的区域分配新的内存,否则就会在堆的其他区域分配并把旧的内存复制到新区域。
        如果大小是0而指针非空,那么就释放内存。如果无法分配空间,那么原来的内存块就保持不变,不过返回的指针是空指针,且errno会设置为ENMOEM,
    **/
    void maindd()
    {
        /**
            下例使用两个变量为字符串分配内存。一开始分配16个字节,但只用到了前面的13个字节(12个十六进制数字外加null结束字符(0))
        */
        char *string1;
        char *string2;
        string1 = (char*)malloc(16);
        strcpy(string1,"0123456789AB");
        
        /**
            紧接着,用realloc函数指定一个范围更小的内存区域。然后打印这两个变量的地址和内容
        */
        string2 = realloc(string1,8);
        printf("string1 value:%p [%s]\n",string1,string1);
        printf("string2 value:%p [%s]\n",string2,string2);
    }
    /**
        alloca函数和变长数组
        alloca函数(微软为malloca)在函数的栈帧上分配内存。函数返回后会自动释放内存。若低层的运行时系统不基于栈,
        allocal函数会很难实现,所以这个函数时不标准的,如果应用程序需要可移植就尽量避免使用它。
        C99引入了变长数组(VLA),允许函数内部声明和创建其长度由变量决定的数组,比如:
        void compute(int size){
            char * buffer[size];
            ...
        }
        这意味着内存分配在运行时完成,且将内存作为栈帧的一部分来分配。另外,如果数组用到sizeof操作符,也是在运行时而不是编译时执行。
        这么做只会有一点小小的运行时开销。而且一旦函数退出,立即释放内存。因为我们没有用malloc这类函数来创建数组,所以不应该用free函数来
        释放它。alloca函数也不应该返回指向数组所在内存的指针,但是可以解决。
        VLA的长度不能改变,一经分配其长度就固定了。
    **/

    /**
        动态内存分配技术
        1,资源获取即初始化
        资源获取即初始化(Resource Acquisition Is Initialization,RAII)是Bjarne Stroustrup发明的技术,可以用来解决C++中资源的分配和释放。
        即使有异常发生,这种技术也能保证资源的初始化和后续的释放。分配的资源最终总是会得到释放。
        有好几种方法可以在C中使用RAII。GNU编译器提供了非标准的扩展来支持这个特性,通过演示如何在一个函数中分配内存然后释放可以说明这种
        扩展。一旦变量超出作用域会自动触发释放过程。
        GNU的扩展需要用到RAII_VARIABLE宏,它声明一个变量,然后给变量关联如下属性
            1,一个类型。
            2,创建变量时执行的函数。
            3,变量超出作用域时执行的函数。
        这个宏如下所示:
            #define RAII_VARIABLE(vartype,varname,initval,dtor)\
                void _dtor_ ## varname (vartype * v){dtor(*v);}\
                vartype varname __attribute__((cleanup(_dtor_ ## varname))) = (initval)
        在下例中,我们将name变量声明为字符指针。创建它时会执行malloc函数,为其分配32字节。当函数结束时,name超出作用域就会执行free函数:
        void raiiExample(){
            RAII_VARIABLE(char*,name,(char*)malloc(32),free);
            strcpy(name,"RAII Example");
            printf("%s\n",name);
        }
        函数执行后会打印"RAII_Example"字符串。不用GNU扩展也可以达到类似效果。
        2、使用异常处理函数
        另外一种处理内存释放的方法是利用异常处理。尽管异常处理不属于标准C,但如果可以使用它且不考虑移植问题,它会很有用。下面说明利用
        Microsoft Visua Studio版的C语言的方法。
        这里的try块包含任何可能在运行时抛出异常的语句。不管有没有异常抛出,都会执行finally块,因此也一定会执行free函数。
        void exceptionExample(){
            int *pi = NULL;
            __try{
                pi = (int*)malloc(sizeof(int));
                *pi = 5;
                printf("%d\n",*pi);
            }
            __finally{
                free(pi);
            }
        }
    */

    展开全文
  • 堆栈与动态分配内存空间

    千次阅读 2017-11-04 14:30:55
    C/C++的动态分配内存空间。

            在开发过程中,我们往往是没办法一开始就决定好存储空间的,除非把存储空间开辟得足够大,但这不切实际。所以我们经常会遇到需要动态分配存储空间的时候,既然常用,那我便记录一下C/C++的动态分配内存空间。打算以常用的动态分配数组为例说明。不过在说明之前,还是先搞清我们程序的内存是在哪儿分配的。简要说明如下:

            程序代码——存放在代码区;

            全局变量、static变量——存放在静态存储区(全局区);

            常量——存放在常量区;

            局部变量、函数形参——存放在栈上;

            程序员自己分配的——存放在堆上;

            更多堆栈内容可以查看这位大神的博客(链接)讲解很全面。

            另外,C语言中内在分布及程序运行中的BSS段、数据段、代码段、堆和栈的概念详情可见这位大神的博客(链接)。

            下面进行动态数组分配,先写C语言,C语言动态内存分配/释放数组,主要依靠malloc、free函数,成对出现,不然容易堆溢出,头文件<malloc.h>

    //C语言动态内存分配/释放数组,主要依靠malloc、free函数,成对出现,不然容易堆溢出,头文件<malloc.h>
    
    #include <stdio.h>
    #include <malloc.h>
    
    int main()
    {
    	int n,i;
    	printf("请输入数组大小:\t");
    	scanf("%d",&n);
    	int *p=(int *)malloc(n*sizeof(int));//在空闲内在池中分配连续内存n*sizeof(int)个字节的堆内存空间
    	if(p!=NULL)
    	{
    		printf("数组大小为%d,内存申请成功,下面对数组赋值并输出\n",n);
    		for(i=0;i<n;i++)
    		{
    			*(p+i)=i;
    			printf("%d\t",*(p+i));
    		}
    		free(p);
    	}
    	else
    	{
    		printf("内存分配失败\n");
    	}
    	return 0;
    
    }

    下面是C++内存分配:

    //C++动态内存分配/释放,主要依靠new、delete运算符,必须成对出现
    
    #include <iostream>
    using namespace std;
    
    int main()
    {
    	int n,i;
    	int *p;
    	cout<<"请输入数组大小:\t"<<endl;
    	cin>>n;
    	p = new int[n];
    	if(p!=NULL)
    	{
    		cout<<"申请内存成功,数组大小为"<<n<<endl;
    		for(i=0;i<n;i++)
    		{
    			*(p+i)=i;
    			cout<<*(p+i)<<endl;
    		}
    	}
    	else
    	{
    		cout<<"申请内存失败!"<<endl;
    	}
    	delete []p;
    	return 0;
    }


    展开全文
  • 动态内存分配 (详解版)

    千次阅读 多人点赞 2021-03-18 20:31:27
    动态内存分配 (详解版) malloc和free C++语言允许使用C语言标准库函数中malloc和free申请和释放内存,保留这两个函数主要有以下3点考虑: C++程序经常要调用写好的C函数,而在C语言中,只能使用malloc和free; ...
  • C/C++动态分配内存

    千次阅读 多人点赞 2018-04-05 13:41:36
    https://blog.csdn.net/Errors_In_Life/article/details/78889951https://blog.csdn.net/a573233077/article/details/50518909https://blog.csdn.net/weiwenhp/article/details/80065871.  需要动态分配...
  • C/C++ 动态内存分配

    万次阅读 多人点赞 2019-06-30 18:03:06
    首先我们看看 c 语言是如何进行动态内存分配的; c 语言主要是使用malloc / calloc / realloc 来进行内存申请的。 malloc / realloc / calloc三者的共同点与不同点: 共同点 1、都是从堆上进行动态内存分配 2、...
  • 动态分配内存

    千次阅读 2016-08-23 16:26:57
    所谓动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间,而是由系统根据程序的需要即时分配,且分配的大小就是...
  • 数组大小分配动态内存分配

    千次阅读 2020-02-22 21:31:40
    在使用数组的时候,总是有一个问题,数组应该有多大?...这种分配固定大小内存分配的方法称为静态内存分配。但是这种分配方法存在比较严重的缺陷,特别是处理某些问题时,在大多数情况下会浪费大量的...
  •  数组的长度是定义好的,在整个程序中固定不变。c++不允许定义元素个数不确定的数组。例如: 1 2 int n; int a[n]; //这种定义是不允许的  但是在实际编程中,往往会出现要处理的数据...
  • C语言动态内存分配函数

    万次阅读 多人点赞 2019-06-02 23:46:57
    目录 1.malloc()2.free()3.calloc()4.realloc()5....所开辟的内存是在栈中开辟的固定大小的 ,如a是4字节 ,数组b是40字节 ,并且数组在申明时必须指定其长度 , 因为数组的内存是在编译时分配好的 . 如果我们想在...
  • 对于MAC OS,Linux,Windows系统,malloc 的请求系统都知道,程序退出时,系统会回收malloc 的所有资源。这个是编译器智能释放内存。当然有些内存系统是...所谓动态内存,是由malloc系列函数进行申请的内存,除非在...
  • 动态内存分配函数

    千次阅读 2018-03-28 21:43:28
    一、静态存储分配动态存储分配: 二、动态内存分配函数 malloc calloc realloc free new delete
  • *所谓动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间,而是由系统根据程序的需要即时分配,且分配的大小就是...
  • 动态内存分配(malloc)详解

    万次阅读 多人点赞 2020-09-11 10:18:05
    也就是说,malloc()分配内存,但没有为它指定名字。 然而,它却可以返回那块内存第一个字节的地址。 因此,可以把那个地址赋值给一个指针变量,并使用该指针来访问那块内存。 因为char代表一个字节,所以传统上...
  • 我们知道程序在运行的过程中是需要占用一定内存的,一般程序所需要的内存由操作系统来分配,由操作系统分配的,自然需要由操作系统回收。但是在实际开发中,用户可以通过一些函数人为地申请内存,再由用户来释放,...
  • 动态分配内存与静态内存

    千次阅读 2016-06-03 22:23:22
    动态分配内存是在运行时完成的,动态内存的分配与释放需要占用CPU资源; 2) 静态内存分配是在栈上分配的,动态内存是堆上分配的; 3) 动态内存分配需要指针或引用数据类型的支持,而静态内存分配不需要; 4) 静态...
  • 内存的静态分配动态分配的区别主要是两个: **一是时间不同。**静态分配发生在程序编译和连接的时候。动态分配则发生在程序调入和执行的时候。 **二是空间不同。**堆都是动态分配的,没有静态分配的堆。栈有2种...
  • Qt动态分配内存的内存回收规则

    千次阅读 2017-03-04 23:04:04
    在Qt的程序中经常会看到只有new而不delete的情况,其实是因为Qt有一套回收内存的机制,主要的规则如下: 1.所有继承自QObject类的类,如果在new的时候指定了父亲,那么它的清理时在父亲被delete的时候delete的,...
  • 静态内存分配动态内存分配

    千次阅读 2019-05-25 14:05:02
    静态内存分配动态内存分配 动机 平时看c/c++的书籍时,总会看到一种观点,说是C/C++语言使用的时候动态内存分配是最重要的,使用malloc等函数分配内存必须要释放,否则及其容易出现内存泄露。但是自己有时候挺...
  • 笔者为C语言新手,想分享...作用:动态开辟byte_size个字节的内存空间,不进行初始化,返回指向此内存的指针,此指针所指数据类型没有确定,需要强转。 举例:int *p=(int *)malloc(5*sizeof(int)); 例解:动态开...
  • 静态分配和动态分配内存的区别

    千次阅读 2014-12-14 17:11:39
    要弄懂这个问题,首先你得知道静态和动态指的是什么。个人觉得卡耐基上的解释很经典:  “The word static refers to things that happen at compile time and link time when the program is constructed—as ...
  • 程序结束时,动态内存会释放吗

    千次阅读 2016-01-19 22:47:34
    所谓动态内存,是由malloc系列函数进行申请的内存,除非在程序中使用free释放,否则该段内存不会被释放掉。 从这个角度来说,即使进程结束,该段内存也会被占用。这种现象被称为内存泄露。 2 大多数操作系统可以...
  • c语言 什么时候需要动态分配内存

    千次阅读 多人点赞 2017-07-04 20:47:44
    我讲解一下c语言中动态分配内存的函数,可能有些初学c语言的人不免要问了:我们为什么要通过函数来实现动态分配内存呢?系统难道不是会自动分配内存吗?? 既然有人会问这样的问题,那么我在这里好好的讲解一下吧!...
  • 【C++札记】动态分配内存(malloc,free)

    千次阅读 2017-07-16 11:08:42
    MM提供的服务:应用程序可以向MM申请一块指定大小的内存(借出),用完之后应用程序应该释放(还回)。 所需头文件 <stdlib.h> 如: void* p = malloc(1024);//申请,从MMM借出内存 free(p); //释放,还回MM ...
  • 如何在程序运行的时候动态程序分配内存? 文章目录1 动态内存分配的意义1.1 C语言中如何动态申请内存空间1.2 malloc和free的用法1.3 calloc与realloc1.31 calloc和realloc的代码案例分析2 总结 1 动态内存分配...
  • 动态内存分配的C代码示例

    千次阅读 2016-09-02 20:58:05
    之前有同学在QQ上问我,...首先,我们来看看内存分配的概念,它是指在程序执行的过程中分配或者回收存储空间的方法。一般说来,内存分配方法分为静态内存分配动态内存分配两种。在本文中,我们主要讨论动态内存分配
  • 动态分配(dynamic allocation)是程序在运行中取得内存的方法。指针为C的动态分配系统提供必要的支持。全局变量是编译时分配的,而非静态的局部变量使用栈空间,两者都不能在运行中增减。然而,程序在运行中也可能...
  • Linux中动态内存分配与回收

    千次阅读 2018-05-16 20:10:20
    1.malloc 和free的原理(http://m.blog.csdn.net/article/details?id=39496057)从操作系统角度来看,进程分配内存有两种方式,分别由两个系统调用完成:brk和mmap(不考虑共享内存)。1、brk是将数据段(.data)的...
  • 在C++中为数组动态分配内存

    千次阅读 2015-06-02 18:14:00
    在C++中为数组动态分配内存的格式如下:   第一步:声明  type (p)[常量1][常量2]...[常量n]; 第二步:申请  p=new type[x][常量1][常量2]...[常量n]; 说明:先定义一个n维的数组指针,其中p是一个指针...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 974,538
精华内容 389,815
关键字:

动态分配内存程序