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

计算机的程序由代码和数据构成,一个程序占用的内存可以分为代码段和数据段,而数据区又分为常量存储区、静态存储区、堆和栈。这里主要讨论一下堆内存和栈内存。
栈内存由自动申请和释放,所申请的内存在变量作用域内有效,退出变量作用域时被释放,这个过程由编译器来完成,安全系数相对较高,效率较堆内存高。堆上的内存由程序员显式的申请并显式的释放,如果只申请不释放,便会造成内存泄露,申请后重复释放,则会造成程序崩溃。因此显式的申请内存更加的“不安全”。
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,而是要防止同一块内存被重复释放。既要防止显式的重复释放,更要防止隐式的重复释放。这样,我们的代码才更安全。

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页