Qt隐式共享浅析

一、什么是隐式共享

Qt 的隐式共享（implicit sharing）机制是一种设计模式，用于在进行数据拷贝时提高效率和减少内存占用。

在 Qt 中，许多类（如 QString、QList 等）都使用了隐式共享机制。这意味着当这些类的实例被拷贝时，实际上并不会立即进行数据的深拷贝，而是共享同一份数据。只有在其中一个实例发生修改时，才会进行实际的数据复制，以确保数据的独立性,即Copy-On-Write。

隐式共享机制通过引用计数（reference counting）来实现。每个共享的实例都包含一个引用计数，用于记录当前有多少个实例共享同一份数据。当一个实例被拷贝时，引用计数会增加；当一个实例被销毁时，引用计数会减少。只有当引用计数为 1 时，才会进行实际的数据复制。

这种设计模式可以提高程序的性能和内存利用率，特别是在处理大量数据拷贝的情况下。同时，开发者也无需过多关注数据的共享和拷贝，从而简化了程序的设计和实现。

总之，Qt 的隐式共享机制是一种高效的数据共享和拷贝方式，它通过引用计数来实现数据的延迟复制，从而提高了程序的性能和内存利用率。

二、隐式共享代码示例

下面是一个简单的例子，展示了QString如何使用隐式共享：

#include <QString>
#include <QDebug>int main() {QString str1 = "Hello, Qt!";QString str2 = str1; // 这里并没有发生真正的数据复制，str1和str2共享同一份数据，拷贝赋值使用的是浅拷贝的方式qDebug() << str1; // 输出 "Hello, Qt!"qDebug() << str2; // 输出 "Hello, Qt!"str2[0] = 'h'; // 在这里，由于str2要修改数据，所以发生了真正的数据复制，str1和str2不再共享数据qDebug() << str1; // 输出 "Hello, Qt!"qDebug() << str2; // 输出 "hello, Qt!"return 0;
}

在上述代码中，当我们创建str2并将其初始化为str1时，并没有发生真正的数据复制，str1和str2实际上是共享同一份数据的。只有当我们试图修改str2的数据时，才会发生真正的数据复制，这就是所谓的写时复制。

这种技术的优点是可以大大减少不必要的数据复制，从而提高程序的性能。但是，它也有一些缺点，例如在多线程环境中可能需要额外的同步操作，以防止数据竞争。

在Qt的源码中，这种技术的实现主要依赖于引用计数和深拷贝。每个可以共享数据的对象都有一个引用计数，当引用计数为1时，表示只有一个对象在使用这份数据，可以直接修改。当引用计数大于1时，表示有多个对象在共享这份数据，如果有一个对象要修改数据，就需要先进行深拷贝，然后再修改新的数据，这样就不会影响到其他对象。

三、自定义一个使用隐式共享技术的数据类型

在Qt中，你可以通过使用QSharedData和QSharedDataPointer类来实现隐式共享（也称为写时复制）。

以下是一个简单的例子，定义了一个自定义的数据类型MyData，它使用了隐式共享技术：

#include <QSharedData>
#include <QSharedDataPointer>class MyData : public QSharedData {
public:MyData() : x(0), y(0) {}MyData(int x, int y) : x(x), y(y) {}int x, y;
};class MySharedType {
public:MySharedType() : data(new MyData) {}MySharedType(int x, int y) : data(new MyData(x, y)) {}MySharedType(const MySharedType &other) : data(other.data) {}MySharedType &operator=(const MySharedType &other) {if (this != &other)data = other.data;return *this;}int x() const { return data->x; }int y() const { return data->y; }void setX(int x) { if (data->x != x) detach(); data->x = x; }void setY(int y) { if (data->y != y) detach(); data->y = y; }private:void detach() { if (data->ref != 1) data = new MyData(*data); }QSharedDataPointer<MyData> data;
};

在这个例子中，MyData类是实际存储数据的类，它继承自QSharedData。MySharedType类是用户使用的类，它包含一个QSharedDataPointer，指向MyData实例。当需要修改数据时，detach方法会被调用，如果有多个MySharedType实例共享同一个MyData实例，那么detach方法会创建一个新的MyData实例，以实现写时复制。

顺便看看 QSharedData 和QSharedDataPointer 的源码实现：

