设计实现C++内存的半自动释放

#ifndef OBJECT_H
#define OBJECT_H
#include <list>
using std::list;
class Object;
typedef list<Object*> ObjectList;
class Object
{
    public:
        virtual ~Object();
        //重新设置对象的父对象
        void setParent(Object *parent);
        //获得当前对象的子对象列表
        inline const ObjectList& getChildern() const;
        //获得当前对象的父对象
        inline const Object* getParent() const;
    protected:
        explicit Object(Object *parent = NULL);
        Object(const Object& obj);
        Object& operator= (const Object &obj);
    private:
        //把当前对象插入到parent指向的父对象的子对象列表中
        inline void _appendObjectList(Object *parent);
        ObjectList childern;//子对象列表
        Object *this_parent;//指向对象的父对象
};
void Object::_appendObjectList(Object *parent)
{
    /***
    函数功能：把当前对象插入到parent指向的父对象的子对象列表中
    返回：无
    ***/
    this_parent = parent;//设置当前对象的父对象
    //若其父对象不为空，则加入到父对象的子对象列表中
    if(this_parent != NULL)
        this_parent->childern.push_back(this);
}
const ObjectList& Object::getChildern() const
{
    return childern;
}
const Object* Object::getParent() const
{
    return this_parent;
}
#endif // OBJECT_H

#include "object.h"
#include <algorithm>
Object::Object(Object *parent)
    :this_parent(parent)
{
    /***
    函数功能：创建一个Object对象，若其parent不为空，
        则把当前对象插入到其子对象列表中
    ***/
    if(this_parent != NULL)
        this_parent->childern.push_back(this);
}
Object::Object(const Object& obj)
{
    /***
    函数功能：根据对象obj，复制一个对象
    ***/
    //复制时，只是把当前对象和obj的父对象设置为同一个父对象
    //并不复制obj的子对象列表
    _appendObjectList(obj.this_parent);
}
Object& Object::operator= (const Object &obj)
{
    /***
    函数功能：若当前对象无父对象，则把obj的父对象设置成当前对象的父对象
    返回：当前对象的引用
    ***/
    if(this_parent == NULL)
    {
        _appendObjectList(obj.this_parent);
    }
    return *this;
}
Object::~Object()
{
    /***
    函数功能：释放由该对象new出来的子对象
    ***/
    //若当前对象有父对象，则将当前对象从共父对象的子对象列表中删除
    if(this_parent != NULL)
    {
        ObjectList::iterator it =
            find(this_parent->childern.begin(),
                 this_parent->childern.end(),
                 this);
        this_parent->childern.erase(it);
// this_parent->childern.remove(this);
    }
    //释放其new出来的子对象
    while(!childern.empty())
    {
        ObjectList::iterator it(childern.begin());
        delete *it;
    }
}
void Object::setParent(Object *parent)
{
    /***
    函数功能：重新设置对象的父对象
    返回：无
    ***/
    //若当前对象有父对象，则把当前对象从其父对象的子对象列表中删除
    if(this_parent != NULL)
    {
        ObjectList::iterator it =
            find(this_parent->childern.begin(),
                 this_parent->childern.end(),
                 this);
        this_parent->childern.erase(it);
// this_parent->childern.remove(this);
    }
    //插入当前对象到parent对象的子对象列表中
    _appendObjectList(parent);
}

#include <iostream>
#include "Object.h"
using namespace std;
class Student:public Object
{
    public:
        Student(Object * parent = NULL)
            :Object(parent){++new_count;}
        ~Student()
        {
            ++delete_count;
        }
        static int new_count;
        static int delete_count;
    private:
        int stu_id;
};
int Student::new_count = 0;
int Student::delete_count = 0;
class Teacher:public Object
{
    public:
        void createStudent()
        {
            for(int i = 0; i < 10; ++i)
                new Student(this);
        }
    private:
};
int main()
{
    {
        Teacher t;
        t.createStudent();
    }
    cout << Student::new_count<<endl;
    cout << Student::delete_count<<endl;
    return 0;
}

void remove (const value_type& val);

int main()
{
    {
        Teacher *t = new Teacher;
        t->createStudent();
    }
    cout << Student::new_count<<endl;
    cout << Student::delete_count<<endl;
    return 0;
}

设计实现C++内存的半自动释放

原文：http://blog.csdn.net/ljianhui/article/details/19649867