【指针】-7

动态内存分配

1. 传统数组的缺点
2. 为什么需要动态分配内存
3. 动态内存分配举例，动态数组的构造
4. 静态内存和动态内存的比较
5. 跨函数使用内存的问题

传统数组的缺点：

• 数组长度必须实现制定，且只能是长整数，不能是变量

例子：

int a[5];
int len= 5;int a[len];//error

• 传统形式定义数组，该数组的内存程序员无法手动释放，数组一旦定义，系统为该数组分配的存储空间就一直存在，除非数组所在的函数运行结束；在一个函数运行期间，系统为该数组分配的存储空间就一直存在，直到该函数运行完毕时，数组的空间才会释放。。。

void f(void)
{
    int a[5] = { 1,2,3,4,5 };
    //20个字节的存储空间程序员无法手动编程释放它
    //它只能在本函数运行完毕时由系统自动释放，f完毕
}

int main()
{
    return 0;
}

• 数组的长度一旦定义，不能在函数运行的过程中动态的扩充或者缩小
• A函数定义的数组，在A函数运行期间可以被其他函数使用，但A函数运行完毕之后，A函数中的数组将无法再被其他函数使用

void g(int *p, len)
{
    p[2] = 88;
}

void f(void)
{
    int a[5] = { 1,2,3,4,5 }；
    g(a, 5);                        
    printf("%d\n", a[2]);   

int main()
{
    return 0;
}

为什么需要动态分配内存?

动态内存解决了传统数组的4个缺陷，传统数组也叫静态数组

动态内存分配举例，动态数组的构造

int main()
{
    int i = 5;//分配了4个字节，静态分配
    int * p = (int *)malloc(4);
        /*
        1.要使用malloc函数，必须添加malloc#include <malloc.h>
        2.malloc函数只有一个形参，并且形参是整型
        3.4表示请求系统为本程序分配4个字节
        4.malloc函数只能返回第一个字节的地址
        5.int * p = (int *)malloc(4);分配了8个字节，p变量占4个字节，p所指向的内存也是占4个字节
        6.p本身所占的内存是静态分配，p所指向的内存是动态分配的
        */
    *p = 5;//*p代表的就是一个int变量，只不过*p这个整型变量的内存分配方式和int i = 5;中的i变量的分配方式不同
    free(p);//free(p)表示把p所指向的内存释放掉，p本身的内存是静态的，不能有程序员手动释放，p本身的的内存只能在p变量所在的函数运行终止时由系统自动释放

}

p指向动态分配的第一个字节的地址，*p代表整个分配的内存。（why？？？如何做得到？）

void f(int *q)
{
    //*p=200;error,不在这个函数范围
    //q=200；error
    *q = 200;
    //free(q);//把q所指向的内存释放掉了!!!
}
int main()
{
    int * p = (int *)malloc(sizeof(int));//sizeof(int)返回值是int所占的字节数
    *p = 10;

    printf("%d",*p);
    f(p);
    printf("%d\n", *p);
}

int main()
{
    int a[5];//如果int占4个字节，则本数组总共包含有20个字节，每4个字节被当做1个int变量来使用
    int len;
    int *pArr;
    int i;

    //动态构造一维数组
    printf("请输入你要存放的元素个数：");
    scanf("%d",&len);
    pArr = (int *)malloc(4 * len);//本行动态的构造了一个一维数组，该一维数组的产生是len，该数组的数组名是pArr，该数组的每个元素是int类型，该类似于 int pArr[len]
    //对于一维数组进行操作
    //对于动态一维数组进行赋值
    for (i = 0; i < len; ++i)
    {
        scanf("%d",&pArr[i]);
    }
    //对于一维数组进行输出
    printf("一维数组的内容是：\n");
    for (i = 0; i < len; ++i)
    {
        printf("%d\n", pArr[i]);
    }
    free(pArr);//释放掉动态分配的数组，跟静态数组一样，函数运行完毕释放掉
}
result:
请输入你要存放的元素个数：5
1
3
5
6
4
一维数组的内容是：
1
3
5
6
4
请按任意键继续. . .

realloc(pArr,100)，数组扩展或者缩小；第一个数组名，第二个是扩展到的数组个数

pArr指向前4个字节，pArr指向前4个字节的内容。（pArr+1）指向后四个字节，*（pArr+1）指向后四个字节的内容

静态内存和动态内存的比较

动态内存与静态内存的区别
静态内存是由系统自动分配，由系统自动释放
静态内存是在栈分配的，
动态内存是程序员手动分配，手动释放
动态内存是在堆分配的（堆排序）

多级指针

想通过r获取i的内容，则需要通过***,即***r

int main()
{
    int i = 10;
    int * p = &i;
    int **q = &p;
    int ***r = &q;
    //r = &p;因为r是***类型，r只能存放int***类型变量的地址
    printf("i=%d ", ***r);
}
result:
i=10 请按任意键继续. . .

void f(int ** q)
{
    //*q就是p，q就是p的地址
}
void g()
{
    int i = 10;
    int *p = &i;
    f(&p);//p是int*类型，&p是int **类型
}

跨函数使用内存

void f(int ** q)//q是指针变量，无论q是什么类型的指针变量，都只占4个字节
{
    *q = (int *)malloc(sizeof(int));//sizeof(数据类型)返回值是该数据类型所占的字节数
                                    //等价于p=（int*）malloc(sizeof(int))
    //q=5;//error
    //*q=5;//p=5
    **q = 5;//*p=5
}
int main()
{
    int * p;
    f(&p);//发送p的地址
    printf("%d\n", *p);//本语句语法没有问题，但逻辑上有问题//内存越界，访问到i了（f函数已经运行完毕）;静态变量不能跨函数使用
}

q1（arr[0]）指向数组第一字节，q2（arr[1]）指向数组第二个字节，相差6个字节