#include<stdio.h>

struct  A
{};

class  B
{};

void   fun(int  a  , int  b) //參數(shù)a，b在棧上， 在函數(shù)體結(jié)束的時(shí)候，棧內(nèi)存釋放
{
   int   c;//局部變量，在棧上， 在函數(shù)體結(jié)束的時(shí)候，棧內(nèi)存釋放
}

int  main()
{
   int  a = 10;//局部變量在棧上，  在main函數(shù)結(jié)束的時(shí)候，棧內(nèi)存釋放

   char  b[] = "hello";//數(shù)組變量也在棧上，  在main函數(shù)結(jié)束的時(shí)候，棧內(nèi)存釋放

   char  *c = NULL;//在棧上，  在main函數(shù)結(jié)束的時(shí)候，棧內(nèi)存釋放

   {
       A   d;//結(jié)構(gòu)體變量，  在棧上 
       B   e;//類對(duì)象在棧上
   } //d,e 在離開這個(gè){}時(shí)，棧內(nèi)存銷毀釋放

   //測(cè)試棧的大小
   //char   buf[1024 * 1024] = { 'A' };//1M時(shí)崩潰了
   char   buf[1000* 1024] = { 'A' };//棧空間略小于1M

   //經(jīng)過編譯期設(shè)置為5M之后，?？臻g變大了
   char   buf[49 * 1024 * 1024 / 10] = { 'A' };//?？臻g略小于5M

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

   return 0;
}

//分配得來得10*4字節(jié)的區(qū)域在堆區(qū)
p1 = (char*)malloc(10*sizeof(int));

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

int  main()
{
   //手動(dòng)分配、這里就是分配了堆內(nèi)存
   int  *p = (int*)malloc(10 *  sizeof(int ));

   //手動(dòng)釋放
   free(p);

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

   return 0;
}

#include<stdio.h>

//儲(chǔ)存在全局靜態(tài)區(qū)
int   a;  				//全局變量，未初始化
short   b = 10;			//全局變量，已賦值
char  *c = NULL;		//全局變量，已賦值
static  int   f = 200;	//靜態(tài)變量

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”是字符串常量，存放在常量區(qū)
char  *p = "AAA";

int  main()
{
   //p1是局部變量，在棧上， “AAA”是字符串常量，存放在常量區(qū)
   char  *p1 = "AAA";

   //p2是局部變量，在棧上，“AAA”不是字符串常量，她只是一種初始化的寫法
   char  p2[]= "AAA";

   //p3是局部變量，在棧上， “AAA”是字符串常量，存放在常量區(qū)
   char  *p3 = "AAA";

   //p4是局部變量，在棧上， “AAB”是字符串常量，存放在常量區(qū)
   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  ,參數(shù)是字節(jié)數(shù) , 并且這塊內(nèi)存空間的值是隨機(jī)的
   int  *p = (int *)malloc(5 *  sizeof(int));
   p[0] = 123;
   for (int i = 0; i < 5; ++i)
   { 
   	printf("%d   ", p[i]); //后面4個(gè)值隨機(jī)
   }
   
   printf("\n------------------------------------------------------------\n " );

   //calloc，參數(shù)兩個(gè)， 自動(dòng)將內(nèi)存空間初始化為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 ，可以調(diào)整內(nèi)存空間的大小 ，并且拷貝原來的內(nèi)容(調(diào)大，或者  縮小)
   //int  *p3 =(int *) realloc(p, 6* sizeof(int));//調(diào)大一點(diǎn)點(diǎn)，兩個(gè)地址相同
   //int  *p3 = (int *)realloc(p, 2 * sizeof(int));//縮小，兩個(gè)地址相同
   int  *p3 = (int *)realloc(p, 100 * sizeof(int));//調(diào)很大，兩個(gè)地址不同 ,釋放原來的內(nèi)存空間
   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函數(shù)實(shí)現(xiàn)
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--)//不判斷是否重疊區(qū)域拷貝
   	*tmp_dest++ = *tmp_source++;
   return dest;
}

