Qt之美（三）隐式数据共享

为了最大化资源使用，和最小化数据拷贝，Qt在很多类中用到了隐式数据共享，以便数据仅在被写入时才被拷贝。该机制也被称为flyweight模式。

让我们以QByteArray为例，看看其是如何实现的。其内部使用一个名为Data的私有结构体来追踪共享的数据：

 

1. struct Data {  
2.   QBasicAtomicInt ref; // 引用计数器，对其的操作是原子的  
3.   int alloc; // 已分配的空间大小  
4.   int size; // 数据的实际大小  
5.   char *data; // 指向数据的指针  
6.   char array[1]; // 数据有可能存于此位置  
7. };  

 

 

这里，如果数据保存在其他位置，则需要用到data来指向实际的数据位置；如果保存在自身，则是array指向的位置。当对象被拷贝时（比如通过赋值运算符），则仅仅拷贝指针，而不拷贝数据本身：

 

1. QByteArray &QByteArray::operator=(const QByteArray & other)  
2. {  
3.   // 增加要使用的共享数据的引用计数器的值  
4.   other.d->ref.ref();  
5.   // 减少当前共享数据的引用计数器的值  
6.   if (!d->ref.deref())  
7.     qFree(d);  
8.   // 指向要使用的共享数据  
9.   d = other.d;  
10.   return *this;  
11. }  

 

 

另一方面，如果共享的数据要被修改（比如通过resize()函数），则会自动拷贝之：

 

1. void QByteArray::resize(int size)  
2. {  
3.   if (size <= 0) {  
4.     // 如果目标大小不为正，则指向一个空的数据块  
5.     Data *x = &shared_empty;  
6.     x->ref.ref();  
7.     if (!d->ref.deref())  
8.       qFree(d);  
9.     d = x;  
10.   } else if (d == &shared_null) {  
11.     // 如果当前是一个null块，则直接创建一个新的共享数据块  
12.     Data *x = static_cast<data *>(qMalloc(sizeof(Data)+size));  
13.     Q_CHECK_PTR(x);  
14.     x->ref = 1;  
15.     x->alloc = x->size = size;  
16.     x->data = x->array;  
17.     x->array[size] = '/0';  
18.     (void) d->ref.deref();  
19.     d = x;  
20.   } else {  
21.     // 如果有其他对象也在使用该共享数据，或者当前分配的空间过大或过小  
22.     // 则重新分配空间，并拷贝数据  
23.     // 注意：该操作在共享的数据块较大时可能会消耗一定的时间  
24.     if (d->ref != 1 || size > d->alloc || (size < d->size && size < d->alloc >> 1))  
25.       realloc(qAllocMore(size, sizeof(Data)));  
26.     if (d->alloc >= size) {  
27.       d->size = size;  
28.       if (d->data == d->array) {  
29.         d->array[size] = '/0';  
30.       }  
31.     }  
32.   }  
33. }  

 

 

现在让我们来看看如何使用QSharedData和QSharedDataPointer来创建自己的共享数据对象。

 

1. // 首先创建一个数据对象，需要继承自QShareData，因为其提供了引用计数器的功能  
2. class SharedData: public QSharedData  
3. {  
4. public:  
5.   SharedData()  
6.     : QSharedData()  
7.     , var(0)  
8.   {}  
9.   SharedData(const SharedData &other)  
10.     : QSharedData(other)  
11.     , var(other.var)  
12.   {}  
13.   int var;  
14. };  
15. // 然后创建数据操作者  
16. class DataOwner  
17. {  
18. public:  
19.   DataOwner()  
20.   : d(new SharedData)  
21.   {}  
22.   DataOwner(int var)  
23.   : d(new SharedData)  
24.   {  
25.     // 对于写操作，运算符->会在需要时自动拷贝共享数据  
26.     d->var = var;  
27.   }  
28. private:  
29.   // 模板类QSharedDataPointer隐藏了隐式共享的实现细节，因此没必要创建拷贝构造函数和赋值运算符  
30.   QSharedDataPointer<SharedData> d;  
31. };  

 

 

相当简单，没错吧！好了，有兴趣的朋友可以用QExplicitlySharedDataPointer来创建显式的数据共享;)