问：为什么要动态分配内存
 
答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类型变量的地址，所以我们就必须要让它有一个明确的指示方向。这样我们就要通过动态分配内存的方式来认为的规定它的方向！
 
     计算机内存的四大区域：栈区，常量区，全局区，堆区（动态分配）
 
栈   区：在栈里面储存一些我们定义的局部变量以及形参；
常量区：主要是储存一些字符常量；
全局区：在全局区里储存一些全局变量和静态变量；
堆       ：堆主要是通过动态分配的储存空间；
以数组为例子来说明动态分配和释放内存
 
#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的工具很强大，在XPS中生成硬件环境后直接生成BSP，基于BSP可建立C语言和C++工程，这里我们很容易跑一个Hello World程序，但是，有时执行自己的程序，得不到想要的结果，仔细检查代码，可能发现与hello world不同的地方也就是在于使用了一个较大的数组或是使用new 关键字或是malloc关键字分配了一个较大的内存，但明明在配置硬件时使用的DDR SDRAM，程序应该在SDRAM上执行才对，而DDR一般容量很大，不可能出现这个问题，仔细分析发现SDK在链接代码时使用了一个lscript.ld
 

 
 

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

 
 

 

#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);
         }
     }
 */

        在开发过程中，我们往往是没办法一开始就决定好存储空间的，除非把存储空间开辟得足够大，但这不切实际。所以我们经常会遇到需要动态分配存储空间的时候，既然常用，那我便记录一下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;
}