C语言开发之内存管理

已于 2022-03-16 17:07:26 修改
阅读量913 收藏
点赞数
分类专栏： 开发技术 文章标签： c语言 算法
于 2022-03-10 19:20:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41876213/article/details/123405692
版权

问题引入

函数exec_func(int* arr, int len)内部申请多个动态数组，当程序执行过程中出现错误时，需要将之前申请的数组全部释放掉，导致代码过于冗长。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

int exec_func(int* arr, int len){
    for(int i = 0; i < len; i++){
        arr[i] = 1;
    }
    srand((unsigned)time(NULL));
    int status = 1;
    //申请辅助数组
    int* a = (int*)malloc(sizeof(int) * len);
    //执行一些程序
    //若大于4则表示该部分代码执行失败
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行a\n");
    if(status == 0){
        free(a);
        a = NULL;
        return status;
    }
    float* b = (float*)malloc(sizeof(float) * len);
    //执行一些程序
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行b\n");
    if(status == 0){
        free(b);
        b = NULL;
        free(a);
        a = NULL;
        return status;
    }
    double* c = (double*)malloc(sizeof(double) * len);
    //执行一些程序
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行c\n");
    if(status == 0){
        free(c);
        c = NULL;
        free(b);
        b = NULL;
        free(a);
        a = NULL;
        return status;
    }
    char* d = (char*)malloc(sizeof(char) * len);
    //执行一些程序
    status = rand() % 10 > 4 ? 1 : 0;
    printf("执行d\n");
    if(status == 0){
        free(d);
        d = NULL;
        free(c);
        c = NULL;
        free(b);
        b = NULL;
        free(a);
        a = NULL;
        return status;
    }
    //后续处理相关的程序
    printf("执行后续\n");
    free(a);
    a = NULL;
    free(b);
    b = NULL;
    free(c);
    c = NULL;
    free(d);
    d = NULL;
    return status;
}

int main(){
    int len = 10;
    int* arr = (int*)malloc(sizeof(int) * 10);
    int status = exec_func(arr, len);
    if(status == 0){
        fprintf(stderr,"执行失败\n");
    }else{
        printf("执行成功\n");
    }
    return 0;
}

方案一

goto语句如下：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

int exec_func(int* arr, int len){
    for(int i = 0; i < len; i++){
        arr[i] = 1;
    }
    srand((unsigned)time(NULL));
    int status = 1;
    //申请辅助数组
    int* a = (int*)malloc(sizeof(int) * len);
    //执行一些程序
    //若大于4则表示该部分代码执行失败
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行a\n");
    if(status == 0){
        goto FREEA;
    }
    float* b = (float*)malloc(sizeof(float) * len);
    //执行一些程序
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行b\n");
    if(status == 0){
        goto FREEB;
    }
    double* c = (double*)malloc(sizeof(double) * len);
    //执行一些程序
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行c\n");
    if(status == 0){
        goto FREEC;
    }
    char* d = (char*)malloc(sizeof(char) * len);
    //执行一些程序
    status = rand() % 10 > 4 ? 1 : 0;
    printf("执行d\n");
    if(status == 0){
        goto FREED;
    }
    //后续处理相关的程序
    printf("执行后续\n");
    FREED: free(d);
    d = NULL;
    FREEC: free(c);
    c = NULL;
    FREEB: free(b);
    b = NULL;
    FREEA: free(a);
    a = NULL;
    return status;
}

int main(){
    int len = 10;
    int* arr = (int*)malloc(sizeof(int) * 10);
    int status = exec_func(arr, len);
    if(status == 0){
        fprintf(stderr,"执行失败\n");
    }else{
        printf("执行成功\n");
    }
    return 0;
}

编译执行

gcc  test_memory.c -o tm
./tm

输出

执行a
执行b
执行c
执行失败

可以看出跳转成功。
goto语句很方便解决上述问题，但是甲方要求禁用goto语句！！！

方案二

与c++中对象的思想一致，将函数中的临时变量存储到结构体struct imitation_class{}中，利用函数指针使相关函数成为结构体struct imitation_class{}的变量，类比对象的构造函数与析构函数，为结构体写初始化函数imitation_class* init_imitation_class()与销毁函数void destory_imitation_class(imitation_class** ic)。初始换函数中初始化动态数组指针为NULL，函数指针指向使用结构体内相关变量的函数，函数执行完毕后，调用析构函数统一释放内存。（注：若存在多个执行函数，考虑到内存问题，可以每执行完一个执行函数调用一次销毁函数。）

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

