C语言基础教程（6）动态分配内存

最新推荐文章于 2021-05-22 07:29:37 发布

LyncDwight

最新推荐文章于 2021-05-22 07:29:37 发布

阅读量315

点赞数

分类专栏： C语言

本文链接：https://blog.csdn.net/hc1151310108/article/details/82686131

版权

C语言专栏收录该内容

32 篇文章 1 订阅

订阅专栏

动态分配内存

动态内存分配 (所有高级语言，没有C里深刻，对JAVA、C#理解有益)

传统数组的缺点：

1.数组长度必须事先指定，而且只能是常整数，不能是变量

例子 int a[5]; //必须事先指定，而且只能是常整数

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

2.传统形式定义的数组，该数组的内存程序员无法手动释放

数组一旦定义，系统为数组分配的内存空间就会一直存在，除非数组所在的函数运行终止。

在一个函数运行期间，系统为该函数中的数组分配的空间会一直存在。

直到该函数运行完毕时，数组的空间才会被系统自动释放（不是清零）。

例子：void f(void){ int a[5]={1,2,3,4,5};....}

//数组a 占20个字节的内存空间，程序员无法手动编程释放它，数组a只能在f()函数结束被系统释放

3. 数组的长度一旦定义，数组长度就不能再更改。

数组的长度不能在函数运行的过程中动态的扩充或缩小

4. 传统方式定义的数组不能跨函数使用

A函数定义的数组，只有在A函数运行期间才可以被其他函数使用，

但A函数运行完毕后，A函数中的数组将无法在被其他函数使用。

#include<stdio.h>

void g(int * pArr, int len){

    pArr[2] = 88; //parr[2]==a[2] 等价于

}

void f(void){

    int a[5] = {1,2,3,4,5}; //数组a 只在f()执行时有效

    g(a,5);

    printf("%d\n", a[2]);

}

int main(void){

    f(); // 结果： 88

    //printf("a[0] = %d\n", a[0]); // error

    return 0;

}

为什么需要动态分配内存

很好的解决的了传统数组的4个缺陷

动态内存分配举例_动态数组的构造难点

/*  
    malloc是memory(内存) allocate(分配)的缩写   动态内存空间是怎么造出来的？
*/

#include <stdio.h>
#include <malloc.h>


int main(void){

    int i = 5; //分配了4个字节，静态分配

    int * p = (int *)malloc(100);

    /*

        1. 要使用malloc函数，必须要添加malloc.h头文件

        2. malloc函数只有一个形参，并且形参是整型

        3. 100表示请求系统为本程序分配100个字节

        4. malloc函数只能返回第一个字节的地址，但此时并不能确定该变量的类型，只有将这个地址被强制
           类型转化成存放整型变量的地址，这时才传达出指向整型变量的信息。

        5. 系统总共分配了104个字节的内存空间,p变量本身占4个字节（静态分配），p所指向的内存占100
           个字节（动态分配） 若为int 则可存25个，若为char则可存100个变量。

        6. p本身所占的内存是静态分配的，p所指向的内存是动态分配的

    */

    free(p);   

    //free(p)表示把p说指向的内存空间给释放掉，

    //p本身的内存不能释放，只有main函数终止时，由系统自动释放

    *p = 5;

    //*p代表的就是一个这int变量，*p这个整型变量的内存分配方式和int i =5;不同。

    //*p是内存是动态分配的， int i是静态的。

    printf("同志们好！\n");


    return 0;

}

/*
    目的： malloc使用_2
*/


#include <stdio.h>
#include <malloc.h>

void f(int * q) //q是p的拷贝或副本 q等价于p *q等价于*p *q=200则*p=200
{

    //*p = 200; //error f()没有p变量，p是在main()函数定义的

    // q = 200;  //error q是指针变量（地址），200是整数int

    *q = 200;   //OK！类型一致

    //  * *q  语法错误 ！*q整型变量， 只有指针变量前可以加*

    //free(q);  //把q指向的内存释放掉

}

int main(void)
{

    int * p = (int *)malloc(sizeof(int));    //sizeof(int)=4;

    *p = 10;

    printf("%d\n", *p); //10

    f(p);

    printf("%d\n", *p); //200

    // f()函数中 free(q)作用后,则输出 -572662307（垃圾值）

    return 0;

}

/*
    目的：动态一维数组示例 

    realloc(pArr, 100)

    //扩充动态内存空间 (原来50变100；原来150变100)

    //保留原来动态内存中未被截取的内容
*/


#include <stdio.h>
#include <malloc.h>

int main(void)
{

    //int a[5]; //系统静态地分配20个字节的空间给数组a

    int len;

    int *pArr;


    printf("请输入你要存放的元素个数：" );

    scanf ("%d", &len); //5

    pArr = (int *)malloc(4*len);    //pArr指向这20个字节动态空间的前4个字节

    /* 
    动态的构造了一个一维数组，该数组的长度len， 数组名是pArr, 数组元素类型是int

    类似与int pArr[len]; len可以根据需要变化
    */

   

    //对一维数组进行操作，如：对动态一维数组进行赋值

    for (int i=0; i<len; ++i)

        scanf("%d", &pArr[i]);  

    printf("动态数组元素为: \n");

   
    //对一维数组进行输出

    for (i=0; i<len; ++i)

        printf("%d\n", pArr[i]);

   
    free(pArr); //动态空间被释放


    printf("%d\n", *(pArr+1)); 

    //动态空间被释放，原来动态数组数元素内容为垃圾值-572662307


    return 0;

}


/*------------在VC++6.0输出结果：

请输入你要存放的元素个数：4

4 6 8 10

动态数组元素为:

4

6

8

10

*/

使用动态数组的优点:

1.动态数组长度不需要事先给定；

2.内存空间可以手动释放；

3.在程序运行中，动态内存空间大小可以通过realloc函数手动扩充或缩小

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

静态内存是由系统自动分配，有系统自动释放
静态内存是在栈分配的
动态内存是由程序员手动分配、手动释放
动态内存是在堆分配的

 /*
   目的： 多级指针  --  自己画几个示意图  就会豁然开朗。
 */

#include <stdio.h>

int main(void){

   int i = 10;     // i

   int * p = &i;      // 最终 *p就是 i;   

   int* *q = &p;  // q 只能存放 int *类型的地址 即p 的地址&p       

   int** *r = &q;  // r 只能存放  int **类型的地址 即q 的地址&q


   //r = &p; //error! 因为r是int***类型，只能存放int **类型变量的地址

   printf("i = %d\n", ***r); //*r = q; **r = *q =p  ***r = **q = *p = i;

   printf("i = %d\n", **q); //*q = p ;  **q = *p  === i

   printf("i = %d\n", *p); //*p = i;

   printf("i = %d\n", i);

   return 0;

}


/*-----------在VC++6.0输出结果：

i = 10

i = 10

i = 10

i = 10

*/

#include <stdio.h>

//多级指针在函数中的应用

void f(int ** q){

   **q = 100;  //*q就是p

}

void g(){

   int i = 10;

   int * p = &i;

   printf("i = %d  *p = %d\n", i, *p);

   f(&p); //p是int *类型   &p就是int ** 类型

   printf("i = %d  *p = %d\n", i, *p);

}

int main(void){

   g();

   return 0;

}

/*

   -----------在VC++6.0输出结果：

   i = 10   *p = 10

   i = 100  *p = 100

*/

#include <stdio.h>
#include <malloc.h>

void f(int * q) //q是p的拷贝副本
{

   *q = 1;

}

void g(int **r){

   **r = 2;

}

void h(int ***s){

   ***s = 3;

}

void i(int ****t){

   ****t = 4;

}

//要想修改函数变量的值，只能发送该变量的地址,修改一个以上的值，必须用指针

int main(void){ 

   int *p = (int *)malloc(4);

   printf("*p = %d\n", *p);    //垃圾值

   f(p); //调用的是指针

   printf("*p = %d\n", *p);    //1

                  
   g(&p);//调用的是指针变量的地址

   printf("*p = %d\n", *p);    //2


   //h(&(&p));// error C2102: '&' requires l-value 

   int **pp = &p; //pp是存放p地址的指针， int ** 整型指针的指针类型

   h(&pp); //调用的是存放p指针的指针的地址   int ***整型指针的指针的指针类型

   printf("*p = %d\n", *p);    //3

  
   int ***ppp = &pp;

   i(&ppp);//调用的是一个三级指针的指针的地址，int **** 整型四级指针

   printf("*p = %d\n", *p);    //4

   return 0;

}

跨函数使用内存的问题难点

/*
   目的：跨函数使用内存

   函数内的静态空间，不能被其他函数调用访问

*/

#include <stdio.h>

void f(int **q) //理解为 int* *q
{
       int i =5;

       //*q等价于p     *p和**q都不等价于p

       //*q = i;       //error *q等价于p 推出 p=i; 错！

       *q = &i;        //**q = *p = i;

}

int main(void){

       int *p;

       f(&p);

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

       return 0;
}

/*结果：5

   本语句语法没有问题，但逻辑上有问题

   内存越界：程序访问了一个不该被访问的内存  

   函数内的静态空间，不能被其他函数调用访问

   函数中的内存空间，随函数终止而被释放。

   内存空间释放后的内容不属于其他函数，其他函数无权限访问。

   但释放后的内存空间的地址是可以被其他函数读取的。

   但指针变量可以存贮任何函数中静态内存空间的地址，p都能存垃圾，p想存谁存谁。

   只是它此时已经没有权限读取（访问） i这个地址的数据了，出错。

*/

/* 
   目的：动态内存可以跨函数访问

   程序运行在栈顶进行

   静态空间是在栈里面分配的，函数终止本质叫做出栈，所以静态空间随着函数终止而释放，

   动态空间是在堆里面分配的，与栈无关，与函数终止无关，不随着函数终止而释放。

   堆和栈相关深入知识就需要《数据结构》和《操作系统》两门课学习，而这两门课难度大，理论性强，短期内    
   收不到立竿见影的成效，属于内功心法，因此大多培训班已经取消了学习。

   可以用free()释放
*/

#include <stdio.h>
#include <malloc.h>

void f(int ** q)   //*q等价p 已经声明了q的类型为int **
{

   *q = (int *)malloc(sizeof(int));//sizeof(整数类型)
    
/*
    不要用4，因为c语言只规定short int字节数 小于 int字节数 小于 long int字节数，没有规定明确的
    字节数，无统一硬性规定。     

    不同软件系统可能出现不同，统一用sizeof(int)来获取实际值

    int * p;在p声明的情况下,

    构造动态空间也可以写成 p = (int *)malloc(sizeof(int));

*/

   // *q等价p, 等价于 p = (int *)malloc(sizeof(int));

   //  q = 5;  //error! q指针

   // *q = 5;  //error! p = 5

     **q = 5;  //OK! 等价于 *p = 5
}


int main(void){

   int * p;

   f(&p);  //只有调用变量的地址，才能改变变量的值

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

   //f函数中，没有free(q);所以动态空间仍然保留，动态空间中的内容可以被访问

   return 0;

}

/*

-----------在VC++6.0输出结果：

5

*/

LyncDwight

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
C语言基础教程（6）动态分配内存

动态分配内存动态内存分配 (所有高级语言，没有C里深刻，对JAVA、C#理解有益) 传统数组的缺点：1.数组长度必须事先指定，而且只能是常整数，不能是变量例子 int a[5]; //必须事先指定，而且只能是常整数 int len = 5; int a[len];//error 2.传统形式定义的数...
复制链接

扫一扫