温故c语言内存管理-百家乐凯发k8

#include
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
#include
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
//储存在全局静态区
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
//“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
#include
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 

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 
#include
#include 
//模拟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
#include
#include
//为了代码的可读性，将设计为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
#include
#include
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
#include
#include
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
#include
#include
#include
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;
}