#ifndef QSHAREDDATA_H
#define QSHAREDDATA_H#include <QtCore/qglobal.h>
#include <QtCore/qatomic.h>
#if QT_DEPRECATED_SINCE(5, 6)
#include <QtCore/qhash.h>
#endif
#include <QtCore/qhashfunctions.h>QT_BEGIN_NAMESPACEtemplate <class T> class QSharedDataPointer;class
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
Q_CORE_EXPORT
#endif
QSharedData
{
public:mutable QAtomicInt ref;   /// 原子计算inline QSharedData() noexcept : ref(0) { }inline QSharedData(const QSharedData &) noexcept : ref(0) { }// using the assignment operator would lead to corruption in the ref-countingQSharedData &operator=(const QSharedData &) = delete;~QSharedData() = default;
};template <class T> class QSharedDataPointer
{
public:typedef T Type;typedef T *pointer;/***************************************************//// 分离数据inline void detach() { if (d && d->ref.loadRelaxed() != 1) detach_helper(); }/***************************************************/inline T &operator*() { detach(); return *d; }inline const T &operator*() const { return *d; }inline T *operator->() { detach(); return d; }inline const T *operator->() const { return d; }inline operator T *() { detach(); return d; }inline operator const T *() const { return d; }inline T *data() { detach(); return d; }inline const T *data() const { return d; }inline const T *constData() const { return d; }inline bool operator==(const QSharedDataPointer<T> &other) const { return d == other.d; }inline bool operator!=(const QSharedDataPointer<T> &other) const { return d != other.d; }inline QSharedDataPointer() { d = nullptr; }inline ~QSharedDataPointer() { if (d && !d->ref.deref()) delete d; }explicit QSharedDataPointer(T *data) noexcept;inline QSharedDataPointer(const QSharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }inline QSharedDataPointer<T> & operator=(const QSharedDataPointer<T> &o) {if (o.d != d) {if (o.d)o.d->ref.ref();T *old = d;d = o.d;if (old && !old->ref.deref())delete old;}return *this;}inline QSharedDataPointer &operator=(T *o) {if (o != d) {if (o)o->ref.ref();T *old = d;d = o;if (old && !old->ref.deref())delete old;}return *this;}QSharedDataPointer(QSharedDataPointer &&o) noexcept : d(o.d) { o.d = nullptr; }inline QSharedDataPointer<T> &operator=(QSharedDataPointer<T> &&other) noexcept{QSharedDataPointer moved(std::move(other));swap(moved);return *this;}inline bool operator!() const { return !d; }inline void swap(QSharedDataPointer &other) noexcept{ qSwap(d, other.d); }protected:T *clone();private:void detach_helper();T *d;
};template <class T> inline bool operator==(std::nullptr_t p1, const QSharedDataPointer<T> &p2)
{Q_UNUSED(p1);return !p2;
}template <class T> inline bool operator==(const QSharedDataPointer<T> &p1, std::nullptr_t p2)
{Q_UNUSED(p2);return !p1;
}template <class T> class QExplicitlySharedDataPointer
{
public:typedef T Type;typedef T *pointer;inline T &operator*() const { return *d; }inline T *operator->() { return d; }inline T *operator->() const { return d; }inline T *data() const { return d; }inline const T *constData() const { return d; }inline T *take() { T *x = d; d = nullptr; return x; }inline void detach() { if (d && d->ref.loadRelaxed() != 1) detach_helper(); }inline void reset(){if(d && !d->ref.deref())delete d;d = nullptr;}inline operator bool () const { return d != nullptr; }inline bool operator==(const QExplicitlySharedDataPointer<T> &other) const { return d == other.d; }inline bool operator!=(const QExplicitlySharedDataPointer<T> &other) const { return d != other.d; }inline bool operator==(const T *ptr) const { return d == ptr; }inline bool operator!=(const T *ptr) const { return d != ptr; }inline QExplicitlySharedDataPointer() { d = nullptr; }inline ~QExplicitlySharedDataPointer() { if (d && !d->ref.deref()) delete d; }explicit QExplicitlySharedDataPointer(T *data) noexcept;inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }template<class X>inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o)
#ifdef QT_ENABLE_QEXPLICITLYSHAREDDATAPOINTER_STATICCAST: d(static_cast<T *>(o.data()))
#else: d(o.data())
#endif{if(d)d->ref.ref();}inline QExplicitlySharedDataPointer<T> & operator=(const QExplicitlySharedDataPointer<T> &o) {if (o.d != d) {if (o.d)o.d->ref.ref();T *old = d;d = o.d;if (old && !old->ref.deref())delete old;}return *this;}inline QExplicitlySharedDataPointer &operator=(T *o) {if (o != d) {if (o)o->ref.ref();T *old = d;d = o;if (old && !old->ref.deref())delete old;}return *this;}inline QExplicitlySharedDataPointer(QExplicitlySharedDataPointer &&o) noexcept : d(o.d) { o.d = nullptr; }inline QExplicitlySharedDataPointer<T> &operator=(QExplicitlySharedDataPointer<T> &&other) noexcept{QExplicitlySharedDataPointer moved(std::move(other));swap(moved);return *this;}inline bool operator!() const { return !d; }inline void swap(QExplicitlySharedDataPointer &other) noexcept{ qSwap(d, other.d); }protected:T *clone();private:void detach_helper();T *d;
};template <class T>
Q_INLINE_TEMPLATE QSharedDataPointer<T>::QSharedDataPointer(T *adata) noexcept: d(adata)
{ if (d) d->ref.ref(); }template <class T>
Q_INLINE_TEMPLATE T *QSharedDataPointer<T>::clone()
{return new T(*d);
}template <class T>
Q_OUTOFLINE_TEMPLATE void QSharedDataPointer<T>::detach_helper()
{T *x = clone();x->ref.ref();if (!d->ref.deref())delete d;d = x;
}template <class T>
Q_INLINE_TEMPLATE T *QExplicitlySharedDataPointer<T>::clone()
{return new T(*d);
}template <class T>
Q_OUTOFLINE_TEMPLATE void QExplicitlySharedDataPointer<T>::detach_helper()
{T *x = clone();x->ref.ref();if (!d->ref.deref())delete d;d = x;
}template <class T>
Q_INLINE_TEMPLATE QExplicitlySharedDataPointer<T>::QExplicitlySharedDataPointer(T *adata) noexcept: d(adata)
{ if (d) d->ref.ref(); }template <class T> inline bool operator==(std::nullptr_t p1, const QExplicitlySharedDataPointer<T> &p2)
{Q_UNUSED(p1);return !p2;
}template <class T> inline bool operator==(const QExplicitlySharedDataPointer<T> &p1, std::nullptr_t p2)
{Q_UNUSED(p2);return !p1;
}template <class T>
Q_INLINE_TEMPLATE void swap(QSharedDataPointer<T> &p1, QSharedDataPointer<T> &p2)
{ p1.swap(p2); }template <class T>
Q_INLINE_TEMPLATE void swap(QExplicitlySharedDataPointer<T> &p1, QExplicitlySharedDataPointer<T> &p2)
{ p1.swap(p2); }template <class T>
Q_INLINE_TEMPLATE uint qHash(const QSharedDataPointer<T> &ptr, uint seed = 0) noexcept
{return qHash(ptr.data(), seed);
}
template <class T>
Q_INLINE_TEMPLATE uint qHash(const QExplicitlySharedDataPointer<T> &ptr, uint seed = 0) noexcept
{return qHash(ptr.data(), seed);
}template<typename T> Q_DECLARE_TYPEINFO_BODY(QSharedDataPointer<T>, Q_MOVABLE_TYPE);
template<typename T> Q_DECLARE_TYPEINFO_BODY(QExplicitlySharedDataPointer<T>, Q_MOVABLE_TYPE);QT_END_NAMESPACE#endif // QSHAREDDATA_H

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/607991.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

