c++ virtual 虚析构函数 资源释放的讨论
关于c++ virtual，析构函数的讨论已经挺多了，参见
http://zxjgoodboy.blog.sohu.com/61482463.html
http://blog.csdn.net/zoukh/article/details/16624
http://blog.csdn.net/han_348154920/article/details/5944351
http://hi.baidu.com/bystander1983/blog/item/d61627553e3afe52d10906d2.html
http://www.cnblogs.com/powersun/archive/2007/08/13/853015.html
http://www.cnblogs.com/xd502djj/archive/2010/09/22/1832912.html
但是这些文章大多在讨论：通过虚析构函数，可以利用多态顺利释放资源，防止内存泄露。
但是我在使用时却恰恰发生了相反的事情，不是内存泄漏，而是内存重复删除。这也是一个需要深思的问题。
我们还是以传统的animal和dog为例。
首先是基类 animal
#pragma once
class animal
{
public :
animal( void );
virtual ~ animal( void );
int * type;
virtual void allocate( int n);
virtual void release();
};
实现
#include " animal.h "
#include " stdio.h "
animal::animal( void ):type( 0 )
{
}
animal:: ~ animal( void )
{
release();
}
void animal::allocate( int n )
{
release();
puts( " allocate from Animal start! " );
type = new int [n];
puts( " allocate from Animal end! " );
}
void animal::release()
{
puts( " release from Animal start! " );
if (type)
{
delete [] type;
}
puts( " release from Animal end! " );
}
.
派生类dog
#pragma once
#include " animal.h "
class dog :
public animal
{
public :
dog( void );
virtual ~ dog( void );
int * country;
virtual void allocate( int n);
virtual void release();
};
.
实现
#include " dog.h "
#include " stdio.h "
dog::dog( void ):country( 0 )
{}
dog:: ~ dog( void )
{}
void dog::allocate( int n)
{
puts( " allocate from Dog start! " );
animal::allocate(n);
country = new int [n];
puts( " allocate from Dog end! " );
}
void dog::release()
{
puts( " release from Dog start! " );
animal::release();
if (country)
{
delete []country;
}
puts( " release from Dog end! " );
}
.
.
main里考察分别使用基类和派生类指针的情形
#include " dog.h "
#include " stdio.h "
int main()
{
animal * a = new dog();
a -> allocate( 12 );
delete a;
puts( " \na finished!\n " );
dog * b = new dog();
b -> allocate( 12 );
delete b;
puts( " \nb finished!\n " );
}
运行结果是
allocate from Dog start !
release from Dog start !
release from Animal start !
release from Animal end !
release from Dog end !
allocate from Animal start !
allocate from Animal end !
allocate from Dog end !
release from Animal start !
release from Animal end !
a finished !
allocate from Dog start !
release from Dog start !
release from Animal start !
release from Animal end !
release from Dog end !
allocate from Animal start !
allocate from Animal end !
allocate from Dog end !
release from Animal start !
release from Animal end !
b finished !
.
两种情形是一致的，但是要注意对于单一情形，在allocate和析构函数中，都是在基类里调用了release()，但表现的结果确完全不同：
allocate成功使用了多态，析构函数却只是调用了animal::release()
产生这种问题的根源在于：派生类的普通成员函数会对基类的同签名函数产生隐藏，调用派生类的函数不会触发基类的函数；但是析构函数就恰恰相反，调用派生类的析构函数后会紧接着调用基类的析构函数。
也就是说，我在dog::allocate()中显式的调用animal::allocate()，也就顺次显式调用release()，实际上使用派生类指针调用基类函数，恰好满足多态条件，因此运行正常。
但是在dog::~dog()中，我没用显示调用基类析构函数，而是系统隐式调用的；但是系统隐式调用时，派生类已经析构了，它是按照animal::~animal()来调用的，那么release()也就只是有基类指针使用，因此没有使用多态，animal发生了内存泄露。
那么，我如果在dog::~dog()中显式的调用release()行不行呢?
我们试试看
dog:: ~ dog( void )
{
release();
}
现在的程序输出是
allocate from Dog start !
release from Dog start !
release from Animal start !
release from Animal end !
release from Dog end !
allocate from Animal start !
allocate from Animal end !
allocate from Dog end !
release from Dog start !
release from Animal start !
release from Animal end !
release from Dog end !
release from Animal start !
没错，就是这些！程序就在这卡着。（我的开发环境是 vs2010+win7）
尝试调试，说程序陷入死锁状态。仔细观察最后5句，发现 dog::~dog()里的release()顺利执行，在调用基类的析构函数时卡住了。类似的情况我在另一个大点的项目中则是直接崩溃了。
分析一下这里原因也好理解，animal::release()函数被调用了两次，第二次调用时产生死锁或者崩溃。
那么是我程序哪里实现的有问题么？
allocate与release都应该是virtual的吧？
dog::release()中必须要调用 animal::release()才合理吧？
那么现在陷入了两难困境：dog::~dog()中到底应不应该调用release()呢？调用，程序崩溃；不调用，内存泄露。
.
.
很让人头疼的问题。
无奈，我只好曲线救国，把release拆分成了两部分来实现，总算可以实现目标，但这样确实太丑了。
animal.h
#pragma once
class animal
{
public:
animal(void);
virtual ~animal(void);
int * type;
virtual void allocate(int n);
virtual void release();
void releaseMyData();
};
animal.cpp
#include " animal.h "
#include " stdio.h "
animal::animal( void ):type( 0 )
{
}
animal:: ~ animal( void )
{
release();
}
void animal::allocate( int n )
{
release();
puts( " allocate from Animal start! " );
type = new int [n];
puts( " allocate from Animal end! " );
}
void animal::release()
{
releaseMyData();
}
void animal::releaseMyData()
{
puts( " release from Animal start! " );
if (type)
{
delete [] type;
}
puts( " release from Animal end! " );
}
dog.h
#pragma once
#include " animal.h "
class dog :
public animal
{
public :
dog( void );
virtual ~ dog( void );
int * country;
virtual void allocate( int n);
virtual void release();
void releaseMyData();
};
dog.cpp
#include " dog.h "
#include " stdio.h "
dog::dog( void ):country( 0 )
{}
dog:: ~ dog( void )
{
releaseMyData();
}
void dog::allocate( int n)
{
puts( " allocate from Dog start! " );
animal::allocate(n);
country = new int [n];
puts( " allocate from Dog end! " );
}
void dog::release()
{
animal::release();
releaseMyData();
}
void dog::releaseMyData()
{
puts( " release from Dog start! " );
if (country)
{
delete []country;
}
puts( " release from Dog end! " );
}
你聪明的，告诉我，我哪里错了？有什么解决方案啊？