new对象数组时的内存布局

Posted 2020-06-13

 

[cpp] view plain copy

 

1. #include <iostream>  
2. #include <limits>  
3.   
4. using namespace std;  
5.   
6. #define SAFE_DELETE(x) \  
7. { \  
8.     if (NULL != (x)) \  
9.     { \  
10.         delete (x); \  
11.         (x) = NULL; \  
12.     } \  
13. }  
14.   
15. #define SAFE_DELETE_ARY(x) \  
16. { \  
17.     if (NULL != (x)) \  
18.     { \  
19.         delete[] (x); \  
20.         (x) = NULL; \  
21.     } \  
22. }  
23.   
24. class CA  
25. {  
26. public:  
27.     CA()  
28.     {  
29.         setter_m_iTest(-1);  
30.     }  
31.   
32.     ~CA() {}  
33.   
34.     void setter_m_iTest(int iIn) {m_iTest = iIn;}  
35.     int getter_m_iTest() {return m_iTest;}  
36.   
37. private:  
38.     int m_iTest;  
39. };  
40.   
41. void fnTestClass();  
42. void clear_cin();  
43.   
44. int main(int argc, char** argv, char** envp)  
45. {  
46.     fnTestClass();  
47.   
48.     cout << "END, press any key to quit" << endl;  
49.     clear_cin();  
50.     getchar();  
51.   
52.     return 0;  
53. }  
54.   
55. void fnTestClass()  
56. {  
57.     int i = 0;  
58.     int iTmp = 0;  
59.     const int iCntAry = 4;  
60.     CA* pCaAry = NULL;  
61.     CA* pCa = NULL;  
62.   
63.     /** new 单个对象时的内存布局 
64.     +   pCa 0x00883e30 
65.     00883E30  01 00 00 00  .... ///< pCa 
66.     */  
67.   
68.     pCa = new CA;  
69.     if (NULL != pCa)  
70.     {  
71.         pCa->setter_m_iTest(1);  
72.         SAFE_DELETE(pCa); ///< delete后, 原来的数据变为 EE FE EE FE  
73.     }  
74.   
75.     /** new对象数组时的内存布局 
76.     +   pCaAry  0x007d3ddc 
77.  
78.       007D3DD8  04 00 00 00  .... ; ///< 类数组元素个数 = 4 
79.       007D3DDC  00 00 00 00  .... ; ///< 类数组开始, CA[0] 
80.       007D3DE0  01 00 00 00  .... ; ///< CA[1] 
81.       007D3DE4  02 00 00 00  .... ; ///< CA[2] 
82.       007D3DE8  03 00 00 00  .... ; ///< CA[3] 
83.     */  
84.       
85.     pCaAry = new CA[iCntAry];  
86.     if (NULL != pCaAry)  
87.     {  
88.         for (i = 0; i < iCntAry; i++)  
89.         {  
90.             pCaAry[i].setter_m_iTest(i);  
91.         }  
92.     }  
93.   
94.     SAFE_DELETE_ARY(pCaAry);  
95.   
96.     /** 手工模拟delete删除单个对象 
97.     */  
98.   
99.     pCa = new CA;  
100.     if (NULL != pCa)  
101.     {  
102.         pCa->setter_m_iTest(1);  
103.         if (NULL != pCa)  
104.         {  
105.             pCa->~CA();  
106.             free(pCa); ///< ok  
107.             pCa = NULL;  
108.         }  
109.     }  
110.   
111.     /** 手工模拟delete删除对象数组 
112.     会报错, 和实际情况不同 
113.     以后再研究 :( 
114.     */  
115.   
116.     // 会报错, 和实际情况不同  
117. //     pCaAry = new CA[iCntAry];  
118. //     if (NULL != pCaAry)  
119. //     {  
120. //         iTmp = *((int*)pCaAry - 1);  
121. //         for (i = 0; i < iTmp; i++)  
122. //         {  
123. //             pCaAry[i].setter_m_iTest(i);  
124. //             pCaAry[i].~CA();  
125. //         }  
126. //   
127. //         free(pCaAry); ///< ! crash  
128. //         pCaAry = NULL;  
129. //     }  
130.   
131.     // 会报错, 和实际情况不同  
132. //     pCaAry = new CA[iCntAry];  
133. //     if (NULL != pCaAry)  
134. //     {  
135. //         iTmp = *((int*)pCaAry - 1);  
136. //         for (i = 0; i < iTmp; i++)  
137. //         {  
138. //             pCaAry[i].setter_m_iTest(i);  
139. //             pCaAry[i].~CA();  
140. //             free(pCaAry + i); ///< ! crash  
141. //         }  
142. //   
143. //         pCaAry = NULL;  
144. //     }  
145. }  
146.   
147. void clear_cin()  
148. {  
149.     cin.clear();  
150.     cin.sync();  
151. }  

http://blog.csdn.net/lostspeed/article/details/50300867