色标在matplotlib和plottable中

色标在matplotlib和plottable中

是这样的&#xff0c;我有一个数组[-4.4, -2.8, -2.6, -2.2, -1.1, 1.1, 1.2, 1.3, 3.6, 6.0, 6.4, 12.3]&#xff0c;它需要绘制散点图&#xff0c;点的颜色来代表数值大小&#xff1b;同时&#xff0c;也需要在plottable上作为一列显示&#xff0c;同样用颜色来代表数值的大小…
阅读更多...
HarmonyOS应用开发学习笔记 ArkTS 布局概述

HarmonyOS应用开发学习笔记 ArkTS 布局概述

一、布局概述 布局指用特定的组件或者属性来管理用户页面所放置UI组件的大小和位置。在实际的开发过程中&#xff0c;需要遵守以下流程保证整体的布局效果 确定页面的布局结构。分析页面中的元素构成。选用适合的布局容器组件或属性控制页面中各个元素的位置和大小约束。 二…
阅读更多...
【JUC】进程和线程

【JUC】进程和线程

目录 &#x1f4e2;什么是进程?&#x1f3a1;什么是线程?&#x1f680;进程和线程的区别?&#x1f3a2;Java 线程和操作系统的线程有啥区别&#xff1f;&#x1f396;️JDK21的虚拟线程&#x1f3af;虚拟线程和平台线程的对比 &#x1f4e2;什么是进程? 进程是程序的一次执…
阅读更多...
Zabbix“专家坐诊”第223期问答汇总

