温故C语言内存管理

#include<stdio.h>

struct  A
{};

class  B
{};

void   fun(int  a  , int  b) //参数a，b在栈上， 在函数体结束的时候，栈内存释放
{
   int   c;//局部变量，在栈上， 在函数体结束的时候，栈内存释放
}

int  main()
{
   int  a = 10;//局部变量在栈上，  在main函数结束的时候，栈内存释放

   char  b[] = "hello";//数组变量也在栈上，  在main函数结束的时候，栈内存释放

   char  *c = NULL;//在栈上，  在main函数结束的时候，栈内存释放

   {
       A   d;//结构体变量，  在栈上 
       B   e;//类对象在栈上
   } //d,e 在离开这个{}时，栈内存销毁释放

   //测试栈的大小
   //char   buf[1024 * 1024] = { 'A' };//1M时崩溃了
   char   buf[1000* 1024] = { 'A' };//栈空间略小于1M

   //经过编译期设置为5M之后，栈空间变大了
   char   buf[49 * 1024 * 1024 / 10] = { 'A' };//栈空间略小于5M

   printf("%d" , sizeof(buf)  );

   return 0;
}

//分配得来得10*4字节的区域在堆区
p1 = (char*)malloc(10*sizeof(int));

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

int  main()
{
   //手动分配、这里就是分配了堆内存
   int  *p = (int*)malloc(10 *  sizeof(int ));

   //手动释放
   free(p);

   int MB = 0;
   while (malloc(1024 * 1024))//每次分配1M
   {
       MB++;
   }
   printf("分配了 %d MB \n", MB); 

   return 0;
}

#include<stdio.h>

//储存在全局静态区
int   a;  				//全局变量，未初始化
short   b = 10;			//全局变量，已赋值
char  *c = NULL;		//全局变量，已赋值
static  int   f = 200;	//静态变量

int  main()
{
   static  int  d = 100;
   static  int  e = 200;

   printf("%p\n", &a);
   printf("%p\n", &b);
   printf("%p\n", &c);
   printf("%p\n", &d);
   printf("%p\n", &e);
   printf("%p\n", &f);
}

#include<stdio.h>

//“AAA”是字符串常量，存放在常量区
char  *p = "AAA";

int  main()
{
   //p1是局部变量，在栈上， “AAA”是字符串常量，存放在常量区
   char  *p1 = "AAA";

   //p2是局部变量，在栈上，“AAA”不是字符串常量，她只是一种初始化的写法
   char  p2[]= "AAA";

   //p3是局部变量，在栈上， “AAA”是字符串常量，存放在常量区
   char  *p3 = "AAA";

   //p4是局部变量，在栈上， “AAB”是字符串常量，存放在常量区
   char  *p4 = "AAB";

   printf("%p\n", p);
   printf("%p\n", p1);
   printf("%p\n", p2);
   printf("%p\n", p3);
   printf("%p\n", p4);
}

void *malloc(
  size_t size
);

void *calloc(
  size_t number,
  size_t size
);

void *realloc(
  void *memblock,
  size_t size
);

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

int  main()
{
   //malloc  ,参数是字节数 , 并且这块内存空间的值是随机的
   int  *p = (int *)malloc(5 *  sizeof(int));
   p[0] = 123;
   for (int i = 0; i < 5; ++i)
   { 
   	printf("%d   ", p[i]); //后面4个值随机
   }
   
   printf("\n------------------------------------------------------------\n " );

   //calloc，参数两个， 自动将内存空间初始化为0
   int   *p2 = (int *)calloc(5, sizeof(int));
   p2[4] = 123;
   for (int i = 0; i < 5; ++i)
   {
   	printf("%d   ", p2[i]); 
   }

   printf("\n------------------------------------------------------------\n ");
    
   //realloc ，可以调整内存空间的大小 ，并且拷贝原来的内容(调大，或者  缩小)
   //int  *p3 =(int *) realloc(p, 6* sizeof(int));//调大一点点，两个地址相同
   //int  *p3 = (int *)realloc(p, 2 * sizeof(int));//缩小，两个地址相同
   int  *p3 = (int *)realloc(p, 100 * sizeof(int));//调很大，两个地址不同 ,释放原来的内存空间
   for (int i = 0; i <2; ++i)
   {
   	printf("%d   ", p3[i]);
   } 

   printf("\np地址：  %p   ，  p3的地址：  %p   ", p,  p3);

   return 0;
}