struct imitation_class{
    int* a;
    float* b;
    double* c;
    char* d;
    int (*__exec_func)(struct imitation_class* ic, int*, int);
};
typedef struct imitation_class imitation_class;

int __exec_func(imitation_class* ic, int* arr, int len){
    for(int i = 0; i < len; i++){
        arr[i] = 1;
    }
    srand((unsigned)time(NULL));
    int status = 1;
    //申请辅助数组
    ic->a = (int*)malloc(sizeof(int) * len);
    //执行一些程序
    //若大于4则表示该部分代码执行失败
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行a\n");
    if(status == 0){
        return status;
    }
    ic->b = (float*)malloc(sizeof(float) * len);
    //执行一些程序
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行b\n");
    if(status == 0){
        return status;
    }
    ic->c = (double*)malloc(sizeof(double) * len);
    //执行一些程序
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行c\n");
    if(status == 0){
        return status;
    }
    ic->d = (char*)malloc(sizeof(char) * len);
    //执行一些程序
    status = rand() % 10 > 4 ? 1 : 0;
    printf("执行d\n");
    if(status == 0){
        return status;
    }
    //后续处理相关的程序
    printf("执行后续\n");
    return status;
}

imitation_class* init_imitation_class(){
    imitation_class* ic = (imitation_class*)malloc(sizeof(imitation_class));
    ic->a = NULL;
    ic->b = NULL;
    ic->c = NULL;
    ic->d = NULL;
    ic->__exec_func = __exec_func;
    return ic;
}

void destory_imitation_class(imitation_class** ic){
    if(ic == NULL || *ic == NULL){
        return;
    }
    imitation_class* pic = *ic;
    if(pic->a != NULL){
        free(pic->a);
        pic->a = NULL;
    }
    if(pic->b != NULL){
        free(pic->b);
        pic->b = NULL;
    }
    if(pic->c != NULL){
        free(pic->c);
        pic->c = NULL;
    }
    if(pic->d != NULL){
        free(pic->d);
        pic->d = NULL;
    }
    free(pic);
    pic = NULL;
    return;
}

//对外函数
int exec_func(int* arr, int len){
    imitation_class* ic = init_imitation_class();
    int status = ic->__exec_func(ic, arr, len);
    destory_imitation_class(&ic);
    return status;
}

int main(){
    int len = 10;
    int* arr = (int*)malloc(sizeof(int) * 10);
    int status = exec_func(arr, len);
    if(status == 0){
        fprintf(stderr,"执行失败\n");
    }else{
        printf("执行成功\n");
    }
    return 0;
}

编译执行

gcc  test_memory.c -o tm
./tm

输出