Zabbix“专家坐诊”第223期问答汇总

来源&#xff1a;乐维社区 问题一 Q&#xff1a;Zabbix 5.0安装完mysql之后怎么备份&#xff1f;忘记mysql当时创建的密码了&#xff0c;怎么样能查看设置的密码&#xff1f; A&#xff1a;mysql初始化密码在 /var/log/mysqld.log中可以看到&#xff0c;搜关键字temporary pas…
阅读更多...
Android studio TabHost应用设计

Android studio TabHost应用设计

一、xml布局文件： 添加TabHost控件 <?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"xmlns:app="http://schemas.…
阅读更多...
【算法分析与设计】移动零

【算法分析与设计】移动零

题目 给定一个数组 nums&#xff0c;编写一个函数将所有 0 移动到数组的末尾&#xff0c;同时保持非零元素的相对顺序。 请注意 &#xff0c;必须在不复制数组的情况下原地对数组进行操作。 示例 1: 输入: nums [0,1,0,3,12] 输出: [1,3,12,0,0] 示例 2: 输入: nums [0…
阅读更多...
电能计量芯片RN8209

电能计量芯片RN8209

电能计量芯片RN8209 简介2、操作2.1、复位2.2 模数转换2.3 有功功率2.4 无功功率2.5 有效值2.4 能量计算 RN8209中文手册 点击下载 简介 2、操作 2.1、复位 2.2 模数转换 2.3 有功功率 RN8209 提供两路有功功率的计算和校正&#xff0c;分别为电流 A 和电压有功功率计算和校正…
阅读更多...
【笔记------freemodbus】一、stm32的裸机modbus-RTU从机移植(HAL库)

【笔记------freemodbus】一、stm32的裸机modbus-RTU从机移植(HAL库)

freemodbus的官方介绍和下载入口&#xff0c;官方仓库链接&#xff1a;https://github.com/cwalter-at/freemodbus modbus自己实现的话往往是有选择的支持几条指令&#xff0c;像断帧和异常处理可能是完全不处理的&#xff0c;用freemodbus实现的话要简单很多&#xff0c;可移植…
阅读更多...
Linux Lha命令教程：学习如何管理.lzh文件(附案例详解和注意事项)

Linux Lha命令教程：学习如何管理.lzh文件(附案例详解和注意事项)

Linux lha命令介绍 lha&#xff08;LHarc&#xff09; 是一种用于文件压缩和解压缩的工具&#xff0c;广泛应用在多个系统中&#xff0c;包括 Windows 和 Linux。利用此命令&#xff0c;用户可以方便地管理 .lzh 或 .lha 文件。它支持多种压缩算法&#xff0c;包括LZH、LZ5、L…
阅读更多...
【leetcode100-033】【链表】排序链表

【leetcode100-033】【链表】排序链表

【题干】 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 【思路】 递归版归并法链表版&#xff5e;没什么特别好说的&#xff08;非递归版归并也是可以哒&#xff0c;但是马上要考试了今天懒得写了&#xff01;打个flag在这里也许哪天想起来…
阅读更多...
linux线程重启

linux线程重启

以下是获取线程id和重启指定线程的示例代码&#xff1a; #include <stdio.h> #include <pthread.h>// 线程函数&#xff0c;用来打印线程ID void *print_thread_id(void *arg) {printf("Thread ID: %lu\n", pthread_self());return NULL; }int main() {…
阅读更多...
PR如何在一个视频里添加多个画面？多窗口画中画PR模板视频素材

