我有一个继承QObject的类层次结构。

我需要在构造之后（对象完全构造时）和销毁之前（对象仍然完整时）执行一些操作。

构造部分没有问题，因为我可以控制对象的构造，将其构造函数设为私有，并将已经可以执行所有所需操作的创建者函数设为公共。

问题来自析构函数。我做了或多或少相同的事情：隐藏析构函数并提供一个销毁函数，该函数执行所有操作，然后销毁对象。

这就是问题的开始：我的类层次结构被用作QJSEngine脚本模块的一部分，该模块获得所有对象的所有权，当需要时，它使用QObject的析构函数销毁它们，从而绕过我的破坏函数。声明我的析构函数为私有是没有帮助的，因为QJSEngine总是可以执行QObject的析构函数（顺便说一句，任何将我的指针转换为QObject的代码片段也可以）。

我要求在调用析构函数之前执行这个操作，因为我使用了一些虚函数，所以我需要在开始销毁过程之前执行这个，所以虚函数调用不会失败。

有办法做到这一点吗？

我附上了一个显示我的问题的基本代码：

class IBase: public QObject {
public:
    template<typename T>
    static IBase * create() {
        IBase * obj=new T;
        obj->afterConstruction();
        return obj;
    }

    void destroy() {
        this->beforeDestruction();
        delete this;
    }

protected:
    IBase(): fBeforeDestruction(false){}
    virtual ~IBase(){
        //Try to perform operations, but it is too late....
        if (!fBeforeDestruction)
            doBeforeDestruction();
    }

    virtual void doAfterConstruction(){}
    virtual void doBeforeDestruction(){}
private:
    bool fBeforeDestruction;
    void afterConstruction() {
        doAfterConstruction();
    }

    void beforeDestruction(){
        fBeforeDestruction=true;
        doBeforeDestruction();
    }
};

class TSubclass: public IBase {
protected:
    TSubclass(){}
    virtual ~TSubclass(){}

    virtual void doAfterConstruction(){
        qDebug()<<"AfterConstruction";
    }
    virtual void doBeforeDestruction(){
        qDebug()<<"BeforeDestruction";
    }
private:
    friend class IBase;
};

int main(int argc, char *argv[])
{
    //QObject *obj=new TSubclass() //Compile time error! Nice!
    QObject *obj=IBase::create<TSubclass>();

    delete obj;//Wrong! BeforeDestruction is NEVER shown!!! <---- How to change this behaviour?

    IBase * obj2=IBase::create<TSubclass>();
    //delete obj2;    //Compile time error! Nice!
    obj2->destroy();  //Nice!
}

编辑：

在一些评论之后，我不得不补充我想在析构函数之前执行几个操作的问题，原因有两个：

>

template <typename T>
class TAfterConstructionBeforeDestruction: public T {
public:
    ~TAfterConstructionBeforeDestruction() {
        this->beforeDestruction();
    }

protected:
    using T::T;
};

class IBase: public QObject {
public:
    //Now it can be public, just as the one in QObject!
    virtual ~IBase(){}

    template<typename T>
    static IBase * create() {
        //Create a 
        IBase * obj=new TAfterConstructionBeforeDestruction<T>;
        obj->afterConstruction();
        return obj;
    }

protected:
    IBase(){}

    virtual void afterConstruction(){}
    virtual void beforeDestruction(){}
};

class TSubclass: public IBase {
public:
    virtual ~TSubclass(){}

protected:
    TSubclass(){}

    virtual void afterConstruction(){
        qDebug()<<"AfterConstruction";
    }
    virtual void beforeDestruction();
private:
    friend class IBase;
};

class TSubclass2: public TSubclass {
public:
    virtual ~TSubclass2(){}
protected:
    TSubclass2(){}
    virtual void beforeDestruction(){
        qDebug()<<"BeforeDestruction from Subclass2";
        TSubclass::beforeDestruction();
    }
};

void TSubclass::beforeDestruction() {
    qDebug()<<"BeforeDestruction";

    TSubclass2 * sub=dynamic_cast<TSubclass2*>(this);
    if (sub) {
        qDebug()<<"We are actually a TSubclass2!";
    }
}

int main(int argc, char *argv[])
{
    //QObject *obj=new TSubclass() //Compile time error! Nice!
    QObject *obj=IBase::create<TSubclass>();

    delete obj;//Now it works fine!

    IBase * obj2=IBase::create<TSubclass2>();
    delete obj2;    //It is still succeeding to dynamic_cast to TSubclass2 without any problem!
}