深入浅出c内存管理

#include <stdio.h>
int main(int argc, const char * argv[]) {
    int a = 100;
    int b = 100;
    printf("%p \n",&a); // 0x7fff5fbff79c
    printf("%p \n",&b); // 0x7fff5fbff798
    
    // a 变量的地址 0x7fff5fbff79c 比 b
    变量的地址 0x7fff5fbff798 要大
    return 0;
}

#include <stdio.h>

int a = 0;                  // 全局初始化区
char p1;                    // 全局未初始化区

int main(int argc, const char * argv[]) {
      int b ;                 // 栈
      char s[] = "abc";       // 栈
      char p2 ;               // 栈
      char p3 = "123456";     // 123456在常量区，p3在栈上。
      static int c = 0 ;      // 全局（静态）初始化区
      
      p1 = (char )malloc(10); // 分配的10字节的区域就在堆区
      p2 = (char )malloc(20); // 分配的20字节的区域就在堆区
      
      printf("%p\n",p1);      // 0xffffffb0
      printf("%p\n",p2);      // 0xffffffc0
      
      //p1 变量的地址 0xffffffb0 比 p2 变量的地址 0xffffffc0 要小
      return 0;                
}

C的存储类别包括4种：auto（自动的）、static（静态的）、register（寄存器的）、extern（外部的）。  

struct page {
	unsigned long flags;        /*存放页的状态*/
	atomic_t _count;        /* 页的引用计数*/
	union {
		atomic_t _mapcount; 
		struct {
			u16 inuse;
			u16 objects;
		};
	};
	union {
		struct {
			unsigned long private;
			struct address_space *mapping;
		};
 
	void *virtual;  /* 页的虚拟地址 Kernel virtual address (NULL if
					not kmapped, ie. highmem) */
	……
};

int brk(void *addr);
void *sbrk(intptr_t increment);

【函数原型】 void *malloc(size_t __size)  
【参数说明】 size 需要分配的内存空间的大小，单位是字节。  
【返回值类型】 void * 表示未确定类型的指针，分配成功返回指向该内存的地址，失败则返回NULL。C、C++规定，void* 类型可以强制转换为任何其它类型的指针。  
【函数功能】 表示向系统申请分配指定 size 个字节的内存空间。

int *a = malloc(4);  //申请4个字节的空间用于存放一个int类型的值
char *b = malloc(2);  //申请2个字节的空间用于存放一个char类型的值

【函数原型】 void *calloc(size_t __count, size_t __size)  
【参数说明】 count 表示个数，size 单位个需要分配的内存空间的大小，单位是字节。  
【返回值类型】 void * 表示未确定类型的指针。
【函数功能】 表示向系统申请分配 count 个长度为 size 一共为 count 乘以 size 个字节长度的连续内存空间，并将每一个字节都初始化为 0。

【函数原型】 void *realloc(void *__ptr, size_t __size)  
【参数说明】 ptr 表示需要修改的内存空间的地址，size 表示需要重写分配的内存空间的大小，单位是字节。  
【返回值类型】 void * 表示未确定类型的指针。  
【函数功能】 表示更改已经配置好的内存空间到指定的大小。

char *d = calloc(2, sizeof(char));  //申请2个sizeof(char) 字节的空间
char *f = realloc(d, 5 * sizeof(char));  //将原来变量d指向的2个sizeof(char) 字节的空间更改到5个sizeof(char) 字节的空间并由变量f指向。

【函数原型】 void free(void *)
【参数说明】 void * 表示需要释放的内存空间对应的内存地址。
【返回值类型】 返回值为空。
【函数功能】 表示用来释放已经动态分配的内存空间。free() 可以释放由 malloc()、calloc()、realloc() 分配的内存空间，以便其他程序再次使用。需要注意的是：free() 不会改变 传入的指针的值，调用 free() 后它仍然会指向相同的内存空间，但是此时该内存已无效，不能被使用。所以建议将释放完的指针设置为 NULL。

char *g = malloc(sizeof(char)); //申请sizeof(char)大小内存空间
free(g);      //释放掉g指针指向的内存空间
g = NULL;     //将g指针指向NULL

int main(int argc, const char * argv[]) 
{
    int a = 3;                   //定义a为整型变量
    int *p1 = &a;                //p1指向 int 型变量
    char *p2;                    //p2指向 char 型变量
    void *p3;               
    //p3为无类型指针变量
    p3 = (void *)p1; //将p1的值转换为void *类型，然后赋值给p3
    p2 = (char *)p3;    //将p3的值转换为char *类型，然后赋值给p2
    printf("%d\n", *p1); //输出a的值 3
    p3 = &a;                    
    printf("%d", *p3); //此处报错，p3无指向，不能指向a 
    return 0;
}

int main(int argc, const char * argv[]) {
    char chars[4] = {'l','o','v','e'};    
    printf("chars[0] = %p\n",&chars[0]); //0x7fff5fbff79b
    printf("chars[1] = %p\n",&chars[1]); //0x7fff5fbff79c
    printf("chars[2] = %p\n",&chars[2]); //0x7fff5fbff79d
    printf("chars[3] = %p\n",&chars[3]); //0x7fff5fbff79e
    return 0;
}

int main(int argc, const char * argv[]) {
    int nums[2] = {5, 6};
    printf("nums[0] = %p\n",&nums[0]); // 0x7fff5fbff7a0
    printf("nums[1] = %p\n",&nums[1]); // 0x7fff5fbff7a4
    return 0;
}

int main(int argc, const char * argv[]) {
    char charsOne[2] = {'a', 'b'};
    char charsTwo[3] = {'c', 'd', 'e'};
    charsTwo[3] = 'f';
    printf("charsOne[0] = %p\n",&charsOne[0]); // 0x7fff5fbff79e
    printf("charsTwo[0] = %p\n",&charsTwo[0]); // 0x7fff5fbff79b
    printf("charsOne[0] = %c\n",charsOne[0]); // f 
    return 0;
}

char a[4] = {0};
a = "123456789";

void free(void *p)
{
    t_block b;
    if(valid_addr(p))//地址的有效性验证
    {
        b = get_block(p);//得到对应的block
        b->free = 1; //如果相邻的上一块内存是空闲的就合并, 合并之后的上一块还是空闲的就继续合并，直到不能合并为止
        while(b->prev && b->prev->free)
        {
            b = fusion(b->prev);
        } 

        //同理去合并后面的空闲block
        while(b->next)
            fusion(b);//内部会判断是否空闲

        //如果当前block是最后面的那个block，此时可以调整break指针了
        if(NULL == b->next)
        {
            if(b->prev) // 当前block前面还有占用的block
                b->prev->next = NULL;
            else       // 当前block就是整个heap仅存的
                base = NULL; // 则重置base
            brk(b); //调整break指针到b地址位置
        }

        //否则不能调整break
    }
}