Qt隐式共享机制

1、浅拷贝

浅拷贝-引用类型。浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同），对其中任何一个对象的改动都会影响另外一个对象。

2、深拷贝

而深拷贝-值类型。深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。

3、隐式共享：

隐式共享又叫做回写复制。当两个对象共享同一份数据时（通过浅拷贝实现数据块的共享），如果数据不改变，不进行数据的复制。而当某个对象需要改变数据时则执行深拷贝。

采用隐式共享技术，将深拷贝和浅拷贝有机地结合起来。

Qt中许多常用的类都使用了隐式共享技术，如QString、QImage、容器类、绘图相关类等等。

QString example: 

1
2
3
4
5

QString str1 = "ubuntu";
QString str2 = str1;        //str2 = "ubuntu"
str2[2] = "m";              //str2 = "ubmntu",str1 = "ubuntu"
str2[0] = "o";              //str2 = "obmntu",str1 = "ubuntu"
str1 = str2;                //str1 = "obmntu",

解释：

line1: 初始化一个内容为"ubuntu"的字符串；
line2: 将字符串对象str1赋值给另外一个字符串str2(由QString的拷贝构造函数完成str2的初始化)。
在对str2赋值的时候，会发生一次浅拷贝，导致两个QString对象都会指向同一个数据结构。该数据结构除了保存字符串“ubuntu”之外，还保存一个引用计数器，用来记录字符串数据的引用次数。此处，str1和str2都指向同一数据结构，所以此时引用计数器的值为2.
line3: 对str2做修改，将会导致一次深拷贝，使得对象str2指向一个新的、不同于str1所指的数据结构(该数据结构中引用计数器值为1，只有str2是指向该结构的)，同时修改原来的、str1所指向的数据结构，设置它的引用计数器值为1(此时只有str1对象指向该结构)；并在这个str2所指向的、新的数据结构上完成数据的修改。引用计数为1就意味着该数据没有被共享。
line4: 进一步对str2做修改，不过不会引起任何形式的拷贝，因为str2所指向的数据结构没有被共享。
line5: 将str2赋给str1.此时，str1修改它指向的数据结构的引用计数器的值位0，表示没有QString类的对象再使用这个数据结构了；因此str1指向的数据结构将会从从内存中释放掉；这一步操作的结构是QString对象str1和str2都指向了字符串为“obmntu”的数据结构，该结构的引用计数为2。

QPen example:

1
2
3
4
5
6
7
8
9
10
11
12
13

void QPen::setStyle(Qt::PenStyle style)
{
    detach();           // detach from common data
    d->style = style;   // set the style member
}

void QPen::detach()
{
    if (d->ref != 1)
    {
        ...             // perform a deep copy
    }
}

使用隐式共享的QPen类与更改内部数据的所有成员函数中的共享数据分离。

隐式共享主要发生在幕后; 程序员很少需要担心它。但是，Qt的容器迭代器具有与STL不同的行为。

隐式共享对STL样式的迭代器有另一个影响：当迭代器在该容器上处于活动状态时，应避免复制容器。迭代器指向内部结构，如果复制容器，则应该非常小心迭代器。例如：

Qt Vector iterator example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

QVector<int> a, b;
a.resize(100000); // make a big vector filled with 0.

QVector<int>::iterator i = a.begin();
// WRONG way of using the iterator i:
b = a;
/*
    Now we should be careful with iterator i since it will point to shared data
    If we do *i = 4 then we would change the shared instance (both vectors)
    The behavior differs from STL containers. Avoid doing such things in Qt.
*/

a[0] = 5;
/*
    Container a is now detached from the shared data,
    and even though i was an iterator from the container a, it now works as an iterator in b.
    Here the situation is that (*i) == 0.
*/

b.clear(); // Now the iterator i is completely invalid.

int j = *i; // Undefined behavior!
/*
    The data from b (which i pointed to) is gone.
    This would be well-defined with STL containers (and (*i) == 5),
    but with QVector this is likely to crash.
*/

4、自定义隐式共享类

实现自己的隐式共享类时，请使用QSharedData和QSharedDataPointer类。

下面，我们以一个员工类为例，来实现一个隐式共享类。步骤如下：

定义类Emplyee，该类只有一个唯一的数据成员，类型为QSharedDataPointer<EmployeeData>。

定义类EmployeeData类，其派生自QSharedData。该类中包含的就是原本应该放在Employee类中的那些数据成员。

类定义如下：

 C++ Code 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#include <QSharedData>
#include <QString>

class EmployeeData : public QSharedData
{
public:
    EmployeeData() : id(-1) { }
    EmployeeData(const EmployeeData &other)
        : QSharedData(other), id(other.id), name(other.name) { }
    ~EmployeeData() { }

    int id;
    QString name;
};

class Employee
{
public:
    Employee()
    {
        d = new EmployeeData;
    }
    Employee(int id, const QString &name)
    {
        d = new EmployeeData;
        setId(id);
        setName(name);
    }
    Employee(const Employee &other)
        : d (other.d)
    {
    }
    void setId(int id)
    {
        d->id = id;
    }
    void setName(const QString &name)
    {
        d->name = name;
    }

    int id() const
    {
        return d->id;
    }
    QString name() const
    {
        return d->name;
    }

private:
    QSharedDataPointer<EmployeeData> d;
};

解释：

在Employee类中，要注意这个数据成员d。所有对employee数据的访问都必须经过d指针的operator->()来操作。对于写访问，operator->()会自动的调用detach()，来创建一个共享数据对象的拷贝，如果该共享数据对象的引用计数大于1的话。也可以确保向一个Employee对象执行写入操作不会影响到其他的共享同一个EmployeeData对象的Employee对象。

类EmployeeData继承自QSharedData，它提供了幕后的引用计数。

在幕后，无论何时一个Employee对象被拷贝、赋值或作为参数传，QSharedDataPointer会自动增加引用计数；无论何时一个Employee对象被删除或超出作用域，QSharedDataPointer会自动递减引用计数。当引用计数为0时，共享的EmployeeData对象会被自动删除。

void setId(int id) { d->id = id; }

void setName(const QString &name) { d->name = name; }

在Employee类的非const成员函数中，无论何时d指针被解引用，QSharedDataPointer都会自动的调用detach()函数来确保该函数作用于一个数据拷贝上。并且，在一个成员函数中，如果对d指针进行了多次解引用，而导致调用了多次detach()，也只会在第一次调用时创建一份拷贝。

int id() const { return d->id; }

QString name() const { return d->name; }

但在Employee的const成员函数中，对d指针的解引用不会导致detach()的调用。

还有，没必要为Employee类实现拷贝构造函数或赋值运算符，因为C++编译器提供的拷贝构造函数和赋值运算符的逐成员拷贝就足够了。

因为，我们唯一需要拷贝的就是d指针，而该指针是一个QSharedDataPointer，它的operator=()仅仅是递增了共享对象EmployeeData的引用计数。

如果要使用显式共享，请使用QExplicitySharedDataPointer。

5、总结

最大化资源有效利用，最小化复制克隆操作。

深入理解：

https://doc.qt.io/qt-5/implicit-sharing.html

深拷贝、浅拷贝、隐式共享

Qt隐式共享与显式共享