C/C++编程：acl动态分配以及释放内存

柔光的暖阳◎ 2022-12-24 07:56 163阅读 0赞

#include <errno.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <stddef.h>
    
    
    static char __FILENAME_UNKNOWN[] = "unknown file";
    static size_t  __malloc_limit = 100000000;
    static char empty_string[] = "";
    
    typedef struct MBLOCK {
        
        size_t signature;		/* set when block is active */
        size_t length;			/* user requested length */
        union {
        
            size_t align;
            char  payload[1];	/* actually a bunch of bytes */
        } u;
    } MBLOCK;
    #define SPACE_FOR(len)	(offsetof(MBLOCK, u.payload[0]) + len)
    
    # define SET_FILE(_ptr_, _filename_) do {  \
    	_ptr_ = strrchr(_filename_, '/');  \
    if (_ptr_ == NULL)  \
    		_ptr_ = filename;  \
    	else  \
    		_ptr_++;  \
    } while (0)
    
    #define SIGNATURE	0xdead
    #define CHECK_OUT_PTR(_ptr_, _real_ptr_, _len_) { \
      _real_ptr_->signature = SIGNATURE; \
      _real_ptr_->length = _len_; \
      _ptr_ = _real_ptr_->u.payload; \
    }
    #define CHECK_IN_PTR(_ptr_, _real_ptr_, _len_, _fname_, _line_) { \
      if (_ptr_ == 0) {\
        printf("%s(%d): null pointer input\n", _fname_, _line_); \
        exit(-1); \
       } \
      _real_ptr_ = (MBLOCK *) (((char*)_ptr_) - offsetof(MBLOCK, u.payload[0])); \
      if (_real_ptr_->signature != SIGNATURE){ \
        printf("%s(%d): corrupt or unallocated block(%d, 0x%x, 0x%x)\n", \
          _fname_, _line_, (int) _real_ptr_->length, \
          (int) _real_ptr_->signature, SIGNATURE); \
          exit(-1); \
      }\
      _real_ptr_->signature = 0; \
      if ((_len_ = _real_ptr_->length) < 1) {\
        printf("%s(%d): corrupt memory block length", _fname_, _line_); \
        exit(-1); \
      }\
    }
    void *acl_default_malloc(const char *filename, int line, size_t len){
        
        char *ptr;
        const char *myname = "acl_default_malloc";
        const char *pname = NULL;
        size_t new_len;
        MBLOCK *real_ptr;
    
        //pname用于调试
        if (filename && *filename)
            SET_FILE(pname, filename);
        else
            pname = __FILENAME_UNKNOWN;
    
    
        // 计算所需要分配空间的大小
        if (len < 1) {
        
            printf("%s(%d), %s: malloc: length %ld invalid",pname, line, myname, (long) len);
            len = 128;
        }
    
        new_len = SPACE_FOR(len);  // 分配空间的长度 = MBLOCK结构体所所需要的空间 + str的所需要的空间 + 1(用来存放\0，表示结束)
        if (new_len <= 0){
        
            printf("%s(%d): new_len(%d) <= 0",myname, __LINE__, (int) new_len);
            exit(-1);
        }else if (new_len >= __malloc_limit) {
        
            printf("%s(%d): new_len(%d) too large",myname, __LINE__, (int) new_len);
        }
    
        // 分配空间
        if ((real_ptr = (MBLOCK *) malloc(new_len)) == NULL) {
         // malloc函数返回一个指针 ，指向已分配大小的内存。如果请求失败，则返回 NULL。
            printf("%s(%d)->%s: malloc: insufficient memory: %s, new_len: %d", pname, line, myname,
                          strerror(errno), (int) new_len);  // 如果失败则退出
            exit(-1);
        }
    
    
    
        // &(*ptr) == &(*(real_ptr->u.payload))
        CHECK_OUT_PTR(ptr, real_ptr, len);
        return ptr;
    }
    char *acl_default_strdup(const char *filename, int line, const char *str){
        
        const char *myname = "acl_default_strdup";
        const char *pname = NULL;
    
    
        if (filename && *filename)  //filename不为null & filename指向的地址也不未null(通过取出filename指向的第一个内存的内容[*filename]是不是null来判断)
            SET_FILE(pname, filename);  //filename默认为调用函数所在文件的全路径地址(包括文件名)，SET_FILE会令pname=文件名
        else
            pname = __FILENAME_UNKNOWN;
    
        if(str == NULL){
          // 如果str本身的地址不可用，报错退出
            printf("%s(%d)->%s: null pointer argument", pname, line, myname);
            exit(-1);
        }
        if (*str == NULL)  // str指向的内容为null
            return (char *) empty_string;
    
        return strcpy((char *)acl_default_malloc(pname, line, strlen(str) + 1), str);
    }
    
    void acl_default_free(const char *filename, int line, void *ptr)
    {
        
        const char *myname = "acl_default_free";
        MBLOCK *real_ptr;
        size_t len;
        const char *pname = NULL;
    
        if (filename && *filename)
            SET_FILE(pname, filename);
        else
            pname = __FILENAME_UNKNOWN;
    
        if (ptr == NULL) {
        
            printf("%s(%d)->%s: ptr null", pname, line, myname);
            return;
        }
        if (ptr != empty_string) {
        
            CHECK_IN_PTR(ptr, real_ptr, len, pname, line);
            free((char *) real_ptr);  // ptr =  {void *| 0x1ff1020} 0x1ff1020
        }
    }
    
    
    
    char *(*__strdup_fn)(const char*, int, const char*)  = acl_default_strdup;
    void  (*__free_fn)(const char*, int, void*) = acl_default_free;
    void *(*__malloc_fn)(const char*, int, size_t) = acl_default_malloc;
    
    
    char *acl_strdup_glue(const char *filename, int line, const char *str){
        
        return (__strdup_fn(filename, line, str));
    }
    
    
    void acl_free_glue(const char *filename, int line, void *ptr){
        
        __free_fn(filename, line, ptr); //after:  ptr =  {void *| 0x1ff1020} 0x1ff1020
    }
    
    void *acl_malloc_glue(const char *filename, int line, size_t size)
    {
        
        return (__malloc_fn(filename, line, size));
    }
    
    
    /**
     * 动态分配内存的宏定义，不初始化新分配的内存空间
     * @param size {size_t} 分配长度
     * @return {void *}
     */
    #define acl_mymalloc(size) acl_malloc_glue(__FILE__, __LINE__, size)
    /**
     * 动态复制字符串宏定义
     * @param str {const char*} 源字符串
     * @return {char*} 新的字符串，需用 acl_myfree 释放
     */
    #define acl_mystrdup(str) acl_strdup_glue(__FILE__, __LINE__, (str))
    /**
     * 释放动态分配的内存空间
     * @param _ptr_ {void*} 动态内存地址
     */
    #define acl_myfree(_ptr_) do {  \
    	if (_ptr_) {  \
    		acl_free_glue(__FILE__, __LINE__, (_ptr_));  \
    		(_ptr_) = NULL;  \
    	}  \
    } while (0)
    
    
    
    int main(){
        
        char *ptr3 = acl_mystrdup("hello world!");  // ptr3 = {char *| 0x1ff1020} "hello world"
        acl_myfree(ptr3);  // ptr3 = {char | 0x0 }NULL
    
        if (ptr3 == NULL){
          // 1
            printf("--------------------------------");
        }
        if (ptr3){
          // 0
            printf("*******************************");  
        }
        getchar();
    }
    
    int main2(){
        
        int   i;
        char *ptr2;
        for (i = 0; i < 100; i++) {
        
            (void) acl_mymalloc(100);
            ptr2 = (char*) acl_mymalloc(100);
            acl_myfree(ptr2);
        }
        getchar();
    }