C 语言

关注公众号 jb51net

关闭
首页 > 软件编程 > C 语言 > Qt 智能指针

深入理解Qt 智能指针

作者：zhaoyongCNSX

智能指针是一种特殊的指针,可以自行管理和释放资源,防止内存泄漏和悬挂指针,本文主要介绍了深入理解Qt 智能指针,具有一定的参考价值,感兴趣的可以了解一下

1. Qt智能指针概述

2. Qt中的智能指针分类

根据不同的使用场景, 可分为以下几种:

3. 共享数据

3.1. 隐式共享

比如, 我们现在有一个类 MyClass, 现在要将其改造成支持隐式共享的类.

#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

3.2. 显式共享

修改上面例子中用到的 QSharedDataPointer 为 QExplicitlySharedDataPointer.

注意: 如果在使用时发现所有写操作的函数中都调用了 detach(), 那就可以直接使用 QSharedDataPointer 了.

#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;
};

4. 共享指针

4.1. QSharedPointer

// 指定 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;
}

4.2. QWeakPointer

打开宏 TEST_memory_will_leak, 则因为产生循环引用, 导致内存泄漏, 表现为: 不会打印 “destruct A”, “destruct B”

关闭宏, 使用 QWeakPointer, 不会产生内存泄漏.

#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
}

5. 范围指针

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

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

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

6. 追踪特定QObject对象生命

[***以下描述可搜索 DevBean 的 continue-using-qpointer 一文获取更详细信息***].

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;
};

RAII, Resource Acquisition Is Initialization, 资源获取就是初始化. 是 C++ 的一种管理资源, 避免泄漏的惯用方法. 比如, QMutexLocker为了方便管理QMutex的加锁和解锁, 在构造该对象时加锁, 在析构时解锁. 

到此这篇关于深入理解Qt 智能指针的文章就介绍到这了,更多相关Qt 智能指针内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文