#include <string.h>

char *strcpy(
  char *strDestination,
  const char *strSource
);

void *memcpy(
  void *dest,
  const void *src,
  size_t count
);

void *memmove(
  void *dest,
  const void *src,
  size_t count
);

void *memset(
  void *dest,
  int c,
  size_t count
);

#include<stdio.h> 
#include<string.h>
#include<assert.h> 

//模拟memcpy函数实现
void  *  MyMemcpy(void *dest, const void *source, size_t count)
{
   assert((NULL != dest) && (NULL != source));
   char *tmp_dest = (char *)dest;
   char *tmp_source = (char *)source;
   while (count--)//不判断是否重叠区域拷贝
   	*tmp_dest++ = *tmp_source++;
   return dest;
}

//模拟memmove函数实现
void * MyMemmove(void *dest, const void *src, size_t n)
{
   char temp[256];
   int i;
   char *d =(char*) dest;
   const char *s =(char *) src;
   for (i = 0; i < n; i++)
   	temp[i] = s[i];
   for (i = 0; i < n; i++)
   	d[i] = temp[i];
   return dest;
}

int  main()
{
    //strcpy进行字符串拷贝  
   //注意：  1. src字符串必须以'\0'结束，  2. dest内存大小必须>=src
   char  a[5];
   //char  b[5] = "ABC";//字符串结尾会自动的有\0 , 此处 b[4]就是'\0' 
   char  b[5];
   b[0] = 'A';
   b[1] = 'B';
   b[2] = 'C';
   b[3] = '\0';//必须加\0，否则strcpy一直向后寻找\0
   strcpy(a, b);
   printf("%s\n", a);

   //memcpy函数， 直接拷贝内存空间，指定拷贝的大小
   int   a2[5];
   int   b2[5] = { 1,2,3,4,5 };//不需要'\0'结束
   memcpy(a2, b2,   3 *sizeof(int)   );//指定拷贝的大小, 单位  字节数
   printf("%d , %d  ,%d\n" , a2[0] ,  a2[1],  a2[2]);

   MyMemcpy(a2 + 3, b2 + 3,   2 * sizeof(int));
   printf("%d , %d \n", a2[3], a2[4]);

   //演示内存重叠的情况
   char  a3[6] = "123";
   //MyMemcpy(a3 + 1, a3, 4); //得到11111
   memcpy(a3 + 1, a3, 4);//虽然它是正确的，但是不保证，重叠拷贝应该避免使用它
   printf("%s\n", a3);

   //memmove功能与memcpy一样，但是了考虑了重叠拷贝的问题，可以保证正确
   char  a4[6] = "123";
   //MyMemmove(a4 + 1, a4, 4);//可以保证正确
   memmove(a4 + 1, a4, 4);//可以保证正确
   printf("%s\n", a4);


   //memset比较简单， 把内存区域初始化化为某个值
   char a5[6];
   memset(a5, 0, 6);
   for (int i = 0; i < 6; ++i)
   {
   	printf("%d", a5[i]);
   }

   return 0;
}

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

//为了代码的可读性，将设计为c++中的类，利用struct 代替

//动态数组
struct  Array
{
   //自动构造函数，它初始化
   Array()
   {
   	grow = 3;
   	size = 3;
   	n = 0;
   	//分配并初始化内存
   	pHead = (int  *)calloc(size  , sizeof(int));
   	assert(pHead != NULL); 
   }

   void   AddElem(int  e)
   {
   	if (n >= size)//说明数组满了
   	{
   		//需要扩大内存
   		size += grow; 
   		pHead = (int  *)realloc( pHead,   size * sizeof(int)  );
   		assert(pHead != NULL);
   	}

   	pHead[n++] = e; //添加元素
   }

   void  Print()
   {
   	printf("\n\n数组总空间：%d   ,   元素个数: %d  \n",  size,  n);
   	for (int i = 0; i < n; ++i)
   	{
   		printf("%d  " ,  pHead[i]);
   	} 
   }

   int   size;//总空间， 不是固定的，可以增大的
   int   n;//当前数组的元素个数
   int   grow;//每次数组内存满了的时候，增长量