//模擬memmove函數(shù)實(shí)現(xiàn)
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進(jìn)行字符串拷貝  
   //注意：  1. src字符串必須以'\0'結(jié)束，  2. dest內(nèi)存大小必須>=src
   char  a[5];
   //char  b[5] = "ABC";//字符串結(jié)尾會(huì)自動(dòng)的有\(zhòng)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函數(shù)， 直接拷貝內(nèi)存空間，指定拷貝的大小
   int   a2[5];
   int   b2[5] = { 1,2,3,4,5 };//不需要'\0'結(jié)束
   memcpy(a2, b2,   3 *sizeof(int)   );//指定拷貝的大小, 單位  字節(jié)數(shù)
   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]);

   //演示內(nèi)存重疊的情況
   char  a3[6] = "123";
   //MyMemcpy(a3 + 1, a3, 4); //得到11111
   memcpy(a3 + 1, a3, 4);//雖然它是正確的，但是不保證，重疊拷貝應(yīng)該避免使用它
   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比較簡(jiǎn)單， 把內(nèi)存區(qū)域初始化化為某個(gè)值
   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>

//為了代碼的可讀性，將設(shè)計(jì)為C++中的類，利用struct 代替

//動(dòng)態(tài)數(shù)組
struct  Array
{
   //自動(dòng)構(gòu)造函數(shù)，它初始化
   Array()
   {
   	grow = 3;
   	size = 3;
   	n = 0;
   	//分配并初始化內(nèi)存
   	pHead = (int  *)calloc(size  , sizeof(int));
   	assert(pHead != NULL); 
   }

   void   AddElem(int  e)
   {
   	if (n >= size)//說明數(shù)組滿了
   	{
   		//需要擴(kuò)大內(nèi)存
   		size += grow; 
   		pHead = (int  *)realloc( pHead,   size * sizeof(int)  );
   		assert(pHead != NULL);
   	}

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

   void  Print()
   {
   	printf("\n\n數(shù)組總空間：%d   ,   元素個(gè)數(shù): %d  \n",  size,  n);
   	for (int i = 0; i < n; ++i)
   	{
   		printf("%d  " ,  pHead[i]);
   	} 
   }

   int   size;//總空間， 不是固定的，可以增大的
   int   n;//當(dāng)前數(shù)組的元素個(gè)數(shù)
   int   grow;//每次數(shù)組內(nèi)存滿了的時(shí)候，增長(zhǎng)量

   int   *pHead;//數(shù)組的起始地址
};

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是棧內(nèi)存，離開此花括號(hào)，棧被釋放回收


int main()
{
   //1.訪問到野指針指向的區(qū)域，越界訪問
   char  *p;//沒有初始化，野指針，亂指一氣
   //strcpy(p, "hello");//非法越界訪問

   //2.數(shù)組下標(biāo)越界訪問
   int   * p2 = (int *)calloc(10, sizeof(int));
   for (size_t i = 0; i <= 10; i++)
   {
   	p2[i] = i;//很難察覺的越界訪問， 下標(biāo)越界
   }

   //3.使用已經(jīng)釋放的內(nèi)存
   char *p3 = (char *)malloc(10);
   free(p3);
   if (p3 != NULL)//這里if不起作用
   {
   	strcpy(p3, "hello");//錯(cuò)誤，p3已經(jīng)被釋放
   }

   //4.企圖訪問一段釋放的?？臻g
   char *p4 = fun();  //p4指向的?？臻g已經(jīng)被釋放
   strcpy(p4, "hello");
   printf("%s\n",p4);

   //5.容易忽略 字符串后面的'\0'
   char  *p5 = (char *)malloc(strlen("hello"));//忘記加1
   strcpy(p5, "hello");//導(dǎo)致p5的長(zhǎng)度不夠，越界

   return 0;
}

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


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

void  GetBuf2(char *p)//p已經(jīng)是一份拷貝，和原參數(shù)無(wú)任何關(guān)系
{
   p= (char *)malloc(10);
}

char  * GetBuf3()
{
   char  *p = "hello";//常量?jī)?nèi)存區(qū)，不可更改
   return p;
}

int main()
{
   //1.丟失了分配的內(nèi)存的首地址，導(dǎo)致無(wú)法釋放
   GetBuf();//忘記接收返回值了

   //2.丟失分配的內(nèi)存地址
   char  *p1= (char *)malloc(10);
   char  *p2 = (char *)malloc(10);
   p1 = p2;//這一步，導(dǎo)致第一次分配的堆內(nèi)存丟失，無(wú)法釋放

   //3.企圖希望傳入指針變量獲取對(duì)內(nèi)存，殊不知是拷貝
   char  *p3 = NULL;
   GetBuf2(p3); //應(yīng)該使用指針的指針，或者引用
   //strcpy(p3, "hello"); //錯(cuò)誤，這里的p3仍然為NULL

   //4.每循環(huán)一次，泄露一次內(nèi)存
   char  * p4 = NULL;
   for (int i = 0; i < 10; ++i)
   {
   	p4= (char *)malloc(10);
   }
   strcpy(p4, "hello"); // 這里的p4只指向最后一次分配的，前面的全部?jī)?nèi)存泄漏

   //5.非法訪問常量區(qū)
   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; //該內(nèi)存塊的總大小 （單元個(gè)數(shù)X每個(gè)單元大小），以字節(jié)為單位

   int             nFree;  //該內(nèi)存塊還有多少個(gè)空閑的單元

   int             nFirst; //當(dāng)前可用空閑單元的序號(hào)，從0開始

   MemoryBlock*    pNext;  //指向下一個(gè)MemoryBlock內(nèi)存塊

   char            aData[1]; //用于標(biāo)記分配內(nèi)存開始的位置  

   //.....這個(gè)結(jié)構(gòu)下面全是內(nèi)存

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

   	 char  *p = aData;//獲取內(nèi)存單元的首地址

   	 for (int i = 0; i < unitCount -1; ++i)
   	 {
   		 *((short *)p) = i + 1; //第0塊的下個(gè)空閑索引是不是第1塊
   		  p += unitSize;
   	 }

   	 *((short *)p) = -1;//最后一塊沒有下一個(gè)空閑空間了，為-1
   }

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

//分配固定內(nèi)存的內(nèi)存池
class  MemoryPool
{

public:
   //初始大小 (每一個(gè)MemoryBlock中初始的單元個(gè)數(shù))
   int             nInitCount; 

