C++ 动态内存管理

 

1. 内存的几种分配方式：

 

         计算机通常具有三种组织方式：堆、栈和静态内存。对应也有三种分配方式：

（1） 在静态存储区中分配。静态存储区中的变量在编译时分配完成，在程序运行整个期间都存在，它的生命周期贯穿整个程序的运行周期。比如全局变量、static变量等。

（2）在栈中分配。自动变量等局部变量在栈中分配存储空间。调用函数时，函数内的局部变量在栈中分配存储空间，它的生命周期与函数的执行时间相同，当函数执行结束时，这些存储单元就会自动释放，其生命周期也就完结了。在栈中分配存储单元效率高，但分配容量有限制。

（3）在堆中分配，亦称动态内存分配。它是唯一一个由程序员管理的内存空间。程序在运行时用new申请空间，并且程序员在不用时用delete释放内存。

 

2. 用new和delete分配内存

 

 （1）new运算符

    <指针名> = new <类型> (<实参表>)

例如：

       int *pInt1,*pInt2;

       pInt1=new int;            //new运算返回一个整数单元的地址

       pInt2=new int (200);    //new一个int单元，并将其初始化为200

      int *pInt3,*pInt4;

      pInt3=new int[10];           //new返回一个有10个整型数组的首地址

      pInt4=new int [2][3];        //同上

     CPoint *poCPoint;

     poCpoint=new CPoint(10,10);  //new返回对象的地址，并在动态内存空间创建了一个对象。执行后，实际得到了两个东西，一个是对象指针变量，另一个是动态内存空间中的对象，而指针变量中的值就是这个动态内存空间中的对象的首地址，也就是动态内存地址。此处的这个对象是没有名字的，如果访问它只有通过这个指针才可以，一旦改变了这个指针的值，就再也没有办法找到对象了，对象所占据的空间也就无法回收，对象也无法访问，造成内存泄露。

（2）delete运算符
 
    delete<指针名>
    delete[]<指针名>     //释放数组
 
例如：（对应上面new的指针）
   
     delete pInt1;
     delete pInt2;
     delete[]pInt3;
     delete[]pInt4;
     delete poCPoint;
执行了delete以后，指针所指向的内存空间就被释放了，但是指针变量的值却没有改变。也就是说指针还指向原来的内存空间。所以执行完delete以后，应该将指针变量的值设为NULL。
   
注：1. 使用new创建数组时，不能为该数组指定初值
        2.使用new分配完了之后，需要判断分配是否成功，才能进行其它操作。
        3.delete只是负责释放指针所指向的内存，而指针本身并没有消失。指针所指向的已经是垃圾了，此时如果再用语句if(p!=NULL)进行防错处理也毫无意义，因为此时指针的值还是原来的值，不是NULL。

 

1. //程序1 ：显示new和delete的基本用法。
2. #include <iostream>
3. using namespace std;
5. class CPoint          //CPoint类
6. {
7. public:
8.     CPoint(int x=0,int y=0);    //构造函数，默认参数x=0,y=0
9.     int SetTemp();             //设置m_temp的值
10.     void Print();              //显示，一般成员函数
11.     void Print() const;         //显示，常成员函数
12. private:
13.     int m_x;
14.     const int m_y;
15.     static const int m_z;
16.     int m_temp;                //增加的数据成员，没有初始化
17. };
19. class CTemp
20. {
21. public:
22.     CTemp(int x)
23.     {
24.         m_temp=x;
25.     }
26. private:
27.     int m_temp;
28. };
30. const int CPoint::m_z=0;          //静态数据初始化方式
32. CPoint::CPoint(int x,int y):m_y(y)       //构造函数，注意常数据成员初始化方式
33. {
34.     m_x=x;
35.     //m_y=y;   //错误,常数据成员必须采用初始化列表的方式初始化,不能用其它赋值方式
36. }
38. int CPoint::SetTemp()
39. {
40.     m_temp++;
41.     return m_temp;
42. }
44. void CPoint::Print()
45. {
46.     cout<<"一般成员函数调用："<<m_x<<","<<m_y<<","<<m_z<<","<<m_temp<<endl;
47. }
49. void CPoint::Print() const
50. {
51.     cout<<"常成员函数调用："<<m_x<<","<<m_y<<","<<m_z<<","<<m_temp<<endl;
52. }
54. //测试函数
55. void main(void)
56. {
57.     const int ARRAY_SIZE=5;
58.     CPoint *pCPoint;
59.     pCPoint=new CPoint[ARRAY_SIZE];//创建5个对象，创建时会自动调用构造函数
60.     if(NULL==pCPoint)
61.     {
62.         cout<<"动态内存分配失败。/n";
63.         exit(0);
64.     }
65.     for(int iCnt=0;iCnt<ARRAY_SIZE;iCnt++)
66.     {
67.         pCPoint[2].SetTemp();           //只修改对象2的m_temp值
68.         pCPoint[iCnt].Print();
69.     }
70.     delete[]pCPoint;  //释放对象数组
71.     //动态释放后，让指针指向NULL，否则，它依然指向原动态空间
72.     pCPoint=NULL;
75.     CTemp *pCTemp=new CTemp(5);
76.     if(NULL==pCTemp)
77.     {
78.         cout<<"动态内存分配失败。/n";
79.         exit(0);
80.     }
81.     //pCTemp=new CTemp[ARRAY_SIZE];  //错误，CTemp没有默认参数构造函数
82.     delete pCTemp;   //释放单个对象
84.     CPoint *pCPoint2=new CPoint(5,6);
85.     if(NULL==pCPoint2)
86.     {
87.         cout<<"动态内存分配失败。/n";
88.         exit(0);
89.     }
90.     delete pCPoint2;
91.     
92.     
93.     //后面的对象都不在动态内存中，不能用delete释放，也无需用户释放，由系统自动释放
94.     CPoint oCPoint1(1,1),oCPoint2;
95.     const CPoint ocCPoint3(3,3);
96.     //ocCPoint3.SetTemp();           //错误，常对象不可以调用一般成员函数
97.     oCPoint1.Print();
98.     oCPoint2.Print();
99.     ocCPoint3.Print();
100. }

输出结果如下：

一般成员函数调用：0,0,0,-842150451
一般成员函数调用：0,0,0,-842150451
一般成员函数调用：0,0,0,-842150448
一般成员函数调用：0,0,0,-842150451
一般成员函数调用：0,0,0,-842150451
一般成员函数调用：1,1,0,-858993460
一般成员函数调用：0,0,0,-858993460
常成员函数调用：3,3,0,-858993460
Press any key to continue

 

可以看出，m_temp的值无法确定，因为它没有初始化。

 

（3）对对象数组中的每一个对象进行初始化有两种方法：

        A、在类中不定义构造函数，而定义一个成员函数专门用来完成初始化。

        B、在所定义的类中增加不带参数或带默认参数的构造函数。

 

3. 常见的动态内存错误

 

（1）使用未分配成功的动态内存空间。

（2）使用未经初始化的动态内存空间。

（3）超过了内存空间的边界使用。

（4）内存泄露。

（5）使用已经释放的内存空间。