C++实现垃圾回收机制

C++实现垃圾回收机制

我想讨论的问题是，如何让下面的代码正确无误：

#include <iostream>

classHuman
{
public:
Human()
{
std::cout << "Human" << std::endl;
}
~Human()
{
std::cout << "~Human()" << std::endl;
}
};
int main()

{

Human*pHuman = new Human;

system(“pause”);

return0;

}

有没有发现其中的错误，而且这个错误很严重，嗯……我想你发现了，没有delete pHuman回收指针所指的内存空间，怎么知道？起码Human的析构函数没有调用，这会造成内存泄漏，非常严重的问题。就想你借了人家钱而不还一样，当然，如果你借的钱少，那问题不至于严重到不可收拾的地步，但是你借了很多钱而不还，那可麻烦了。

在Java、C#、AS这些语言中，上面的代码是没有任何问题的，因为你借了这些内存空间，在程序结束后，虚拟机会帮你还，也就是说，它们自带有垃圾回收机制，而C++？必须得手动delete，如果只是new出来一两个，手动delete还不觉得这么麻烦，但是如果你new出来很多东西，那怎么办，你得一个个记住，然后一个个delete？就像你借了很多人的钱，你必须记住谁谁借了钱给我，你这时会感叹，如果能有个人帮我还钱，那该多好啊，那样的话，你就只管借而不用担心钱没还而惹来的麻烦了。那在C++里，怎么实现呢？

你可能会想到用智能指针来管理，嗯……很好的想法，很自然的，你会修改上面的代码：

intmain()

{

std::auto_ptr<Human> pHuman(new Human);

system(“pause”);

return;

}

如果编译器说std里没有auto_ptr的话，#include<memory>就可以了，这就是智能指针的好处，只要你这个智能指针不是new创建出来的，它会答应帮你delete掉，如果你是new出来的，那么也得delete，否则它无法完成它的承诺。

也就是说要像下面那样：

int main()

{

std::auto_ptr<Human>*pHuman = new std::auto_ptr<Human>(new Human);

delete pHuman;

system(“pause”);

return;

}

如果你new创建智能指针的话，问题又继续循环了，所以智能指针不是用new出来的，否则你也必须delete。也就是说你借了那个帮你还钱的人的钱，所以你得先把钱还给他，他才帮你还清其他的钱。

OK，你保证你使用智能指针不new创建出来，那事情是不是就完了呢？当然还没，使用std::auto_ptr还有其他要注意的问题，想知道详细的话，研究Effective
C++和More Effective C++便可以了解。但在这里不是我讨论的重点，我想讨论的是，智能指针的原理是什么？看下面代码便清楚了：

classHumanPtr
{
private:
Human* m_ptr;
public:
HumanPtr(Human* ptr = 0):m_ptr(ptr)
{
}
~HumanPtr()
{
if(m_ptr)
{
deletem_ptr;
m_ptr = 0;
}
}
};
那么像下面那样子使用：

int main()

{

HumanPtrpHuman(new Human);

/.../

}

也就是只要把new创建出来的那个指针放到一个对象里保存，而这个对象不是使用new创建的，只要符合这个规则即可实现只需new创建，而不用delete。

那为什么会自动帮我delete呢？

我们知道，每个对象都有一个生命周期，当生命结束后，系统会调用它的析构函数，然后回收它的内存空间。像上面那个HumanPtr pHuman，它的生命周期是整个程序运行时间，如果程序结束，它也结束，因为它是在栈里开辟空间的，在栈里开辟的空间，系统会自动回收掉，而在堆里开辟的，系统无法自动做到，如果能做到，也就没必要在这里讨论这么多了，标准库也就没必要弄出一个什么智能指针的东西了。

因此，智能指针都应该是在栈里开辟空间。

当然std::auto_ptr比这个HumanPtr做的事情还要多，但是它便是基于这个思想的。但是，这样还是没有解决我的问题。

我想要的是下面的代码正确无误：

int main()

{

Human* pHuman = new Human;

system(“pause”);

return0;

}

现在的问题是，这段代码造成了内存泄漏，如何解决这个问题？

嗯……要解决这个问题，只需调用delete pHuman就可以了，那能不能让系统帮我们调用呢？答案是可以的，看下面的代码：

//.h头文件

//对象

classObject
{
public:
//自定义的operator new
static
void* operator new(std::size_t);
//自定义的operator delete
static
void operator delete(void* pVoid);

virtual~Object() = 0{};
};
//单体
classJSingleton
{
protected:
JSingleton(){};
virtual~JSingleton() = 0{};
private:
JSingleton(constJSingleton&);
JSingleton& operator=(const JSingleton&);
};
//工厂
classFactory:public JSingleton
{
protected:
Factory(){};
virtual~Factory();
private:
std::vector<Object*> m_pObjects;
friend
class auto_ptr<Factory>;
staticauto_ptr<Factory> s_factory;
public:
staticFactory* Instance();
//增加对象
voidAddObject(Object* pObject)
{
m_pObjects.push_back(pObject);
};
//移除对象
voidEraseObject(Object *pObject);
};
classHuman:public Object
{
public:
Human()
{
std::cout << "Human" << endl;
}
~Human()
{
std::cout << "~Human()" << endl;
}
};
//.cpp文件