```bash
gcc  test_memory.c -o tm
./tm

输出

执行a
执行b
执行c
执行失败

方案二变种

如果函数内的动态变量过多，可以考虑在函数执行前分配一块特别大的buffer，供后续使用。这种方式的缺点也显而易见，如果某些动态变量空间大小需要在执行之后才能确定，不可能提前计算好内存大小。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

struct imitation_class{
    char* buffer;
    int (*__exec_func)(struct imitation_class* ic, int*, int);
};
typedef struct imitation_class imitation_class;

int __exec_func(imitation_class* ic, int* arr, int len){
    //提前计算内存空间
    int len_a = len, len_b = len, len_c = len, len_d = len;
    int total_Byte = sizeof(int) * len_a + sizeof(float) * len_b 
                    + sizeof(double) * len_c + sizeof(char) * len_d;
    ic->buffer = (char*)malloc(total_Byte);
    char* pointer = ic->buffer;
    for(int i = 0; i < len; i++){
        arr[i] = 1;
    }
    srand((unsigned)time(NULL));
    int status = 1;
    //申请辅助数组
    int* a = (int*)pointer;
    pointer = (char*)((int*)pointer + len_a);
    //执行一些程序
    //若大于4则表示该部分代码执行失败
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行a\n");
    if(status == 0){
        return status;
    }
    float* b = (float*)pointer;
    pointer = (char*)((float*)pointer + len_b);
    //执行一些程序
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行b\n");
    if(status == 0){
        return status;
    }
    double* c = (double*)pointer;
    pointer = (char*)((float*)pointer + len_c);
    //执行一些程序
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行c\n");
    if(status == 0){
        return status;
    }
    char* d = (char*)pointer;
    pointer = (char*)((char*)pointer + len_c);
    //执行一些程序
    status = rand() % 10 > 4 ? 1 : 0;
    printf("执行d\n");
    if(status == 0){
        return status;
    }
    //后续处理相关的程序
    printf("执行后续\n");
    return status;
}

imitation_class* init_imitation_class(){
    imitation_class* ic = (imitation_class*)malloc(sizeof(imitation_class));
    ic->buffer = NULL;
    ic->__exec_func = __exec_func;
    return ic;
}

void destory_imitation_class(imitation_class** ic){
    if(ic == NULL || *ic == NULL){
        return;
    }
    imitation_class* pic = *ic;
    if(pic->buffer != NULL){
        free(pic->buffer);
        pic->buffer = NULL;
    }
    free(pic);
    pic = NULL;
    return;
}

//对外函数
int exec_func(int* arr, int len){
    imitation_class* ic = init_imitation_class();
    int status = ic->__exec_func(ic, arr, len);
    destory_imitation_class(&ic);
    return status;
}

int main(){
    int len = 10;
    int* arr = (int*)malloc(sizeof(int) * 10);
    int status = exec_func(arr, len);
    if(status == 0){
        fprintf(stderr,"执行失败\n");
    }else{
        printf("执行成功\n");
    }
    free(arr);
    return 0;
}

针对已经完成部分的项目而言，需要重新写结构体，初始换函数与销毁函数，再将执行函数拆分为对外函数(int exec_func(int* arr, int len))与内部函数(int __exec_func(int* arr, int len))。但是时间不宽裕，大型项目按照“问题引入"部分写了大半，不想做太多改动，怎么办呢？

方案三

引入内存管理模块！大致思想是将所有申请的内存压入链表栈中，写一个销毁链表的函数统一销毁申请的内存。
见代码：
trash.h
将所有数据类型全部转换为void**，即将动态数组头指针的地址存入value中。如果仅将动态数组头指针存入value，那么内存释放之后无法对改头指针赋值为NULL，可能导致内存释放后使用（主要原因还是释放内存不赋值为NULL不符合甲方编程规范），所以这里选择void**。

#include<stdio.h>
struct trash_node{
    void** value;
    struct trash_node* next;
};
typedef struct trash_node trash_node;

trash_node* create_trash_node();
void trash_push(trash_node* head, void** ele);
void trash_destory(trash_node** head);

trash.c

#include <stdlib.h>
#include <stdio.h>
#include "trash.h"

trash_node* create_trash_node(){
    trash_node* head = (trash_node*)malloc(sizeof(trash_node));
    if(head == NULL){
        return NULL;
    }
    head->next = NULL;
    head->value = NULL;
    return head;
}

void trash_push(trash_node* head, void** ele){
    if(head == NULL || ele == NULL){
        return;
    }
    trash_node* tmp_node = (trash_node*)malloc(sizeof(trash_node));
    if(tmp_node == NULL){
        return;
    }
    tmp_node->value = ele;
    tmp_node->next = head->next;
    head->next = tmp_node;
    return;
}

void trash_destory(trash_node** head){
    if(head == NULL || *head == NULL){
        return;
    }
    trash_node* next_node = *head;
    trash_node* free_node = *head;
    while(next_node != NULL){
        free_node = next_node;
        next_node = next_node->next;
        if(free_node != NULL){
            if(free_node->value != NULL && *(free_node->value) != NULL){
                free(*(free_node->value));
                *(free_node->value) = NULL;
            }
            free_node->value = NULL;
            free(free_node);
            free_node = NULL;
        }
    }
    return;
}

具体使用方式为:
1.在函数开头调用trash_node* create_trash_node()函数，创建内存管理模块头指针。
2.每次申请内存，都将该内存头指针的地址利用函数void trash_push(trash_node* head, void** ele)链接到head中。
3.当遇到程序执行错误需要退出或执行完毕的时候，调用void trash_destory(trash_node** head)函数即可实现对所有已申请内存的释放。
用例代码：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include "trash.h"

int exec_func(int* arr, int len){
    trash_node* head = create_trash_node();
    for(int i = 0; i < len; i++){
        arr[i] = 1;
    }
    srand((unsigned)time(NULL));
    int status = 1;
    //申请辅助数组
    int* a = (int*)malloc(sizeof(int) * len);
    trash_push(head, (void**)&a);
    //执行一些程序
    //若大于4则表示该部分代码执行失败
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行a\n");
    if(status == 0){
        trash_destory(&head);
        return status;
    }
    float* b = (float*)malloc(sizeof(float) * len);
    trash_push(head, (void**)&b);
    //执行一些程序
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行b\n");
    if(status == 0){
        trash_destory(&head);
        return status;
    }
    double* c = (double*)malloc(sizeof(double) * len);
    trash_push(head, (void**)&c);
    //执行一些程序
    status = rand() % 10 > 3 ? 1 : 0;
    printf("执行c\n");
    if(status == 0){
        trash_destory(&head);
        return status;
    }
    char* d = (char*)malloc(sizeof(char) * len);
    trash_push(head, (void**)&d);
    //执行一些程序
    status = rand() % 10 > 4 ? 1 : 0;
    printf("执行d\n");
    if(status == 0){
        trash_destory(&head);
        return status;
    }
    //后续处理相关的程序
    printf("执行后续\n");
    trash_destory(&head);
    return status;
}

int main(){
    int len = 10;
    int* arr = (int*)malloc(sizeof(int) * 10);
    int status = exec_func(arr, len);
    if(status == 0){
        fprintf(stderr,"执行失败\n");
    }else{
        printf("执行成功\n");
    }
    return 0;
}

编译执行

gcc  test_memory.c -o tm
./tm

输出

```bash
gcc  test_memory.c -o tm
./tm

