Stack vs. Heap

 

栈比堆更有效率

要注意的是：
如果你的对象需要在其他函数中使用就不能在栈上分配。因为在栈上的对象会随着

函数的返回而消亡。
如果你需要一个可变长度的对象也不能在栈上分配，因为栈上分配的内存必须在编

译的时候就要确定。
当你定义一个对象（比如类的实例）在栈上。当这个对象生命期结束的时候，会自

动调用析构函数来打扫内存。相反，如果你是在堆上分配的，那么你必须警觉内存

泄露的问题！

举个例子：

1. <code> 
3.   // ** Stack Allocation ** 
4.   { 
5.       // Allocate MyClass instance on the stack 
6.       MyClass c; 
8.       … use c 
10.   } // c destructor called by C++ compiler 
12.   // ** Heap Allocation ** 
13.   { 
14.       // Allocate on the heap 
15.       MyClass * ptrC = new MyClass(); 
17.       …use heap-allocated instance 
18.       ptrC->DoSomething(…); 
20.   } // Destructor *not* called here! Memory leak! 
21.    // Must do an explicit delete ptrC; 
23. </code> 

总之，如果你只是一个小的对象，你可以在栈上分配内存。相反，如果你的对象要

占用大量内存。你就应该在堆上分配。

同时注意到，C++ 的STL容器类 （比如 std::vector）是可以分配在栈上的。但是

请注意，其内部实现中的内存分配实际上是在堆上进行的。比如：
std::vector<double>someData(1000)
这个向量对象(someData)是分配在栈上的。没错吧？可是 ，其内部数据(这1000个

double类型的值)是通过std::vector的内部机制分配在堆上的。

 

总之，如果一个对象需要在其局部作用域之外存在，就需要在堆上分配内存。反之

，就在栈上分配内存才合适。
另外，当我们在堆上分配内存的时候，使用一些标准库里面的类型(CArray or

std::vector )是一个比较好的选择。因为有其生成的对象的析构函数保证在其离开

作用域的时候正常的调用，而不会产生内存泄露等严重问题。

1. Case 1:
2. Poor strategy: 
3. CMyDIalog * dlg = new CMyDialog; 
4. dlg->DoModal(); 
5. //… 
6. delete dlg; 
8. Good strategy:
10. CMyDialog dlg; 
11. dlg.DoModal(); 
12. //… 
13. Case 2:
14. Poor strategy: 
15. LPBYTE b = new BYTE[size]; 
16. //… 
17. delete b; 
18. Good strategy:
19. CByteArray b; 
20. b.SetSize(size); 
22. or 
24. std::vector<BYTE> b; 
25. b.resize(size); 
26. Case 3:
28. Poor strategy: 
30. LPDWORD d = new DWORD; 
31. *d = 0; 
32. Function1(d); 
33. //… 
34. delete d; 
36. Good strategy:
38. DWORD d = 0; 
39. Function1(&d); 
40. // … 
41. Case 4:
43. Poor strategy(failing strategy): 
45. TCHAR buffer[COMPILE_TIME_SIZE]; 
46. read_stuff_into(buffer); 
47. PostMessage(WM_USE_DATA, (WPARAM)buffer); 
49. Good strategy: 
51. TCHAR buffer[COMPILE_TIME_SIZE]; 
52. read_stuff_into(buffer); 
53. SendMessage(WM_USE_DATA, (WPARAM)buffer); 
55. or
57. TCHAR * buffer = new TCHAR[COMPILE_TIME_SIZE]; 
58. read_stuff_into(buffer); 
59. PostMessage(WM_USE_DATA, (WPARAM)buffer);  //delete the pointer in the message handler

 上述例子表明了这些在函数中声明的对象在其离开函数作用域之后仍然是需要存在

的。

如果你没有必要把内存分配在堆上那就不做

如果你需要对象存在更长的时间，请放在堆上。