   //(后面增加的MemoryBlock中單元個(gè)數(shù))   
   int             nGrowSize; 
    
   //分配單元大小，MemoryBlock中每個(gè)單元的大小
   int             nUnitSize; 

   //內(nèi)存塊鏈表
   MemoryBlock*    pBlock;

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

   char  *  Alloc() //每次只返回 nUnitSize 大小的內(nèi)存
   {
   	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，說明內(nèi)存池已滿
   	{
   		pB = (MemoryBlock  *) new (nGrowSize  * nUnitSize) MemoryBlock(nGrowSize, nUnitSize);
   		assert(pB != NULL);

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

   	//得到第一個(gè)可用的空閑內(nèi)存地址
   	char *pFree = pB->aData + pB->nFirst * nUnitSize;
   	//把nFirst值改為下一個(gè)空閑的索引 （存儲(chǔ)在當(dāng)前內(nèi)存的前兩個(gè)字節(jié)）
   	pB->nFirst = *((short*)pFree);
   	pB->nFree--;
   	return  pFree;  
   }

   void   Free(void  *p)
   {
     //考慮這個(gè)地址落在哪個(gè) MemoryBlock 上
   	MemoryBlock  *  pB = pBlock;
   	while (pB  != NULL  &&   p <  pB->aData   ||  p > pB->aData+  pB->nSize   )
   	{
   		pB = pB->pNext;
   	}
   	 
   	if (pB!= NULL)//找到了p所在的MemoryBlock
   	{
   		 //銷毀之前先讓它的前兩個(gè)字節(jié)指向nFirst （當(dāng)前空閑的索引）
   		*((short*)p) = pB->nFirst;

   		 //nFirst的值指向當(dāng)前釋放的
   		 pB->nFirst = ((char *)p - pB->aData) / nUnitSize;

   		 pB->nFree++;
   	}
   	else
   	{
   		printf("錯(cuò)誤，此內(nèi)存并非內(nèi)存池分配的！\n");
   	}
   }

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

   	MemoryBlock  *  pB = pBlock;
   	while (pB != NULL )
   	{
   		printf("\n首地址：%p   總大?。?d   空閑個(gè)數(shù): %d   下一個(gè)空閑：%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;
}