#include<memory>

#include<iostream>

#include<vector>

auto_ptr<Factory>Factory::s_factory;
Factory*Factory::Instance()
{
//如果工厂没有创建
if(s_factory.get() == 0)
{
s_factory.reset(newFactory);
}
returns_factory.get();
}
Factory::~Factory()
{
//在工厂里保存的所有指针删除，回收空间
for (DWORD i= 0; i < m_pObjects.size(); ++i)
{
if(m_pObjects[i])
{
::deletem_pObjects[i];//调用全局的delete
}
}
}
//移除对象
voidFactory::EraseObject(Object *pObject)
{
vector<Object*>::iterator iter =m_pObjects.begin();
//遍历寻找对应的指针
while (iter!= m_pObjects.end())
{
if (*iter== pObject)
{
iter = m_pObjects.erase(iter);//移除操作返回的是移除后的下一个
::operatordelete(pObject);//调用全局的delete
return;
}
else
{
++iter;
}
}
}
void*Object::operatornew(std::size_tst)
{
Human *pHuman = (Human*)::operatornew(st);//调用全局的new
Factory *pf = Factory::Instance();//获得唯一实例化的引用
pf->AddObject(pHuman);//将创建后的指针放到工厂里保存
returnpHuman;
}
void Object::operatordelete(void* pObject)
{
Factory *pFactory = Factory::Instance();//获得唯一实例化的引用
pFactory->EraseObject((Object*)pObject);//移除工厂中保存对象的指针
}
//main主函数

intmain()

{

Human *pHuman = new Human;
system("pause");
return 0;
}

运行上面的代码，你会发现当程序结束后，Human的析构函数调用了，那Human的空间有没有回收掉呢？答案是肯定的，我测试过，是没问题的，你可以自己做一下测试，可以创建一万个Human出来，然后看一下内存，程序结束后，再看一下内存，需要注意的是程序结束后是看不到内存了，而内存的释放又是在程序结束后的，因此，你可以将工厂设置为可以delete掉的，可以提前结束它的生命，又或者是提供一个Clear函数接口来测试，那样就可以看到内存的变化了。这里的工厂用的是单体模式，保证只存在一份实例，如果对单体模式不了解的话，可以看下我的另一篇关于单体模式的文章。

当然，这里只是提供一个思路和一份实现而已，你可以有你自己的一份实现，但是原理都差不多，就是把new创建出来的指针放到一个对象管理，这里采用的是工厂，这个对象要保证如果用户不自行delete，那么在程序结束后，这个delete工作将由这个对象执行。如果Human是一个抽象类，上面那个Factory也能正常工作。

这里需要注意的是，在使用new和delete时的一些事情，当使用new实例化时，编译器做了两件工作：

（1）首先在堆内存开辟了该类大小的空间，也就是说会先调用operator new(std::size_t)函数开辟空间，至于调用全局的还是这个类的，就要看这个类是否重载了operator new(std::size_t)，如果这个类重载了，便调用该类提供的，编译器会调用sizeof(Human)计算出这个类的内存大小，然后作为实参传入到这个函数中，这个函数分配好空间了，返回这个内存空间的首地址。

（2）分配好内存空间后，调用这个类的构造函数，上面调用的是默认构造函数。

那么当delete的时候，编译器也做了两件事，是new相反顺序的，

（1）首先调用这个对象的析构函数

（2）再调用void operatordelete(void*)函数进行回收空间，至于调用全局

还是这个类提供的，就看这个类是否重载了这个函数。

关于operator new
与operator delete的信息，可以研究一下C++ Primer第四版，那里会有更详细的说明。

还得注意的是，这里采用的是vector顺序表来存储指针，如果你担心内存，可以采用list链表才存储，因为vector的erase移除操作并非是真正的释放空间，虽然你delete掉了pHuman的指针所指的内存，但是vector内部并没有收回掉那4个字节的内存，因为它要预留着下次来使用，那样就不需要再分配内存了。当然，你可以调用vector的析构函数来释放vector保存指针的那4个字节内存。

还有个问题是，如果自定义一个新类型时，必须得继承Object，不然得自行提供operator new和operator delete，否则无法自动回收内存。

可能还有其他的情况我没考虑到，如果发现，强烈希望指出。希望这个技术能对你有用。

这是最后源代码的链接http://download.csdn.net/detail/zx504287/4988003