   int   *pHead;//数组的起始地址
};

int  main()
{
   Array  arr; 

   arr.AddElem(1);
   arr.AddElem(2);
   arr.AddElem(3);
   arr.AddElem(4);
   arr.AddElem(5);
   arr.AddElem(6);
   arr.AddElem(7);
   arr.AddElem(8);  
   arr.Print(); 

   arr.AddElem(11);
   arr.AddElem(22);
   arr.AddElem(33);
   arr.AddElem(44);
   arr.AddElem(55);  
   arr.Print();

   return  0;
}

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

char  * fun()
{
   char arr[10];
    return  arr;
}//arr是栈内存，离开此花括号，栈被释放回收


int main()
{
   //1.访问到野指针指向的区域，越界访问
   char  *p;//没有初始化，野指针，乱指一气
   //strcpy(p, "hello");//非法越界访问

   //2.数组下标越界访问
   int   * p2 = (int *)calloc(10, sizeof(int));
   for (size_t i = 0; i <= 10; i++)
   {
   	p2[i] = i;//很难察觉的越界访问， 下标越界
   }

   //3.使用已经释放的内存
   char *p3 = (char *)malloc(10);
   free(p3);
   if (p3 != NULL)//这里if不起作用
   {
   	strcpy(p3, "hello");//错误，p3已经被释放
   }

   //4.企图访问一段释放的栈空间
   char *p4 = fun();  //p4指向的栈空间已经被释放
   strcpy(p4, "hello");
   printf("%s\n",p4);

   //5.容易忽略 字符串后面的'\0'
   char  *p5 = (char *)malloc(strlen("hello"));//忘记加1
   strcpy(p5, "hello");//导致p5的长度不够，越界

   return 0;
}

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


char  * GetBuf()
{
   return  (char *)malloc(10);
}

void  GetBuf2(char *p)//p已经是一份拷贝，和原参数无任何关系
{
   p= (char *)malloc(10);
}

char  * GetBuf3()
{
   char  *p = "hello";//常量内存区，不可更改
   return p;
}

