安全的代码之内存的申请和释放

计算机的程序由代码和数据构成，一个程序占用的内存可以分为代码段和数据段，而数据区又分为常量存储区、静态存储区、堆和栈。这里主要讨论一下堆内存和栈内存。
栈内存由自动申请和释放，所申请的内存在变量作用域内有效，退出变量作用域时被释放，这个过程由编译器来完成，安全系数相对较高，效率较堆内存高。堆上的内存由程序员显式的申请并显式的释放，如果只申请不释放，便会造成内存泄露，申请后重复释放，则会造成程序崩溃。因此显式的申请内存更加的“不安全”。
C++可以通过new操作符从堆上申请内存，通过delete来显式地释放内存。我们来看下面一段程序：
class A
{
public：
       int data；
};
int main()
{
       A *pA = new A;-------------------------------------------------⑴
       std::cout << pA->data << std::endl;--------------------------⑵
       delete pA;--------------------------------------------------------⑶
       return 0;
}
上面一段代码表面上看是没有问题，但实际上是非常不安全的。首先从堆上new内存不一定能够成功，而在⑵处直接访问指针指向的对象，是非常危险的，违背了“指针使用前要判空”的原则；此外，在⑶处释放内存也是一个不好的习惯，相对好一点的习惯来释放一块内存是这样的：判空（首先判断该指针是否空指针）、释放（delete）、置空（将指针置成NULL，防止野指针）。
C++的delete总共作了两件事情：调用对象的析构函数、free内存。而delete一个指针干的事情无非是这样的：现在有一个指针指向了一块内存，调用该指针指向对象的析构函数，将该指针指向的内存放入内存空闲队列当中。需要注意的是：free一块内存，并不是说这块内存就没有了，所做的改变只是该块内存中的标志位由“使用中”修改成了“未使用”，而这块内存还是确确实实存在的，指针还是指向了这块内存的首地址。而这时候如果再free这块内存，换句话说再来修改这个标志位的话，编译器是不能够容忍的，而再来访问这个指针指向的内存，也会引起意想不到的结果的。请看下面一段代码：
int main()
{
A *pA = new A;-------------------------------------------------⑴
       std::cout << pA->data << std::endl;--------------------------⑵
       delete pA;--------------------------------------------------------⑶
    std::cout << pA->data << std::endl;--------------------------⑷
    delete pA;--------------------------------------------------------⑸
       return 0;
}
上面一段代码在⑶处对指针进行了释放，而在⑷处又访问了pA指向内存的一个变量，对于这种情况，如果这一段内存还没被占用，那么访问到的数据可能还是正常的，但如果该段内存已经被其它线程所占用，那么获得的将是不可预料的结果。而对于⑸处的操作，相当于让一个标志位从0变成0，这样编译器是不允许的，必将造成系统core dump。
因此对于指针的使用，我们要求使用前先判空；对于指针的delete我们要严格按照三部曲来执行。
对于delete我们可以实现如下的宏：
#define DELETE(p)\
do\
{\
    if(NULL != p)\
    {\
        delete(p);\
        p = NULL;\
}\
}\
while(0)
这样，我们来改写一下上面的main函数：
int main()
{
A *pA = new A;-------------------------------------------------⑴
       if(NULL != pA)
       {
std::cout << pA->data << std::endl;--------------------⑵
}
       DELETE(pA);------------------------------------------------------⑶
    if(NULL != pA)
       {
        std::cout << pA->data << std::endl;--------------------⑷
}
    DELETE (pA);------------------------------------------------------⑸
       return 0;
}

在坚持以上申请和释放的原则之后，⑷和⑸处的代码实际上没有做任何事情，⑷处的代码根本将不被执行，这样相对就安全的多。

但是不是我们坚持了申请和释放的原则并有了DELETE之后就万事大吉了呢？不是的，请看下面一段代码：
void fuction(A* pA)
{
    if(NULL != pA)
       {
        std::cout << pA->data << std::endl;
}
    DELETE(pA);---------------------------------⑴
}
int main()
{
       A* pA = new A;
       if(NULL != pA)
       {
        std::cout << pA->data << std::endl;
}
       DELETE(pA);-----------------------------------------------⑵
}
上面的代码有没有问题？答案是肯定的，从表面上看，使用了我们自己定义的宏对指针进行delete，应该是没有问题的。
但实际上，程序的执行是这样的：在main函数种new了一块内存用pA指向，但在调用fuction方法时，该指针作为临时变量又被拷贝了一份，也就是说有两个指针指向了同一块内存区域，我们姑且假定新拷贝出来的指针为pB，在进入fuction函数时，实际效果如下图所示：

而在退出fuction函数时实际效果如下图：

也就是说，pA指向了一个已经被释放的内存，而pA并不是NULL，而这时候在main函数当中对pA进行delete操作，判空是不起作用的，从而释放了一块被释放的内存，程序core dump。
此外，我们再来看一下拷贝构造带来的隐患。
对于一个类而言，应该有一个构造函数、一个析构函数，此外还需要有一个拷贝构造函数，如果程序员没有显示的定义这三个函数，那么编译器将默认生成这三个函数，对于拷贝构造函数而言，编译器生成的拷贝构造函数将使用“按位拷贝”，即所谓的“浅拷贝”。请看下面一段代码：
class B
{
pubic:
       B()
       {
              m_pA = new A;
}
~B()
{
       DELETE(m_pA);
}
       private:
              A * m_pA;
}
 
void fuction(B b)
{
}
 
int main()
{
       B* pB = new B;
       fuction(*pB);
       DELETE(pB);
}
上面的代码有没有问题呢？很遗憾，也是有问题的。在进入fuction函数的时候*pB被进行了一次拷贝构造，放在了栈空间上，在fuction函数退出时，栈空间上的对象被释放，B的析构函数被调用，所指向的内存已经被free，而退出main函数的时候，又进行了一次DELETE，这时候相当于重复调用B的析构函数重复释放一块内存，这将给程序带来致命的后果。
解决上述问题的一个办法：使用引用传递来代替值传递，这样将不会进行拷贝构造，在栈退出时也不会进行析构。实际上，我们是不赞成使用值传递来处理内部结构体的，因为这样会进行多次的拷贝构造和析构，对程序的性能也会造成很大的影响。
解决问题的另外一个办法：为class B增加一个私有的拷贝构造函数（可以只声明，不实现），这样，上述代码在编译的时候即会报错，而不会出现运行时的bug。
我们习惯用指针指向一块内存，但我们不能被指针华丽的外表所迷惑，我们的目的不是防止指针被重复的delete，而是要防止同一块内存被重复释放。既要防止显式的重复释放，更要防止隐式的重复释放。这样，我们的代码才更安全。