C/C++内存分布
int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
const char* 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);
}
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里? globaVar是全局变量,全局变量和静态变量都放在静态区.C
staticGlobalVar在哪里? C
staticVar在哪里? C
前两个变量定义在函数之前,在执行Test前就会初始化,后面这个staticVar则是在执行到该语句后才初始化.前两个在哪都能用,作用域是全局的,而staticVar只能在Test内使用
而前两个虽然都是全局变量,但是链接属性不同,globalVar所有文件可见,但是staticGlobalVar只在当前文件可见.
localVar在哪里? A
num1 在哪里? A
char2在哪里? 是一个数组,所以存在栈区 A
*char2在哪里? 数组名是首元素地址,解引用就是首元素,所以还是栈 A
pChar3在哪里? pChar3是地址,存在栈上
*pChar3在哪里? pChar3是地址,指向常量字符串,所以存在常量区 D
ptr1在哪里? ptr1是地址,所以存在栈 A
*ptr1在哪里? ptr1指向的内容是malloc的,解引用后应该存在堆 B
sizeof(num1) = 40;num1是长度为10的数组,sizeof得到的是内存大小.int是4字节,所以大小为10×4=40.
sizeof(char2) = 5;除了”abcd”外,还有个”\0″
strlen(char2)=4; strlen遇到\0就直接结束
sizeof(pChar3) = 4/8;pChar3是个指针,取决于平台

操作系统的内存管理:
1.分段:用途不同的数据放到不同的区域.
2.分页:每个进程都要自己的虚拟内存和物理内存,二者之间会进行映射.我们平时看到的都是虚拟地址,去访问空间如果发现没有触发缺页中断,然后就会在中断中建立地址联系.
动态内存管理
动态内存管理指向堆区申请一片空间.
malloc:申请空间;
calloc:申请空间并初始化为0;
realloc:对原本申请的空间进行扩容.
除了这些方式外,C++还提供了新的申请\释放空间的方式.
int main()
{
int* p2 = new int(10);//申请一个四字节的int空间,初始化为10
int* p3 = new int[10];//申请10个int的空间,共40字节
delete p2;
delete[] p3;
return 0;
}

既然C已经有了malloc和free,那C++的new和delete意义何在?
1.对于申请内置类型的空间,它们效果是意义的,但是如果是申请自定义类型,效果就有区别了
class A
{
private:
int _a;
public:
A()
:_a(0)
{}
};
int main()
{
A* a1 = (A*)malloc(sizeof(A));
A* a2 = new A;
return 0;
}
得到的结果如下:

可以看到,使用new来分配内存时会调用其构造函数进行初始化.同样的,free只会是对内存进行释放,而delete还会调用其析构函数再释放空间.
operator new和operator delete
new/delete是一个操作符,而operator new/delete实际上是一个函数。它的用法与malloc一致
class A
{
private:
int _a;
public:
A()
:_a(0)
{
cout << "A()" << endl;
}
~A()
{
cout << "~A()" << endl;
}
};
int main()
{
A* a1 = (A*)malloc(sizeof(A));
A* a2 = new A;
A* p3 = (A*)operator new(sizeof(A));
operator delete(p3);
return 0;
}
得到的结果是:只调用了一次构造函数,是由new调用的,那么operator new有啥用?
operator new和malloc的区别在于对申请失败时的处理。
malloc申请空间失败以后会返回0,而operator new失败后会抛异常(直接让程序崩溃).抛异常的解决方式是可以利用catch对异常进行捕获,实际上是面向对象的一种处理错误的方式.
#补充
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
// try to allocate size bytes
void *p;
while ((p = malloc(size)) == 0)
{
/*
operator new:该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间失败,尝试执行空间不足应对措施,如果该应对措施用户设置了,则继续申请,否则抛异常
*/
if (_callnewh(size) == 0)
{
// report no memory
// 如果申请内存失败了,这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}
}
return (p);
}
可以看到:实现为将malloc的结果赋值给p,如果p!=0,也就是申请空间成功,就会跳出while,并将p返回;如果申请失败,p=0,就会进入while调用一个函数_callnewh,这个函数内就会抛出bad_alloc的异常.
所以实际上,operator new就是由malloc实现的,在绝大部分时候都和malloc一致,只有分配错误处理上的区别.所以
operator new=malloc+抛异常;new=operator new+构造函数
而operator delete和delete没有区别,只是为了保证对称性.
#define free(p) _free_dbg(p, _NORMAL_BLOCK)
void operator delete(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_FINALLY
return;
}
默认调用的new是全局的new,但是我们也可也在类中自己定义,重载一个专属的operator new.
new和delete的实现原理
new的原理
1.调用operator new函数申请空间
2.在申请的空间上执行构造函数,完成对象的构造
delete的原理
1.在空间上执行析构函数,完成对象中资源的清理工作
2.调用operator delete函数释放对象的空间
new T[N]的原理
1.调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对象空间的申请
2.在申请的空间上执行N次构造函数
delete[]的原理
1.在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理
2.调用operator delete[]释放空间,实际在operator delete[]中调用operator delete来释放空间
定位new
假设我想模拟如下行为
int main()
{
A* p = new A;
delete p;
return 0;
}
new=operator new+构造函数,所以我利用operator new申请一块空间,然后调用构造函数.但是构造函数是不能显式调用的,为了能够对一块已经存在的空间调用构造函数进行初始化,我们出现了定位new/replacement new
int main()
{
A* p3 = (A*)operator new(sizeof(A));
new(p3)A(10);//定位new:new()+构造函数
p3->~A();//析构函数是可以显式调用的
return 0;
}
常见问题
1.malloc/free和new/delete的区别是什么
malloc/free和new/delete的共同点是:都是从堆上申请空间,并且需要用户手动释放。不同的地
方是:
- malloc和free是函数,new和delete是操作符
- malloc申请的空间不会初始化,new可以初始化
- malloc申请空间时,需要手动计算空间大小并传递,new只需在其后跟上空间的类型即可, 如果是多个对象,[]中指定对象个数即可
- malloc的返回值为void*, 在使用时必须强转,new不需要,因为new后跟的是空间的类型
- malloc申请空间失败时,返回的是NULL,因此使用时必须判空,new不需要,但是new需要捕获异常
- 申请自定义类型对象时,malloc/free只会开辟空间,不会调用构造函数与析构函数,而new在申请空间后会调用构造函数完成对象的初始化,delete在释放空间前会调用析构函数完成空间中资源的清理
2.内存泄漏
如果忘记释放开辟的内存就会导致内存泄漏。如果程序长期运行就会导致内存不断被占用造成响应越来越慢,最终导致卡死。泄漏的地址依然在那,但是没有办法再给其他程序使用。

