深入理解Qt 智能指针

#if 1   // MyClass 原始版本
class MyClass {
public:
	MyClass(){}
	MyClass(const MyClass &other) {
		m_id = other.GetId();
		m_path = other.GetPath();
	}
	~MyClass(){}

	int GetId() const { return m_id; }
	void SetId(int val) { m_id = val; }
	QString GetPath() const { return m_path; }
	void SetPath(QString val) { m_path = val; }
private:
	int m_id = -1;
	QString m_path;
};

#else // MyClass 支持隐式共享
// 1. 将 MyClass 的所有数据成员都放到 MyClassData 中. 
// 2. 在 MyClass 中维护一个 QSharedDataPointer<MyClassData> d.
// 3. MyClass 中通过 d-> 的形式访问数据.
// 4. MyClassData 继承自 QSharedData.

#include <QSharedData>
#include <QSharedDataPointer>
class MyClassData : public QSharedData
{
public:
	MyClassData(){}
	MyClassData(const MyClassData &other)
		: QSharedData(other), id(other.id), path(other.path) {}
	~MyClassData(){}

	int id = -1;
	QString path;
};

class MyClass {
public:
	MyClass(){ d = new MyClassData(); }
	MyClass(int id, const QString & path) {
		d = new MyClassData();
		SetId(id);
		SetPath(path);
	}
	MyClass(const MyClass &other) : d(other.d){}
	~MyClass(){}

	int GetId() const { return d->id; }
	void SetId(int val) { d->id = val; }
	QString GetPath() const { return d->path; }
	void SetPath(QString val) { d->path = val; }
private:
	QSharedDataPointer<MyClassData> d;
};
#endif

#include <QExplicitlySharedDataPointer>
class MyClass {
public:
	MyClass(){ d = new MyClassData(); }
	MyClass(int id, const QString & path) {
		d = new MyClassData();
		SetId(id);
		SetPath(path);
	}
	MyClass(const MyClass &other) : d(other.d){}
	~MyClass(){}

	int GetId() const { return d->id; }
	void SetId(int val) { 
		// 需要手动调用 detach()
		d.detach();
		d->id = val; 
	}
	QString GetPath() const { return d->path; }
	void SetPath(QString val) { 
		// 需要手动调用 detach()
		d.detach();
		d->path = val; 
	}
private:
	QExplicitlySharedDataPointer<MyClassData> d;
};

// 指定 Deleter
static void doDeleteLater(MyObject *obj)
{
    obj->deleteLater();
}

void TestSPtr()
{
    QSharedPointer<MyObject> obj(new MyObject, doDeleteLater);

    // 调用 clear 清除引用计数, 并调用 Deleter 删除指针对象.
    // 此处将调用 doDeleteLater
    obj.clear();

    QSharedPointer<MyObject> pObj1 = obj;
    pObj1->show();

    if (pObj1) {

    }
}

/*------------- 实现单例 -------------*/
// cpp 中定义全局变量
QSharedPointer<MyObject> g_ptrMyObj;

QSharedPointer<MyObject> GetMyObj() {
    if (g_ptrMyObj.data() == NULL) {
        g_ptrMyObj.reset(new MyObject());
    }
    return g_ptrMyObj;
}

#include <QSharedPointer>
#include <QWeakPointer>

class A;
class B;

#define TEST_memory_will_leak

class A {
public:
	~A() {
		qDebug() << "destruct A";
	}
#ifdef TEST_memory_will_leak
	QSharedPointer<B> ptr_B;
#else
	QWeakPointer<B> ptr_B;
#endif //TEST_memory_will_leak
};


class B {
public:
	~B() {
		qDebug() << "destruct B";
	}
#ifdef TEST_memory_will_leak
	QSharedPointer<A> ptr_A;
#else
	QWeakPointer<A> ptr_A;
#endif //TEST_memory_will_leak
};


int main()
{
	QSharedPointer<A> nA(new A());
	QSharedPointer<B> nB(new B());

    // 若内部使用 QSharedPointer, 则此处会形成循环引用.
	nA->ptr_B = nB;
	nB->ptr_A = nA;

#ifdef TEST_memory_will_leak
	if (!nA->ptr_B.isNull()) {
		qDebug() << "use shared ptr";
	}
#else
	if (!nA->ptr_B.toStrongRef().isNull()) {
		qDebug() << "use weak ptr";
	}
#endif TEST_memory_will_leak
}

void main() 
{
    {
        QScopedPointer<MyClass> p(new MyClass());
        p->func();
    } // 退出作用域后析构

    {
        QScopedArrayPointer<int> p(new int[10] );

        p[1] = 10;
    } // 退出作用域后析构
}

class MyHelper{
public:
    MyHelper(QPushButton *btn)
        : m_btn(btn)
        , m_btn2(NULL) {}

    void SetBtn(QPushButton *btn) {
        m_btn2 = btn;
    }

    void FuncShow() {
        // 当外部的 QPushButton 析构后, 该值自动设置为 NULL
        if (m_btn) {
            m_btn->show();
        }

        if (m_btn2) {
            m_btn2->show();
        }
    }
private:
    QPointer<QPushButton> m_btn;
    QPointer<QPushButton> m_btn2;
};