intglobalVar=1;
staticintstaticGlobalVar=1;
voidTest()
{
staticintstaticVar=1;
intlocalVar=1;
intnum1[10] = { 1, 2, 3, 4 };
charchar2[] ="abcd";
constchar*pChar3="abcd";
int*ptr1= (int*)malloc(sizeof(int) *4);
int*ptr2= (int*)calloc(4, sizeof(int));
int*ptr3= (int*)realloc(ptr2, sizeof(int) *4);
free(ptr1);
free(ptr3);
}
1.选择题：选项 : A.栈B.堆C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？____staticGlobalVar在哪里？____staticVar在哪里？____localVar在哪里？____num1在哪里？____char2在哪里？____*char2在哪里？___pChar3在哪里？____*pChar3在哪里？____ptr1在哪里？____*ptr1在哪里？____2.填空题：sizeof(num1) =____;
sizeof(char2) =____; strlen(char2) =____;
sizeof(pChar3) =____; strlen(pChar3) =____;
sizeof(ptr1) =____;
3.sizeof和strlen区别？

voidTest()
{
int*p1= (int*)malloc(sizeof(int));
free(p1);
// 1.malloc/calloc/realloc的区别是什么？int*p2= (int*)calloc(4, sizeof(int));
int*p3= (int*)realloc(p2, sizeof(int) *10);
// 这里需要free(p2)吗？答案是不需要，为什么？因为realloc将p2原本指向的内存释放，并重新开辟了新的内存给了p3free(p3);
}

voidTest()
{
int*ptr4=newint;//动态开辟一个int空间deleteptr4;
int*ptr5=newint(10);//动态申请一个int类型的空间并初始化为10deleteptr5;
int*ptr6=newint[3];//申请3个int类型的空间delete[] ptr6;
int*ptr7=newint[3] {1, 2, 3};//申请3个int类型的空间并进行初始化delete[] ptr7;
}

classA{
public:
A(inta=0)
        :_a(a)
    {
cout<<"A():"<<this<<endl;
    }
~A()
    {
cout<<"~A():"<<this<<endl;
    }
private:
int_a;
};
intmain()
{
// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数A*p1= (A*)malloc(sizeof(A));
A*p2=newA(1);
free(p1);
deletep2;
// 内置类型是几乎是一样的int*p3= (int*)malloc(sizeof(int)); // Cint*p4=newint;
free(p3);
deletep4;
A*p5= (A*)malloc(sizeof(A) *10);
A*p6=newA[10];
free(p5);
delete[] p6;
return0;
}

void*__CRTDECLoperatornew(size_tsize) _THROW1(_STDbad_alloc)
{
// try to allocate size bytesvoid*p;
while ((p=malloc(size)) ==0)
if (_callnewh(size) ==0)
        {
// report no memory// 如果申请内存失败了，这里会抛出bad_alloc 类型异常staticconststd::bad_allocnomem;
_RAISE(nomem);
        }
return (p);
}
/*operator delete: 该函数最终是通过free来释放空间的*/voidoperatordelete(void*pUserData)
{
_CrtMemBlockHeader*pHead;
RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData==NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */__TRY/* get a pointer to memory block header */pHead=pHdr(pUserData);
/* verify block type */_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg(pUserData, pHead->nBlockUse);
__FINALLY_munlock(_HEAP_LOCK); /* release other threads */__END_TRY_FINALLYreturn;
}
/*free的实现*/#define free(p) _free_dbg(p, _NORMAL_BLOCK)

#include<iostream>usingnamespacestd;
voidTest()
{
try    {
while (1)
        {
// new失败 抛异常 -- 不需要检查返回值char*p1=newchar[1024*1024*1024];
cout<< (void*)p1<<endl;
        }
    }
catch (conststd::exception&e)
    {
cout<<e.what() <<endl;
    }
}
intmain()
{
Test();
return0;
}

classA{
public:
A(inta=0)
        : _a(a)
    {
cout<<"A():"<<this<<endl;
    }
~A()
    {
cout<<"~A():"<<this<<endl;
    }
private:
int_a;
};
intmain()
{
A*p1=newA[10];
delete[] p1;
return0;
}

classA{
public:
A(inta=0)
        : _a(a)
    {
cout<<"A():"<<this<<endl;
    }
~A()
    {
cout<<"~A():"<<this<<endl;
    }
private:
int_a;
};
intmain()
{
A*p3= (A*)malloc(sizeof(A));
if (p3==nullptr)
    {
perror("malloc fail");
exit(-1);
    }
// 定位new -- 对p3指向空间，显示调用构造函数初始化new(p3)A(1);
deletep3;
return0;
}

voidMemoryLeaks()
{
// 1.内存申请了忘记释放int*p1= (int*)malloc(sizeof(int));
int*p2=newint;
// 2.异常安全问题int*p3=newint[10];
Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.delete[] p3;
}

intmain()
{
int*p=newint[10];
// 将该函数放在main函数之后，每次程序退出的时候就会检测是否存在内存泄漏_CrtDumpMemoryLeaks();
return0;
}