[Qt] viii مدیریت حافظه هوشمند

    // ...
    QPointer<QLabel> label = new QLabel("Testing");
    // ... (may be destructive operations to the label object)
    if (label)
        label->show();

#include 
#include 

class Debugger
{
public:
    Debugger()
    {
        qDebug() << "Debugger constructor called.";
        qDebug() << "";
    }

    ~Debugger()
    {
        qDebug() << "Debugger destructor called.";
        qDebug() << "";
    }

public:
    void debug(const QString &message)
    {
        qDebug() << "Debugger debugged called:";
        qDebug() << "    " << message;
    }
};

class ImportantObject
{
public:
    ImportantObject(QString name)
        : m_name(name)
    {}

    ~ImportantObject()
    {
        m_debugger->debug(QString("%1 exit").arg(m_name));
    }

public:
    void setDebugger(QSharedPointer<Debugger> &debugger)
    {
        m_debugger = debugger;
    }

private:
    QString m_name;
    QSharedPointer<Debugger> m_debugger;
};

int main(int argc, char *argv[])
{
    // Scopes:
    //     Think like functions, where the variables are not usable outside of it
    //     Sometimes called closures
    ImportantObject *obj1 = new ImportantObject("Important Object I");
    {
        QSharedPointer<Debugger> debugger(new Debugger);
        {
            QSharedPointer<Debugger> copiedDebugger(debugger);
        }

        obj1->setDebugger(debugger);

        {
            ImportantObject obj2("Important Object II");
            obj2.setDebugger(debugger);
        }
    }

    delete obj1;
    return 0;
}

Debugger constructor called.

Debugger debugged called:
     "Important Object II exit"
Debugger debugged called:
     "Important Object I exit"
Debugger destructor called.

#include 
#include 

class Debugger
{
public:
    Debugger()
    {
        qDebug() << "Debugger constructor called.";
        qDebug() << "";
    }

    ~Debugger()
    {
        qDebug() << "Debugger destructor called.";
        qDebug() << "";
    }

public:
    void debug(const QString &message)
    {
        qDebug() << "Debugger debugged called:";
        qDebug() << "    " << message;
        qDebug() << "";
    }
};

class ImportantObject
{
public:
    ImportantObject(QString name)
        : m_name(name)
    {}

    ~ImportantObject()
    {
        m_debugger->debug(QString("%1 exit").arg(m_name));
    }

public:
    void setDebugger(QSharedPointer<Debugger> &debugger)
    {
        m_debugger = debugger;
    }

private:
    QString m_name;
    QSharedPointer<Debugger> m_debugger;
};

int main(int argc, char *argv[])
{
    // Scopes:
    //     Think like functions, where the variables are not usable outside of it
    //     Sometimes called closures
    ImportantObject *obj1 = new ImportantObject("Important Object I");
    {
        QSharedPointer<Debugger> debugger(new Debugger);
        QWeakPointer<Debugger> weakReference(debugger);

        if (!weakReference.isNull())
            qDebug() << "At I: Weak reference is not null\n";

        {
            QSharedPointer<Debugger> copiedDebugger(debugger);
            weakReference = copiedDebugger;
        }

        obj1->setDebugger(debugger);

        {
            ImportantObject obj2("Important Object II");
            obj2.setDebugger(debugger);
        }

        if (!weakReference.isNull())
            qDebug() << "At II: Weak reference is not null\n";
    }

    delete obj1;
    return 0;
}

Debugger constructor called.

At I: Weak reference is not null

Debugger debugged called:
     "Important Object II exit"

At II: Weak reference is not null

Debugger debugged called:
     "Important Object I exit"

Debugger destructor called.

QScopedPointer<int, QScopedPointerArrayDeleter<int> > arrayPointer(new int[42]);

QScopedPointer<int, QScopedPointerPodDeleter> podPointer(reinterpret_cast<int *>(malloc(42)));

struct ScopedPointerCustomDeleter
{
    static inline void cleanup(MyCustomClass *pointer)
    {
        myCustomDeallocator(pointer);
    }
};

QScopedPointer<MyCustomClass, ScopedPointerCustomDeleter> customPointer(new MyCustomClass);

int function(Enum enum)
{
    QScopedPointer<Class> myClass = new Class;
    switch (enum)
    {
    case 1:
        if (function1(myClass))
        {
            if (externalProcess(myClass))
                return finalProcess(myClass);
            else if (anotherProcess(myClass))
                return 42;
            else if (someFunction(myClass))
                return -1;
            errorProcess(myClass);
            return 0;
        }

        else
        {
            return (yetAnother(myClass) ? 1 : 0);
        }
        break;
    case 2:
        externalProcess(myClass); break;
    default:
        return yetAnotherProcessOtherThanThose(myClass);
    }
    errorProcess(myClass);
    return -42;
}

Constructor(QObject *parent = nullptr)

/*!
    Destroys the object, deleting all its child objects.

    All signals to and from the object are automatically disconnected, and
    any pending posted events for the object are removed from the event
    queue. However, it is often safer to use deleteLater() rather than
    deleting a QObject subclass directly.

    \warning All child objects are deleted. If any of these objects
    are on the stack or global, sooner or later your program will
    crash. We do not recommend holding pointers to child objects from
    outside the parent. If you still do, the destroyed() signal gives
    you an opportunity to detect when an object is destroyed.

    \warning Deleting a QObject while it is handling an event
    delivered to it can cause a crash. You must not delete the QObject
    directly if it exists in a different thread than the one currently
    executing. Use deleteLater() instead, which will cause the event
    loop to delete the object after all pending events have been
    delivered to it.

    \sa deleteLater()
*/