输出

执行a
执行b
执行c
执行d
执行后续
执行成功

方案三PULS

如果函数中存在申请的空间在函数外仍然需要被使用，但是程序执行过程中出现错误时要被销毁怎么办？设计方案为添加四个标识，分别为SAVE_FOR_OUT（外部需要），TEMP_SPACE（外部不需要），OCCUR_ERROR（程序执行出错）以及EXE_NORMAL（程序正常执行）。
那么在该函数中，存在四种状态如下：

外部是否需要程序是否出错是否完全释放
SAVE_FOR_OUTOCCUR_ERROR是
SAVE_FOR_OUTEXE_NORMAL否
TEMP_SPACEOCCUR_ERROR是
TEMP_SPACEEXE_NORMAL是

可以看出，只有当状态为SAVE_FOR_OUT且EXE_NORMAL时不会释放。见代码：
trash.h

#ifndef ML_TRASH_H
#define ML_TRASH_H

#ifdef __cplusplus
extern "C"{
#endif

//在程序结束时不会释放改地址空间
#define SAVE_FOR_OUT 1
//在程序结束时需要全部释放
#define TEMP_SPACE 0
//程序执行出错
#define OCCUR_ERROR 1
//程序正常结束
#define EXE_NORMAL 0

#define trash_push(type, head, ele, _is_save) {                     \
    if(!_trash_push(head, (void**)&(ele), _is_save)){               \
        return (type)0;                                             \
    }                                                               \
}

#define trash_destory(type, head, is_error) {   \
    if(!_trash_destory(&(head), is_error)){     \
        return (type)0;                         \
    }                                           \
}
/**
* \brief 存储动态空间地址的地址，用来对内存进行管理
* \param value 动态空间地址的地址
* \param is_save 执行结束是否释放，仅接受SAVE_FOR_OUT与TEMP_SPACE
* \param next 指向下一个节点
*/
struct trash_node{
    void** value;
    int is_save;
    struct trash_node* next;
};
typedef struct trash_node trash_node;