PR如何在一个视频里添加多个画面？多窗口画中画PR模板视频素材

Premiere Pro 2021模板&#xff0c;多窗口布局&#xff0c;多画面组合&#xff0c;小窗口视频&#xff0c;画中画视频效果制作素材PR模板mogrt文件。 4K、HD可调整到任何分辨率。 100多窗口布局样式。 来自PR模板网&#xff1a;https://prmuban.com/37059.html
阅读更多...
深入了解pnpm：一种高效的包管理工具

深入了解pnpm：一种高效的包管理工具

✨专栏介绍 在当今数字化时代&#xff0c;Web应用程序已经成为了人们生活和工作中不可或缺的一部分。而要构建出令人印象深刻且功能强大的Web应用程序&#xff0c;就需要掌握一系列前端技术。前端技术涵盖了HTML、CSS和JavaScript等核心技术&#xff0c;以及各种框架、库和工具…
阅读更多...
Unity | 渡鸦避难所-6 | 有限状态机控制角色行为逻辑

Unity | 渡鸦避难所-6 | 有限状态机控制角色行为逻辑

1 有限状态机简介 有限状态机&#xff08;英语&#xff1a;finite-state machine&#xff0c;缩写&#xff1a;FSM&#xff09;&#xff0c;简称状态机&#xff0c;是表示有限个状态以及在这些状态之间的转移和动作等行为的数学计算模型 在游戏开发中应用有限状态机&#xff…
阅读更多...
#Uniapp：编译器#ifdef --- #endif #ifndef --- #endif

#Uniapp：编译器#ifdef --- #endif #ifndef --- #endif

编译器#ifdef — #endif &#ifndef — #endif uni-app能实现一套代码、多端运行&#xff0c;核心是通过编译器 运行时实现的 定义 以 #ifdef 或 #ifndef 加 %PLATFORM% 开头&#xff0c;以 #endif 结尾。 #ifdef&#xff1a;if defined 仅在某平台存在#ifndef&#xff…
阅读更多...
JavaWeb——后端之登录功能

JavaWeb——后端之登录功能

6. 登录功能 6.1 登录认证 只进行用户名和密码是否存在的操作 Slf4j RestController public class LoginController {Autowiredpublic EmpService empService;PostMapping("/login")public Result login(RequestBody Emp emp) {log.info("{}员工登录", …
阅读更多...
ASP .net core微服务实战

ASP .net core微服务实战

>>>>>>>>>>>>>>开发<<<<<<<<<<<<<<<< 0)用户 用户到nginx之间需要用https&#xff0c;避免被监听。 1)nginx // 做统一的分发&#xff0c;到微服务&#xff0c;相当于网关,提供统…
阅读更多...
APP出海需知——Admob广告变现竞价策略

APP出海需知——Admob广告变现竞价策略

越来越多的出海公司更加重视应用的广告变现&#xff0c;Admob因其提供丰富的广告资源&#xff0c;稳定的平台支持&#xff0c;被广泛采用接入。 Admob广告变现策略 1、bidding竞价策略 Bidding目前是Admob广泛推广的较成熟的变现方案&#xff0c;当竞价网络和瀑布流混合时&a…
阅读更多...
第二百五十四回

第二百五十四回

文章目录 1. 概念介绍2. 思路与方法2.1 实现思路2.2 实现方法 3. 代码与效果3.1 示例代码3.2 运行效果 4. 内容总结 我们在上一章回中介绍了"如何给图片添加阴影"相关的内容&#xff0c;本章回中将介绍自定义Radio组件.闲话休提&#xff0c;让我们一起Talk Flutter吧…
阅读更多...
socket通信实现TCP协议的同步通信

socket通信实现TCP协议的同步通信

实现tcp通信&#xff0c;一般第一想到的是用netty框架&#xff0c;但是netty实现的通信一般是异步&#xff0c;发送消息后&#xff0c;不需要等到回复。 最近遇到一个需求时&#xff0c;与某个网关进行tcp通信&#xff0c;发送请求消息之后会立马回复&#xff0c;并且不同的请…
阅读更多...
最新文章

Copyright @ 2022~2023