QObject::~QObject()
{
    Q_D(QObject);
    d->wasDeleted = true;
    d->blockSig = 0; // unblock signals so we always emit destroyed()

    if (!d->bindingStorage.isValid()) {
        // this might be the case after an incomplete thread-move
        // remove this object from the pending list in that case
        if (QThread *ownThread = thread()) {
            auto *privThread = static_cast<QThreadPrivate *>(
                        QObjectPrivate::get(ownThread));
            privThread->removeObjectWithPendingBindingStatusChange(this);
        }
    }

    // If we reached this point, we need to clear the binding data
    // as the corresponding properties are no longer useful
    d->clearBindingStorage();

    QtSharedPointer::ExternalRefCountData *sharedRefcount = d->sharedRefcount.loadRelaxed();
    if (sharedRefcount) {
        if (sharedRefcount->strongref.loadRelaxed() > 0) {
            qWarning("QObject: shared QObject was deleted directly. The program is malformed and may crash.");
            // but continue deleting, it's too late to stop anyway
        }

        // indicate to all QWeakPointers that this QObject has now been deleted
        sharedRefcount->strongref.storeRelaxed(0);
        if (!sharedRefcount->weakref.deref())
            delete sharedRefcount;
    }

    if (!d->wasWidget && d->isSignalConnected(0)) {
        emit destroyed(this);
    }

    if (!d->isDeletingChildren && d->declarativeData && QAbstractDeclarativeData::destroyed)
        QAbstractDeclarativeData::destroyed(d->declarativeData, this);

    QObjectPrivate::ConnectionData *cd = d->connections.loadAcquire();
    if (cd) {
        if (cd->currentSender) {
            cd->currentSender->receiverDeleted();
            cd->currentSender = nullptr;
        }

        QBasicMutex *signalSlotMutex = signalSlotLock(this);
        QMutexLocker locker(signalSlotMutex);

        // disconnect all receivers
        int receiverCount = cd->signalVectorCount();
        for (int signal = -1; signal < receiverCount; ++signal) {
            QObjectPrivate::ConnectionList &connectionList = cd->connectionsForSignal(signal);

            while (QObjectPrivate::Connection *c = connectionList.first.loadRelaxed()) {
                Q_ASSERT(c->receiver.loadAcquire());

                QBasicMutex *m = signalSlotLock(c->receiver.loadRelaxed());
                bool needToUnlock = QOrderedMutexLocker::relock(signalSlotMutex, m);
                if (c == connectionList.first.loadAcquire() && c->receiver.loadAcquire()) {
                    cd->removeConnection(c);
                    Q_ASSERT(connectionList.first.loadRelaxed() != c);
                }
                if (needToUnlock)
                    m->unlock();
            }
        }

        /* Disconnect all senders:
         */
        while (QObjectPrivate::Connection *node = cd->senders) {
            Q_ASSERT(node->receiver.loadAcquire());
            QObject *sender = node->sender;
            // Send disconnectNotify before removing the connection from sender's connection list.
            // This ensures any eventual destructor of sender will block on getting receiver's lock
            // and not finish until we release it.
            sender->disconnectNotify(QMetaObjectPrivate::signal(sender->metaObject(), node->signal_index));
            QBasicMutex *m = signalSlotLock(sender);
            bool needToUnlock = QOrderedMutexLocker::relock(signalSlotMutex, m);
            //the node has maybe been removed while the mutex was unlocked in relock?
            if (node != cd->senders) {
                // We hold the wrong mutex
                Q_ASSERT(needToUnlock);
                m->unlock();
                continue;
            }

            QObjectPrivate::ConnectionData *senderData = sender->d_func()->connections.loadRelaxed();
            Q_ASSERT(senderData);

            QtPrivate::QSlotObjectBase *slotObj = nullptr;
            if (node->isSlotObject) {
                slotObj = node->slotObj;
                node->isSlotObject = false;
            }

            senderData->removeConnection(node);
            /*
              When we unlock, another thread has the chance to delete/modify sender data.
              Thus we need to call cleanOrphanedConnections before unlocking. We use the
              variant of the function which assumes that the lock is already held to avoid
              a deadlock.
              We need to hold m, the sender lock. Considering that we might execute arbitrary user
              code, we should already release the signalSlotMutex here – unless they are the same.
            */
            const bool locksAreTheSame = signalSlotMutex == m;
            if (!locksAreTheSame)
                locker.unlock();
            senderData->cleanOrphanedConnections(
                        sender,
                        QObjectPrivate::ConnectionData::AlreadyLockedAndTemporarilyReleasingLock
                        );
            if (needToUnlock)
                m->unlock();

            if (locksAreTheSame) // otherwise already unlocked
                locker.unlock();
            if (slotObj)
                slotObj->destroyIfLastRef();
            locker.relock();
        }

        // invalidate all connections on the object and make sure
        // activate() will skip them
        cd->currentConnectionId.storeRelaxed(0);
    }
    if (cd && !cd->ref.deref())
        delete cd;
    d->connections.storeRelaxed(nullptr);

    if (!d->children.isEmpty())
        d->deleteChildren();

    if (Q_UNLIKELY(qtHookData[QHooks::RemoveQObject]))
        reinterpret_cast<QHooks::RemoveQObjectCallback>(qtHookData[QHooks::RemoveQObject])(this);

    Q_TRACE(QObject_dtor, this);

    if (d->parent)        // remove it from parent object
        d->setParent_helper(nullptr);
}

void SomethingsManager::run()
{
    Manager *m1 = new Manager(this);
    // ...
    // ...
    QObjectCleanupHandler cleanup;
    cleanup.add(m1);
    cleanup.add(m2);
    // ...

    exec();
}