/**
* \brief create_trash_node 函数，创建垃圾回收头指针
* \return 返回垃圾回收头指针
*/
trash_node* create_trash_node();
/**
* \brief trash_push 记录内存地址的地址
* \param head 垃圾头指针
* \param ele 内存地址的地址
* \return int 正确执行返回1，错误执行返回0
*/
int _trash_push(trash_node* head, void** ele, int _is_save);
/**
* \brief trash_destory 释放记录到head内的动态内存与节点内存
* \param head 垃圾头指针
* \param is_error 程序是否出错，如果出错的话将对所有内存进行释放；
*                 如果正常执行，将仅释放符号is_save = TEMP_SPACE对应的地址空间
*/
int _trash_destory(trash_node** head, int is_error);

#ifdef __cplusplus
}
#endif

#endif

trash.c

#include <stdlib.h>
#include <stdio.h>
#include "trash.h"

trash_node* create_trash_node(){
    trash_node* head = (trash_node*)malloc(sizeof(trash_node));
    if(head == NULL){
        return NULL;
    }
    head->next = NULL;
    head->value = NULL;
    return head;
}

int _trash_push(trash_node* head, void** ele, int _is_save){
    if(head == NULL || ele == NULL){
        return 0;
    }
    if(_is_save != SAVE_FOR_OUT && _is_save != TEMP_SPACE){
        return 0;
    }
    trash_node* tmp_node = (trash_node*)malloc(sizeof(trash_node));
    if(tmp_node == NULL){
        _trash_destory(&head, OCCUR_ERROR);
        return 0;
    }
    tmp_node->value = ele;
    tmp_node->is_save = _is_save;
    tmp_node->next = head->next;
    head->next = tmp_node;
    return 1;
}

int _trash_destory(trash_node** head, int is_error){
    if(head == NULL || *head == NULL){
        return 0;
    }
    if(is_error != OCCUR_ERROR && is_error != EXE_NORMAL){
        return 0;
    }
    trash_node* next_node = *head;
    trash_node* free_node = *head;
    while(next_node != NULL){
        free_node = next_node;
        next_node = next_node->next;
        if(free_node != NULL){
            //绘制is_error与is_save状态表可以看到，当is_error >= is_save时所有内存必须释放
            if(is_error >= free_node->is_save && free_node->value != NULL && *(free_node->value) != NULL){
                free(*(free_node->value));
                *(free_node->value) = NULL;
            }
            free_node->value = NULL;
            free(free_node);
            free_node = NULL;
        }
    }
    return 1;
}

test_memory.c

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include "trash.h"

int* exec_func(int* arr, int len){
    trash_node* head = create_trash_node();
    for(int i = 0; i < len; i++){
        arr[i] = 1;
    }
    srand((unsigned)time(NULL));
    int status = 1;
    //申请辅助数组
    int* a = (int*)malloc(sizeof(int) * len);
    for(int i = 0; i < len; i++){
        a[i] = arr[i];
    }
    trash_push(int*, head, a, SAVE_FOR_OUT);
    //执行一些程序
    //若大于1则表示该部分代码执行失败
    status = rand() % 10 > 1 ? 1 : 0;
    printf("执行a\n");
    if(status == 0){
        trash_destory(int*, head, OCCUR_ERROR);
        return NULL;
    }
    float* b = (float*)malloc(sizeof(float) * len);
    trash_push(int*, head, b, TEMP_SPACE);
    //执行一些程序
    status = rand() % 10 > 1 ? 1 : 0;
    printf("执行b\n");
    if(status == 0){
        trash_destory(int*, head, OCCUR_ERROR);
        return NULL;
    }
    double* c = (double*)malloc(sizeof(double) * len);
    trash_push(int*, head, c, TEMP_SPACE);
    //执行一些程序
    status = rand() % 10 > 1 ? 1 : 0;
    printf("执行c\n");
    if(status == 0){
        trash_destory(int*, head, OCCUR_ERROR);
        return NULL;
    }
    char* d = (char*)malloc(sizeof(char) * len);
    trash_push(int*, head, d, TEMP_SPACE);
    //执行一些程序
    status = rand() % 10 > 1 ? 1 : 0;
    printf("执行d\n");
    if(status == 0){
        trash_destory(int*, head, OCCUR_ERROR);
        return NULL;
    }
    //后续处理相关的程序
    printf("执行后续\n");
    trash_destory(int*, head, EXE_NORMAL);
    return a;
}