int main()
{
   //1.丢失了分配的内存的首地址，导致无法释放
   GetBuf();//忘记接收返回值了

   //2.丢失分配的内存地址
   char  *p1= (char *)malloc(10);
   char  *p2 = (char *)malloc(10);
   p1 = p2;//这一步，导致第一次分配的堆内存丢失，无法释放

   //3.企图希望传入指针变量获取对内存，殊不知是拷贝
   char  *p3 = NULL;
   GetBuf2(p3); //应该使用指针的指针，或者引用
   //strcpy(p3, "hello"); //错误，这里的p3仍然为NULL

   //4.每循环一次，泄露一次内存
   char  * p4 = NULL;
   for (int i = 0; i < 10; ++i)
   {
   	p4= (char *)malloc(10);
   }
   strcpy(p4, "hello"); // 这里的p4只指向最后一次分配的，前面的全部内存泄漏

   //5.非法访问常量区
   char *p5 = GetBuf3();
   strcpy(p5, "hello");  

   return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

class  MemoryBlock
{
public:
   int             nSize; //该内存块的总大小 （单元个数X每个单元大小），以字节为单位

   int             nFree;  //该内存块还有多少个空闲的单元

   int             nFirst; //当前可用空闲单元的序号，从0开始

   MemoryBlock*    pNext;  //指向下一个MemoryBlock内存块

   char            aData[1]; //用于标记分配内存开始的位置  

   //.....这个结构下面全是内存

public:
   MemoryBlock(int  unitCount, int  unitSize)
   {
   	 nSize = unitCount* unitSize;
   	 nFree = unitCount;
   	 nFirst = 0;
   	 pNext = NULL;

   	 char  *p = aData;//获取内存单元的首地址

   	 for (int i = 0; i < unitCount -1; ++i)
   	 {
   		 *((short *)p) = i + 1; //第0块的下个空闲索引是不是第1块
   		  p += unitSize;
   	 }

   	 *((short *)p) = -1;//最后一块没有下一个空闲空间了，为-1
   }

   void  *  operator new (size_t  t,  int   size)
   {
   	 int  headSize = sizeof(MemoryBlock);
         return   ::operator  new(headSize + size);
   }
};

//分配固定内存的内存池
class  MemoryPool
{

public:
   //初始大小 (每一个MemoryBlock中初始的单元个数)
   int             nInitCount; 

   //(后面增加的MemoryBlock中单元个数)   
   int             nGrowSize; 
    
   //分配单元大小，MemoryBlock中每个单元的大小
   int             nUnitSize; 

   //内存块链表
   MemoryBlock*    pBlock;

public:
   MemoryPool( int  _nInitCount, int  _nGrowSize, int _nUnitSize)
   {
   	nInitCount = _nInitCount;
   	nGrowSize = _nGrowSize;
   	nUnitSize = _nUnitSize;
   	pBlock = NULL;
   }

   char  *  Alloc() //每次只返回 nUnitSize 大小的内存
   {
   	if (pBlock == NULL)
   	{
   		 MemoryBlock  *   p =(MemoryBlock  *) new (nInitCount * nUnitSize) MemoryBlock(nInitCount, nUnitSize);
   		 assert(p != NULL);

   		 pBlock = p;
   	}

   	MemoryBlock  *  pB = pBlock;
   	while (pB !=NULL  &&   pB->nFree==0)
   	{
   		pB = pB->pNext;
   	}

   	if (pB == NULL)//一直没找到了可以分配的MemoryBlock，说明内存池已满
   	{
   		pB = (MemoryBlock  *) new (nGrowSize  * nUnitSize) MemoryBlock(nGrowSize, nUnitSize);
   		assert(pB != NULL);

   		pB->pNext = pBlock;
   		pBlock = pB; 
   	}

   	//得到第一个可用的空闲内存地址
   	char *pFree = pB->aData + pB->nFirst * nUnitSize;
   	//把nFirst值改为下一个空闲的索引 （存储在当前内存的前两个字节）
   	pB->nFirst = *((short*)pFree);
   	pB->nFree--;
   	return  pFree;  
   }

   void   Free(void  *p)
   {
     //考虑这个地址落在哪个 MemoryBlock 上
   	MemoryBlock  *  pB = pBlock;
   	while (pB  != NULL  &&   p <  pB->aData   ||  p > pB->aData+  pB->nSize   )
   	{
   		pB = pB->pNext;
   	}
   	 
   	if (pB!= NULL)//找到了p所在的MemoryBlock
   	{
   		 //销毁之前先让它的前两个字节指向nFirst （当前空闲的索引）
   		*((short*)p) = pB->nFirst;

   		 //nFirst的值指向当前释放的
   		 pB->nFirst = ((char *)p - pB->aData) / nUnitSize;

   		 pB->nFree++;
   	}
   	else
   	{
   		printf("错误，此内存并非内存池分配的！\n");
   	}
   }

   void  Print()
   {
   	printf("\n\n\n");

   	MemoryBlock  *  pB = pBlock;
   	while (pB != NULL )
   	{
   		printf("\n首地址：%p   总大小：%d   空闲个数: %d   下一个空闲：%d  \n",
   			pB->aData ,  pB->nSize, pB->nFree ,pB->nFirst);

   		for (int i = 0; i < pB->nSize / nUnitSize; ++i)
   		{
   			printf("\t %d" ,  *  ((int *) ( pB->aData + i * nUnitSize )));
   		}
   		 
   		pB = pB->pNext;

   		printf("\n---------------------------------------------------------\n");
   	}
   }
};

int main()
{
   MemoryPool   pool(3, 3, 4);

   int  *p1 = (int *)pool.Alloc();
   *p1 = 111;

   int  *p2 = (int *)pool.Alloc();
   *p2 = 222;
    
   int  *p3 = (int *)pool.Alloc();
   *p3 = 333;

   pool.Print();

   int  *p4 = (int *)pool.Alloc();
   *p4 = 444;

   pool.Print();


   int  *p5 = (int *)pool.Alloc();
   *p5 = 555;

   pool.Print();

   pool.Free( p1);
   pool.Free(p2);
   pool.Free(p3);
   pool.Print();

    p1 = (int *)pool.Alloc();
   *p1 = 111;

    p2 = (int *)pool.Alloc();
   *p2 = 222;

    p3 = (int *)pool.Alloc();
   *p3 = 333;
   pool.Print();

   return 0;
}