关于学习NDK基础知识这些就够了（三）

一、内存分配：
对象可以使用静态 或 动态的方式分配内存空间。
静态分配：编译器在处理程序源代码时分配。
动态分配：程序在执行时调用malloc库函数申请分配。

1. 区别

   1、静态内存分配是在程序执行之前进行的因而效率比较高，而动态内存分配则可以灵活的处理未知数目的。
   2、静态对象是有名字的变量，可以直接对其进行操作；动态对象是没有名字的变量，需要通过指针间接地对它进行操作。
   3、静态对象的分配与释放由编译器自动处理；动态对象的分配与释放必须由程序员显式地管理，它通过malloc()（开辟空间）和free（释放内存）两个函数（C++中为new和delete运算符）来完成。

   以下是采用静态分配方式的例子：
   int a=100;

   此行代码指示编译器分配足够的存储区以存放一个整型值，该存储区与名字a相关联，并用数值100初始化该存储区。

   以下是采用动态分配方式的例子。
   p1 = (char *)malloc(10*sizeof(int));//分配得来得10*4字节的区域在堆区

   此行代码分配了10个int类型的对象，然后返回对象在内存中的地址，接着这个地址被用来初始化指针对象p1，对于动态分配的内存唯一的访问方式是通过指针间接地访问，其释放方法为

2. C语言内存分配：
   1.栈区(stack)：不同的操作系统下，分配的栈的内存大小不一样。例如windows下，栈内存分配2M（确定的常数），超出了限制，提示stack overflow错误，栈内存的特性是：自动分配，释放
   2.堆区(heap)：程序员手动分配释放，操作系统80%内存
   3.全局区或静态区
   4.字符常量区
   5.程序代码区

3. 代码实例

//栈内存
void stackFun(){
    int a[1024];
    //栈内存自动释放
}

//堆内存
void heapFun(){
    //40M内存
    //字节
    //void *任意类型的指针
    int* p = malloc(1024 * 1024 * 10 * sizeof(int));

    //释放
    free(p);
}

void main(){    
    //在堆内存上，分配40M的内存
    while (1){
        Sleep(1000);    
        stackFun();
    }

    getchar();
}

注意我们的关键字：malloc 开辟内存空间

//创建一个数组，动态指定数组的大小
//（在程序运行过长中，可以随意的开辟指定大小的内存，以供使用，相当于Java中的集合）
//静态内存分配，分配内存大小的是固定，
//问题：1.很容易超出栈内存的最大值 
//     2.为了防止内存不够用会开辟更多的内存，容易浪费内存
//动态内存分配，在程序运行过程中，动态指定需要使用的内存大小，手动释放，释放之后这些内存还可以被重新使用
/*
void main(){
    //静态内存分配创建数组，数组的大小是固定的
    //int i = 10;
    //int a[i];

    //动态创建数组
    int len;
    printf("输入数组的长度：");
    scanf("%d",&len);

    //开辟内存，大小len*4字节
    int* p = malloc(len * sizeof(int));
    //p是数组的首地址，p就是数组的名称
    //给数组元素赋值（使用这一块刚刚开辟出来的内存区域）
    int i = 0;
    for (; i < len - 1; i++){
        p[i] = rand() % 100;//随机数
        printf("%d,%#x\n", p[i], &p[i]);
    }

    //手动释放内存
    free(p);

    getchar();
}
*/

动态分配内存中的重新分配内存：关键字：realloc

void main(){
    int len;
    printf("第一次输入数组的长度：");
    scanf("%d", &len);

    //int* p = malloc(len * sizeof(int));   
    int* p = calloc(len, sizeof(int));//另一种开辟内存的方式，我们一般用malloc开辟
    int i = 0;
    for (; i < len; i++){
        p[i] = rand() % 100;
        printf("%d,%#x\n", p[i], &p[i]);
    }

    int addLen;
    printf("输入数组增加的长度：");
    scanf("%d", &addLen);//C语言中的输入函数，与小黑框交互

    //内存不够用，扩大刚刚分配的内存空间
    //1.原来内存的指针 2.内存扩大之后的总大小        
    int* p2 = realloc(p, sizeof(int) * (len + addLen));
    if (p2 == NULL){
        printf("重新分配失败，世界那么大，容不下我。。。");
    }

    //重新赋值
    i = 0;
    printf("--------------------------\n");
    for (; i < len + addLen; i++){
        p2[i] = rand() % 200;
        printf("%d,%#x\n", p2[i], &p2[i]);
    }

    //手动释放内存
    if (p != NULL){
        free(p);//如果只调用free 内存释放了，但是p还是有值得，需要手动写为NULL
        p = NULL;
    }   
    if (p2 != NULL){
        free(p2);
        p2 = NULL;
    }

    getchar();
}

注意：
    重新分配内存的两种情况：


 - 缩小

缩小，缩小的那一部分数据会丢失

 - 扩大
     扩大，（连续的）
     1.如果当前内存段后面有需要的内存空间，直接扩展这段内存空间，realloc返回原指针
    2.如果当前内存段后面的空闲字节不够，那么就使用堆中的第一个能够满足这一要求的内存块，将目前的数据复制到新的位置，并将原来的数据库释放掉，返回新的内存地址
    3.如果申请失败，返回NULL，原来的指针仍然有效

void main(){
int len;
printf(“输入数组的长度：”);
scanf(“%d”, &len);

int* p = malloc(len * sizeof(int));     
int i = 0;
for (; i < len; i++){
    p[i] = rand() % 100;
    printf("%d,%#x\n", p[i], &p[i]);
}

if (p != NULL){
    free(p);
    p = NULL;
}

getchar();

}
“`

内存分配的几个注意细节
1.不能多次释放
2.释放完之后（指针仍然有值），给指针置NULL，标志释放完成
3.内存泄露（p重新赋值之后，再free，并没有真正释放内存）