int main(){
    int len = 10;
    int* arr = (int*)malloc(sizeof(int) * 10);
    int* a = exec_func(arr, len);
    if(a == NULL){
        fprintf(stderr,"main执行失败\n");
    }else{
        for(int i = 0; i < len; i++){
            printf("%d, ", a[i]);
        }
        printf("\n");
        free(a);
    }
    free(arr);
    return 0;
}

编译执行

执行a
执行b
执行c
执行d
执行后续
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
程适场
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言之内存管理
Arithmetic-logic
03-22 280
C语言内存管理 一.系统中的堆、栈 和 数据结构堆、栈 系统中的堆、栈和数据结构堆、栈不是一个概念。可以说系统中的堆、栈是真实的内存物理区，数据结构中的堆、栈是抽象的数据存储结构。 数据结构堆、栈 1.栈：实际上就是满足后进先出的性质，是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。 2.堆：堆是一种完全二叉树或者近似完全二叉树，完全二叉树是效率很高的数据结...
C语言内存管理
jaj2003的博客
01-22 2039
从设计原来上来讲，CPU自身是不存取数据的，指令和数据必须通过内存才能读入CPU，然后将计算结果返回到内存中，也就是说CPU只负责计算和处理指令，其内容和结果都保存在内存中，掌控了内存就控制了一切，能够与硬件直接对话的底层语言都是围绕内存工作的。 虚拟内存 在计算机发展初期，程序是直接运行在硬件之上的，这时cpu和内存完全由程序员管理，需要程序员自己处理各种边界条件和安全问题，此时程序所操作的内存是真实的，也是不安全的。直接在硬件上写程序，优点是代码透明，性能高，缺点是大部分精力都放在解决各种硬件问题，效率
C语言的内存分配{静态内存&动态内存&堆栈}
热门推荐
xiandang8023的博客
07-28 1万+
除此之外，c语言还允许建立内存动态分配区域，以存放一些临时用的数据，这些数据不必在程序的声明部分定义，也不必等到函数结束时才释放，而是需要时随时开辟，不需要是随时释放。通常是用于那些在编译期间就能确定存储大小的变量的存储区，但它用于的是在整个程序运行期间都可见的全局变量和静态变量。静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。所有的函数外部定义的变量，它的作用域是整个程序，也就是所有的源文件，包括.c和.h文件。已初始化的静态变量存放在.data段。..
C语言+单片机-内存分布详解，全网最全，值得收藏保存
Wang_XB_3434的博客
06-21 5144
数据段，指初始化为0值的可读可写数据，它与RW-data的区别是程序刚运行时这些数据初始值全都为0，程序运行时和RW-data的性质一样，它们也常驻在RAM区，应用程序可以更改其内容。通过了解程序的大小，特别是RO-data和RW-data的大小，可以确保所使用的内存空间不会超出设备的可用内存范围，避免内存溢出和相关的错误。)，它占用的空间为Code + RO-data + RW-data的总和，所以如果这些内容比芯片的FLASH空间大，程序就无法被正常保存在芯片的FLASH了。
最全C C++中的内存管理_c语言函数临时变量分配在哪(3)，2024年最新字节跳动Andorid岗25k+的面试题
最新发布
2401_84164672的博客
05-16 396
对于自定义类型：new创建对象时不仅会开辟空间，还会调用它的构造函数.而malloc不会调用构造函数，这是重要的区别之一.class Testpublic:Test(): _data(0)~Test()private:int _data;int main()//C语言创建//C++创建对象//1.堆上申请空间2.调用其构造函数return 0;可以看到malloc的对象并没有初始化，即并没有调用构造函数.而new的对象调用了构造函数被成功初始化为0.同时。
C语言-内存管理
weixin_61655560的博客
05-11 452
加载对应的库函数就可以申请动态的内存对应的头文件。
C语言进阶笔记（十） | 动态内存管理
KYG__U_O的博客
09-24 448
为什么存在动态内存分配 我们已经掌握了部分内存开辟的方式，比如： int a = 10; float f = 1.1; int arr[10] = { 0 }；//等等 但是，这些开辟内存空间的方式有两个特点： 1. 空间开辟大小是固定的。 2. 数组在申明的时候，必须指定数组的长度，它所需要的内存在编译时分配。 然而对于空间的需求，有时候我们需要的空间大小在程序运行的时候才能知道，那上述开辟空间的方式就不能满足了，这时候就需要动态存开辟了。 动态内存函数绍 malloc和free
C语言之goto
weixin_43772611的博客
07-16 2400
本文记录的是C语言中的goto知识。
使用C语言开发的超市管理系统
03-22
在本项目中，"使用C语言开发的超市管理系统"是一个为初学者设计的实践项目，旨在帮助他们加深对C语言的理解并提升编程能力。这个管理系统是用C语言编写的，C语言是一种底层、高效且广泛应用的编程语言，常用于操作...
C语言内存管理与联合结构课件笔记.md
08-25
本课件首先介绍了C语言中的内存管理知识,包括堆栈概念、动态内存分配函数及内存泄漏等问题,并给出了示例代码。然后详细讲解了C语言中的结构体与联合的定义、访问及嵌套使用,每部分都配有代码实例说明。内容结构清晰,...
C语言项目开发 学生信息管理系统.
01-21
数据录入是系统的基础操作，它涉及到内存管理和数据结构的运用。在学生信息管理系统中，我们需要设计一个结构体来存储学生的各项信息，如姓名、学号、年龄、性别等。通过用户界面接收输入，将数据存储到结构体数组中...
C语言实现内存管理
03-21
通过C语言，基本实现了内存管理过程中的创建、修改、删除等操作
c语言内存管理
06-03
c语言操作系统课程设计内存管理 nt addCalculate(int sn,int sd)//地址换算，sn为逻辑地址，sd为段内地址 { int add; if(sn>s.len) { printf("段号%d大于段表长度%d，越界中断\n",sn,s.len); return 0; } ……
C语言开发图书管理系统
12-09
3. 动态内存管理：使用`malloc`、`calloc`、`realloc`和`free`来动态分配和释放内存，避免内存泄漏。 4. 错误处理：通过`errno`和`perror`捕获和报告运行时错误。 5. 程序结构：遵循结构化编程原则，使用函数封装...
AWorks编程：嵌入式C语言的内存管理
01-19
本文将以C语言为例介绍动态内存管理的原理。 　C／C＋＋语言与其他语言不同，它需要开发者自己管理内存资源。对于动态内存的使用不当容易造成段错误或者内存泄漏。尤其是内存泄漏，内存泄漏往往是在程序运行一段...
C语言知识整理（3）：内存管理（详细版）
asqwzx123123123123的博客
12-20 2190
　　在计算机系统，特别是嵌入式系统中，内存资源是非常有限的。尤其对于移动端开发者来说，硬件资源的限制使得其在程序设计中首要考虑的问题就是如何有效地管理内存资源。本文是作者在学习C语言内存管理的过程中做的一个总结，如有不妥之处，望读者不吝指正。 一、几个基本概念 　　在C语言中，关于内存管理的知识点比较多，如函数、变量、作用域、指针等，在探究C语言内存管理机制时，先简单复习下这几个基本...
c语言中的内存管理
weixin_45172119的博客
03-26 838
c语言中的内存管理
C语言：动态内存管理(动态内存+柔性数组讲解)
2301_77649794的博客
07-20 216
C语言提供了一个动态内存的开辟的函数：malloc这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。1.如果开辟成功，则返回一个指向开辟好空间的指针。2.如果开辟失败，则返回一个NULL指针，因此malloc的返回值一定要做检查。3.返回值的类型是 void*(返回值为指针)，所以malloc函数并不知道开辟空间的类型，具体在使用的时候使用者自己来决定(强制类型转换)。4.如果参数size 为0，malloc的行为是标准是未定义的，取决于编译器。int main()
【C语言】小王带您轻松实现动态内存管理（简单易懂）
小王学代码
01-15 2380
本文主要是对于malloc、calloc、realloc、free函数的介绍和使用细节的说明，还有一些关于动态内存管理的函数，学会了这些，对于以后数据结构的内容会更加得心应手，所以希望大家能多多支持，接下来，下一章，我们跟大家讲解一下，文件管理的内容。学会了就可以更新通讯录啦
C语言多线程内存管理与错误检测模块
“C语言多线程内存管理...这个多线程内存管理模块对于开发多线程应用尤其有用，因为它可以帮助开发者在复杂的并发环境中定位内存问题，确保程序的稳定性和效率。通过这种方式，可以显著提高C语言程序的健壮性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值